| /* Definitions of various defaults for tm.h macros. |
| Copyright (C) 1992, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, |
| 2005, 2007, 2008, 2009, 2010 |
| Free Software Foundation, Inc. |
| Contributed by Ron Guilmette (rfg@monkeys.com) |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 3, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| Under Section 7 of GPL version 3, you are granted additional |
| permissions described in the GCC Runtime Library Exception, version |
| 3.1, as published by the Free Software Foundation. |
| |
| You should have received a copy of the GNU General Public License and |
| a copy of the GCC Runtime Library Exception along with this program; |
| see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #ifndef GCC_DEFAULTS_H |
| #define GCC_DEFAULTS_H |
| |
| #ifndef GET_ENVIRONMENT |
| #define GET_ENVIRONMENT(VALUE, NAME) do { (VALUE) = getenv (NAME); } while (0) |
| #endif |
| |
| #define obstack_chunk_alloc ((void *(*) (long)) xmalloc) |
| #define obstack_chunk_free ((void (*) (void *)) free) |
| #define OBSTACK_CHUNK_SIZE 0 |
| #define gcc_obstack_init(OBSTACK) \ |
| _obstack_begin ((OBSTACK), OBSTACK_CHUNK_SIZE, 0, \ |
| obstack_chunk_alloc, \ |
| obstack_chunk_free) |
| |
| /* Store in OUTPUT a string (made with alloca) containing an |
| assembler-name for a local static variable or function named NAME. |
| LABELNO is an integer which is different for each call. */ |
| |
| #ifndef ASM_PN_FORMAT |
| # ifndef NO_DOT_IN_LABEL |
| # define ASM_PN_FORMAT "%s.%lu" |
| # else |
| # ifndef NO_DOLLAR_IN_LABEL |
| # define ASM_PN_FORMAT "%s$%lu" |
| # else |
| # define ASM_PN_FORMAT "__%s_%lu" |
| # endif |
| # endif |
| #endif /* ! ASM_PN_FORMAT */ |
| |
| #ifndef ASM_FORMAT_PRIVATE_NAME |
| # define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ |
| do { const char *const name_ = (NAME); \ |
| char *const output_ = (OUTPUT) = \ |
| (char *) alloca (strlen (name_) + 32); \ |
| sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \ |
| } while (0) |
| #endif |
| |
| /* Choose a reasonable default for ASM_OUTPUT_ASCII. */ |
| |
| #ifndef ASM_OUTPUT_ASCII |
| #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ |
| do { \ |
| FILE *_hide_asm_out_file = (MYFILE); \ |
| const unsigned char *_hide_p = (const unsigned char *) (MYSTRING); \ |
| int _hide_thissize = (MYLENGTH); \ |
| { \ |
| FILE *asm_out_file = _hide_asm_out_file; \ |
| const unsigned char *p = _hide_p; \ |
| int thissize = _hide_thissize; \ |
| int i; \ |
| fprintf (asm_out_file, "\t.ascii \""); \ |
| \ |
| for (i = 0; i < thissize; i++) \ |
| { \ |
| int c = p[i]; \ |
| if (c == '\"' || c == '\\') \ |
| putc ('\\', asm_out_file); \ |
| if (ISPRINT(c)) \ |
| putc (c, asm_out_file); \ |
| else \ |
| { \ |
| fprintf (asm_out_file, "\\%o", c); \ |
| /* After an octal-escape, if a digit follows, \ |
| terminate one string constant and start another. \ |
| The VAX assembler fails to stop reading the escape \ |
| after three digits, so this is the only way we \ |
| can get it to parse the data properly. */ \ |
| if (i < thissize - 1 && ISDIGIT(p[i + 1])) \ |
| fprintf (asm_out_file, "\"\n\t.ascii \""); \ |
| } \ |
| } \ |
| fprintf (asm_out_file, "\"\n"); \ |
| } \ |
| } \ |
| while (0) |
| #endif |
| |
| /* This is how we tell the assembler to equate two values. */ |
| #ifdef SET_ASM_OP |
| #ifndef ASM_OUTPUT_DEF |
| #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \ |
| do { fprintf ((FILE), "%s", SET_ASM_OP); \ |
| assemble_name (FILE, LABEL1); \ |
| fprintf (FILE, ","); \ |
| assemble_name (FILE, LABEL2); \ |
| fprintf (FILE, "\n"); \ |
| } while (0) |
| #endif |
| #endif |
| |
| #ifndef TLS_COMMON_ASM_OP |
| #define TLS_COMMON_ASM_OP ".tls_common" |
| #endif |
| |
| #if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON) |
| #define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE) \ |
| do \ |
| { \ |
| fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP); \ |
| assemble_name ((FILE), (NAME)); \ |
| fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n", \ |
| (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT); \ |
| } \ |
| while (0) |
| #endif |
| |
| /* Decide whether to defer emitting the assembler output for an equate |
| of two values. The default is to not defer output. */ |
| #ifndef TARGET_DEFERRED_OUTPUT_DEFS |
| #define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false |
| #endif |
| |
| /* This is how to output the definition of a user-level label named |
| NAME, such as the label on a static function or variable NAME. */ |
| |
| #ifndef ASM_OUTPUT_LABEL |
| #define ASM_OUTPUT_LABEL(FILE,NAME) \ |
| do { assemble_name ((FILE), (NAME)); fputs (":\n", (FILE)); } while (0) |
| #endif |
| |
| /* Output the definition of a compiler-generated label named NAME. */ |
| #ifndef ASM_OUTPUT_INTERNAL_LABEL |
| #define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME) \ |
| do { \ |
| assemble_name_raw ((FILE), (NAME)); \ |
| fputs (":\n", (FILE)); \ |
| } while (0) |
| #endif |
| |
| /* This is how to output a reference to a user-level label named NAME. */ |
| |
| #ifndef ASM_OUTPUT_LABELREF |
| #define ASM_OUTPUT_LABELREF(FILE,NAME) asm_fprintf ((FILE), "%U%s", (NAME)) |
| #endif |
| |
| /* Allow target to print debug info labels specially. This is useful for |
| VLIW targets, since debug info labels should go into the middle of |
| instruction bundles instead of breaking them. */ |
| |
| #ifndef ASM_OUTPUT_DEBUG_LABEL |
| #define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \ |
| (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM) |
| #endif |
| |
| /* This is how we tell the assembler that a symbol is weak. */ |
| #ifndef ASM_OUTPUT_WEAK_ALIAS |
| #if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF) |
| #define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE) \ |
| do \ |
| { \ |
| ASM_WEAKEN_LABEL (STREAM, NAME); \ |
| if (VALUE) \ |
| ASM_OUTPUT_DEF (STREAM, NAME, VALUE); \ |
| } \ |
| while (0) |
| #endif |
| #endif |
| |
| /* This is how we tell the assembler that a symbol is a weak alias to |
| another symbol that doesn't require the other symbol to be defined. |
| Uses of the former will turn into weak uses of the latter, i.e., |
| uses that, in case the latter is undefined, will not cause errors, |
| and will add it to the symbol table as weak undefined. However, if |
| the latter is referenced directly, a strong reference prevails. */ |
| #ifndef ASM_OUTPUT_WEAKREF |
| #if defined HAVE_GAS_WEAKREF |
| #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE) \ |
| do \ |
| { \ |
| fprintf ((FILE), "\t.weakref\t"); \ |
| assemble_name ((FILE), (NAME)); \ |
| fprintf ((FILE), ","); \ |
| assemble_name ((FILE), (VALUE)); \ |
| fprintf ((FILE), "\n"); \ |
| } \ |
| while (0) |
| #endif |
| #endif |
| |
| /* How to emit a .type directive. */ |
| #ifndef ASM_OUTPUT_TYPE_DIRECTIVE |
| #if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT |
| #define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE) \ |
| do \ |
| { \ |
| fputs (TYPE_ASM_OP, STREAM); \ |
| assemble_name (STREAM, NAME); \ |
| fputs (", ", STREAM); \ |
| fprintf (STREAM, TYPE_OPERAND_FMT, TYPE); \ |
| putc ('\n', STREAM); \ |
| } \ |
| while (0) |
| #endif |
| #endif |
| |
| /* How to emit a .size directive. */ |
| #ifndef ASM_OUTPUT_SIZE_DIRECTIVE |
| #ifdef SIZE_ASM_OP |
| #define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE) \ |
| do \ |
| { \ |
| HOST_WIDE_INT size_ = (SIZE); \ |
| fputs (SIZE_ASM_OP, STREAM); \ |
| assemble_name (STREAM, NAME); \ |
| fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \ |
| } \ |
| while (0) |
| |
| #define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME) \ |
| do \ |
| { \ |
| fputs (SIZE_ASM_OP, STREAM); \ |
| assemble_name (STREAM, NAME); \ |
| fputs (", .-", STREAM); \ |
| assemble_name (STREAM, NAME); \ |
| putc ('\n', STREAM); \ |
| } \ |
| while (0) |
| |
| #endif |
| #endif |
| |
| /* This determines whether or not we support weak symbols. */ |
| #ifndef SUPPORTS_WEAK |
| #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL) |
| #define SUPPORTS_WEAK 1 |
| #else |
| #define SUPPORTS_WEAK 0 |
| #endif |
| #endif |
| |
| /* This determines whether or not we support the discriminator |
| attribute in the .loc directive. */ |
| #ifndef SUPPORTS_DISCRIMINATOR |
| #ifdef HAVE_GAS_DISCRIMINATOR |
| #define SUPPORTS_DISCRIMINATOR 1 |
| #else |
| #define SUPPORTS_DISCRIMINATOR 0 |
| #endif |
| #endif |
| |
| /* This determines whether or not we support link-once semantics. */ |
| #ifndef SUPPORTS_ONE_ONLY |
| #ifdef MAKE_DECL_ONE_ONLY |
| #define SUPPORTS_ONE_ONLY 1 |
| #else |
| #define SUPPORTS_ONE_ONLY 0 |
| #endif |
| #endif |
| |
| /* This determines whether weak symbols must be left out of a static |
| archive's table of contents. Defining this macro to be nonzero has |
| the consequence that certain symbols will not be made weak that |
| otherwise would be. The C++ ABI requires this macro to be zero; |
| see the documentation. */ |
| #ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC |
| #define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0 |
| #endif |
| |
| /* This determines whether or not we need linkonce unwind information. */ |
| #ifndef TARGET_USES_WEAK_UNWIND_INFO |
| #define TARGET_USES_WEAK_UNWIND_INFO 0 |
| #endif |
| |
| /* By default, there is no prefix on user-defined symbols. */ |
| #ifndef USER_LABEL_PREFIX |
| #define USER_LABEL_PREFIX "" |
| #endif |
| |
| /* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to |
| provide a weak attribute. Else define it to nothing. |
| |
| This would normally belong in ansidecl.h, but SUPPORTS_WEAK is |
| not available at that time. |
| |
| Note, this is only for use by target files which we know are to be |
| compiled by GCC. */ |
| #ifndef TARGET_ATTRIBUTE_WEAK |
| # if SUPPORTS_WEAK |
| # define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak)) |
| # else |
| # define TARGET_ATTRIBUTE_WEAK |
| # endif |
| #endif |
| |
| /* Determines whether we may use common symbols to represent one-only |
| semantics (a.k.a. "vague linkage"). */ |
| #ifndef USE_COMMON_FOR_ONE_ONLY |
| # define USE_COMMON_FOR_ONE_ONLY 1 |
| #endif |
| |
| /* By default we can assume that all global symbols are in one namespace, |
| across all shared libraries. */ |
| #ifndef MULTIPLE_SYMBOL_SPACES |
| # define MULTIPLE_SYMBOL_SPACES 0 |
| #endif |
| |
| /* If the target supports init_priority C++ attribute, give |
| SUPPORTS_INIT_PRIORITY a nonzero value. */ |
| #ifndef SUPPORTS_INIT_PRIORITY |
| #define SUPPORTS_INIT_PRIORITY 1 |
| #endif /* SUPPORTS_INIT_PRIORITY */ |
| |
| /* If duplicate library search directories can be removed from a |
| linker command without changing the linker's semantics, give this |
| symbol a nonzero. */ |
| #ifndef LINK_ELIMINATE_DUPLICATE_LDIRECTORIES |
| #define LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 0 |
| #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */ |
| |
| /* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that |
| the rest of the DWARF 2 frame unwind support is also provided. */ |
| #if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) \ |
| && !defined (TARGET_UNWIND_INFO) |
| #define DWARF2_UNWIND_INFO 1 |
| #endif |
| |
| /* If we have named sections, and we're using crtstuff to run ctors, |
| use them for registering eh frame information. */ |
| #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ |
| && !defined(EH_FRAME_IN_DATA_SECTION) |
| #ifndef EH_FRAME_SECTION_NAME |
| #define EH_FRAME_SECTION_NAME ".eh_frame" |
| #endif |
| #endif |
| |
| /* On many systems, different EH table encodings are used under |
| difference circumstances. Some will require runtime relocations; |
| some will not. For those that do not require runtime relocations, |
| we would like to make the table read-only. However, since the |
| read-only tables may need to be combined with read-write tables |
| that do require runtime relocation, it is not safe to make the |
| tables read-only unless the linker will merge read-only and |
| read-write sections into a single read-write section. If your |
| linker does not have this ability, but your system is such that no |
| encoding used with non-PIC code will ever require a runtime |
| relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in |
| your target configuration file. */ |
| #ifndef EH_TABLES_CAN_BE_READ_ONLY |
| #ifdef HAVE_LD_RO_RW_SECTION_MIXING |
| #define EH_TABLES_CAN_BE_READ_ONLY 1 |
| #else |
| #define EH_TABLES_CAN_BE_READ_ONLY 0 |
| #endif |
| #endif |
| |
| /* If we have named section and we support weak symbols, then use the |
| .jcr section for recording java classes which need to be registered |
| at program start-up time. */ |
| #if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK |
| #ifndef JCR_SECTION_NAME |
| #define JCR_SECTION_NAME ".jcr" |
| #endif |
| #endif |
| |
| /* This decision to use a .jcr section can be overridden by defining |
| USE_JCR_SECTION to 0 in target file. This is necessary if target |
| can define JCR_SECTION_NAME but does not have crtstuff or |
| linker support for .jcr section. */ |
| #ifndef TARGET_USE_JCR_SECTION |
| #ifdef JCR_SECTION_NAME |
| #define TARGET_USE_JCR_SECTION 1 |
| #else |
| #define TARGET_USE_JCR_SECTION 0 |
| #endif |
| #endif |
| |
| /* Number of hardware registers that go into the DWARF-2 unwind info. |
| If not defined, equals FIRST_PSEUDO_REGISTER */ |
| |
| #ifndef DWARF_FRAME_REGISTERS |
| #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER |
| #endif |
| |
| /* How to renumber registers for dbx and gdb. If not defined, assume |
| no renumbering is necessary. */ |
| |
| #ifndef DBX_REGISTER_NUMBER |
| #define DBX_REGISTER_NUMBER(REGNO) (REGNO) |
| #endif |
| |
| /* Default sizes for base C types. If the sizes are different for |
| your target, you should override these values by defining the |
| appropriate symbols in your tm.h file. */ |
| |
| #ifndef BITS_PER_UNIT |
| #define BITS_PER_UNIT 8 |
| #endif |
| |
| #ifndef BITS_PER_WORD |
| #define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD) |
| #endif |
| |
| #ifndef CHAR_TYPE_SIZE |
| #define CHAR_TYPE_SIZE BITS_PER_UNIT |
| #endif |
| |
| #ifndef BOOL_TYPE_SIZE |
| /* `bool' has size and alignment `1', on almost all platforms. */ |
| #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE |
| #endif |
| |
| #ifndef SHORT_TYPE_SIZE |
| #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) |
| #endif |
| |
| #ifndef INT_TYPE_SIZE |
| #define INT_TYPE_SIZE BITS_PER_WORD |
| #endif |
| |
| #ifndef LONG_TYPE_SIZE |
| #define LONG_TYPE_SIZE BITS_PER_WORD |
| #endif |
| |
| #ifndef LONG_LONG_TYPE_SIZE |
| #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) |
| #endif |
| |
| #ifndef WCHAR_TYPE_SIZE |
| #define WCHAR_TYPE_SIZE INT_TYPE_SIZE |
| #endif |
| |
| #ifndef FLOAT_TYPE_SIZE |
| #define FLOAT_TYPE_SIZE BITS_PER_WORD |
| #endif |
| |
| #ifndef DOUBLE_TYPE_SIZE |
| #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) |
| #endif |
| |
| #ifndef LONG_DOUBLE_TYPE_SIZE |
| #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) |
| #endif |
| |
| #ifndef DECIMAL32_TYPE_SIZE |
| #define DECIMAL32_TYPE_SIZE 32 |
| #endif |
| |
| #ifndef DECIMAL64_TYPE_SIZE |
| #define DECIMAL64_TYPE_SIZE 64 |
| #endif |
| |
| #ifndef DECIMAL128_TYPE_SIZE |
| #define DECIMAL128_TYPE_SIZE 128 |
| #endif |
| |
| #ifndef SHORT_FRACT_TYPE_SIZE |
| #define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT |
| #endif |
| |
| #ifndef FRACT_TYPE_SIZE |
| #define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2) |
| #endif |
| |
| #ifndef LONG_FRACT_TYPE_SIZE |
| #define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4) |
| #endif |
| |
| #ifndef LONG_LONG_FRACT_TYPE_SIZE |
| #define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8) |
| #endif |
| |
| #ifndef SHORT_ACCUM_TYPE_SIZE |
| #define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2) |
| #endif |
| |
| #ifndef ACCUM_TYPE_SIZE |
| #define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2) |
| #endif |
| |
| #ifndef LONG_ACCUM_TYPE_SIZE |
| #define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2) |
| #endif |
| |
| #ifndef LONG_LONG_ACCUM_TYPE_SIZE |
| #define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2) |
| #endif |
| |
| /* We let tm.h override the types used here, to handle trivial differences |
| such as the choice of unsigned int or long unsigned int for size_t. |
| When machines start needing nontrivial differences in the size type, |
| it would be best to do something here to figure out automatically |
| from other information what type to use. */ |
| |
| #ifndef SIZE_TYPE |
| #define SIZE_TYPE "long unsigned int" |
| #endif |
| |
| #ifndef PID_TYPE |
| #define PID_TYPE "int" |
| #endif |
| |
| /* If GCC knows the exact uint_least16_t and uint_least32_t types from |
| <stdint.h>, use them for char16_t and char32_t. Otherwise, use |
| these guesses; getting the wrong type of a given width will not |
| affect C++ name mangling because in C++ these are distinct types |
| not typedefs. */ |
| |
| #ifdef UINT_LEAST16_TYPE |
| #define CHAR16_TYPE UINT_LEAST16_TYPE |
| #else |
| #define CHAR16_TYPE "short unsigned int" |
| #endif |
| |
| #ifdef UINT_LEAST32_TYPE |
| #define CHAR32_TYPE UINT_LEAST32_TYPE |
| #else |
| #define CHAR32_TYPE "unsigned int" |
| #endif |
| |
| #ifndef WCHAR_TYPE |
| #define WCHAR_TYPE "int" |
| #endif |
| |
| /* WCHAR_TYPE gets overridden by -fshort-wchar. */ |
| #define MODIFIED_WCHAR_TYPE \ |
| (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE) |
| |
| #ifndef PTRDIFF_TYPE |
| #define PTRDIFF_TYPE "long int" |
| #endif |
| |
| #ifndef WINT_TYPE |
| #define WINT_TYPE "unsigned int" |
| #endif |
| |
| #ifndef INTMAX_TYPE |
| #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
| ? "int" \ |
| : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
| ? "long int" \ |
| : "long long int")) |
| #endif |
| |
| #ifndef UINTMAX_TYPE |
| #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
| ? "unsigned int" \ |
| : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \ |
| ? "long unsigned int" \ |
| : "long long unsigned int")) |
| #endif |
| |
| |
| /* There are no default definitions of these <stdint.h> types. */ |
| |
| #ifndef SIG_ATOMIC_TYPE |
| #define SIG_ATOMIC_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT8_TYPE |
| #define INT8_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT16_TYPE |
| #define INT16_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT32_TYPE |
| #define INT32_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT64_TYPE |
| #define INT64_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT8_TYPE |
| #define UINT8_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT16_TYPE |
| #define UINT16_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT32_TYPE |
| #define UINT32_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT64_TYPE |
| #define UINT64_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_LEAST8_TYPE |
| #define INT_LEAST8_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_LEAST16_TYPE |
| #define INT_LEAST16_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_LEAST32_TYPE |
| #define INT_LEAST32_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_LEAST64_TYPE |
| #define INT_LEAST64_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_LEAST8_TYPE |
| #define UINT_LEAST8_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_LEAST16_TYPE |
| #define UINT_LEAST16_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_LEAST32_TYPE |
| #define UINT_LEAST32_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_LEAST64_TYPE |
| #define UINT_LEAST64_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_FAST8_TYPE |
| #define INT_FAST8_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_FAST16_TYPE |
| #define INT_FAST16_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_FAST32_TYPE |
| #define INT_FAST32_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INT_FAST64_TYPE |
| #define INT_FAST64_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_FAST8_TYPE |
| #define UINT_FAST8_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_FAST16_TYPE |
| #define UINT_FAST16_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_FAST32_TYPE |
| #define UINT_FAST32_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINT_FAST64_TYPE |
| #define UINT_FAST64_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef INTPTR_TYPE |
| #define INTPTR_TYPE ((const char *) NULL) |
| #endif |
| |
| #ifndef UINTPTR_TYPE |
| #define UINTPTR_TYPE ((const char *) NULL) |
| #endif |
| |
| /* Width in bits of a pointer. Mind the value of the macro `Pmode'. */ |
| #ifndef POINTER_SIZE |
| #define POINTER_SIZE BITS_PER_WORD |
| #endif |
| |
| #ifndef PIC_OFFSET_TABLE_REGNUM |
| #define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM |
| #endif |
| |
| #ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES |
| #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0 |
| #endif |
| |
| #ifndef TARGET_DECLSPEC |
| #if TARGET_DLLIMPORT_DECL_ATTRIBUTES |
| /* If the target supports the "dllimport" attribute, users are |
| probably used to the "__declspec" syntax. */ |
| #define TARGET_DECLSPEC 1 |
| #else |
| #define TARGET_DECLSPEC 0 |
| #endif |
| #endif |
| |
| /* By default, the preprocessor should be invoked the same way in C++ |
| as in C. */ |
| #ifndef CPLUSPLUS_CPP_SPEC |
| #ifdef CPP_SPEC |
| #define CPLUSPLUS_CPP_SPEC CPP_SPEC |
| #endif |
| #endif |
| |
| #ifndef ACCUMULATE_OUTGOING_ARGS |
| #define ACCUMULATE_OUTGOING_ARGS 0 |
| #endif |
| |
| /* Supply a default definition for PUSH_ARGS. */ |
| #ifndef PUSH_ARGS |
| #ifdef PUSH_ROUNDING |
| #define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS |
| #else |
| #define PUSH_ARGS 0 |
| #endif |
| #endif |
| |
| /* Decide whether a function's arguments should be processed |
| from first to last or from last to first. |
| |
| They should if the stack and args grow in opposite directions, but |
| only if we have push insns. */ |
| |
| #ifdef PUSH_ROUNDING |
| |
| #ifndef PUSH_ARGS_REVERSED |
| #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD) |
| #define PUSH_ARGS_REVERSED PUSH_ARGS |
| #endif |
| #endif |
| |
| #endif |
| |
| #ifndef PUSH_ARGS_REVERSED |
| #define PUSH_ARGS_REVERSED 0 |
| #endif |
| |
| /* Default value for the alignment (in bits) a C conformant malloc has to |
| provide. This default is intended to be safe and always correct. */ |
| #ifndef MALLOC_ABI_ALIGNMENT |
| #define MALLOC_ABI_ALIGNMENT BITS_PER_WORD |
| #endif |
| |
| /* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY. |
| STACK_BOUNDARY is required. */ |
| #ifndef PREFERRED_STACK_BOUNDARY |
| #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY |
| #endif |
| |
| /* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not |
| defined. */ |
| #ifndef INCOMING_STACK_BOUNDARY |
| #define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY |
| #endif |
| |
| #ifndef TARGET_DEFAULT_PACK_STRUCT |
| #define TARGET_DEFAULT_PACK_STRUCT 0 |
| #endif |
| |
| /* By default, the C++ compiler will use function addresses in the |
| vtable entries. Setting this nonzero tells the compiler to use |
| function descriptors instead. The value of this macro says how |
| many words wide the descriptor is (normally 2). It is assumed |
| that the address of a function descriptor may be treated as a |
| pointer to a function. */ |
| #ifndef TARGET_VTABLE_USES_DESCRIPTORS |
| #define TARGET_VTABLE_USES_DESCRIPTORS 0 |
| #endif |
| |
| /* By default, the vtable entries are void pointers, the so the alignment |
| is the same as pointer alignment. The value of this macro specifies |
| the alignment of the vtable entry in bits. It should be defined only |
| when special alignment is necessary. */ |
| #ifndef TARGET_VTABLE_ENTRY_ALIGN |
| #define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE |
| #endif |
| |
| /* There are a few non-descriptor entries in the vtable at offsets below |
| zero. If these entries must be padded (say, to preserve the alignment |
| specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of |
| words in each data entry. */ |
| #ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE |
| #define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1 |
| #endif |
| |
| /* Decide whether it is safe to use a local alias for a virtual function |
| when constructing thunks. */ |
| #ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P |
| #ifdef ASM_OUTPUT_DEF |
| #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1 |
| #else |
| #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0 |
| #endif |
| #endif |
| |
| /* Select a format to encode pointers in exception handling data. We |
| prefer those that result in fewer dynamic relocations. Assume no |
| special support here and encode direct references. */ |
| #ifndef ASM_PREFERRED_EH_DATA_FORMAT |
| #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL) DW_EH_PE_absptr |
| #endif |
| |
| /* By default, the C++ compiler will use the lowest bit of the pointer |
| to function to indicate a pointer-to-member-function points to a |
| virtual member function. However, if FUNCTION_BOUNDARY indicates |
| function addresses aren't always even, the lowest bit of the delta |
| field will be used. */ |
| #ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION |
| #define TARGET_PTRMEMFUNC_VBIT_LOCATION \ |
| (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \ |
| ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta) |
| #endif |
| |
| #ifndef DEFAULT_GDB_EXTENSIONS |
| #define DEFAULT_GDB_EXTENSIONS 1 |
| #endif |
| |
| /* If more than one debugging type is supported, you must define |
| PREFERRED_DEBUGGING_TYPE to choose the default. */ |
| |
| #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \ |
| + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \ |
| + defined (VMS_DEBUGGING_INFO)) |
| #ifndef PREFERRED_DEBUGGING_TYPE |
| #error You must define PREFERRED_DEBUGGING_TYPE |
| #endif /* no PREFERRED_DEBUGGING_TYPE */ |
| |
| /* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE |
| here so other code needn't care. */ |
| #elif defined DBX_DEBUGGING_INFO |
| #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG |
| |
| #elif defined SDB_DEBUGGING_INFO |
| #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG |
| |
| #elif defined DWARF2_DEBUGGING_INFO |
| #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG |
| |
| #elif defined VMS_DEBUGGING_INFO |
| #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG |
| |
| #elif defined XCOFF_DEBUGGING_INFO |
| #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG |
| |
| #else |
| /* No debugging format is supported by this target. */ |
| #define PREFERRED_DEBUGGING_TYPE NO_DEBUG |
| #endif |
| |
| #ifndef LARGEST_EXPONENT_IS_NORMAL |
| #define LARGEST_EXPONENT_IS_NORMAL(SIZE) 0 |
| #endif |
| |
| #ifndef ROUND_TOWARDS_ZERO |
| #define ROUND_TOWARDS_ZERO 0 |
| #endif |
| |
| #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL |
| #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false |
| #endif |
| |
| /* True if the targets integer-comparison functions return { 0, 1, 2 |
| } to indicate { <, ==, > }. False if { -1, 0, 1 } is used |
| instead. The libgcc routines are biased. */ |
| #ifndef TARGET_LIB_INT_CMP_BIASED |
| #define TARGET_LIB_INT_CMP_BIASED (true) |
| #endif |
| |
| /* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files, |
| then the word-endianness is the same as for integers. */ |
| #ifndef FLOAT_WORDS_BIG_ENDIAN |
| #define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN |
| #endif |
| |
| #ifdef TARGET_FLT_EVAL_METHOD |
| #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 1 |
| #else |
| #define TARGET_FLT_EVAL_METHOD 0 |
| #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 0 |
| #endif |
| |
| #ifndef TARGET_DEC_EVAL_METHOD |
| #define TARGET_DEC_EVAL_METHOD 2 |
| #endif |
| |
| #ifndef HOT_TEXT_SECTION_NAME |
| #define HOT_TEXT_SECTION_NAME ".text.hot" |
| #endif |
| |
| #ifndef UNLIKELY_EXECUTED_TEXT_SECTION_NAME |
| #define UNLIKELY_EXECUTED_TEXT_SECTION_NAME ".text.unlikely" |
| #endif |
| |
| #ifndef HAS_LONG_COND_BRANCH |
| #define HAS_LONG_COND_BRANCH 0 |
| #endif |
| |
| #ifndef HAS_LONG_UNCOND_BRANCH |
| #define HAS_LONG_UNCOND_BRANCH 0 |
| #endif |
| |
| /* By default, only attempt to parallelize bitwise operations, and |
| possibly adds/subtracts using bit-twiddling. */ |
| #ifndef UNITS_PER_SIMD_WORD |
| #define UNITS_PER_SIMD_WORD(MODE) UNITS_PER_WORD |
| #endif |
| |
| /* Determine whether __cxa_atexit, rather than atexit, is used to |
| register C++ destructors for local statics and global objects. */ |
| #ifndef DEFAULT_USE_CXA_ATEXIT |
| #define DEFAULT_USE_CXA_ATEXIT 0 |
| #endif |
| |
| /* If none of these macros are defined, the port must use the new |
| technique of defining constraints in the machine description. |
| tm_p.h will define those macros that machine-independent code |
| still uses. */ |
| #if !defined CONSTRAINT_LEN \ |
| && !defined REG_CLASS_FROM_LETTER \ |
| && !defined REG_CLASS_FROM_CONSTRAINT \ |
| && !defined CONST_OK_FOR_LETTER_P \ |
| && !defined CONST_OK_FOR_CONSTRAINT_P \ |
| && !defined CONST_DOUBLE_OK_FOR_LETTER_P \ |
| && !defined CONST_DOUBLE_OK_FOR_CONSTRAINT_P \ |
| && !defined EXTRA_CONSTRAINT \ |
| && !defined EXTRA_CONSTRAINT_STR \ |
| && !defined EXTRA_MEMORY_CONSTRAINT \ |
| && !defined EXTRA_ADDRESS_CONSTRAINT |
| |
| #define USE_MD_CONSTRAINTS |
| |
| #if GCC_VERSION >= 3000 && defined IN_GCC |
| /* These old constraint macros shouldn't appear anywhere in a |
| configuration using MD constraint definitions. */ |
| #pragma GCC poison REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P \ |
| CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT |
| #endif |
| |
| #else /* old constraint mechanism in use */ |
| |
| /* Determine whether extra constraint letter should be handled |
| via address reload (like 'o'). */ |
| #ifndef EXTRA_MEMORY_CONSTRAINT |
| #define EXTRA_MEMORY_CONSTRAINT(C,STR) 0 |
| #endif |
| |
| /* Determine whether extra constraint letter should be handled |
| as an address (like 'p'). */ |
| #ifndef EXTRA_ADDRESS_CONSTRAINT |
| #define EXTRA_ADDRESS_CONSTRAINT(C,STR) 0 |
| #endif |
| |
| /* When a port defines CONSTRAINT_LEN, it should use DEFAULT_CONSTRAINT_LEN |
| for all the characters that it does not want to change, so things like the |
| 'length' of a digit in a matching constraint is an implementation detail, |
| and not part of the interface. */ |
| #define DEFAULT_CONSTRAINT_LEN(C,STR) 1 |
| |
| #ifndef CONSTRAINT_LEN |
| #define CONSTRAINT_LEN(C,STR) DEFAULT_CONSTRAINT_LEN (C, STR) |
| #endif |
| |
| #if defined (CONST_OK_FOR_LETTER_P) && ! defined (CONST_OK_FOR_CONSTRAINT_P) |
| #define CONST_OK_FOR_CONSTRAINT_P(VAL,C,STR) CONST_OK_FOR_LETTER_P (VAL, C) |
| #endif |
| |
| #if defined (CONST_DOUBLE_OK_FOR_LETTER_P) && ! defined (CONST_DOUBLE_OK_FOR_CONSTRAINT_P) |
| #define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(OP,C,STR) \ |
| CONST_DOUBLE_OK_FOR_LETTER_P (OP, C) |
| #endif |
| |
| #ifndef REG_CLASS_FROM_CONSTRAINT |
| #define REG_CLASS_FROM_CONSTRAINT(C,STR) REG_CLASS_FROM_LETTER (C) |
| #endif |
| |
| #if defined (EXTRA_CONSTRAINT) && ! defined (EXTRA_CONSTRAINT_STR) |
| #define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C) |
| #endif |
| |
| #endif /* old constraint mechanism in use */ |
| |
| #ifndef REGISTER_MOVE_COST |
| #define REGISTER_MOVE_COST(m, x, y) 2 |
| #endif |
| |
| /* Determine whether the entire c99 runtime |
| is present in the runtime library. */ |
| #ifndef TARGET_C99_FUNCTIONS |
| #define TARGET_C99_FUNCTIONS 0 |
| #endif |
| |
| /* Determine whether the target runtime library has |
| a sincos implementation following the GNU extension. */ |
| #ifndef TARGET_HAS_SINCOS |
| #define TARGET_HAS_SINCOS 0 |
| #endif |
| |
| /* Indicate that CLZ and CTZ are undefined at zero. */ |
| #ifndef CLZ_DEFINED_VALUE_AT_ZERO |
| #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
| #endif |
| #ifndef CTZ_DEFINED_VALUE_AT_ZERO |
| #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) 0 |
| #endif |
| |
| /* Provide a default value for STORE_FLAG_VALUE. */ |
| #ifndef STORE_FLAG_VALUE |
| #define STORE_FLAG_VALUE 1 |
| #endif |
| |
| /* This macro is used to determine what the largest unit size that |
| move_by_pieces can use is. */ |
| |
| /* MOVE_MAX_PIECES is the number of bytes at a time which we can |
| move efficiently, as opposed to MOVE_MAX which is the maximum |
| number of bytes we can move with a single instruction. */ |
| |
| #ifndef MOVE_MAX_PIECES |
| #define MOVE_MAX_PIECES MOVE_MAX |
| #endif |
| |
| #ifndef STACK_POINTER_OFFSET |
| #define STACK_POINTER_OFFSET 0 |
| #endif |
| |
| #ifndef LOCAL_REGNO |
| #define LOCAL_REGNO(REGNO) 0 |
| #endif |
| |
| /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, |
| the stack pointer does not matter. The value is tested only in |
| functions that have frame pointers. */ |
| #ifndef EXIT_IGNORE_STACK |
| #define EXIT_IGNORE_STACK 0 |
| #endif |
| |
| /* Assume that case vectors are not pc-relative. */ |
| #ifndef CASE_VECTOR_PC_RELATIVE |
| #define CASE_VECTOR_PC_RELATIVE 0 |
| #endif |
| |
| /* Assume that trampolines need function alignment. */ |
| #ifndef TRAMPOLINE_ALIGNMENT |
| #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY |
| #endif |
| |
| /* Register mappings for target machines without register windows. */ |
| #ifndef INCOMING_REGNO |
| #define INCOMING_REGNO(N) (N) |
| #endif |
| |
| #ifndef OUTGOING_REGNO |
| #define OUTGOING_REGNO(N) (N) |
| #endif |
| |
| #ifndef SHIFT_COUNT_TRUNCATED |
| #define SHIFT_COUNT_TRUNCATED 0 |
| #endif |
| |
| #ifndef LEGITIMATE_PIC_OPERAND_P |
| #define LEGITIMATE_PIC_OPERAND_P(X) 1 |
| #endif |
| |
| #ifndef TARGET_MEM_CONSTRAINT |
| #define TARGET_MEM_CONSTRAINT 'm' |
| #endif |
| |
| #ifndef REVERSIBLE_CC_MODE |
| #define REVERSIBLE_CC_MODE(MODE) 0 |
| #endif |
| |
| /* Biggest alignment supported by the object file format of this machine. */ |
| #ifndef MAX_OFILE_ALIGNMENT |
| #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT |
| #endif |
| |
| #ifndef FRAME_GROWS_DOWNWARD |
| #define FRAME_GROWS_DOWNWARD 0 |
| #endif |
| |
| /* On most machines, the CFA coincides with the first incoming parm. */ |
| #ifndef ARG_POINTER_CFA_OFFSET |
| #define ARG_POINTER_CFA_OFFSET(FNDECL) \ |
| (FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size) |
| #endif |
| |
| /* On most machines, we use the CFA as DW_AT_frame_base. */ |
| #ifndef CFA_FRAME_BASE_OFFSET |
| #define CFA_FRAME_BASE_OFFSET(FNDECL) 0 |
| #endif |
| |
| /* The offset from the incoming value of %sp to the top of the stack frame |
| for the current function. */ |
| #ifndef INCOMING_FRAME_SP_OFFSET |
| #define INCOMING_FRAME_SP_OFFSET 0 |
| #endif |
| |
| #ifndef HARD_REGNO_NREGS_HAS_PADDING |
| #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0 |
| #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1 |
| #endif |
| |
| #ifndef OUTGOING_REG_PARM_STACK_SPACE |
| #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0 |
| #endif |
| |
| /* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by |
| the backend. MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best |
| effort stack alignment supported by the backend. If the backend |
| supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and |
| MAX_STACK_ALIGNMENT are the same. Otherwise, the incoming stack |
| boundary will limit the maximum guaranteed stack alignment. */ |
| #ifdef MAX_STACK_ALIGNMENT |
| #define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT |
| #else |
| #define MAX_STACK_ALIGNMENT STACK_BOUNDARY |
| #define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY |
| #endif |
| |
| #define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY) |
| |
| #ifndef LOCAL_ALIGNMENT |
| #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT |
| #endif |
| |
| #ifndef STACK_SLOT_ALIGNMENT |
| #define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \ |
| ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN)) |
| #endif |
| |
| #ifndef LOCAL_DECL_ALIGNMENT |
| #define LOCAL_DECL_ALIGNMENT(DECL) \ |
| LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL)) |
| #endif |
| |
| #ifndef MINIMUM_ALIGNMENT |
| #define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN) |
| #endif |
| |
| /* Alignment value for attribute ((aligned)). */ |
| #ifndef ATTRIBUTE_ALIGNED_VALUE |
| #define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT |
| #endif |
| |
| /* Many ports have no mode-dependent addresses (except possibly autoincrement |
| and autodecrement addresses, which are handled by target-independent code |
| in recog.c). */ |
| #ifndef GO_IF_MODE_DEPENDENT_ADDRESS |
| #define GO_IF_MODE_DEPENDENT_ADDRESS(X, WIN) |
| #endif |
| |
| /* For most ports anything that evaluates to a constant symbolic |
| or integer value is acceptable as a constant address. */ |
| #ifndef CONSTANT_ADDRESS_P |
| #define CONSTANT_ADDRESS_P(X) (CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE) |
| #endif |
| |
| #endif /* ! GCC_DEFAULTS_H */ |
