Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /* Definitions of various defaults for tm.h macros.
  2.    Copyright (C) 1992, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
  3.    2005, 2007, 2008, 2009, 2010
  4.    Free Software Foundation, Inc.
  5.    Contributed by Ron Guilmette (rfg@monkeys.com)
  6.  
  7. This file is part of GCC.
  8.  
  9. GCC is free software; you can redistribute it and/or modify it under
  10. the terms of the GNU General Public License as published by the Free
  11. Software Foundation; either version 3, or (at your option) any later
  12. version.
  13.  
  14. GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17. for more details.
  18.  
  19. Under Section 7 of GPL version 3, you are granted additional
  20. permissions described in the GCC Runtime Library Exception, version
  21. 3.1, as published by the Free Software Foundation.
  22.  
  23. You should have received a copy of the GNU General Public License and
  24. a copy of the GCC Runtime Library Exception along with this program;
  25. see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  26. <http://www.gnu.org/licenses/>.  */
  27.  
  28. #ifndef GCC_DEFAULTS_H
  29. #define GCC_DEFAULTS_H
  30.  
  31. #ifndef GET_ENVIRONMENT
  32. #define GET_ENVIRONMENT(VALUE, NAME) do { (VALUE) = getenv (NAME); } while (0)
  33. #endif
  34.  
  35. #define obstack_chunk_alloc     ((void *(*) (long)) xmalloc)
  36. #define obstack_chunk_free      ((void (*) (void *)) free)
  37. #define OBSTACK_CHUNK_SIZE      0
  38. #define gcc_obstack_init(OBSTACK)                       \
  39.   _obstack_begin ((OBSTACK), OBSTACK_CHUNK_SIZE, 0,     \
  40.                   obstack_chunk_alloc,                  \
  41.                   obstack_chunk_free)
  42.  
  43. /* Store in OUTPUT a string (made with alloca) containing an
  44.    assembler-name for a local static variable or function named NAME.
  45.    LABELNO is an integer which is different for each call.  */
  46.  
  47. #ifndef ASM_PN_FORMAT
  48. # ifndef NO_DOT_IN_LABEL
  49. #  define ASM_PN_FORMAT "%s.%lu"
  50. # else
  51. #  ifndef NO_DOLLAR_IN_LABEL
  52. #   define ASM_PN_FORMAT "%s$%lu"
  53. #  else
  54. #   define ASM_PN_FORMAT "__%s_%lu"
  55. #  endif
  56. # endif
  57. #endif /* ! ASM_PN_FORMAT */
  58.  
  59. #ifndef ASM_FORMAT_PRIVATE_NAME
  60. # define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
  61.   do { const char *const name_ = (NAME); \
  62.        char *const output_ = (OUTPUT) = \
  63.          (char *) alloca (strlen (name_) + 32); \
  64.        sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \
  65.   } while (0)
  66. #endif
  67.  
  68. /* Choose a reasonable default for ASM_OUTPUT_ASCII.  */
  69.  
  70. #ifndef ASM_OUTPUT_ASCII
  71. #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
  72.   do {                                                                        \
  73.     FILE *_hide_asm_out_file = (MYFILE);                                      \
  74.     const unsigned char *_hide_p = (const unsigned char *) (MYSTRING);        \
  75.     int _hide_thissize = (MYLENGTH);                                          \
  76.     {                                                                         \
  77.       FILE *asm_out_file = _hide_asm_out_file;                                \
  78.       const unsigned char *p = _hide_p;                                       \
  79.       int thissize = _hide_thissize;                                          \
  80.       int i;                                                                  \
  81.       fprintf (asm_out_file, "\t.ascii \"");                                  \
  82.                                                                               \
  83.       for (i = 0; i < thissize; i++)                                          \
  84.         {                                                                     \
  85.           int c = p[i];                                                       \
  86.           if (c == '\"' || c == '\\')                                         \
  87.             putc ('\\', asm_out_file);                                        \
  88.           if (ISPRINT(c))                                                     \
  89.             putc (c, asm_out_file);                                           \
  90.           else                                                                \
  91.             {                                                                 \
  92.               fprintf (asm_out_file, "\\%o", c);                              \
  93.               /* After an octal-escape, if a digit follows,                   \
  94.                  terminate one string constant and start another.             \
  95.                  The VAX assembler fails to stop reading the escape           \
  96.                  after three digits, so this is the only way we               \
  97.                  can get it to parse the data properly.  */                   \
  98.               if (i < thissize - 1 && ISDIGIT(p[i + 1]))                      \
  99.                 fprintf (asm_out_file, "\"\n\t.ascii \"");                    \
  100.           }                                                                   \
  101.         }                                                                     \
  102.       fprintf (asm_out_file, "\"\n");                                         \
  103.     }                                                                         \
  104.   }                                                                           \
  105.   while (0)
  106. #endif
  107.  
  108. /* This is how we tell the assembler to equate two values.  */
  109. #ifdef SET_ASM_OP
  110. #ifndef ASM_OUTPUT_DEF
  111. #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
  112.  do {   fprintf ((FILE), "%s", SET_ASM_OP);                             \
  113.         assemble_name (FILE, LABEL1);                                   \
  114.         fprintf (FILE, ",");                                            \
  115.         assemble_name (FILE, LABEL2);                                   \
  116.         fprintf (FILE, "\n");                                           \
  117.   } while (0)
  118. #endif
  119. #endif
  120.  
  121. #ifndef TLS_COMMON_ASM_OP
  122. #define TLS_COMMON_ASM_OP ".tls_common"
  123. #endif
  124.  
  125. #if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON)
  126. #define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE)                   \
  127.   do                                                                    \
  128.     {                                                                   \
  129.       fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP);                    \
  130.       assemble_name ((FILE), (NAME));                                   \
  131.       fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",          \
  132.                (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT);              \
  133.     }                                                                   \
  134.   while (0)
  135. #endif
  136.  
  137. /* Decide whether to defer emitting the assembler output for an equate
  138.    of two values.  The default is to not defer output.  */
  139. #ifndef TARGET_DEFERRED_OUTPUT_DEFS
  140. #define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false
  141. #endif
  142.  
  143. /* This is how to output the definition of a user-level label named
  144.    NAME, such as the label on a static function or variable NAME.  */
  145.  
  146. #ifndef ASM_OUTPUT_LABEL
  147. #define ASM_OUTPUT_LABEL(FILE,NAME) \
  148.   do { assemble_name ((FILE), (NAME)); fputs (":\n", (FILE)); } while (0)
  149. #endif
  150.  
  151. /* Output the definition of a compiler-generated label named NAME.  */
  152. #ifndef ASM_OUTPUT_INTERNAL_LABEL
  153. #define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME)    \
  154.   do {                                          \
  155.     assemble_name_raw ((FILE), (NAME));         \
  156.     fputs (":\n", (FILE));                      \
  157.   } while (0)
  158. #endif
  159.  
  160. /* This is how to output a reference to a user-level label named NAME.  */
  161.  
  162. #ifndef ASM_OUTPUT_LABELREF
  163. #define ASM_OUTPUT_LABELREF(FILE,NAME)  asm_fprintf ((FILE), "%U%s", (NAME))
  164. #endif
  165.  
  166. /* Allow target to print debug info labels specially.  This is useful for
  167.    VLIW targets, since debug info labels should go into the middle of
  168.    instruction bundles instead of breaking them.  */
  169.  
  170. #ifndef ASM_OUTPUT_DEBUG_LABEL
  171. #define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \
  172.   (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM)
  173. #endif
  174.  
  175. /* This is how we tell the assembler that a symbol is weak.  */
  176. #ifndef ASM_OUTPUT_WEAK_ALIAS
  177. #if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF)
  178. #define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE)      \
  179.   do                                                    \
  180.     {                                                   \
  181.       ASM_WEAKEN_LABEL (STREAM, NAME);                  \
  182.       if (VALUE)                                        \
  183.         ASM_OUTPUT_DEF (STREAM, NAME, VALUE);           \
  184.     }                                                   \
  185.   while (0)
  186. #endif
  187. #endif
  188.  
  189. /* This is how we tell the assembler that a symbol is a weak alias to
  190.    another symbol that doesn't require the other symbol to be defined.
  191.    Uses of the former will turn into weak uses of the latter, i.e.,
  192.    uses that, in case the latter is undefined, will not cause errors,
  193.    and will add it to the symbol table as weak undefined.  However, if
  194.    the latter is referenced directly, a strong reference prevails.  */
  195. #ifndef ASM_OUTPUT_WEAKREF
  196. #if defined HAVE_GAS_WEAKREF
  197. #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE)                     \
  198.   do                                                                    \
  199.     {                                                                   \
  200.       fprintf ((FILE), "\t.weakref\t");                                 \
  201.       assemble_name ((FILE), (NAME));                                   \
  202.       fprintf ((FILE), ",");                                            \
  203.       assemble_name ((FILE), (VALUE));                                  \
  204.       fprintf ((FILE), "\n");                                           \
  205.     }                                                                   \
  206.   while (0)
  207. #endif
  208. #endif
  209.  
  210. /* How to emit a .type directive.  */
  211. #ifndef ASM_OUTPUT_TYPE_DIRECTIVE
  212. #if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT
  213. #define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE)   \
  214.   do                                                    \
  215.     {                                                   \
  216.       fputs (TYPE_ASM_OP, STREAM);                      \
  217.       assemble_name (STREAM, NAME);                     \
  218.       fputs (", ", STREAM);                             \
  219.       fprintf (STREAM, TYPE_OPERAND_FMT, TYPE);         \
  220.       putc ('\n', STREAM);                              \
  221.     }                                                   \
  222.   while (0)
  223. #endif
  224. #endif
  225.  
  226. /* How to emit a .size directive.  */
  227. #ifndef ASM_OUTPUT_SIZE_DIRECTIVE
  228. #ifdef SIZE_ASM_OP
  229. #define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE)   \
  230.   do                                                    \
  231.     {                                                   \
  232.       HOST_WIDE_INT size_ = (SIZE);                     \
  233.       fputs (SIZE_ASM_OP, STREAM);                      \
  234.       assemble_name (STREAM, NAME);                     \
  235.       fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \
  236.     }                                                   \
  237.   while (0)
  238.  
  239. #define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME)          \
  240.   do                                                    \
  241.     {                                                   \
  242.       fputs (SIZE_ASM_OP, STREAM);                      \
  243.       assemble_name (STREAM, NAME);                     \
  244.       fputs (", .-", STREAM);                           \
  245.       assemble_name (STREAM, NAME);                     \
  246.       putc ('\n', STREAM);                              \
  247.     }                                                   \
  248.   while (0)
  249.  
  250. #endif
  251. #endif
  252.  
  253. /* This determines whether or not we support weak symbols.  */
  254. #ifndef SUPPORTS_WEAK
  255. #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
  256. #define SUPPORTS_WEAK 1
  257. #else
  258. #define SUPPORTS_WEAK 0
  259. #endif
  260. #endif
  261.  
  262. /* This determines whether or not we support the discriminator
  263.    attribute in the .loc directive.  */
  264. #ifndef SUPPORTS_DISCRIMINATOR
  265. #ifdef HAVE_GAS_DISCRIMINATOR
  266. #define SUPPORTS_DISCRIMINATOR 1
  267. #else
  268. #define SUPPORTS_DISCRIMINATOR 0
  269. #endif
  270. #endif
  271.  
  272. /* This determines whether or not we support link-once semantics.  */
  273. #ifndef SUPPORTS_ONE_ONLY
  274. #ifdef MAKE_DECL_ONE_ONLY
  275. #define SUPPORTS_ONE_ONLY 1
  276. #else
  277. #define SUPPORTS_ONE_ONLY 0
  278. #endif
  279. #endif
  280.  
  281. /* This determines whether weak symbols must be left out of a static
  282.    archive's table of contents.  Defining this macro to be nonzero has
  283.    the consequence that certain symbols will not be made weak that
  284.    otherwise would be.  The C++ ABI requires this macro to be zero;
  285.    see the documentation.  */
  286. #ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC
  287. #define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0
  288. #endif
  289.  
  290. /* This determines whether or not we need linkonce unwind information.  */
  291. #ifndef TARGET_USES_WEAK_UNWIND_INFO
  292. #define TARGET_USES_WEAK_UNWIND_INFO 0
  293. #endif
  294.  
  295. /* By default, there is no prefix on user-defined symbols.  */
  296. #ifndef USER_LABEL_PREFIX
  297. #define USER_LABEL_PREFIX ""
  298. #endif
  299.  
  300. /* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to
  301.    provide a weak attribute.  Else define it to nothing.
  302.  
  303.    This would normally belong in ansidecl.h, but SUPPORTS_WEAK is
  304.    not available at that time.
  305.  
  306.    Note, this is only for use by target files which we know are to be
  307.    compiled by GCC.  */
  308. #ifndef TARGET_ATTRIBUTE_WEAK
  309. # if SUPPORTS_WEAK
  310. #  define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak))
  311. # else
  312. #  define TARGET_ATTRIBUTE_WEAK
  313. # endif
  314. #endif
  315.  
  316. /* Determines whether we may use common symbols to represent one-only
  317.    semantics (a.k.a. "vague linkage").  */
  318. #ifndef USE_COMMON_FOR_ONE_ONLY
  319. # define USE_COMMON_FOR_ONE_ONLY 1
  320. #endif
  321.  
  322. /* By default we can assume that all global symbols are in one namespace,
  323.    across all shared libraries.  */
  324. #ifndef MULTIPLE_SYMBOL_SPACES
  325. # define MULTIPLE_SYMBOL_SPACES 0
  326. #endif
  327.  
  328. /* If the target supports init_priority C++ attribute, give
  329.    SUPPORTS_INIT_PRIORITY a nonzero value.  */
  330. #ifndef SUPPORTS_INIT_PRIORITY
  331. #define SUPPORTS_INIT_PRIORITY 1
  332. #endif /* SUPPORTS_INIT_PRIORITY */
  333.  
  334. /* If duplicate library search directories can be removed from a
  335.    linker command without changing the linker's semantics, give this
  336.    symbol a nonzero.  */
  337. #ifndef LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
  338. #define LINK_ELIMINATE_DUPLICATE_LDIRECTORIES 0
  339. #endif /* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES */
  340.  
  341. /* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that
  342.    the rest of the DWARF 2 frame unwind support is also provided.  */
  343. #if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX) \
  344.     && !defined (TARGET_UNWIND_INFO)
  345. #define DWARF2_UNWIND_INFO 1
  346. #endif
  347.  
  348. /* If we have named sections, and we're using crtstuff to run ctors,
  349.    use them for registering eh frame information.  */
  350. #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \
  351.     && !defined(EH_FRAME_IN_DATA_SECTION)
  352. #ifndef EH_FRAME_SECTION_NAME
  353. #define EH_FRAME_SECTION_NAME ".eh_frame"
  354. #endif
  355. #endif
  356.  
  357. /* On many systems, different EH table encodings are used under
  358.    difference circumstances.  Some will require runtime relocations;
  359.    some will not.  For those that do not require runtime relocations,
  360.    we would like to make the table read-only.  However, since the
  361.    read-only tables may need to be combined with read-write tables
  362.    that do require runtime relocation, it is not safe to make the
  363.    tables read-only unless the linker will merge read-only and
  364.    read-write sections into a single read-write section.  If your
  365.    linker does not have this ability, but your system is such that no
  366.    encoding used with non-PIC code will ever require a runtime
  367.    relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in
  368.    your target configuration file.  */
  369. #ifndef EH_TABLES_CAN_BE_READ_ONLY
  370. #ifdef HAVE_LD_RO_RW_SECTION_MIXING
  371. #define EH_TABLES_CAN_BE_READ_ONLY 1
  372. #else
  373. #define EH_TABLES_CAN_BE_READ_ONLY 0
  374. #endif
  375. #endif
  376.  
  377. /* If we have named section and we support weak symbols, then use the
  378.    .jcr section for recording java classes which need to be registered
  379.    at program start-up time.  */
  380. #if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK
  381. #ifndef JCR_SECTION_NAME
  382. #define JCR_SECTION_NAME ".jcr"
  383. #endif
  384. #endif
  385.  
  386. /* This decision to use a .jcr section can be overridden by defining
  387.    USE_JCR_SECTION to 0 in target file.  This is necessary if target
  388.    can define JCR_SECTION_NAME but does not have crtstuff or
  389.    linker support for .jcr section.  */
  390. #ifndef TARGET_USE_JCR_SECTION
  391. #ifdef JCR_SECTION_NAME
  392. #define TARGET_USE_JCR_SECTION 1
  393. #else
  394. #define TARGET_USE_JCR_SECTION 0
  395. #endif
  396. #endif
  397.  
  398. /* Number of hardware registers that go into the DWARF-2 unwind info.
  399.    If not defined, equals FIRST_PSEUDO_REGISTER  */
  400.  
  401. #ifndef DWARF_FRAME_REGISTERS
  402. #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER
  403. #endif
  404.  
  405. /* How to renumber registers for dbx and gdb.  If not defined, assume
  406.    no renumbering is necessary.  */
  407.  
  408. #ifndef DBX_REGISTER_NUMBER
  409. #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
  410. #endif
  411.  
  412. /* Default sizes for base C types.  If the sizes are different for
  413.    your target, you should override these values by defining the
  414.    appropriate symbols in your tm.h file.  */
  415.  
  416. #ifndef BITS_PER_UNIT
  417. #define BITS_PER_UNIT 8
  418. #endif
  419.  
  420. #ifndef BITS_PER_WORD
  421. #define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD)
  422. #endif
  423.  
  424. #ifndef CHAR_TYPE_SIZE
  425. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  426. #endif
  427.  
  428. #ifndef BOOL_TYPE_SIZE
  429. /* `bool' has size and alignment `1', on almost all platforms.  */
  430. #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  431. #endif
  432.  
  433. #ifndef SHORT_TYPE_SIZE
  434. #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
  435. #endif
  436.  
  437. #ifndef INT_TYPE_SIZE
  438. #define INT_TYPE_SIZE BITS_PER_WORD
  439. #endif
  440.  
  441. #ifndef LONG_TYPE_SIZE
  442. #define LONG_TYPE_SIZE BITS_PER_WORD
  443. #endif
  444.  
  445. #ifndef LONG_LONG_TYPE_SIZE
  446. #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
  447. #endif
  448.  
  449. #ifndef WCHAR_TYPE_SIZE
  450. #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  451. #endif
  452.  
  453. #ifndef FLOAT_TYPE_SIZE
  454. #define FLOAT_TYPE_SIZE BITS_PER_WORD
  455. #endif
  456.  
  457. #ifndef DOUBLE_TYPE_SIZE
  458. #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
  459. #endif
  460.  
  461. #ifndef LONG_DOUBLE_TYPE_SIZE
  462. #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
  463. #endif
  464.  
  465. #ifndef DECIMAL32_TYPE_SIZE
  466. #define DECIMAL32_TYPE_SIZE 32
  467. #endif
  468.  
  469. #ifndef DECIMAL64_TYPE_SIZE
  470. #define DECIMAL64_TYPE_SIZE 64
  471. #endif
  472.  
  473. #ifndef DECIMAL128_TYPE_SIZE
  474. #define DECIMAL128_TYPE_SIZE 128
  475. #endif
  476.  
  477. #ifndef SHORT_FRACT_TYPE_SIZE
  478. #define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT
  479. #endif
  480.  
  481. #ifndef FRACT_TYPE_SIZE
  482. #define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2)
  483. #endif
  484.  
  485. #ifndef LONG_FRACT_TYPE_SIZE
  486. #define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4)
  487. #endif
  488.  
  489. #ifndef LONG_LONG_FRACT_TYPE_SIZE
  490. #define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8)
  491. #endif
  492.  
  493. #ifndef SHORT_ACCUM_TYPE_SIZE
  494. #define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2)
  495. #endif
  496.  
  497. #ifndef ACCUM_TYPE_SIZE
  498. #define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2)
  499. #endif
  500.  
  501. #ifndef LONG_ACCUM_TYPE_SIZE
  502. #define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2)
  503. #endif
  504.  
  505. #ifndef LONG_LONG_ACCUM_TYPE_SIZE
  506. #define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2)
  507. #endif
  508.  
  509. /* We let tm.h override the types used here, to handle trivial differences
  510.    such as the choice of unsigned int or long unsigned int for size_t.
  511.    When machines start needing nontrivial differences in the size type,
  512.    it would be best to do something here to figure out automatically
  513.    from other information what type to use.  */
  514.  
  515. #ifndef SIZE_TYPE
  516. #define SIZE_TYPE "long unsigned int"
  517. #endif
  518.  
  519. #ifndef PID_TYPE
  520. #define PID_TYPE "int"
  521. #endif
  522.  
  523. /* If GCC knows the exact uint_least16_t and uint_least32_t types from
  524.    <stdint.h>, use them for char16_t and char32_t.  Otherwise, use
  525.    these guesses; getting the wrong type of a given width will not
  526.    affect C++ name mangling because in C++ these are distinct types
  527.    not typedefs.  */
  528.  
  529. #ifdef UINT_LEAST16_TYPE
  530. #define CHAR16_TYPE UINT_LEAST16_TYPE
  531. #else
  532. #define CHAR16_TYPE "short unsigned int"
  533. #endif
  534.  
  535. #ifdef UINT_LEAST32_TYPE
  536. #define CHAR32_TYPE UINT_LEAST32_TYPE
  537. #else
  538. #define CHAR32_TYPE "unsigned int"
  539. #endif
  540.  
  541. #ifndef WCHAR_TYPE
  542. #define WCHAR_TYPE "int"
  543. #endif
  544.  
  545. /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  546. #define MODIFIED_WCHAR_TYPE \
  547.         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  548.  
  549. #ifndef PTRDIFF_TYPE
  550. #define PTRDIFF_TYPE "long int"
  551. #endif
  552.  
  553. #ifndef WINT_TYPE
  554. #define WINT_TYPE "unsigned int"
  555. #endif
  556.  
  557. #ifndef INTMAX_TYPE
  558. #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  559.                      ? "int"                                    \
  560.                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  561.                         ? "long int"                            \
  562.                         : "long long int"))
  563. #endif
  564.  
  565. #ifndef UINTMAX_TYPE
  566. #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  567.                      ? "unsigned int"                           \
  568.                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  569.                         ? "long unsigned int"                   \
  570.                         : "long long unsigned int"))
  571. #endif
  572.  
  573.  
  574. /* There are no default definitions of these <stdint.h> types.  */
  575.  
  576. #ifndef SIG_ATOMIC_TYPE
  577. #define SIG_ATOMIC_TYPE ((const char *) NULL)
  578. #endif
  579.  
  580. #ifndef INT8_TYPE
  581. #define INT8_TYPE ((const char *) NULL)
  582. #endif
  583.  
  584. #ifndef INT16_TYPE
  585. #define INT16_TYPE ((const char *) NULL)
  586. #endif
  587.  
  588. #ifndef INT32_TYPE
  589. #define INT32_TYPE ((const char *) NULL)
  590. #endif
  591.  
  592. #ifndef INT64_TYPE
  593. #define INT64_TYPE ((const char *) NULL)
  594. #endif
  595.  
  596. #ifndef UINT8_TYPE
  597. #define UINT8_TYPE ((const char *) NULL)
  598. #endif
  599.  
  600. #ifndef UINT16_TYPE
  601. #define UINT16_TYPE ((const char *) NULL)
  602. #endif
  603.  
  604. #ifndef UINT32_TYPE
  605. #define UINT32_TYPE ((const char *) NULL)
  606. #endif
  607.  
  608. #ifndef UINT64_TYPE
  609. #define UINT64_TYPE ((const char *) NULL)
  610. #endif
  611.  
  612. #ifndef INT_LEAST8_TYPE
  613. #define INT_LEAST8_TYPE ((const char *) NULL)
  614. #endif
  615.  
  616. #ifndef INT_LEAST16_TYPE
  617. #define INT_LEAST16_TYPE ((const char *) NULL)
  618. #endif
  619.  
  620. #ifndef INT_LEAST32_TYPE
  621. #define INT_LEAST32_TYPE ((const char *) NULL)
  622. #endif
  623.  
  624. #ifndef INT_LEAST64_TYPE
  625. #define INT_LEAST64_TYPE ((const char *) NULL)
  626. #endif
  627.  
  628. #ifndef UINT_LEAST8_TYPE
  629. #define UINT_LEAST8_TYPE ((const char *) NULL)
  630. #endif
  631.  
  632. #ifndef UINT_LEAST16_TYPE
  633. #define UINT_LEAST16_TYPE ((const char *) NULL)
  634. #endif
  635.  
  636. #ifndef UINT_LEAST32_TYPE
  637. #define UINT_LEAST32_TYPE ((const char *) NULL)
  638. #endif
  639.  
  640. #ifndef UINT_LEAST64_TYPE
  641. #define UINT_LEAST64_TYPE ((const char *) NULL)
  642. #endif
  643.  
  644. #ifndef INT_FAST8_TYPE
  645. #define INT_FAST8_TYPE ((const char *) NULL)
  646. #endif
  647.  
  648. #ifndef INT_FAST16_TYPE
  649. #define INT_FAST16_TYPE ((const char *) NULL)
  650. #endif
  651.  
  652. #ifndef INT_FAST32_TYPE
  653. #define INT_FAST32_TYPE ((const char *) NULL)
  654. #endif
  655.  
  656. #ifndef INT_FAST64_TYPE
  657. #define INT_FAST64_TYPE ((const char *) NULL)
  658. #endif
  659.  
  660. #ifndef UINT_FAST8_TYPE
  661. #define UINT_FAST8_TYPE ((const char *) NULL)
  662. #endif
  663.  
  664. #ifndef UINT_FAST16_TYPE
  665. #define UINT_FAST16_TYPE ((const char *) NULL)
  666. #endif
  667.  
  668. #ifndef UINT_FAST32_TYPE
  669. #define UINT_FAST32_TYPE ((const char *) NULL)
  670. #endif
  671.  
  672. #ifndef UINT_FAST64_TYPE
  673. #define UINT_FAST64_TYPE ((const char *) NULL)
  674. #endif
  675.  
  676. #ifndef INTPTR_TYPE
  677. #define INTPTR_TYPE ((const char *) NULL)
  678. #endif
  679.  
  680. #ifndef UINTPTR_TYPE
  681. #define UINTPTR_TYPE ((const char *) NULL)
  682. #endif
  683.  
  684. /* Width in bits of a pointer.  Mind the value of the macro `Pmode'.  */
  685. #ifndef POINTER_SIZE
  686. #define POINTER_SIZE BITS_PER_WORD
  687. #endif
  688.  
  689. #ifndef PIC_OFFSET_TABLE_REGNUM
  690. #define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM
  691. #endif
  692.  
  693. #ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES
  694. #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0
  695. #endif
  696.  
  697. #ifndef TARGET_DECLSPEC
  698. #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
  699. /* If the target supports the "dllimport" attribute, users are
  700.    probably used to the "__declspec" syntax.  */
  701. #define TARGET_DECLSPEC 1
  702. #else
  703. #define TARGET_DECLSPEC 0
  704. #endif
  705. #endif
  706.  
  707. /* By default, the preprocessor should be invoked the same way in C++
  708.    as in C.  */
  709. #ifndef CPLUSPLUS_CPP_SPEC
  710. #ifdef CPP_SPEC
  711. #define CPLUSPLUS_CPP_SPEC CPP_SPEC
  712. #endif
  713. #endif
  714.  
  715. #ifndef ACCUMULATE_OUTGOING_ARGS
  716. #define ACCUMULATE_OUTGOING_ARGS 0
  717. #endif
  718.  
  719. /* Supply a default definition for PUSH_ARGS.  */
  720. #ifndef PUSH_ARGS
  721. #ifdef PUSH_ROUNDING
  722. #define PUSH_ARGS       !ACCUMULATE_OUTGOING_ARGS
  723. #else
  724. #define PUSH_ARGS       0
  725. #endif
  726. #endif
  727.  
  728. /* Decide whether a function's arguments should be processed
  729.    from first to last or from last to first.
  730.  
  731.    They should if the stack and args grow in opposite directions, but
  732.    only if we have push insns.  */
  733.  
  734. #ifdef PUSH_ROUNDING
  735.  
  736. #ifndef PUSH_ARGS_REVERSED
  737. #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
  738. #define PUSH_ARGS_REVERSED  PUSH_ARGS
  739. #endif
  740. #endif
  741.  
  742. #endif
  743.  
  744. #ifndef PUSH_ARGS_REVERSED
  745. #define PUSH_ARGS_REVERSED 0
  746. #endif
  747.  
  748. /* Default value for the alignment (in bits) a C conformant malloc has to
  749.    provide. This default is intended to be safe and always correct.  */
  750. #ifndef MALLOC_ABI_ALIGNMENT
  751. #define MALLOC_ABI_ALIGNMENT BITS_PER_WORD
  752. #endif
  753.  
  754. /* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY.
  755.    STACK_BOUNDARY is required.  */
  756. #ifndef PREFERRED_STACK_BOUNDARY
  757. #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
  758. #endif
  759.  
  760. /* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not
  761.    defined.  */
  762. #ifndef INCOMING_STACK_BOUNDARY
  763. #define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY
  764. #endif
  765.  
  766. #ifndef TARGET_DEFAULT_PACK_STRUCT
  767. #define TARGET_DEFAULT_PACK_STRUCT 0
  768. #endif
  769.  
  770. /* By default, the C++ compiler will use function addresses in the
  771.    vtable entries.  Setting this nonzero tells the compiler to use
  772.    function descriptors instead.  The value of this macro says how
  773.    many words wide the descriptor is (normally 2).  It is assumed
  774.    that the address of a function descriptor may be treated as a
  775.    pointer to a function.  */
  776. #ifndef TARGET_VTABLE_USES_DESCRIPTORS
  777. #define TARGET_VTABLE_USES_DESCRIPTORS 0
  778. #endif
  779.  
  780. /* By default, the vtable entries are void pointers, the so the alignment
  781.    is the same as pointer alignment.  The value of this macro specifies
  782.    the alignment of the vtable entry in bits.  It should be defined only
  783.    when special alignment is necessary.  */
  784. #ifndef TARGET_VTABLE_ENTRY_ALIGN
  785. #define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE
  786. #endif
  787.  
  788. /* There are a few non-descriptor entries in the vtable at offsets below
  789.    zero.  If these entries must be padded (say, to preserve the alignment
  790.    specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of
  791.    words in each data entry.  */
  792. #ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE
  793. #define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1
  794. #endif
  795.  
  796. /* Decide whether it is safe to use a local alias for a virtual function
  797.    when constructing thunks.  */
  798. #ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P
  799. #ifdef ASM_OUTPUT_DEF
  800. #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1
  801. #else
  802. #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0
  803. #endif
  804. #endif
  805.  
  806. /* Select a format to encode pointers in exception handling data.  We
  807.    prefer those that result in fewer dynamic relocations.  Assume no
  808.    special support here and encode direct references.  */
  809. #ifndef ASM_PREFERRED_EH_DATA_FORMAT
  810. #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL)  DW_EH_PE_absptr
  811. #endif
  812.  
  813. /* By default, the C++ compiler will use the lowest bit of the pointer
  814.    to function to indicate a pointer-to-member-function points to a
  815.    virtual member function.  However, if FUNCTION_BOUNDARY indicates
  816.    function addresses aren't always even, the lowest bit of the delta
  817.    field will be used.  */
  818. #ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION
  819. #define TARGET_PTRMEMFUNC_VBIT_LOCATION \
  820.   (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \
  821.    ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta)
  822. #endif
  823.  
  824. #ifndef DEFAULT_GDB_EXTENSIONS
  825. #define DEFAULT_GDB_EXTENSIONS 1
  826. #endif
  827.  
  828. /* If more than one debugging type is supported, you must define
  829.    PREFERRED_DEBUGGING_TYPE to choose the default.  */
  830.  
  831. #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \
  832.          + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \
  833.          + defined (VMS_DEBUGGING_INFO))
  834. #ifndef PREFERRED_DEBUGGING_TYPE
  835. #error You must define PREFERRED_DEBUGGING_TYPE
  836. #endif /* no PREFERRED_DEBUGGING_TYPE */
  837.  
  838. /* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE
  839.    here so other code needn't care.  */
  840. #elif defined DBX_DEBUGGING_INFO
  841. #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
  842.  
  843. #elif defined SDB_DEBUGGING_INFO
  844. #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
  845.  
  846. #elif defined DWARF2_DEBUGGING_INFO
  847. #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
  848.  
  849. #elif defined VMS_DEBUGGING_INFO
  850. #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
  851.  
  852. #elif defined XCOFF_DEBUGGING_INFO
  853. #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
  854.  
  855. #else
  856. /* No debugging format is supported by this target.  */
  857. #define PREFERRED_DEBUGGING_TYPE NO_DEBUG
  858. #endif
  859.  
  860. #ifndef LARGEST_EXPONENT_IS_NORMAL
  861. #define LARGEST_EXPONENT_IS_NORMAL(SIZE) 0
  862. #endif
  863.  
  864. #ifndef ROUND_TOWARDS_ZERO
  865. #define ROUND_TOWARDS_ZERO 0
  866. #endif
  867.  
  868. #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL
  869. #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false
  870. #endif
  871.  
  872. /* True if the targets integer-comparison functions return { 0, 1, 2
  873.    } to indicate { <, ==, > }.  False if { -1, 0, 1 } is used
  874.    instead.  The libgcc routines are biased.  */
  875. #ifndef TARGET_LIB_INT_CMP_BIASED
  876. #define TARGET_LIB_INT_CMP_BIASED (true)
  877. #endif
  878.  
  879. /* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files,
  880.    then the word-endianness is the same as for integers.  */
  881. #ifndef FLOAT_WORDS_BIG_ENDIAN
  882. #define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
  883. #endif
  884.  
  885. #ifdef TARGET_FLT_EVAL_METHOD
  886. #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 1
  887. #else
  888. #define TARGET_FLT_EVAL_METHOD 0
  889. #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 0
  890. #endif
  891.  
  892. #ifndef TARGET_DEC_EVAL_METHOD
  893. #define TARGET_DEC_EVAL_METHOD 2
  894. #endif
  895.  
  896. #ifndef HOT_TEXT_SECTION_NAME
  897. #define HOT_TEXT_SECTION_NAME ".text.hot"
  898. #endif
  899.  
  900. #ifndef UNLIKELY_EXECUTED_TEXT_SECTION_NAME
  901. #define UNLIKELY_EXECUTED_TEXT_SECTION_NAME ".text.unlikely"
  902. #endif
  903.  
  904. #ifndef HAS_LONG_COND_BRANCH
  905. #define HAS_LONG_COND_BRANCH 0
  906. #endif
  907.  
  908. #ifndef HAS_LONG_UNCOND_BRANCH
  909. #define HAS_LONG_UNCOND_BRANCH 0
  910. #endif
  911.  
  912. /* By default, only attempt to parallelize bitwise operations, and
  913.    possibly adds/subtracts using bit-twiddling.  */
  914. #ifndef UNITS_PER_SIMD_WORD
  915. #define UNITS_PER_SIMD_WORD(MODE) UNITS_PER_WORD
  916. #endif
  917.  
  918. /* Determine whether __cxa_atexit, rather than atexit, is used to
  919.    register C++ destructors for local statics and global objects.  */
  920. #ifndef DEFAULT_USE_CXA_ATEXIT
  921. #define DEFAULT_USE_CXA_ATEXIT 0
  922. #endif
  923.  
  924. /* If none of these macros are defined, the port must use the new
  925.    technique of defining constraints in the machine description.
  926.    tm_p.h will define those macros that machine-independent code
  927.    still uses.  */
  928. #if  !defined CONSTRAINT_LEN                    \
  929.   && !defined REG_CLASS_FROM_LETTER             \
  930.   && !defined REG_CLASS_FROM_CONSTRAINT         \
  931.   && !defined CONST_OK_FOR_LETTER_P             \
  932.   && !defined CONST_OK_FOR_CONSTRAINT_P         \
  933.   && !defined CONST_DOUBLE_OK_FOR_LETTER_P      \
  934.   && !defined CONST_DOUBLE_OK_FOR_CONSTRAINT_P  \
  935.   && !defined EXTRA_CONSTRAINT                  \
  936.   && !defined EXTRA_CONSTRAINT_STR              \
  937.   && !defined EXTRA_MEMORY_CONSTRAINT           \
  938.   && !defined EXTRA_ADDRESS_CONSTRAINT
  939.  
  940. #define USE_MD_CONSTRAINTS
  941.  
  942. #if GCC_VERSION >= 3000 && defined IN_GCC
  943. /* These old constraint macros shouldn't appear anywhere in a
  944.    configuration using MD constraint definitions.  */
  945. #pragma GCC poison REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P \
  946.                    CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT
  947. #endif
  948.  
  949. #else /* old constraint mechanism in use */
  950.  
  951. /* Determine whether extra constraint letter should be handled
  952.    via address reload (like 'o').  */
  953. #ifndef EXTRA_MEMORY_CONSTRAINT
  954. #define EXTRA_MEMORY_CONSTRAINT(C,STR) 0
  955. #endif
  956.  
  957. /* Determine whether extra constraint letter should be handled
  958.    as an address (like 'p').  */
  959. #ifndef EXTRA_ADDRESS_CONSTRAINT
  960. #define EXTRA_ADDRESS_CONSTRAINT(C,STR) 0
  961. #endif
  962.  
  963. /* When a port defines CONSTRAINT_LEN, it should use DEFAULT_CONSTRAINT_LEN
  964.    for all the characters that it does not want to change, so things like the
  965.   'length' of a digit in a matching constraint is an implementation detail,
  966.    and not part of the interface.  */
  967. #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
  968.  
  969. #ifndef CONSTRAINT_LEN
  970. #define CONSTRAINT_LEN(C,STR) DEFAULT_CONSTRAINT_LEN (C, STR)
  971. #endif
  972.  
  973. #if defined (CONST_OK_FOR_LETTER_P) && ! defined (CONST_OK_FOR_CONSTRAINT_P)
  974. #define CONST_OK_FOR_CONSTRAINT_P(VAL,C,STR) CONST_OK_FOR_LETTER_P (VAL, C)
  975. #endif
  976.  
  977. #if defined (CONST_DOUBLE_OK_FOR_LETTER_P) && ! defined (CONST_DOUBLE_OK_FOR_CONSTRAINT_P)
  978. #define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(OP,C,STR) \
  979.   CONST_DOUBLE_OK_FOR_LETTER_P (OP, C)
  980. #endif
  981.  
  982. #ifndef REG_CLASS_FROM_CONSTRAINT
  983. #define REG_CLASS_FROM_CONSTRAINT(C,STR) REG_CLASS_FROM_LETTER (C)
  984. #endif
  985.  
  986. #if defined (EXTRA_CONSTRAINT) && ! defined (EXTRA_CONSTRAINT_STR)
  987. #define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C)
  988. #endif
  989.  
  990. #endif /* old constraint mechanism in use */
  991.  
  992. #ifndef REGISTER_MOVE_COST
  993. #define REGISTER_MOVE_COST(m, x, y) 2
  994. #endif
  995.  
  996. /* Determine whether the entire c99 runtime
  997.    is present in the runtime library.  */
  998. #ifndef TARGET_C99_FUNCTIONS
  999. #define TARGET_C99_FUNCTIONS 0
  1000. #endif
  1001.  
  1002. /* Determine whether the target runtime library has
  1003.    a sincos implementation following the GNU extension.  */
  1004. #ifndef TARGET_HAS_SINCOS
  1005. #define TARGET_HAS_SINCOS 0
  1006. #endif
  1007.  
  1008. /* Indicate that CLZ and CTZ are undefined at zero.  */
  1009. #ifndef CLZ_DEFINED_VALUE_AT_ZERO
  1010. #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)  0
  1011. #endif
  1012. #ifndef CTZ_DEFINED_VALUE_AT_ZERO
  1013. #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)  0
  1014. #endif
  1015.  
  1016. /* Provide a default value for STORE_FLAG_VALUE.  */
  1017. #ifndef STORE_FLAG_VALUE
  1018. #define STORE_FLAG_VALUE  1
  1019. #endif
  1020.  
  1021. /* This macro is used to determine what the largest unit size that
  1022.    move_by_pieces can use is.  */
  1023.  
  1024. /* MOVE_MAX_PIECES is the number of bytes at a time which we can
  1025.    move efficiently, as opposed to  MOVE_MAX which is the maximum
  1026.    number of bytes we can move with a single instruction.  */
  1027.  
  1028. #ifndef MOVE_MAX_PIECES
  1029. #define MOVE_MAX_PIECES   MOVE_MAX
  1030. #endif
  1031.  
  1032. #ifndef STACK_POINTER_OFFSET
  1033. #define STACK_POINTER_OFFSET    0
  1034. #endif
  1035.  
  1036. #ifndef LOCAL_REGNO
  1037. #define LOCAL_REGNO(REGNO)  0
  1038. #endif
  1039.  
  1040. /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
  1041.    the stack pointer does not matter.  The value is tested only in
  1042.    functions that have frame pointers.  */
  1043. #ifndef EXIT_IGNORE_STACK
  1044. #define EXIT_IGNORE_STACK 0
  1045. #endif
  1046.  
  1047. /* Assume that case vectors are not pc-relative.  */
  1048. #ifndef CASE_VECTOR_PC_RELATIVE
  1049. #define CASE_VECTOR_PC_RELATIVE 0
  1050. #endif
  1051.  
  1052. /* Assume that trampolines need function alignment.  */
  1053. #ifndef TRAMPOLINE_ALIGNMENT
  1054. #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
  1055. #endif
  1056.  
  1057. /* Register mappings for target machines without register windows.  */
  1058. #ifndef INCOMING_REGNO
  1059. #define INCOMING_REGNO(N) (N)
  1060. #endif
  1061.  
  1062. #ifndef OUTGOING_REGNO
  1063. #define OUTGOING_REGNO(N) (N)
  1064. #endif
  1065.  
  1066. #ifndef SHIFT_COUNT_TRUNCATED
  1067. #define SHIFT_COUNT_TRUNCATED 0
  1068. #endif
  1069.  
  1070. #ifndef LEGITIMATE_PIC_OPERAND_P
  1071. #define LEGITIMATE_PIC_OPERAND_P(X) 1
  1072. #endif
  1073.  
  1074. #ifndef TARGET_MEM_CONSTRAINT
  1075. #define TARGET_MEM_CONSTRAINT 'm'
  1076. #endif
  1077.  
  1078. #ifndef REVERSIBLE_CC_MODE
  1079. #define REVERSIBLE_CC_MODE(MODE) 0
  1080. #endif
  1081.  
  1082. /* Biggest alignment supported by the object file format of this machine.  */
  1083. #ifndef MAX_OFILE_ALIGNMENT
  1084. #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
  1085. #endif
  1086.  
  1087. #ifndef FRAME_GROWS_DOWNWARD
  1088. #define FRAME_GROWS_DOWNWARD 0
  1089. #endif
  1090.  
  1091. /* On most machines, the CFA coincides with the first incoming parm.  */
  1092. #ifndef ARG_POINTER_CFA_OFFSET
  1093. #define ARG_POINTER_CFA_OFFSET(FNDECL) \
  1094.   (FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size)
  1095. #endif
  1096.  
  1097. /* On most machines, we use the CFA as DW_AT_frame_base.  */
  1098. #ifndef CFA_FRAME_BASE_OFFSET
  1099. #define CFA_FRAME_BASE_OFFSET(FNDECL) 0
  1100. #endif
  1101.  
  1102. /* The offset from the incoming value of %sp to the top of the stack frame
  1103.    for the current function.  */
  1104. #ifndef INCOMING_FRAME_SP_OFFSET
  1105. #define INCOMING_FRAME_SP_OFFSET 0
  1106. #endif
  1107.  
  1108. #ifndef HARD_REGNO_NREGS_HAS_PADDING
  1109. #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0
  1110. #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1
  1111. #endif
  1112.  
  1113. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  1114. #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0
  1115. #endif
  1116.  
  1117. /* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by
  1118.    the backend.  MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best
  1119.    effort stack alignment supported by the backend.  If the backend
  1120.    supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and
  1121.    MAX_STACK_ALIGNMENT are the same.  Otherwise, the incoming stack
  1122.    boundary will limit the maximum guaranteed stack alignment.  */
  1123. #ifdef MAX_STACK_ALIGNMENT
  1124. #define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT
  1125. #else
  1126. #define MAX_STACK_ALIGNMENT STACK_BOUNDARY
  1127. #define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY
  1128. #endif
  1129.  
  1130. #define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY)
  1131.  
  1132. #ifndef LOCAL_ALIGNMENT
  1133. #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
  1134. #endif
  1135.  
  1136. #ifndef STACK_SLOT_ALIGNMENT
  1137. #define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \
  1138.   ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN))
  1139. #endif
  1140.  
  1141. #ifndef LOCAL_DECL_ALIGNMENT
  1142. #define LOCAL_DECL_ALIGNMENT(DECL) \
  1143.   LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL))
  1144. #endif
  1145.  
  1146. #ifndef MINIMUM_ALIGNMENT
  1147. #define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN)
  1148. #endif
  1149.  
  1150. /* Alignment value for attribute ((aligned)).  */
  1151. #ifndef ATTRIBUTE_ALIGNED_VALUE
  1152. #define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT
  1153. #endif
  1154.  
  1155. /* Many ports have no mode-dependent addresses (except possibly autoincrement
  1156.    and autodecrement addresses, which are handled by target-independent code
  1157.    in recog.c).  */
  1158. #ifndef GO_IF_MODE_DEPENDENT_ADDRESS
  1159. #define GO_IF_MODE_DEPENDENT_ADDRESS(X, WIN)
  1160. #endif
  1161.  
  1162. /* For most ports anything that evaluates to a constant symbolic
  1163.    or integer value is acceptable as a constant address.  */
  1164. #ifndef CONSTANT_ADDRESS_P
  1165. #define CONSTANT_ADDRESS_P(X)   (CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE)
  1166. #endif
  1167.  
  1168. #endif  /* ! GCC_DEFAULTS_H */
  1169.