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-2015 Free Software Foundation, Inc.
  3.    Contributed by Ron Guilmette (rfg@monkeys.com)
  4.  
  5. This file is part of GCC.
  6.  
  7. GCC is free software; you can redistribute it and/or modify it under
  8. the terms of the GNU General Public License as published by the Free
  9. Software Foundation; either version 3, or (at your option) any later
  10. version.
  11.  
  12. GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. Under Section 7 of GPL version 3, you are granted additional
  18. permissions described in the GCC Runtime Library Exception, version
  19. 3.1, as published by the Free Software Foundation.
  20.  
  21. You should have received a copy of the GNU General Public License and
  22. a copy of the GCC Runtime Library Exception along with this program;
  23. see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24. <http://www.gnu.org/licenses/>.  */
  25.  
  26. #ifndef GCC_DEFAULTS_H
  27. #define GCC_DEFAULTS_H
  28.  
  29. /* How to start an assembler comment.  */
  30. #ifndef ASM_COMMENT_START
  31. #define ASM_COMMENT_START ";#"
  32. #endif
  33.  
  34. /* Store in OUTPUT a string (made with alloca) containing an
  35.    assembler-name for a local static variable or function named NAME.
  36.    LABELNO is an integer which is different for each call.  */
  37.  
  38. #ifndef ASM_PN_FORMAT
  39. # ifndef NO_DOT_IN_LABEL
  40. #  define ASM_PN_FORMAT "%s.%lu"
  41. # else
  42. #  ifndef NO_DOLLAR_IN_LABEL
  43. #   define ASM_PN_FORMAT "%s$%lu"
  44. #  else
  45. #   define ASM_PN_FORMAT "__%s_%lu"
  46. #  endif
  47. # endif
  48. #endif /* ! ASM_PN_FORMAT */
  49.  
  50. #ifndef ASM_FORMAT_PRIVATE_NAME
  51. # define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
  52.   do { const char *const name_ = (NAME); \
  53.        char *const output_ = (OUTPUT) = \
  54.          (char *) alloca (strlen (name_) + 32); \
  55.        sprintf (output_, ASM_PN_FORMAT, name_, (unsigned long)(LABELNO)); \
  56.   } while (0)
  57. #endif
  58.  
  59. /* Choose a reasonable default for ASM_OUTPUT_ASCII.  */
  60.  
  61. #ifndef ASM_OUTPUT_ASCII
  62. #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
  63.   do {                                                                        \
  64.     FILE *_hide_asm_out_file = (MYFILE);                                      \
  65.     const unsigned char *_hide_p = (const unsigned char *) (MYSTRING);        \
  66.     int _hide_thissize = (MYLENGTH);                                          \
  67.     {                                                                         \
  68.       FILE *asm_out_file = _hide_asm_out_file;                                \
  69.       const unsigned char *p = _hide_p;                                       \
  70.       int thissize = _hide_thissize;                                          \
  71.       int i;                                                                  \
  72.       fprintf (asm_out_file, "\t.ascii \"");                                  \
  73.                                                                               \
  74.       for (i = 0; i < thissize; i++)                                          \
  75.         {                                                                     \
  76.           int c = p[i];                                                       \
  77.           if (c == '\"' || c == '\\')                                         \
  78.             putc ('\\', asm_out_file);                                        \
  79.           if (ISPRINT (c))                                                    \
  80.             putc (c, asm_out_file);                                           \
  81.           else                                                                \
  82.             {                                                                 \
  83.               fprintf (asm_out_file, "\\%o", c);                              \
  84.               /* After an octal-escape, if a digit follows,                   \
  85.                  terminate one string constant and start another.             \
  86.                  The VAX assembler fails to stop reading the escape           \
  87.                  after three digits, so this is the only way we               \
  88.                  can get it to parse the data properly.  */                   \
  89.               if (i < thissize - 1 && ISDIGIT (p[i + 1]))                     \
  90.                 fprintf (asm_out_file, "\"\n\t.ascii \"");                    \
  91.           }                                                                   \
  92.         }                                                                     \
  93.       fprintf (asm_out_file, "\"\n");                                         \
  94.     }                                                                         \
  95.   }                                                                           \
  96.   while (0)
  97. #endif
  98.  
  99. /* This is how we tell the assembler to equate two values.  */
  100. #ifdef SET_ASM_OP
  101. #ifndef ASM_OUTPUT_DEF
  102. #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
  103.  do {   fprintf ((FILE), "%s", SET_ASM_OP);                             \
  104.         assemble_name (FILE, LABEL1);                                   \
  105.         fprintf (FILE, ",");                                            \
  106.         assemble_name (FILE, LABEL2);                                   \
  107.         fprintf (FILE, "\n");                                           \
  108.   } while (0)
  109. #endif
  110. #endif
  111.  
  112. #ifndef IFUNC_ASM_TYPE
  113. #define IFUNC_ASM_TYPE "gnu_indirect_function"
  114. #endif
  115.  
  116. #ifndef TLS_COMMON_ASM_OP
  117. #define TLS_COMMON_ASM_OP ".tls_common"
  118. #endif
  119.  
  120. #if defined (HAVE_AS_TLS) && !defined (ASM_OUTPUT_TLS_COMMON)
  121. #define ASM_OUTPUT_TLS_COMMON(FILE, DECL, NAME, SIZE)                   \
  122.   do                                                                    \
  123.     {                                                                   \
  124.       fprintf ((FILE), "\t%s\t", TLS_COMMON_ASM_OP);                    \
  125.       assemble_name ((FILE), (NAME));                                   \
  126.       fprintf ((FILE), ","HOST_WIDE_INT_PRINT_UNSIGNED",%u\n",          \
  127.                (SIZE), DECL_ALIGN (DECL) / BITS_PER_UNIT);              \
  128.     }                                                                   \
  129.   while (0)
  130. #endif
  131.  
  132. /* Decide whether to defer emitting the assembler output for an equate
  133.    of two values.  The default is to not defer output.  */
  134. #ifndef TARGET_DEFERRED_OUTPUT_DEFS
  135. #define TARGET_DEFERRED_OUTPUT_DEFS(DECL,TARGET) false
  136. #endif
  137.  
  138. /* This is how to output the definition of a user-level label named
  139.    NAME, such as the label on variable NAME.  */
  140.  
  141. #ifndef ASM_OUTPUT_LABEL
  142. #define ASM_OUTPUT_LABEL(FILE,NAME) \
  143.   do {                                          \
  144.     assemble_name ((FILE), (NAME));             \
  145.     fputs (":\n", (FILE));                      \
  146.   } while (0)
  147. #endif
  148.  
  149. /* This is how to output the definition of a user-level label named
  150.    NAME, such as the label on a function.  */
  151.  
  152. #ifndef ASM_OUTPUT_FUNCTION_LABEL
  153. #define ASM_OUTPUT_FUNCTION_LABEL(FILE, NAME, DECL) \
  154.   ASM_OUTPUT_LABEL ((FILE), (NAME))
  155. #endif
  156.  
  157. /* Output the definition of a compiler-generated label named NAME.  */
  158. #ifndef ASM_OUTPUT_INTERNAL_LABEL
  159. #define ASM_OUTPUT_INTERNAL_LABEL(FILE,NAME)    \
  160.   do {                                          \
  161.     assemble_name_raw ((FILE), (NAME));         \
  162.     fputs (":\n", (FILE));                      \
  163.   } while (0)
  164. #endif
  165.  
  166. /* This is how to output a reference to a user-level label named NAME.  */
  167.  
  168. #ifndef ASM_OUTPUT_LABELREF
  169. #define ASM_OUTPUT_LABELREF(FILE,NAME)  \
  170.   do {                                                  \
  171.     fputs (user_label_prefix, (FILE));                  \
  172.     fputs ((NAME), (FILE));                             \
  173.   } while (0);
  174. #endif
  175.  
  176. /* Allow target to print debug info labels specially.  This is useful for
  177.    VLIW targets, since debug info labels should go into the middle of
  178.    instruction bundles instead of breaking them.  */
  179.  
  180. #ifndef ASM_OUTPUT_DEBUG_LABEL
  181. #define ASM_OUTPUT_DEBUG_LABEL(FILE, PREFIX, NUM) \
  182.   (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM)
  183. #endif
  184.  
  185. /* This is how we tell the assembler that a symbol is weak.  */
  186. #ifndef ASM_OUTPUT_WEAK_ALIAS
  187. #if defined (ASM_WEAKEN_LABEL) && defined (ASM_OUTPUT_DEF)
  188. #define ASM_OUTPUT_WEAK_ALIAS(STREAM, NAME, VALUE)      \
  189.   do                                                    \
  190.     {                                                   \
  191.       ASM_WEAKEN_LABEL (STREAM, NAME);                  \
  192.       if (VALUE)                                        \
  193.         ASM_OUTPUT_DEF (STREAM, NAME, VALUE);           \
  194.     }                                                   \
  195.   while (0)
  196. #endif
  197. #endif
  198.  
  199. /* This is how we tell the assembler that a symbol is a weak alias to
  200.    another symbol that doesn't require the other symbol to be defined.
  201.    Uses of the former will turn into weak uses of the latter, i.e.,
  202.    uses that, in case the latter is undefined, will not cause errors,
  203.    and will add it to the symbol table as weak undefined.  However, if
  204.    the latter is referenced directly, a strong reference prevails.  */
  205. #ifndef ASM_OUTPUT_WEAKREF
  206. #if defined HAVE_GAS_WEAKREF
  207. #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE)                     \
  208.   do                                                                    \
  209.     {                                                                   \
  210.       fprintf ((FILE), "\t.weakref\t");                                 \
  211.       assemble_name ((FILE), (NAME));                                   \
  212.       fprintf ((FILE), ",");                                            \
  213.       assemble_name ((FILE), (VALUE));                                  \
  214.       fprintf ((FILE), "\n");                                           \
  215.     }                                                                   \
  216.   while (0)
  217. #endif
  218. #endif
  219.  
  220. /* How to emit a .type directive.  */
  221. #ifndef ASM_OUTPUT_TYPE_DIRECTIVE
  222. #if defined TYPE_ASM_OP && defined TYPE_OPERAND_FMT
  223. #define ASM_OUTPUT_TYPE_DIRECTIVE(STREAM, NAME, TYPE)   \
  224.   do                                                    \
  225.     {                                                   \
  226.       fputs (TYPE_ASM_OP, STREAM);                      \
  227.       assemble_name (STREAM, NAME);                     \
  228.       fputs (", ", STREAM);                             \
  229.       fprintf (STREAM, TYPE_OPERAND_FMT, TYPE);         \
  230.       putc ('\n', STREAM);                              \
  231.     }                                                   \
  232.   while (0)
  233. #endif
  234. #endif
  235.  
  236. /* How to emit a .size directive.  */
  237. #ifndef ASM_OUTPUT_SIZE_DIRECTIVE
  238. #ifdef SIZE_ASM_OP
  239. #define ASM_OUTPUT_SIZE_DIRECTIVE(STREAM, NAME, SIZE)   \
  240.   do                                                    \
  241.     {                                                   \
  242.       HOST_WIDE_INT size_ = (SIZE);                     \
  243.       fputs (SIZE_ASM_OP, STREAM);                      \
  244.       assemble_name (STREAM, NAME);                     \
  245.       fprintf (STREAM, ", " HOST_WIDE_INT_PRINT_DEC "\n", size_); \
  246.     }                                                   \
  247.   while (0)
  248.  
  249. #define ASM_OUTPUT_MEASURED_SIZE(STREAM, NAME)          \
  250.   do                                                    \
  251.     {                                                   \
  252.       fputs (SIZE_ASM_OP, STREAM);                      \
  253.       assemble_name (STREAM, NAME);                     \
  254.       fputs (", .-", STREAM);                           \
  255.       assemble_name (STREAM, NAME);                     \
  256.       putc ('\n', STREAM);                              \
  257.     }                                                   \
  258.   while (0)
  259.  
  260. #endif
  261. #endif
  262.  
  263. /* This determines whether or not we support weak symbols.  SUPPORTS_WEAK
  264.    must be a preprocessor constant.  */
  265. #ifndef SUPPORTS_WEAK
  266. #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
  267. #define SUPPORTS_WEAK 1
  268. #else
  269. #define SUPPORTS_WEAK 0
  270. #endif
  271. #endif
  272.  
  273. /* This determines whether or not we support weak symbols during target
  274.    code generation.  TARGET_SUPPORTS_WEAK can be any valid C expression.  */
  275. #ifndef TARGET_SUPPORTS_WEAK
  276. #define TARGET_SUPPORTS_WEAK (SUPPORTS_WEAK)
  277. #endif
  278.  
  279. /* This determines whether or not we support the discriminator
  280.    attribute in the .loc directive.  */
  281. #ifndef SUPPORTS_DISCRIMINATOR
  282. #ifdef HAVE_GAS_DISCRIMINATOR
  283. #define SUPPORTS_DISCRIMINATOR 1
  284. #else
  285. #define SUPPORTS_DISCRIMINATOR 0
  286. #endif
  287. #endif
  288.  
  289. /* This determines whether or not we support link-once semantics.  */
  290. #ifndef SUPPORTS_ONE_ONLY
  291. #ifdef MAKE_DECL_ONE_ONLY
  292. #define SUPPORTS_ONE_ONLY 1
  293. #else
  294. #define SUPPORTS_ONE_ONLY 0
  295. #endif
  296. #endif
  297.  
  298. /* This determines whether weak symbols must be left out of a static
  299.    archive's table of contents.  Defining this macro to be nonzero has
  300.    the consequence that certain symbols will not be made weak that
  301.    otherwise would be.  The C++ ABI requires this macro to be zero;
  302.    see the documentation.  */
  303. #ifndef TARGET_WEAK_NOT_IN_ARCHIVE_TOC
  304. #define TARGET_WEAK_NOT_IN_ARCHIVE_TOC 0
  305. #endif
  306.  
  307. /* This determines whether or not we need linkonce unwind information.  */
  308. #ifndef TARGET_USES_WEAK_UNWIND_INFO
  309. #define TARGET_USES_WEAK_UNWIND_INFO 0
  310. #endif
  311.  
  312. /* By default, there is no prefix on user-defined symbols.  */
  313. #ifndef USER_LABEL_PREFIX
  314. #define USER_LABEL_PREFIX ""
  315. #endif
  316.  
  317. /* If the target supports weak symbols, define TARGET_ATTRIBUTE_WEAK to
  318.    provide a weak attribute.  Else define it to nothing.
  319.  
  320.    This would normally belong in ansidecl.h, but SUPPORTS_WEAK is
  321.    not available at that time.
  322.  
  323.    Note, this is only for use by target files which we know are to be
  324.    compiled by GCC.  */
  325. #ifndef TARGET_ATTRIBUTE_WEAK
  326. # if SUPPORTS_WEAK
  327. #  define TARGET_ATTRIBUTE_WEAK __attribute__ ((weak))
  328. # else
  329. #  define TARGET_ATTRIBUTE_WEAK
  330. # endif
  331. #endif
  332.  
  333. /* By default we can assume that all global symbols are in one namespace,
  334.    across all shared libraries.  */
  335. #ifndef MULTIPLE_SYMBOL_SPACES
  336. # define MULTIPLE_SYMBOL_SPACES 0
  337. #endif
  338.  
  339. /* If the target supports init_priority C++ attribute, give
  340.    SUPPORTS_INIT_PRIORITY a nonzero value.  */
  341. #ifndef SUPPORTS_INIT_PRIORITY
  342. #define SUPPORTS_INIT_PRIORITY 1
  343. #endif /* SUPPORTS_INIT_PRIORITY */
  344.  
  345. /* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that
  346.    the rest of the DWARF 2 frame unwind support is also provided.  */
  347. #if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX)
  348. #define DWARF2_UNWIND_INFO 1
  349. #endif
  350.  
  351. /* If we have named sections, and we're using crtstuff to run ctors,
  352.    use them for registering eh frame information.  */
  353. #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \
  354.     && !defined (EH_FRAME_IN_DATA_SECTION)
  355. #ifndef EH_FRAME_SECTION_NAME
  356. #define EH_FRAME_SECTION_NAME ".eh_frame"
  357. #endif
  358. #endif
  359.  
  360. /* On many systems, different EH table encodings are used under
  361.    difference circumstances.  Some will require runtime relocations;
  362.    some will not.  For those that do not require runtime relocations,
  363.    we would like to make the table read-only.  However, since the
  364.    read-only tables may need to be combined with read-write tables
  365.    that do require runtime relocation, it is not safe to make the
  366.    tables read-only unless the linker will merge read-only and
  367.    read-write sections into a single read-write section.  If your
  368.    linker does not have this ability, but your system is such that no
  369.    encoding used with non-PIC code will ever require a runtime
  370.    relocation, then you can define EH_TABLES_CAN_BE_READ_ONLY to 1 in
  371.    your target configuration file.  */
  372. #ifndef EH_TABLES_CAN_BE_READ_ONLY
  373. #ifdef HAVE_LD_RO_RW_SECTION_MIXING
  374. #define EH_TABLES_CAN_BE_READ_ONLY 1
  375. #else
  376. #define EH_TABLES_CAN_BE_READ_ONLY 0
  377. #endif
  378. #endif
  379.  
  380. /* If we have named section and we support weak symbols, then use the
  381.    .jcr section for recording java classes which need to be registered
  382.    at program start-up time.  */
  383. #if defined (TARGET_ASM_NAMED_SECTION) && SUPPORTS_WEAK
  384. #ifndef JCR_SECTION_NAME
  385. #define JCR_SECTION_NAME ".jcr"
  386. #endif
  387. #endif
  388.  
  389. /* This decision to use a .jcr section can be overridden by defining
  390.    USE_JCR_SECTION to 0 in target file.  This is necessary if target
  391.    can define JCR_SECTION_NAME but does not have crtstuff or
  392.    linker support for .jcr section.  */
  393. #ifndef TARGET_USE_JCR_SECTION
  394. #ifdef JCR_SECTION_NAME
  395. #define TARGET_USE_JCR_SECTION 1
  396. #else
  397. #define TARGET_USE_JCR_SECTION 0
  398. #endif
  399. #endif
  400.  
  401. /* Number of hardware registers that go into the DWARF-2 unwind info.
  402.    If not defined, equals FIRST_PSEUDO_REGISTER  */
  403.  
  404. #ifndef DWARF_FRAME_REGISTERS
  405. #define DWARF_FRAME_REGISTERS FIRST_PSEUDO_REGISTER
  406. #endif
  407.  
  408. /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
  409. #ifndef DWARF_CIE_DATA_ALIGNMENT
  410. #ifdef STACK_GROWS_DOWNWARD
  411. #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
  412. #else
  413. #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
  414. #endif
  415. #endif
  416.  
  417. /* The DWARF 2 CFA column which tracks the return address.  Normally this
  418.    is the column for PC, or the first column after all of the hard
  419.    registers.  */
  420. #ifndef DWARF_FRAME_RETURN_COLUMN
  421. #ifdef PC_REGNUM
  422. #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGNUM (PC_REGNUM)
  423. #else
  424. #define DWARF_FRAME_RETURN_COLUMN       DWARF_FRAME_REGISTERS
  425. #endif
  426. #endif
  427.  
  428. /* How to renumber registers for dbx and gdb.  If not defined, assume
  429.    no renumbering is necessary.  */
  430.  
  431. #ifndef DBX_REGISTER_NUMBER
  432. #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
  433. #endif
  434.  
  435. /* The mapping from gcc register number to DWARF 2 CFA column number.
  436.    By default, we just provide columns for all registers.  */
  437. #ifndef DWARF_FRAME_REGNUM
  438. #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
  439. #endif
  440.  
  441. /* The mapping from dwarf CFA reg number to internal dwarf reg numbers.  */
  442. #ifndef DWARF_REG_TO_UNWIND_COLUMN
  443. #define DWARF_REG_TO_UNWIND_COLUMN(REGNO) (REGNO)
  444. #endif
  445.  
  446. /* Map register numbers held in the call frame info that gcc has
  447.    collected using DWARF_FRAME_REGNUM to those that should be output in
  448.    .debug_frame and .eh_frame.  */
  449. #ifndef DWARF2_FRAME_REG_OUT
  450. #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
  451. #endif
  452.  
  453. /* The size of addresses as they appear in the Dwarf 2 data.
  454.    Some architectures use word addresses to refer to code locations,
  455.    but Dwarf 2 info always uses byte addresses.  On such machines,
  456.    Dwarf 2 addresses need to be larger than the architecture's
  457.    pointers.  */
  458. #ifndef DWARF2_ADDR_SIZE
  459. #define DWARF2_ADDR_SIZE ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT)
  460. #endif
  461.  
  462. /* The size in bytes of a DWARF field indicating an offset or length
  463.    relative to a debug info section, specified to be 4 bytes in the
  464.    DWARF-2 specification.  The SGI/MIPS ABI defines it to be the same
  465.    as PTR_SIZE.  */
  466. #ifndef DWARF_OFFSET_SIZE
  467. #define DWARF_OFFSET_SIZE 4
  468. #endif
  469.  
  470. /* The size in bytes of a DWARF 4 type signature.  */
  471. #ifndef DWARF_TYPE_SIGNATURE_SIZE
  472. #define DWARF_TYPE_SIGNATURE_SIZE 8
  473. #endif
  474.  
  475. /* Default sizes for base C types.  If the sizes are different for
  476.    your target, you should override these values by defining the
  477.    appropriate symbols in your tm.h file.  */
  478.  
  479. #if BITS_PER_UNIT == 8
  480. #define LOG2_BITS_PER_UNIT 3
  481. #elif BITS_PER_UNIT == 16
  482. #define LOG2_BITS_PER_UNIT 4
  483. #else
  484. #error Unknown BITS_PER_UNIT
  485. #endif
  486.  
  487. #ifndef BITS_PER_WORD
  488. #define BITS_PER_WORD (BITS_PER_UNIT * UNITS_PER_WORD)
  489. #endif
  490.  
  491. #ifndef CHAR_TYPE_SIZE
  492. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  493. #endif
  494.  
  495. #ifndef BOOL_TYPE_SIZE
  496. /* `bool' has size and alignment `1', on almost all platforms.  */
  497. #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
  498. #endif
  499.  
  500. #ifndef SHORT_TYPE_SIZE
  501. #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
  502. #endif
  503.  
  504. #ifndef INT_TYPE_SIZE
  505. #define INT_TYPE_SIZE BITS_PER_WORD
  506. #endif
  507.  
  508. #ifndef LONG_TYPE_SIZE
  509. #define LONG_TYPE_SIZE BITS_PER_WORD
  510. #endif
  511.  
  512. #ifndef LONG_LONG_TYPE_SIZE
  513. #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
  514. #endif
  515.  
  516. #ifndef WCHAR_TYPE_SIZE
  517. #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  518. #endif
  519.  
  520. #ifndef FLOAT_TYPE_SIZE
  521. #define FLOAT_TYPE_SIZE BITS_PER_WORD
  522. #endif
  523.  
  524. #ifndef DOUBLE_TYPE_SIZE
  525. #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
  526. #endif
  527.  
  528. #ifndef LONG_DOUBLE_TYPE_SIZE
  529. #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
  530. #endif
  531.  
  532. #ifndef DECIMAL32_TYPE_SIZE
  533. #define DECIMAL32_TYPE_SIZE 32
  534. #endif
  535.  
  536. #ifndef DECIMAL64_TYPE_SIZE
  537. #define DECIMAL64_TYPE_SIZE 64
  538. #endif
  539.  
  540. #ifndef DECIMAL128_TYPE_SIZE
  541. #define DECIMAL128_TYPE_SIZE 128
  542. #endif
  543.  
  544. #ifndef SHORT_FRACT_TYPE_SIZE
  545. #define SHORT_FRACT_TYPE_SIZE BITS_PER_UNIT
  546. #endif
  547.  
  548. #ifndef FRACT_TYPE_SIZE
  549. #define FRACT_TYPE_SIZE (BITS_PER_UNIT * 2)
  550. #endif
  551.  
  552. #ifndef LONG_FRACT_TYPE_SIZE
  553. #define LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 4)
  554. #endif
  555.  
  556. #ifndef LONG_LONG_FRACT_TYPE_SIZE
  557. #define LONG_LONG_FRACT_TYPE_SIZE (BITS_PER_UNIT * 8)
  558. #endif
  559.  
  560. #ifndef SHORT_ACCUM_TYPE_SIZE
  561. #define SHORT_ACCUM_TYPE_SIZE (SHORT_FRACT_TYPE_SIZE * 2)
  562. #endif
  563.  
  564. #ifndef ACCUM_TYPE_SIZE
  565. #define ACCUM_TYPE_SIZE (FRACT_TYPE_SIZE * 2)
  566. #endif
  567.  
  568. #ifndef LONG_ACCUM_TYPE_SIZE
  569. #define LONG_ACCUM_TYPE_SIZE (LONG_FRACT_TYPE_SIZE * 2)
  570. #endif
  571.  
  572. #ifndef LONG_LONG_ACCUM_TYPE_SIZE
  573. #define LONG_LONG_ACCUM_TYPE_SIZE (LONG_LONG_FRACT_TYPE_SIZE * 2)
  574. #endif
  575.  
  576. /* We let tm.h override the types used here, to handle trivial differences
  577.    such as the choice of unsigned int or long unsigned int for size_t.
  578.    When machines start needing nontrivial differences in the size type,
  579.    it would be best to do something here to figure out automatically
  580.    from other information what type to use.  */
  581.  
  582. #ifndef SIZE_TYPE
  583. #define SIZE_TYPE "long unsigned int"
  584. #endif
  585.  
  586. #ifndef SIZETYPE
  587. #define SIZETYPE SIZE_TYPE
  588. #endif
  589.  
  590. #ifndef PID_TYPE
  591. #define PID_TYPE "int"
  592. #endif
  593.  
  594. /* If GCC knows the exact uint_least16_t and uint_least32_t types from
  595.    <stdint.h>, use them for char16_t and char32_t.  Otherwise, use
  596.    these guesses; getting the wrong type of a given width will not
  597.    affect C++ name mangling because in C++ these are distinct types
  598.    not typedefs.  */
  599.  
  600. #ifdef UINT_LEAST16_TYPE
  601. #define CHAR16_TYPE UINT_LEAST16_TYPE
  602. #else
  603. #define CHAR16_TYPE "short unsigned int"
  604. #endif
  605.  
  606. #ifdef UINT_LEAST32_TYPE
  607. #define CHAR32_TYPE UINT_LEAST32_TYPE
  608. #else
  609. #define CHAR32_TYPE "unsigned int"
  610. #endif
  611.  
  612. #ifndef WCHAR_TYPE
  613. #define WCHAR_TYPE "int"
  614. #endif
  615.  
  616. /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  617. #define MODIFIED_WCHAR_TYPE \
  618.         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  619.  
  620. #ifndef PTRDIFF_TYPE
  621. #define PTRDIFF_TYPE "long int"
  622. #endif
  623.  
  624. #ifndef WINT_TYPE
  625. #define WINT_TYPE "unsigned int"
  626. #endif
  627.  
  628. #ifndef INTMAX_TYPE
  629. #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  630.                      ? "int"                                    \
  631.                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  632.                         ? "long int"                            \
  633.                         : "long long int"))
  634. #endif
  635.  
  636. #ifndef UINTMAX_TYPE
  637. #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  638.                      ? "unsigned int"                           \
  639.                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  640.                         ? "long unsigned int"                   \
  641.                         : "long long unsigned int"))
  642. #endif
  643.  
  644.  
  645. /* There are no default definitions of these <stdint.h> types.  */
  646.  
  647. #ifndef SIG_ATOMIC_TYPE
  648. #define SIG_ATOMIC_TYPE ((const char *) NULL)
  649. #endif
  650.  
  651. #ifndef INT8_TYPE
  652. #define INT8_TYPE ((const char *) NULL)
  653. #endif
  654.  
  655. #ifndef INT16_TYPE
  656. #define INT16_TYPE ((const char *) NULL)
  657. #endif
  658.  
  659. #ifndef INT32_TYPE
  660. #define INT32_TYPE ((const char *) NULL)
  661. #endif
  662.  
  663. #ifndef INT64_TYPE
  664. #define INT64_TYPE ((const char *) NULL)
  665. #endif
  666.  
  667. #ifndef UINT8_TYPE
  668. #define UINT8_TYPE ((const char *) NULL)
  669. #endif
  670.  
  671. #ifndef UINT16_TYPE
  672. #define UINT16_TYPE ((const char *) NULL)
  673. #endif
  674.  
  675. #ifndef UINT32_TYPE
  676. #define UINT32_TYPE ((const char *) NULL)
  677. #endif
  678.  
  679. #ifndef UINT64_TYPE
  680. #define UINT64_TYPE ((const char *) NULL)
  681. #endif
  682.  
  683. #ifndef INT_LEAST8_TYPE
  684. #define INT_LEAST8_TYPE ((const char *) NULL)
  685. #endif
  686.  
  687. #ifndef INT_LEAST16_TYPE
  688. #define INT_LEAST16_TYPE ((const char *) NULL)
  689. #endif
  690.  
  691. #ifndef INT_LEAST32_TYPE
  692. #define INT_LEAST32_TYPE ((const char *) NULL)
  693. #endif
  694.  
  695. #ifndef INT_LEAST64_TYPE
  696. #define INT_LEAST64_TYPE ((const char *) NULL)
  697. #endif
  698.  
  699. #ifndef UINT_LEAST8_TYPE
  700. #define UINT_LEAST8_TYPE ((const char *) NULL)
  701. #endif
  702.  
  703. #ifndef UINT_LEAST16_TYPE
  704. #define UINT_LEAST16_TYPE ((const char *) NULL)
  705. #endif
  706.  
  707. #ifndef UINT_LEAST32_TYPE
  708. #define UINT_LEAST32_TYPE ((const char *) NULL)
  709. #endif
  710.  
  711. #ifndef UINT_LEAST64_TYPE
  712. #define UINT_LEAST64_TYPE ((const char *) NULL)
  713. #endif
  714.  
  715. #ifndef INT_FAST8_TYPE
  716. #define INT_FAST8_TYPE ((const char *) NULL)
  717. #endif
  718.  
  719. #ifndef INT_FAST16_TYPE
  720. #define INT_FAST16_TYPE ((const char *) NULL)
  721. #endif
  722.  
  723. #ifndef INT_FAST32_TYPE
  724. #define INT_FAST32_TYPE ((const char *) NULL)
  725. #endif
  726.  
  727. #ifndef INT_FAST64_TYPE
  728. #define INT_FAST64_TYPE ((const char *) NULL)
  729. #endif
  730.  
  731. #ifndef UINT_FAST8_TYPE
  732. #define UINT_FAST8_TYPE ((const char *) NULL)
  733. #endif
  734.  
  735. #ifndef UINT_FAST16_TYPE
  736. #define UINT_FAST16_TYPE ((const char *) NULL)
  737. #endif
  738.  
  739. #ifndef UINT_FAST32_TYPE
  740. #define UINT_FAST32_TYPE ((const char *) NULL)
  741. #endif
  742.  
  743. #ifndef UINT_FAST64_TYPE
  744. #define UINT_FAST64_TYPE ((const char *) NULL)
  745. #endif
  746.  
  747. #ifndef INTPTR_TYPE
  748. #define INTPTR_TYPE ((const char *) NULL)
  749. #endif
  750.  
  751. #ifndef UINTPTR_TYPE
  752. #define UINTPTR_TYPE ((const char *) NULL)
  753. #endif
  754.  
  755. /* Width in bits of a pointer.  Mind the value of the macro `Pmode'.  */
  756. #ifndef POINTER_SIZE
  757. #define POINTER_SIZE BITS_PER_WORD
  758. #endif
  759. #ifndef POINTER_SIZE_UNITS
  760. #define POINTER_SIZE_UNITS ((POINTER_SIZE + BITS_PER_UNIT - 1) / BITS_PER_UNIT)
  761. #endif
  762.  
  763.  
  764. #ifndef PIC_OFFSET_TABLE_REGNUM
  765. #define PIC_OFFSET_TABLE_REGNUM INVALID_REGNUM
  766. #endif
  767.  
  768. #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
  769. #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED 0
  770. #endif
  771.  
  772. #ifndef TARGET_DLLIMPORT_DECL_ATTRIBUTES
  773. #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 0
  774. #endif
  775.  
  776. #ifndef TARGET_DECLSPEC
  777. #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
  778. /* If the target supports the "dllimport" attribute, users are
  779.    probably used to the "__declspec" syntax.  */
  780. #define TARGET_DECLSPEC 1
  781. #else
  782. #define TARGET_DECLSPEC 0
  783. #endif
  784. #endif
  785.  
  786. /* By default, the preprocessor should be invoked the same way in C++
  787.    as in C.  */
  788. #ifndef CPLUSPLUS_CPP_SPEC
  789. #ifdef CPP_SPEC
  790. #define CPLUSPLUS_CPP_SPEC CPP_SPEC
  791. #endif
  792. #endif
  793.  
  794. #ifndef ACCUMULATE_OUTGOING_ARGS
  795. #define ACCUMULATE_OUTGOING_ARGS 0
  796. #endif
  797.  
  798. /* By default, use the GNU runtime for Objective C.  */
  799. #ifndef NEXT_OBJC_RUNTIME
  800. #define NEXT_OBJC_RUNTIME 0
  801. #endif
  802.  
  803. /* Supply a default definition for PUSH_ARGS.  */
  804. #ifndef PUSH_ARGS
  805. #ifdef PUSH_ROUNDING
  806. #define PUSH_ARGS       !ACCUMULATE_OUTGOING_ARGS
  807. #else
  808. #define PUSH_ARGS       0
  809. #endif
  810. #endif
  811.  
  812. /* Decide whether a function's arguments should be processed
  813.    from first to last or from last to first.
  814.  
  815.    They should if the stack and args grow in opposite directions, but
  816.    only if we have push insns.  */
  817.  
  818. #ifdef PUSH_ROUNDING
  819.  
  820. #ifndef PUSH_ARGS_REVERSED
  821. #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
  822. #define PUSH_ARGS_REVERSED  PUSH_ARGS
  823. #endif
  824. #endif
  825.  
  826. #endif
  827.  
  828. #ifndef PUSH_ARGS_REVERSED
  829. #define PUSH_ARGS_REVERSED 0
  830. #endif
  831.  
  832. /* Default value for the alignment (in bits) a C conformant malloc has to
  833.    provide. This default is intended to be safe and always correct.  */
  834. #ifndef MALLOC_ABI_ALIGNMENT
  835. #define MALLOC_ABI_ALIGNMENT BITS_PER_WORD
  836. #endif
  837.  
  838. /* If PREFERRED_STACK_BOUNDARY is not defined, set it to STACK_BOUNDARY.
  839.    STACK_BOUNDARY is required.  */
  840. #ifndef PREFERRED_STACK_BOUNDARY
  841. #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
  842. #endif
  843.  
  844. /* Set INCOMING_STACK_BOUNDARY to PREFERRED_STACK_BOUNDARY if it is not
  845.    defined.  */
  846. #ifndef INCOMING_STACK_BOUNDARY
  847. #define INCOMING_STACK_BOUNDARY PREFERRED_STACK_BOUNDARY
  848. #endif
  849.  
  850. #ifndef TARGET_DEFAULT_PACK_STRUCT
  851. #define TARGET_DEFAULT_PACK_STRUCT 0
  852. #endif
  853.  
  854. /* By default, the vtable entries are void pointers, the so the alignment
  855.    is the same as pointer alignment.  The value of this macro specifies
  856.    the alignment of the vtable entry in bits.  It should be defined only
  857.    when special alignment is necessary.  */
  858. #ifndef TARGET_VTABLE_ENTRY_ALIGN
  859. #define TARGET_VTABLE_ENTRY_ALIGN POINTER_SIZE
  860. #endif
  861.  
  862. /* There are a few non-descriptor entries in the vtable at offsets below
  863.    zero.  If these entries must be padded (say, to preserve the alignment
  864.    specified by TARGET_VTABLE_ENTRY_ALIGN), set this to the number of
  865.    words in each data entry.  */
  866. #ifndef TARGET_VTABLE_DATA_ENTRY_DISTANCE
  867. #define TARGET_VTABLE_DATA_ENTRY_DISTANCE 1
  868. #endif
  869.  
  870. /* Decide whether it is safe to use a local alias for a virtual function
  871.    when constructing thunks.  */
  872. #ifndef TARGET_USE_LOCAL_THUNK_ALIAS_P
  873. #ifdef ASM_OUTPUT_DEF
  874. #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 1
  875. #else
  876. #define TARGET_USE_LOCAL_THUNK_ALIAS_P(DECL) 0
  877. #endif
  878. #endif
  879.  
  880. /* Select a format to encode pointers in exception handling data.  We
  881.    prefer those that result in fewer dynamic relocations.  Assume no
  882.    special support here and encode direct references.  */
  883. #ifndef ASM_PREFERRED_EH_DATA_FORMAT
  884. #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL)  DW_EH_PE_absptr
  885. #endif
  886.  
  887. /* By default, the C++ compiler will use the lowest bit of the pointer
  888.    to function to indicate a pointer-to-member-function points to a
  889.    virtual member function.  However, if FUNCTION_BOUNDARY indicates
  890.    function addresses aren't always even, the lowest bit of the delta
  891.    field will be used.  */
  892. #ifndef TARGET_PTRMEMFUNC_VBIT_LOCATION
  893. #define TARGET_PTRMEMFUNC_VBIT_LOCATION \
  894.   (FUNCTION_BOUNDARY >= 2 * BITS_PER_UNIT \
  895.    ? ptrmemfunc_vbit_in_pfn : ptrmemfunc_vbit_in_delta)
  896. #endif
  897.  
  898. #ifndef DEFAULT_GDB_EXTENSIONS
  899. #define DEFAULT_GDB_EXTENSIONS 1
  900. #endif
  901.  
  902. /* If more than one debugging type is supported, you must define
  903.    PREFERRED_DEBUGGING_TYPE to choose the default.  */
  904.  
  905. #if 1 < (defined (DBX_DEBUGGING_INFO) + defined (SDB_DEBUGGING_INFO) \
  906.          + defined (DWARF2_DEBUGGING_INFO) + defined (XCOFF_DEBUGGING_INFO) \
  907.          + defined (VMS_DEBUGGING_INFO))
  908. #ifndef PREFERRED_DEBUGGING_TYPE
  909. #error You must define PREFERRED_DEBUGGING_TYPE
  910. #endif /* no PREFERRED_DEBUGGING_TYPE */
  911.  
  912. /* If only one debugging format is supported, define PREFERRED_DEBUGGING_TYPE
  913.    here so other code needn't care.  */
  914. #elif defined DBX_DEBUGGING_INFO
  915. #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
  916.  
  917. #elif defined SDB_DEBUGGING_INFO
  918. #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG
  919.  
  920. #elif defined DWARF2_DEBUGGING_INFO
  921. #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
  922.  
  923. #elif defined VMS_DEBUGGING_INFO
  924. #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
  925.  
  926. #elif defined XCOFF_DEBUGGING_INFO
  927. #define PREFERRED_DEBUGGING_TYPE XCOFF_DEBUG
  928.  
  929. #else
  930. /* No debugging format is supported by this target.  */
  931. #define PREFERRED_DEBUGGING_TYPE NO_DEBUG
  932. #endif
  933.  
  934. #ifndef FLOAT_LIB_COMPARE_RETURNS_BOOL
  935. #define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false
  936. #endif
  937.  
  938. /* True if the targets integer-comparison functions return { 0, 1, 2
  939.    } to indicate { <, ==, > }.  False if { -1, 0, 1 } is used
  940.    instead.  The libgcc routines are biased.  */
  941. #ifndef TARGET_LIB_INT_CMP_BIASED
  942. #define TARGET_LIB_INT_CMP_BIASED (true)
  943. #endif
  944.  
  945. /* If FLOAT_WORDS_BIG_ENDIAN is not defined in the header files,
  946.    then the word-endianness is the same as for integers.  */
  947. #ifndef FLOAT_WORDS_BIG_ENDIAN
  948. #define FLOAT_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
  949. #endif
  950.  
  951. #ifndef REG_WORDS_BIG_ENDIAN
  952. #define REG_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
  953. #endif
  954.  
  955. #ifdef TARGET_FLT_EVAL_METHOD
  956. #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 1
  957. #else
  958. #define TARGET_FLT_EVAL_METHOD 0
  959. #define TARGET_FLT_EVAL_METHOD_NON_DEFAULT 0
  960. #endif
  961.  
  962. #ifndef TARGET_DEC_EVAL_METHOD
  963. #define TARGET_DEC_EVAL_METHOD 2
  964. #endif
  965.  
  966. #ifndef HAS_LONG_COND_BRANCH
  967. #define HAS_LONG_COND_BRANCH 0
  968. #endif
  969.  
  970. #ifndef HAS_LONG_UNCOND_BRANCH
  971. #define HAS_LONG_UNCOND_BRANCH 0
  972. #endif
  973.  
  974. /* Determine whether __cxa_atexit, rather than atexit, is used to
  975.    register C++ destructors for local statics and global objects.  */
  976. #ifndef DEFAULT_USE_CXA_ATEXIT
  977. #define DEFAULT_USE_CXA_ATEXIT 0
  978. #endif
  979.  
  980. #if GCC_VERSION >= 3000 && defined IN_GCC
  981. /* These old constraint macros shouldn't appear anywhere in a
  982.    configuration using MD constraint definitions.  */
  983. #endif
  984.  
  985. /* Determin whether the target runtime library is Bionic */
  986. #ifndef TARGET_HAS_BIONIC
  987. #define TARGET_HAS_BIONIC 0
  988. #endif
  989.  
  990. /* Indicate that CLZ and CTZ are undefined at zero.  */
  991. #ifndef CLZ_DEFINED_VALUE_AT_ZERO
  992. #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)  0
  993. #endif
  994. #ifndef CTZ_DEFINED_VALUE_AT_ZERO
  995. #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)  0
  996. #endif
  997.  
  998. /* Provide a default value for STORE_FLAG_VALUE.  */
  999. #ifndef STORE_FLAG_VALUE
  1000. #define STORE_FLAG_VALUE  1
  1001. #endif
  1002.  
  1003. /* This macro is used to determine what the largest unit size that
  1004.    move_by_pieces can use is.  */
  1005.  
  1006. /* MOVE_MAX_PIECES is the number of bytes at a time which we can
  1007.    move efficiently, as opposed to  MOVE_MAX which is the maximum
  1008.    number of bytes we can move with a single instruction.  */
  1009.  
  1010. #ifndef MOVE_MAX_PIECES
  1011. #define MOVE_MAX_PIECES   MOVE_MAX
  1012. #endif
  1013.  
  1014. /* STORE_MAX_PIECES is the number of bytes at a time that we can
  1015.    store efficiently.  Due to internal GCC limitations, this is
  1016.    MOVE_MAX_PIECES limited by the number of bytes GCC can represent
  1017.    for an immediate constant.  */
  1018.  
  1019. #ifndef STORE_MAX_PIECES
  1020. #define STORE_MAX_PIECES  MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT))
  1021. #endif
  1022.  
  1023. #ifndef MAX_MOVE_MAX
  1024. #define MAX_MOVE_MAX MOVE_MAX
  1025. #endif
  1026.  
  1027. #ifndef MIN_UNITS_PER_WORD
  1028. #define MIN_UNITS_PER_WORD UNITS_PER_WORD
  1029. #endif
  1030.  
  1031. #ifndef MAX_BITS_PER_WORD
  1032. #define MAX_BITS_PER_WORD BITS_PER_WORD
  1033. #endif
  1034.  
  1035. #ifndef STACK_POINTER_OFFSET
  1036. #define STACK_POINTER_OFFSET    0
  1037. #endif
  1038.  
  1039. #ifndef LOCAL_REGNO
  1040. #define LOCAL_REGNO(REGNO)  0
  1041. #endif
  1042.  
  1043. #ifndef HONOR_REG_ALLOC_ORDER
  1044. #define HONOR_REG_ALLOC_ORDER 0
  1045. #endif
  1046.  
  1047. /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
  1048.    the stack pointer does not matter.  The value is tested only in
  1049.    functions that have frame pointers.  */
  1050. #ifndef EXIT_IGNORE_STACK
  1051. #define EXIT_IGNORE_STACK 0
  1052. #endif
  1053.  
  1054. /* Assume that case vectors are not pc-relative.  */
  1055. #ifndef CASE_VECTOR_PC_RELATIVE
  1056. #define CASE_VECTOR_PC_RELATIVE 0
  1057. #endif
  1058.  
  1059. /* Assume that trampolines need function alignment.  */
  1060. #ifndef TRAMPOLINE_ALIGNMENT
  1061. #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
  1062. #endif
  1063.  
  1064. /* Register mappings for target machines without register windows.  */
  1065. #ifndef INCOMING_REGNO
  1066. #define INCOMING_REGNO(N) (N)
  1067. #endif
  1068.  
  1069. #ifndef OUTGOING_REGNO
  1070. #define OUTGOING_REGNO(N) (N)
  1071. #endif
  1072.  
  1073. #ifndef SHIFT_COUNT_TRUNCATED
  1074. #define SHIFT_COUNT_TRUNCATED 0
  1075. #endif
  1076.  
  1077. #ifndef LEGITIMATE_PIC_OPERAND_P
  1078. #define LEGITIMATE_PIC_OPERAND_P(X) 1
  1079. #endif
  1080.  
  1081. #ifndef TARGET_MEM_CONSTRAINT
  1082. #define TARGET_MEM_CONSTRAINT 'm'
  1083. #endif
  1084.  
  1085. #ifndef REVERSIBLE_CC_MODE
  1086. #define REVERSIBLE_CC_MODE(MODE) 0
  1087. #endif
  1088.  
  1089. /* Biggest alignment supported by the object file format of this machine.  */
  1090. #ifndef MAX_OFILE_ALIGNMENT
  1091. #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
  1092. #endif
  1093.  
  1094. #ifndef FRAME_GROWS_DOWNWARD
  1095. #define FRAME_GROWS_DOWNWARD 0
  1096. #endif
  1097.  
  1098. #ifndef RETURN_ADDR_IN_PREVIOUS_FRAME
  1099. #define RETURN_ADDR_IN_PREVIOUS_FRAME 0
  1100. #endif
  1101.  
  1102. /* On most machines, the CFA coincides with the first incoming parm.  */
  1103. #ifndef ARG_POINTER_CFA_OFFSET
  1104. #define ARG_POINTER_CFA_OFFSET(FNDECL) \
  1105.   (FIRST_PARM_OFFSET (FNDECL) + crtl->args.pretend_args_size)
  1106. #endif
  1107.  
  1108. /* On most machines, we use the CFA as DW_AT_frame_base.  */
  1109. #ifndef CFA_FRAME_BASE_OFFSET
  1110. #define CFA_FRAME_BASE_OFFSET(FNDECL) 0
  1111. #endif
  1112.  
  1113. /* The offset from the incoming value of %sp to the top of the stack frame
  1114.    for the current function.  */
  1115. #ifndef INCOMING_FRAME_SP_OFFSET
  1116. #define INCOMING_FRAME_SP_OFFSET 0
  1117. #endif
  1118.  
  1119. #ifndef HARD_REGNO_NREGS_HAS_PADDING
  1120. #define HARD_REGNO_NREGS_HAS_PADDING(REGNO, MODE) 0
  1121. #define HARD_REGNO_NREGS_WITH_PADDING(REGNO, MODE) -1
  1122. #endif
  1123.  
  1124. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  1125. #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 0
  1126. #endif
  1127.  
  1128. /* MAX_STACK_ALIGNMENT is the maximum stack alignment guaranteed by
  1129.    the backend.  MAX_SUPPORTED_STACK_ALIGNMENT is the maximum best
  1130.    effort stack alignment supported by the backend.  If the backend
  1131.    supports stack alignment, MAX_SUPPORTED_STACK_ALIGNMENT and
  1132.    MAX_STACK_ALIGNMENT are the same.  Otherwise, the incoming stack
  1133.    boundary will limit the maximum guaranteed stack alignment.  */
  1134. #ifdef MAX_STACK_ALIGNMENT
  1135. #define MAX_SUPPORTED_STACK_ALIGNMENT MAX_STACK_ALIGNMENT
  1136. #else
  1137. #define MAX_STACK_ALIGNMENT STACK_BOUNDARY
  1138. #define MAX_SUPPORTED_STACK_ALIGNMENT PREFERRED_STACK_BOUNDARY
  1139. #endif
  1140.  
  1141. #define SUPPORTS_STACK_ALIGNMENT (MAX_STACK_ALIGNMENT > STACK_BOUNDARY)
  1142.  
  1143. #ifndef LOCAL_ALIGNMENT
  1144. #define LOCAL_ALIGNMENT(TYPE, ALIGNMENT) ALIGNMENT
  1145. #endif
  1146.  
  1147. #ifndef STACK_SLOT_ALIGNMENT
  1148. #define STACK_SLOT_ALIGNMENT(TYPE,MODE,ALIGN) \
  1149.   ((TYPE) ? LOCAL_ALIGNMENT ((TYPE), (ALIGN)) : (ALIGN))
  1150. #endif
  1151.  
  1152. #ifndef LOCAL_DECL_ALIGNMENT
  1153. #define LOCAL_DECL_ALIGNMENT(DECL) \
  1154.   LOCAL_ALIGNMENT (TREE_TYPE (DECL), DECL_ALIGN (DECL))
  1155. #endif
  1156.  
  1157. #ifndef MINIMUM_ALIGNMENT
  1158. #define MINIMUM_ALIGNMENT(EXP,MODE,ALIGN) (ALIGN)
  1159. #endif
  1160.  
  1161. /* Alignment value for attribute ((aligned)).  */
  1162. #ifndef ATTRIBUTE_ALIGNED_VALUE
  1163. #define ATTRIBUTE_ALIGNED_VALUE BIGGEST_ALIGNMENT
  1164. #endif
  1165.  
  1166. #ifndef SLOW_UNALIGNED_ACCESS
  1167. #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  1168. #endif
  1169.  
  1170. /* For most ports anything that evaluates to a constant symbolic
  1171.    or integer value is acceptable as a constant address.  */
  1172. #ifndef CONSTANT_ADDRESS_P
  1173. #define CONSTANT_ADDRESS_P(X)   (CONSTANT_P (X) && GET_CODE (X) != CONST_DOUBLE)
  1174. #endif
  1175.  
  1176. #ifndef MAX_FIXED_MODE_SIZE
  1177. #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
  1178. #endif
  1179.  
  1180. /* Nonzero if structures and unions should be returned in memory.
  1181.  
  1182.    This should only be defined if compatibility with another compiler or
  1183.    with an ABI is needed, because it results in slower code.  */
  1184.  
  1185. #ifndef DEFAULT_PCC_STRUCT_RETURN
  1186. #define DEFAULT_PCC_STRUCT_RETURN 1
  1187. #endif
  1188.  
  1189. #ifdef GCC_INSN_FLAGS_H
  1190. /* Dependent default target macro definitions
  1191.  
  1192.    This section of defaults.h defines target macros that depend on generated
  1193.    headers.  This is a bit awkward:  We want to put all default definitions
  1194.    for target macros in defaults.h, but some of the defaults depend on the
  1195.    HAVE_* flags defines of insn-flags.h.  But insn-flags.h is not always
  1196.    included by files that do include defaults.h.
  1197.  
  1198.    Fortunately, the default macro definitions that depend on the HAVE_*
  1199.    macros are also the ones that will only be used inside GCC itself, i.e.
  1200.    not in the gen* programs or in target objects like libgcc.
  1201.  
  1202.    Obviously, it would be best to keep this section of defaults.h as small
  1203.    as possible, by converting the macros defined below to target hooks or
  1204.    functions.
  1205. */
  1206.  
  1207. /* The default branch cost is 1.  */
  1208. #ifndef BRANCH_COST
  1209. #define BRANCH_COST(speed_p, predictable_p) 1
  1210. #endif
  1211.  
  1212. /* If a memory-to-memory move would take MOVE_RATIO or more simple
  1213.    move-instruction sequences, we will do a movmem or libcall instead.  */
  1214.  
  1215. #ifndef MOVE_RATIO
  1216. #if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti)
  1217. #define MOVE_RATIO(speed) 2
  1218. #else
  1219. /* If we are optimizing for space (-Os), cut down the default move ratio.  */
  1220. #define MOVE_RATIO(speed) ((speed) ? 15 : 3)
  1221. #endif
  1222. #endif
  1223.  
  1224. /* If a clear memory operation would take CLEAR_RATIO or more simple
  1225.    move-instruction sequences, we will do a setmem or libcall instead.  */
  1226.  
  1227. #ifndef CLEAR_RATIO
  1228. #if defined (HAVE_setmemqi) || defined (HAVE_setmemhi) || defined (HAVE_setmemsi) || defined (HAVE_setmemdi) || defined (HAVE_setmemti)
  1229. #define CLEAR_RATIO(speed) 2
  1230. #else
  1231. /* If we are optimizing for space, cut down the default clear ratio.  */
  1232. #define CLEAR_RATIO(speed) ((speed) ? 15 :3)
  1233. #endif
  1234. #endif
  1235.  
  1236. /* If a memory set (to value other than zero) operation would take
  1237.    SET_RATIO or more simple move-instruction sequences, we will do a movmem
  1238.    or libcall instead.  */
  1239. #ifndef SET_RATIO
  1240. #define SET_RATIO(speed) MOVE_RATIO (speed)
  1241. #endif
  1242.  
  1243. /* Supply a default definition for FUNCTION_ARG_PADDING:
  1244.    usually pad upward, but pad short args downward on
  1245.    big-endian machines.  */
  1246.  
  1247. #define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE)                        \
  1248.   (! BYTES_BIG_ENDIAN                                                   \
  1249.    ? upward                                                             \
  1250.    : (((MODE) == BLKmode                                                \
  1251.        ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST         \
  1252.           && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \
  1253.        : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY)                       \
  1254.       ? downward : upward))
  1255.  
  1256. #ifndef FUNCTION_ARG_PADDING
  1257. #define FUNCTION_ARG_PADDING(MODE, TYPE)        \
  1258.   DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE))
  1259. #endif
  1260.  
  1261. /* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save.
  1262.    Normally move_insn, so Pmode stack pointer.  */
  1263.  
  1264. #ifndef STACK_SAVEAREA_MODE
  1265. #define STACK_SAVEAREA_MODE(LEVEL) Pmode
  1266. #endif
  1267.  
  1268. /* Supply a default definition of STACK_SIZE_MODE for
  1269.    allocate_dynamic_stack_space.  Normally PLUS/MINUS, so word_mode.  */
  1270.  
  1271. #ifndef STACK_SIZE_MODE
  1272. #define STACK_SIZE_MODE word_mode
  1273. #endif
  1274.  
  1275. /* Provide default values for the macros controlling stack checking.  */
  1276.  
  1277. /* The default is neither full builtin stack checking...  */
  1278. #ifndef STACK_CHECK_BUILTIN
  1279. #define STACK_CHECK_BUILTIN 0
  1280. #endif
  1281.  
  1282. /* ...nor static builtin stack checking.  */
  1283. #ifndef STACK_CHECK_STATIC_BUILTIN
  1284. #define STACK_CHECK_STATIC_BUILTIN 0
  1285. #endif
  1286.  
  1287. /* The default interval is one page (4096 bytes).  */
  1288. #ifndef STACK_CHECK_PROBE_INTERVAL_EXP
  1289. #define STACK_CHECK_PROBE_INTERVAL_EXP 12
  1290. #endif
  1291.  
  1292. /* The default is not to move the stack pointer.  */
  1293. #ifndef STACK_CHECK_MOVING_SP
  1294. #define STACK_CHECK_MOVING_SP 0
  1295. #endif
  1296.  
  1297. /* This is a kludge to try to capture the discrepancy between the old
  1298.    mechanism (generic stack checking) and the new mechanism (static
  1299.    builtin stack checking).  STACK_CHECK_PROTECT needs to be bumped
  1300.    for the latter because part of the protection area is effectively
  1301.    included in STACK_CHECK_MAX_FRAME_SIZE for the former.  */
  1302. #ifdef STACK_CHECK_PROTECT
  1303. #define STACK_OLD_CHECK_PROTECT STACK_CHECK_PROTECT
  1304. #else
  1305. #define STACK_OLD_CHECK_PROTECT                                         \
  1306.  (targetm_common.except_unwind_info (&global_options) == UI_SJLJ        \
  1307.   ? 75 * UNITS_PER_WORD                                                 \
  1308.   : 8 * 1024)
  1309. #endif
  1310.  
  1311. /* Minimum amount of stack required to recover from an anticipated stack
  1312.    overflow detection.  The default value conveys an estimate of the amount
  1313.    of stack required to propagate an exception.  */
  1314. #ifndef STACK_CHECK_PROTECT
  1315. #define STACK_CHECK_PROTECT                                             \
  1316.  (targetm_common.except_unwind_info (&global_options) == UI_SJLJ        \
  1317.   ? 75 * UNITS_PER_WORD                                                 \
  1318.   : 12 * 1024)
  1319. #endif
  1320.  
  1321. /* Make the maximum frame size be the largest we can and still only need
  1322.    one probe per function.  */
  1323. #ifndef STACK_CHECK_MAX_FRAME_SIZE
  1324. #define STACK_CHECK_MAX_FRAME_SIZE \
  1325.   ((1 << STACK_CHECK_PROBE_INTERVAL_EXP) - UNITS_PER_WORD)
  1326. #endif
  1327.  
  1328. /* This is arbitrary, but should be large enough everywhere.  */
  1329. #ifndef STACK_CHECK_FIXED_FRAME_SIZE
  1330. #define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD)
  1331. #endif
  1332.  
  1333. /* Provide a reasonable default for the maximum size of an object to
  1334.    allocate in the fixed frame.  We may need to be able to make this
  1335.    controllable by the user at some point.  */
  1336. #ifndef STACK_CHECK_MAX_VAR_SIZE
  1337. #define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100)
  1338. #endif
  1339.  
  1340. /* By default, the C++ compiler will use function addresses in the
  1341.    vtable entries.  Setting this nonzero tells the compiler to use
  1342.    function descriptors instead.  The value of this macro says how
  1343.    many words wide the descriptor is (normally 2).  It is assumed
  1344.    that the address of a function descriptor may be treated as a
  1345.    pointer to a function.  */
  1346. #ifndef TARGET_VTABLE_USES_DESCRIPTORS
  1347. #define TARGET_VTABLE_USES_DESCRIPTORS 0
  1348. #endif
  1349.  
  1350. #ifndef SWITCHABLE_TARGET
  1351. #define SWITCHABLE_TARGET 0
  1352. #endif
  1353.  
  1354. /* If the target supports integers that are wider than two
  1355.    HOST_WIDE_INTs on the host compiler, then the target should define
  1356.    TARGET_SUPPORTS_WIDE_INT and make the appropriate fixups.
  1357.    Otherwise the compiler really is not robust.  */
  1358. #ifndef TARGET_SUPPORTS_WIDE_INT
  1359. #define TARGET_SUPPORTS_WIDE_INT 0
  1360. #endif
  1361.  
  1362. #endif /* GCC_INSN_FLAGS_H  */
  1363.  
  1364. #endif  /* ! GCC_DEFAULTS_H */
  1365.