gcc/target.def

   1 /* Target hook definitions.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   3    2011
   4    Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 3, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; see the file COPYING3.  If not see
  18    <http://www.gnu.org/licenses/>.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!  */
  23
  24 /* See target-hooks-macros.h for details of macros that should be
  25    provided by the including file, and how to use them here.  */
  26 #include "target-hooks-macros.h"
  27
  28 #undef HOOK_TYPE
  29 #define HOOK_TYPE "Target Hook"
  30
  31 HOOK_VECTOR (TARGET_INITIALIZER, gcc_target)
  32
  33 /* Functions that output assembler for the target.  */
  34 #define HOOK_PREFIX "TARGET_ASM_"
  35 HOOK_VECTOR (TARGET_ASM_OUT, asm_out)
  36
  37 /* Opening and closing parentheses for asm expression grouping.  */
  38 DEFHOOKPOD
  39 (open_paren,
  40  "",
  41  const char *, "(")
  42 DEFHOOKPODX (close_paren, const char *, ")")
  43
  44 /* Assembler instructions for creating various kinds of integer object.  */
  45 DEFHOOKPOD
  46 (byte_op,
  47  "",
  48  const char *, "\t.byte\t")
  49 DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP)
  50 DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP)
  51
  52 /* The maximum number of bytes to skip when applying
  53    LABEL_ALIGN_AFTER_BARRIER.  */
  54 DEFHOOK
  55 (label_align_after_barrier_max_skip,
  56  "",
  57  int, (rtx label),
  58  default_label_align_after_barrier_max_skip)
  59
  60 /* The maximum number of bytes to skip when applying
  61    LOOP_ALIGN.  */
  62 DEFHOOK
  63 (loop_align_max_skip,
  64  "",
  65  int, (rtx label),
  66  default_loop_align_max_skip)
  67
  68 /* The maximum number of bytes to skip when applying
  69    LABEL_ALIGN.  */
  70 DEFHOOK
  71 (label_align_max_skip,
  72  "",
  73  int, (rtx label),
  74  default_label_align_max_skip)
  75
  76 /* The maximum number of bytes to skip when applying
  77    JUMP_ALIGN.  */
  78 DEFHOOK
  79 (jump_align_max_skip,
  80  "",
  81  int, (rtx label),
  82  default_jump_align_max_skip)
  83
  84 /* Try to output the assembler code for an integer object whose
  85    value is given by X.  SIZE is the size of the object in bytes and
  86    ALIGNED_P indicates whether it is aligned.  Return true if
  87    successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
  88    and UNALIGNED_OP are NULL.  */
  89 DEFHOOK
  90 (integer,
  91  "",
  92  /* Only handles cases for which BYTE_OP, ALIGNED_OP and UNALIGNED_OP are
  93     NULL.  */
  94  bool, (rtx x, unsigned int size, int aligned_p),
  95  default_assemble_integer)
  96
  97 /* Output code that will globalize a label.  */
  98 DEFHOOK
  99 (globalize_label,
 100  "",
 101  void, (FILE *stream, const char *name),
 102  default_globalize_label)
 103
 104 /* Output code that will globalize a declaration.  */
 105 DEFHOOK
 106 (globalize_decl_name,
 107  "",
 108  void, (FILE *stream, tree decl), default_globalize_decl_name)
 109
 110 /* Output code that will emit a label for unwind info, if this
 111    target requires such labels.  Second argument is the decl the
 112    unwind info is associated with, third is a boolean: true if
 113    this is for exception handling, fourth is a boolean: true if
 114    this is only a placeholder for an omitted FDE.  */
 115 DEFHOOK
 116 (emit_unwind_label,
 117  "",
 118  void, (FILE *stream, tree decl, int for_eh, int empty),
 119  default_emit_unwind_label)
 120
 121 /* Output code that will emit a label to divide up the exception table.  */
 122 DEFHOOK
 123 (emit_except_table_label,
 124  "",
 125  void, (FILE *stream),
 126  default_emit_except_table_label)
 127
 128 /* Emit a directive for setting the personality for the function.  */
 129 DEFHOOK
 130 (emit_except_personality,
 131  "If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be\
 132  used to emit a directive to install a personality hook into the unwind\
 133  info.  This hook should not be used if dwarf2 unwind info is used.",
 134  void, (rtx personality),
 135  NULL)
 136
 137 /* Emit any directives required to unwind this instruction.  */
 138 DEFHOOK
 139 (unwind_emit,
 140  "",
 141  void, (FILE *stream, rtx insn),
 142  NULL)
 143
 144 DEFHOOKPOD
 145 (unwind_emit_before_insn,
 146  "True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before\
 147  the assembly for @var{insn} has been emitted, false if the hook should\
 148  be called afterward.",
 149  bool, true)
 150
 151 /* Generate an internal label.
 152    For now this is just a wrapper for ASM_GENERATE_INTERNAL_LABEL.  */
 153 DEFHOOK_UNDOC
 154 (generate_internal_label,
 155  "",
 156  void, (char *buf, const char *prefix, unsigned long labelno),
 157  default_generate_internal_label)
 158
 159 /* Output an internal label.  */
 160 DEFHOOK
 161 (internal_label,
 162  "",
 163  void, (FILE *stream, const char *prefix, unsigned long labelno),
 164  default_internal_label)
 165
 166 /* Output label for the constant.  */
 167 DEFHOOK
 168 (declare_constant_name,
 169  "",
 170  void, (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size),
 171  default_asm_declare_constant_name)
 172
 173 /* Emit a ttype table reference to a typeinfo object.  */
 174 DEFHOOK
 175 (ttype,
 176  "",
 177  bool, (rtx sym),
 178  hook_bool_rtx_false)
 179
 180 /* Emit an assembler directive to set visibility for the symbol
 181    associated with the tree decl.  */
 182 DEFHOOK
 183 (assemble_visibility,
 184  "",
 185  void, (tree decl, int visibility),
 186  default_assemble_visibility)
 187
 188 /* Output the assembler code for entry to a function.  */
 189 DEFHOOK
 190 (function_prologue,
 191  "",
 192  void, (FILE *file, HOST_WIDE_INT size),
 193  default_function_pro_epilogue)
 194
 195 /* Output the assembler code for end of prologue.  */
 196 DEFHOOK
 197 (function_end_prologue,
 198  "",
 199  void, (FILE *file),
 200  no_asm_to_stream)
 201
 202 /* Output the assembler code for start of epilogue.  */
 203 DEFHOOK
 204 (function_begin_epilogue,
 205  "",
 206  void, (FILE *file),
 207  no_asm_to_stream)
 208
 209 /* Output the assembler code for function exit.  */
 210 DEFHOOK
 211 (function_epilogue,
 212  "",
 213  void, (FILE *file, HOST_WIDE_INT size),
 214  default_function_pro_epilogue)
 215
 216 /* Initialize target-specific sections.  */
 217 DEFHOOK
 218 (init_sections,
 219  "",
 220  void, (void),
 221  hook_void_void)
 222
 223 /* Tell assembler to change to section NAME with attributes FLAGS.
 224    If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
 225    which this section is associated.  */
 226 DEFHOOK
 227 (named_section,
 228  "",
 229  void, (const char *name, unsigned int flags, tree decl),
 230  default_no_named_section)
 231
 232 /* Return preferred text (sub)section for function DECL.
 233    Main purpose of this function is to separate cold, normal and hot
 234    functions. STARTUP is true when function is known to be used only
 235    at startup (from static constructors or it is main()).
 236    EXIT is true when function is known to be used only at exit
 237    (from static destructors).
 238    Return NULL if function should go to default text section.  */
 239 DEFHOOK
 240 (function_section,
 241  "",
 242  section *, (tree decl, enum node_frequency freq, bool startup, bool exit),
 243  default_function_section)
 244
 245 /* Output the assembler code for function exit.  */
 246 DEFHOOK
 247 (function_switched_text_sections,
 248  "Used by the target to emit any assembler directives or additional\
 249   labels needed when a function is partitioned between different\
 250   sections.  Output should be written to @var{file}.  The function\
 251   decl is available as @var{decl} and the new section is `cold' if\
 252   @var{new_is_cold} is @code{true}.",
 253  void, (FILE *file, tree decl, bool new_is_cold),
 254  default_function_switched_text_sections)
 255
 256 /* Return a mask describing how relocations should be treated when
 257    selecting sections.  Bit 1 should be set if global relocations
 258    should be placed in a read-write section; bit 0 should be set if
 259    local relocations should be placed in a read-write section.  */
 260 DEFHOOK
 261 (reloc_rw_mask,
 262  "",
 263  int, (void),
 264  default_reloc_rw_mask)
 265
 266  /* Return a section for EXP.  It may be a DECL or a constant.  RELOC
 267     is nonzero if runtime relocations must be applied; bit 1 will be
 268     set if the runtime relocations require non-local name resolution.
 269     ALIGN is the required alignment of the data.  */
 270 DEFHOOK
 271 (select_section,
 272  "",
 273  section *, (tree exp, int reloc, unsigned HOST_WIDE_INT align),
 274  default_select_section)
 275
 276 /* Return a section for X.  MODE is X's mode and ALIGN is its
 277    alignment in bits.  */
 278 DEFHOOK
 279 (select_rtx_section,
 280  "",
 281  section *, (enum machine_mode mode, rtx x, unsigned HOST_WIDE_INT align),
 282  default_select_rtx_section)
 283
 284 /* Select a unique section name for DECL.  RELOC is the same as
 285    for SELECT_SECTION.  */
 286 DEFHOOK
 287 (unique_section,
 288  "",
 289  void, (tree decl, int reloc),
 290  default_unique_section)
 291
 292 /* Return the readonly data section associated with function DECL.  */
 293 DEFHOOK
 294 (function_rodata_section,
 295  "",
 296  section *, (tree decl),
 297  default_function_rodata_section)
 298
 299 /* Nonnull if the target wants to override the default ".rodata" prefix
 300    for mergeable data sections.  */
 301 DEFHOOKPOD
 302 (mergeable_rodata_prefix,
 303  "Usually, the compiler uses the prefix @code{\".rodata\"} to construct\n\
 304 section names for mergeable constant data.  Define this macro to override\n\
 305 the string if a different section name should be used.",
 306  const char *, ".rodata")
 307
 308 /* Output a constructor for a symbol with a given priority.  */
 309 DEFHOOK
 310 (constructor,
 311  "",
 312  void, (rtx symbol, int priority), NULL)
 313
 314 /* Output a destructor for a symbol with a given priority.  */
 315 DEFHOOK
 316 (destructor,
 317  "",
 318  void, (rtx symbol, int priority), NULL)
 319
 320 /* Output the assembler code for a thunk function.  THUNK_DECL is the
 321    declaration for the thunk function itself, FUNCTION is the decl for
 322    the target function.  DELTA is an immediate constant offset to be
 323    added to THIS.  If VCALL_OFFSET is nonzero, the word at
 324    *(*this + vcall_offset) should be added to THIS.  */
 325 DEFHOOK
 326 (output_mi_thunk,
 327  "",
 328  void, (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
 329         HOST_WIDE_INT vcall_offset, tree function),
 330  NULL)
 331
 332 /* Determine whether output_mi_thunk would succeed.  */
 333 /* ??? Ideally, this hook would not exist, and success or failure
 334    would be returned from output_mi_thunk directly.  But there's
 335    too much undo-able setup involved in invoking output_mi_thunk.
 336    Could be fixed by making output_mi_thunk emit rtl instead of
 337    text to the output file.  */
 338 DEFHOOK
 339 (can_output_mi_thunk,
 340  "",
 341  bool, (const_tree thunk_fndecl, HOST_WIDE_INT delta,
 342         HOST_WIDE_INT vcall_offset, const_tree function),
 343  hook_bool_const_tree_hwi_hwi_const_tree_false)
 344
 345 /* Output any boilerplate text needed at the beginning of a
 346    translation unit.  */
 347 DEFHOOK
 348 (file_start,
 349  "",
 350  void, (void),
 351  default_file_start)
 352
 353 /* Output any boilerplate text needed at the end of a translation unit.  */
 354 DEFHOOK
 355 (file_end,
 356  "",
 357  void, (void),
 358  hook_void_void)
 359
 360 /* Output any boilerplate text needed at the beginning of an
 361    LTO output stream.  */
 362 DEFHOOK
 363 (lto_start,
 364  "",
 365  void, (void),
 366  hook_void_void)
 367
 368 /* Output any boilerplate text needed at the end of an
 369    LTO output stream.  */
 370 DEFHOOK
 371 (lto_end,
 372  "",
 373  void, (void),
 374  hook_void_void)
 375
 376 /* Output any boilerplace text needed at the end of a
 377    translation unit before debug and unwind info is emitted.  */
 378 DEFHOOK
 379 (code_end,
 380  "",
 381  void, (void),
 382  hook_void_void)
 383
 384 /* Output an assembler pseudo-op to declare a library function name
 385    external.  */
 386 DEFHOOK
 387 (external_libcall,
 388  "",
 389  void, (rtx symref),
 390  default_external_libcall)
 391
 392 /* Output an assembler directive to mark decl live. This instructs
 393    linker to not dead code strip this symbol.  */
 394 DEFHOOK
 395 (mark_decl_preserved,
 396  "",
 397  void, (const char *symbol),
 398  hook_void_constcharptr)
 399
 400 /* Output a record of the command line switches that have been passed.  */
 401 DEFHOOK
 402 (record_gcc_switches,
 403  "",
 404  int, (print_switch_type type, const char *text),
 405  NULL)
 406
 407 /* The name of the section that the example ELF implementation of
 408    record_gcc_switches will use to store the information.  Target
 409    specific versions of record_gcc_switches may or may not use
 410    this information.  */
 411 DEFHOOKPOD
 412 (record_gcc_switches_section,
 413  "",
 414  const char *, ".GCC.command.line")
 415
 416 /* Output the definition of a section anchor.  */
 417 DEFHOOK
 418 (output_anchor,
 419  "",
 420  void, (rtx x),
 421  default_asm_output_anchor)
 422
 423 /* Output a DTP-relative reference to a TLS symbol.  */
 424 DEFHOOK
 425 (output_dwarf_dtprel,
 426  "",
 427  void, (FILE *file, int size, rtx x),
 428  NULL)
 429
 430 /* Some target machines need to postscan each insn after it is output.  */
 431 DEFHOOK
 432 (final_postscan_insn,
 433  "",
 434  void, (FILE *file, rtx insn, rtx *opvec, int noperands),
 435  NULL)
 436
 437 /* Emit the trampoline template.  This hook may be NULL.  */
 438 DEFHOOK
 439 (trampoline_template,
 440  "",
 441  void, (FILE *f),
 442  NULL)
 443
 444 DEFHOOK
 445 (output_source_filename,
 446  "Output COFF information or DWARF debugging information which indicates\
 447  that filename @var{name} is the current source file to the stdio\
 448  stream @var{file}.\n\
 449  \n\
 450  This target hook need not be defined if the standard form of output\
 451  for the file format in use is appropriate.",
 452  void ,(FILE *file, const char *name),
 453  default_asm_output_source_filename)
 454
 455 DEFHOOK
 456 (output_addr_const_extra,
 457  "",
 458  bool, (FILE *file, rtx x),
 459  hook_bool_FILEptr_rtx_false)
 460
 461 /* ??? The TARGET_PRINT_OPERAND* hooks are part of the asm_out struct,
 462    even though that is not reflected in the macro name to override their
 463    initializers.  */
 464 #undef HOOK_PREFIX
 465 #define HOOK_PREFIX "TARGET_"
 466
 467 /* Emit a machine-specific insn operand.  */
 468 /* ??? tm.texi only documents the old macro PRINT_OPERAND,
 469    not this  hook, and uses a different name for the argument FILE.  */
 470 DEFHOOK_UNDOC
 471 (print_operand,
 472  "",
 473  void, (FILE *file, rtx x, int code),
 474  default_print_operand)
 475
 476 /* Emit a machine-specific memory address.  */
 477 /* ??? tm.texi only documents the old macro PRINT_OPERAND_ADDRESS,
 478    not this  hook, and uses different argument names.  */
 479 DEFHOOK_UNDOC
 480 (print_operand_address,
 481  "",
 482  void, (FILE *file, rtx addr),
 483  default_print_operand_address)
 484
 485 /* Determine whether CODE is a valid punctuation character for the
 486    `print_operand' hook.  */
 487 /* ??? tm.texi only documents the old macro PRINT_OPERAND_PUNCT_VALID_P,
 488    not this  hook.  */
 489 DEFHOOK_UNDOC
 490 (print_operand_punct_valid_p,
 491  "",
 492  bool ,(unsigned char code),
 493  default_print_operand_punct_valid_p)
 494
 495 /* Given a symbol name, perform same mangling as assemble_name and
 496    ASM_OUTPUT_LABELREF, returning result as an IDENTIFIER_NODE.  */
 497 DEFHOOK
 498 (mangle_assembler_name,
 499  "Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s\
 500  @code{assemble_name}, but in memory rather than to a file stream, returning\
 501  result as an @code{IDENTIFIER_NODE}.  Required for correct LTO symtabs.  The\
 502  default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and\
 503  then prepends the @code{USER_LABEL_PREFIX}, if any.",
 504  tree, (const char *name),
 505  default_mangle_assembler_name)
 506
 507 HOOK_VECTOR_END (asm_out)
 508
 509 /* Functions relating to instruction scheduling.  All of these
 510    default to null pointers, which haifa-sched.c looks for and handles.  */
 511 #undef HOOK_PREFIX
 512 #define HOOK_PREFIX "TARGET_SCHED_"
 513 HOOK_VECTOR (TARGET_SCHED, sched)
 514
 515 /* Given the current cost, COST, of an insn, INSN, calculate and
 516    return a new cost based on its relationship to DEP_INSN through
 517    the dependence LINK.  The default is to make no adjustment.  */
 518 DEFHOOK
 519 (adjust_cost,
 520  "",
 521  int, (rtx insn, rtx link, rtx dep_insn, int cost), NULL)
 522
 523 /* Adjust the priority of an insn as you see fit.  Returns the new priority.  */
 524 DEFHOOK
 525 (adjust_priority,
 526  "",
 527  int, (rtx insn, int priority), NULL)
 528
 529 /* Function which returns the maximum number of insns that can be
 530    scheduled in the same machine cycle.  This must be constant
 531    over an entire compilation.  The default is 1.  */
 532 DEFHOOK
 533 (issue_rate,
 534  "",
 535  int, (void), NULL)
 536
 537 /* Calculate how much this insn affects how many more insns we
 538    can emit this cycle.  Default is they all cost the same.  */
 539 DEFHOOK
 540 (variable_issue,
 541  "",
 542  int, (FILE *file, int verbose, rtx insn, int more), NULL)
 543
 544 /* Initialize machine-dependent scheduling code.  */
 545 DEFHOOK
 546 (init,
 547  "",
 548  void, (FILE *file, int verbose, int max_ready), NULL)
 549
 550 /* Finalize machine-dependent scheduling code.  */
 551 DEFHOOK
 552 (finish,
 553  "",
 554  void, (FILE *file, int verbose), NULL)
 555
 556  /* Initialize machine-dependent function wide scheduling code.  */
 557 DEFHOOK
 558 (init_global,
 559  "",
 560  void, (FILE *file, int verbose, int old_max_uid), NULL)
 561
 562 /* Finalize machine-dependent function wide scheduling code.  */
 563 DEFHOOK
 564 (finish_global,
 565  "",
 566  void, (FILE *file, int verbose), NULL)
 567
 568 /* Reorder insns in a machine-dependent fashion, in two different
 569        places.  Default does nothing.  */
 570 DEFHOOK
 571 (reorder,
 572  "",
 573  int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL)
 574
 575 DEFHOOK
 576 (reorder2,
 577  "",
 578  int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL)
 579
 580 /* The following member value is a pointer to a function called
 581    after evaluation forward dependencies of insns in chain given
 582    by two parameter values (head and tail correspondingly).  */
 583 DEFHOOK
 584 (dependencies_evaluation_hook,
 585  "",
 586  void, (rtx head, rtx tail), NULL)
 587
 588 /* The values of the following four members are pointers to functions
 589    used to simplify the automaton descriptions.  dfa_pre_cycle_insn and
 590    dfa_post_cycle_insn give functions returning insns which are used to
 591    change the pipeline hazard recognizer state when the new simulated
 592    processor cycle correspondingly starts and finishes.  The function
 593    defined by init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are
 594    used to initialize the corresponding insns.  The default values of
 595    the members result in not changing the automaton state when the
 596    new simulated processor cycle correspondingly starts and finishes.  */
 597
 598 DEFHOOK
 599 (init_dfa_pre_cycle_insn,
 600  "",
 601  void, (void), NULL)
 602
 603 DEFHOOK
 604 (dfa_pre_cycle_insn,
 605  "",
 606  rtx, (void), NULL)
 607
 608 DEFHOOK
 609 (init_dfa_post_cycle_insn,
 610  "",
 611  void, (void), NULL)
 612
 613 DEFHOOK
 614 (dfa_post_cycle_insn,
 615  "",
 616  rtx, (void), NULL)
 617
 618 /* The values of the following two members are pointers to
 619    functions used to simplify the automaton descriptions.
 620    dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
 621    immediately before and after cycle is advanced.  */
 622
 623 DEFHOOK
 624 (dfa_pre_advance_cycle,
 625  "",
 626  void, (void), NULL)
 627
 628 DEFHOOK
 629 (dfa_post_advance_cycle,
 630  "",
 631  void, (void), NULL)
 632
 633 /* The following member value is a pointer to a function returning value
 634    which defines how many insns in queue `ready' will we try for
 635    multi-pass scheduling.  If the member value is nonzero and the
 636    function returns positive value, the DFA based scheduler will make
 637    multi-pass scheduling for the first cycle.  In other words, we will
 638    try to choose ready insn which permits to start maximum number of
 639    insns on the same cycle.  */
 640 DEFHOOK
 641 (first_cycle_multipass_dfa_lookahead,
 642  "",
 643  int, (void), NULL)
 644
 645 /* The following member value is pointer to a function controlling
 646    what insns from the ready insn queue will be considered for the
 647    multipass insn scheduling.  If the hook returns zero for insn
 648    passed as the parameter, the insn will be not chosen to be issued.  */
 649 DEFHOOK
 650 (first_cycle_multipass_dfa_lookahead_guard,
 651  "",
 652  int, (rtx insn), NULL)
 653
 654 /* This hook prepares the target for a new round of multipass
 655    scheduling.
 656    DATA is a pointer to target-specific data used for multipass scheduling.
 657    READY_TRY and N_READY represent the current state of search in the
 658    optimization space.  The target can filter out instructions that
 659    should not be tried during current round by setting corresponding
 660    elements in READY_TRY to non-zero.
 661    FIRST_CYCLE_INSN_P is true if this is the first round of multipass
 662    scheduling on current cycle.  */
 663 DEFHOOK
 664 (first_cycle_multipass_begin,
 665  "",
 666  void, (void *data, char *ready_try, int n_ready, bool first_cycle_insn_p),
 667  NULL)
 668
 669 /* This hook is called when multipass scheduling evaluates instruction INSN.
 670    DATA is a pointer to target-specific data that can be used to record effects
 671    of INSN on CPU that are not described in DFA.
 672    READY_TRY and N_READY represent the current state of search in the
 673    optimization space.  The target can filter out instructions that
 674    should not be tried after issueing INSN by setting corresponding
 675    elements in READY_TRY to non-zero.
 676    INSN is the instruction being evaluated.
 677    PREV_DATA is a pointer to target-specific data corresponding
 678    to a state before issueing INSN.  */
 679 DEFHOOK
 680 (first_cycle_multipass_issue,
 681  "",
 682  void, (void *data, char *ready_try, int n_ready, rtx insn,
 683         const void *prev_data), NULL)
 684
 685 /* This hook is called when multipass scheduling backtracks from evaluation of
 686    instruction corresponding to DATA.
 687    DATA is a pointer to target-specific data that stores the effects
 688    of instruction from which the algorithm backtracks on CPU that are not
 689    described in DFA.
 690    READY_TRY and N_READY represent the current state of search in the
 691    optimization space.  The target can filter out instructions that
 692    should not be tried after issueing INSN by setting corresponding
 693    elements in READY_TRY to non-zero.  */
 694 DEFHOOK
 695 (first_cycle_multipass_backtrack,
 696  "",
 697  void, (const void *data, char *ready_try, int n_ready), NULL)
 698
 699 /* This hook notifies the target about the result of the concluded current
 700    round of multipass scheduling.
 701    DATA is a pointer.
 702    If DATA is non-NULL it points to target-specific data used for multipass
 703    scheduling which corresponds to instruction at the start of the chain of
 704    the winning solution.  DATA is NULL when multipass scheduling cannot find
 705    a good enough solution on current cycle and decides to retry later,
 706    usually after advancing the cycle count.  */
 707 DEFHOOK
 708 (first_cycle_multipass_end,
 709  "",
 710  void, (const void *data), NULL)
 711
 712 /* This hook is called to initialize target-specific data for multipass
 713    scheduling after it has been allocated.
 714    DATA is a pointer to target-specific data that stores the effects
 715    of instruction from which the algorithm backtracks on CPU that are not
 716    described in DFA.  */
 717 DEFHOOK
 718 (first_cycle_multipass_init,
 719  "",
 720  void, (void *data), NULL)
 721
 722 /* This hook is called to finalize target-specific data for multipass
 723    scheduling before it is deallocated.
 724    DATA is a pointer to target-specific data that stores the effects
 725    of instruction from which the algorithm backtracks on CPU that are not
 726    described in DFA.  */
 727 DEFHOOK
 728 (first_cycle_multipass_fini,
 729  "",
 730  void, (void *data), NULL)
 731
 732 /* The following member value is pointer to a function called by
 733    the insn scheduler before issuing insn passed as the third
 734    parameter on given cycle.  If the hook returns nonzero, the
 735    insn is not issued on given processors cycle.  Instead of that,
 736    the processor cycle is advanced.  If the value passed through
 737    the last parameter is zero, the insn ready queue is not sorted
 738    on the new cycle start as usually.  The first parameter passes
 739    file for debugging output.  The second one passes the scheduler
 740    verbose level of the debugging output.  The forth and the fifth
 741    parameter values are correspondingly processor cycle on which
 742    the previous insn has been issued and the current processor cycle.  */
 743 DEFHOOK
 744 (dfa_new_cycle,
 745  "",
 746  int, (FILE *dump, int verbose, rtx insn, int last_clock,
 747        int clock, int *sort_p),
 748  NULL)
 749
 750 /* The following member value is a pointer to a function called by the
 751    insn scheduler.  It should return true if there exists a dependence
 752    which is considered costly by the target, between the insn
 753    DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP).  The first parameter is
 754    the dep that represents the dependence between the two insns.  The
 755    second argument is the cost of the dependence as estimated by
 756    the scheduler.  The last argument is the distance in cycles
 757    between the already scheduled insn (first parameter) and the
 758    second insn (second parameter).  */
 759 DEFHOOK
 760 (is_costly_dependence,
 761  "",
 762  bool, (struct _dep *_dep, int cost, int distance), NULL)
 763
 764 DEFHOOK_UNDOC
 765 (adjust_cost_2,
 766  "Given the current cost, @var{cost}, of an insn, @var{insn}, calculate and\
 767  return a new cost based on its relationship to @var{dep_insn} through the\
 768  dependence of weakness @var{dw}.  The default is to make no adjustment.",
 769  int, (rtx insn, int dep_type1, rtx dep_insn, int cost, int dw), NULL)
 770
 771 /* The following member value is a pointer to a function called
 772    by the insn scheduler. This hook is called to notify the backend
 773    that new instructions were emitted.  */
 774 DEFHOOK
 775 (h_i_d_extended,
 776  "",
 777  void, (void), NULL)
 778
 779 /* Next 5 functions are for multi-point scheduling.  */
 780
 781 /* Allocate memory for scheduler context.  */
 782 DEFHOOK
 783 (alloc_sched_context,
 784  "",
 785  void *, (void), NULL)
 786
 787 /* Fills the context from the local machine scheduler context.  */
 788 DEFHOOK
 789 (init_sched_context,
 790  "",
 791  void, (void *tc, bool clean_p), NULL)
 792
 793 /* Sets local machine scheduler context to a saved value.  */
 794 DEFHOOK
 795 (set_sched_context,
 796  "",
 797  void, (void *tc), NULL)
 798
 799 /* Clears a scheduler context so it becomes like after init.  */
 800 DEFHOOK
 801 (clear_sched_context,
 802  "",
 803  void, (void *tc), NULL)
 804
 805 /* Frees the scheduler context.  */
 806 DEFHOOK
 807 (free_sched_context,
 808  "",
 809  void, (void *tc), NULL)
 810
 811 /* The following member value is a pointer to a function called
 812    by the insn scheduler.
 813    The first parameter is an instruction, the second parameter is the type
 814    of the requested speculation, and the third parameter is a pointer to the
 815    speculative pattern of the corresponding type (set if return value == 1).
 816    It should return
 817    -1, if there is no pattern, that will satisfy the requested speculation type,
 818    0, if current pattern satisfies the requested speculation type,
 819    1, if pattern of the instruction should be changed to the newly
 820    generated one.  */
 821 DEFHOOK
 822 (speculate_insn,
 823  "",
 824  int, (rtx insn, int request, rtx *new_pat), NULL)
 825
 826 /* The following member value is a pointer to a function called
 827    by the insn scheduler.  It should return true if the check instruction
 828    passed as the parameter needs a recovery block.  */
 829 DEFHOOK
 830 (needs_block_p,
 831  "",
 832  bool, (int dep_status), NULL)
 833
 834 /* The following member value is a pointer to a function called
 835    by the insn scheduler.  It should return a pattern for the check
 836    instruction.
 837    The first parameter is a speculative instruction, the second parameter
 838    is the label of the corresponding recovery block (or null, if it is a
 839    simple check).  If the mutation of the check is requested (e.g. from
 840    ld.c to chk.a), the third parameter is true - in this case the first
 841    parameter is the previous check.  */
 842 DEFHOOK
 843 (gen_spec_check,
 844  "",
 845  rtx, (rtx insn, rtx label, int mutate_p), NULL)
 846
 847 /* The following member value is a pointer to a function controlling
 848    what insns from the ready insn queue will be considered for the
 849    multipass insn scheduling.  If the hook returns zero for the insn
 850    passed as the parameter, the insn will not be chosen to be
 851    issued.  This hook is used to discard speculative instructions,
 852    that stand at the first position of the ready list.  */
 853 DEFHOOK
 854 (first_cycle_multipass_dfa_lookahead_guard_spec,
 855  "",
 856  bool, (const_rtx insn), NULL)
 857
 858 /* The following member value is a pointer to a function that provides
 859    information about the speculation capabilities of the target.
 860    The parameter is a pointer to spec_info variable.  */
 861 DEFHOOK
 862 (set_sched_flags,
 863  "",
 864  void, (struct spec_info_def *spec_info), NULL)
 865
 866 DEFHOOK_UNDOC
 867 (get_insn_spec_ds,
 868  "Return speculation types of instruction @var{insn}.",
 869  int, (rtx insn), NULL)
 870
 871 DEFHOOK_UNDOC
 872 (get_insn_checked_ds,
 873  "Return speculation types that are checked for instruction @var{insn}",
 874  int, (rtx insn), NULL)
 875
 876 DEFHOOK_UNDOC
 877 (skip_rtx_p,
 878  "Return bool if rtx scanning should just skip current layer and\
 879  advance to the inner rtxes.",
 880  bool, (const_rtx x), NULL)
 881
 882 /* The following member value is a pointer to a function that provides
 883    information about the target resource-based lower bound which is
 884    used by the swing modulo scheduler.  The parameter is a pointer
 885    to ddg variable.  */
 886 DEFHOOK
 887 (sms_res_mii,
 888  "",
 889  int, (struct ddg *g), NULL)
 890
 891 /* The following member value is a function that initializes dispatch
 892    schedling and adds instructions to dispatch window according to its
 893    parameters.  */
 894 DEFHOOK
 895 (dispatch_do,
 896 "",
 897 void, (rtx insn, int x),
 898 hook_void_rtx_int)
 899
 900 /* The following member value is a a function that returns true is
 901    dispatch schedling is supported in hardware and condition passed
 902    as the second parameter is true.  */
 903 DEFHOOK
 904 (dispatch,
 905 "",
 906 bool, (rtx insn, int x),
 907 hook_bool_rtx_int_false)
 908
 909 DEFHOOKPOD
 910 (exposed_pipeline,
 911 "True if the processor has an exposed pipeline, which means that not just\n\
 912 the order of instructions is important for correctness when scheduling, but\n\
 913 also the latencies of operations.",
 914 bool, false)
 915
 916 /* The following member value is a function that returns number
 917    of operations reassociator should try to put in parallel for
 918    statements of the given type.  By default 1 is used.  */
 919 DEFHOOK
 920 (reassociation_width,
 921 "This hook is called by tree reassociator to determine a level of\n\
 922 parallelism required in output calculations chain.",
 923 int, (unsigned int opc, enum machine_mode mode),
 924 hook_int_uint_mode_1)
 925
 926 HOOK_VECTOR_END (sched)
 927
 928 /* Functions relating to vectorization.  */
 929 #undef HOOK_PREFIX
 930 #define HOOK_PREFIX "TARGET_VECTORIZE_"
 931 HOOK_VECTOR (TARGET_VECTORIZE, vectorize)
 932
 933 /* The following member value is a pointer to a function called
 934    by the vectorizer, and return the decl of the target builtin
 935    function.  */
 936 DEFHOOK
 937 (builtin_mask_for_load,
 938  "",
 939  tree, (void), NULL)
 940
 941 /* Returns a code for builtin that realizes vectorized version of
 942    function, or NULL_TREE if not available.  */
 943 DEFHOOK
 944 (builtin_vectorized_function,
 945  "",
 946  tree, (tree fndecl, tree vec_type_out, tree vec_type_in),
 947  default_builtin_vectorized_function)
 948
 949 /* Returns a function declaration for a builtin that realizes the
 950    vector conversion, or NULL_TREE if not available.  */
 951 DEFHOOK
 952 (builtin_conversion,
 953  "",
 954  tree, (unsigned code, tree dest_type, tree src_type),
 955  default_builtin_vectorized_conversion)
 956
 957 /* Target builtin that implements vector widening multiplication.
 958    builtin_mul_widen_eve computes the element-by-element products
 959    for the even elements, and builtin_mul_widen_odd computes the
 960    element-by-element products for the odd elements.  */
 961 DEFHOOK
 962 (builtin_mul_widen_even,
 963  "",
 964  tree, (tree x), NULL)
 965
 966 DEFHOOK
 967 (builtin_mul_widen_odd,
 968  "",
 969  tree, (tree x), NULL)
 970
 971 /* Cost of different vector/scalar statements in vectorization cost
 972    model. In case of misaligned vector loads and stores the cost depends
 973    on the data type and misalignment value.  */
 974 DEFHOOK
 975 (builtin_vectorization_cost,
 976  "",
 977  int, (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign),
 978  default_builtin_vectorization_cost)
 979
 980 /* Return true if vector alignment is reachable (by peeling N
 981    iterations) for the given type.  */
 982 DEFHOOK
 983 (vector_alignment_reachable,
 984  "",
 985  bool, (const_tree type, bool is_packed),
 986  default_builtin_vector_alignment_reachable)
 987
 988 /* Return true if a vector created for vec_perm_const is valid.  */
 989 DEFHOOK
 990 (vec_perm_const_ok,
 991  "",
 992  bool, (tree vec_type, tree mask),
 993  hook_bool_tree_tree_true)
 994
 995 /* Return true if the target supports misaligned store/load of a
 996    specific factor denoted in the third parameter.  The last parameter
 997    is true if the access is defined in a packed struct.  */
 998 DEFHOOK
 999 (support_vector_misalignment,
1000  "",
1001  bool,
1002  (enum machine_mode mode, const_tree type, int misalignment, bool is_packed),
1003  default_builtin_support_vector_misalignment)
1004
1005 /* Returns the preferred mode for SIMD operations for the specified
1006    scalar mode.  */
1007 DEFHOOK
1008 (preferred_simd_mode,
1009  "",
1010  enum machine_mode,
1011  (enum machine_mode mode),
1012  default_preferred_simd_mode)
1013
1014 /* Returns a mask of vector sizes to iterate over when auto-vectorizing
1015    after processing the preferred one derived from preferred_simd_mode.  */
1016 DEFHOOK
1017 (autovectorize_vector_sizes,
1018  "",
1019  unsigned int,
1020  (void),
1021  default_autovectorize_vector_sizes)
1022
1023 HOOK_VECTOR_END (vectorize)
1024
1025 #undef HOOK_PREFIX
1026 #define HOOK_PREFIX "TARGET_"
1027
1028 /* Allow target specific overriding of option settings after options have
1029   been changed by an attribute or pragma or when it is reset at the
1030   end of the code affected by an attribute or pragma.  */
1031 DEFHOOK
1032 (override_options_after_change,
1033  "",
1034  void, (void),
1035  hook_void_void)
1036
1037 DEFHOOK_UNDOC
1038 (eh_return_filter_mode,
1039  "Return machine mode for filter value.",
1040  enum machine_mode, (void),
1041  default_eh_return_filter_mode)
1042
1043 /* Return machine mode for libgcc expanded cmp instructions.  */
1044 DEFHOOK
1045 (libgcc_cmp_return_mode,
1046  "",
1047  enum machine_mode, (void),
1048  default_libgcc_cmp_return_mode)
1049
1050 /* Return machine mode for libgcc expanded shift instructions.  */
1051 DEFHOOK
1052 (libgcc_shift_count_mode,
1053  "",
1054  enum machine_mode, (void),
1055  default_libgcc_shift_count_mode)
1056
1057 /* Return machine mode to be used for _Unwind_Word type.  */
1058 DEFHOOK
1059 (unwind_word_mode,
1060  "",
1061  enum machine_mode, (void),
1062  default_unwind_word_mode)
1063
1064 /* Given two decls, merge their attributes and return the result.  */
1065 DEFHOOK
1066 (merge_decl_attributes,
1067  "",
1068  tree, (tree olddecl, tree newdecl),
1069  merge_decl_attributes)
1070
1071 /* Given two types, merge their attributes and return the result.  */
1072 DEFHOOK
1073 (merge_type_attributes,
1074  "",
1075  tree, (tree type1, tree type2),
1076  merge_type_attributes)
1077
1078 /* Table of machine attributes and functions to handle them.
1079    Ignored if NULL.  */
1080 DEFHOOKPOD
1081 (attribute_table,
1082  "",
1083  const struct attribute_spec *, NULL)
1084
1085 /* Return true iff attribute NAME expects a plain identifier as its first
1086    argument.  */
1087 DEFHOOK
1088 (attribute_takes_identifier_p,
1089  "",
1090  bool, (const_tree name),
1091  hook_bool_const_tree_false)
1092
1093 /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
1094    one if they are compatible and two if they are nearly compatible
1095    (which causes a warning to be generated).  */
1096 DEFHOOK
1097 (comp_type_attributes,
1098  "",
1099  int, (const_tree type1, const_tree type2),
1100  hook_int_const_tree_const_tree_1)
1101
1102 /* Assign default attributes to the newly defined TYPE.  */
1103 DEFHOOK
1104 (set_default_type_attributes,
1105  "",
1106  void, (tree type),
1107  hook_void_tree)
1108
1109 /* Insert attributes on the newly created DECL.  */
1110 DEFHOOK
1111 (insert_attributes,
1112  "",
1113  void, (tree node, tree *attr_ptr),
1114  hook_void_tree_treeptr)
1115
1116 /* Return true if FNDECL (which has at least one machine attribute)
1117    can be inlined despite its machine attributes, false otherwise.  */
1118 DEFHOOK
1119 (function_attribute_inlinable_p,
1120  "",
1121  bool, (const_tree fndecl),
1122  hook_bool_const_tree_false)
1123
1124 /* Return true if bitfields in RECORD_TYPE should follow the
1125    Microsoft Visual C++ bitfield layout rules.  */
1126 DEFHOOK
1127 (ms_bitfield_layout_p,
1128  "",
1129  bool, (const_tree record_type),
1130  hook_bool_const_tree_false)
1131
1132 /* For now this is only an interface to WORDS_BIG_ENDIAN for
1133    target-independent code like the front ends, need performance testing
1134    before switching completely to the target hook.  */
1135 DEFHOOK_UNDOC
1136 (words_big_endian,
1137  "",
1138  bool, (void),
1139  targhook_words_big_endian)
1140
1141 /* Likewise for FLOAT_WORDS_BIG_ENDIAN.  */
1142 DEFHOOK_UNDOC
1143 (float_words_big_endian,
1144  "",
1145  bool, (void),
1146  targhook_float_words_big_endian)
1147
1148 /* True if the target supports decimal floating point.  */
1149 DEFHOOK
1150 (decimal_float_supported_p,
1151  "",
1152  bool, (void),
1153  default_decimal_float_supported_p)
1154
1155 /* True if the target supports fixed-point.  */
1156 DEFHOOK
1157 (fixed_point_supported_p,
1158  "",
1159  bool, (void),
1160  default_fixed_point_supported_p)
1161
1162 /* Return true if anonymous bitfields affect structure alignment.  */
1163 DEFHOOK
1164 (align_anon_bitfield,
1165  "",
1166  bool, (void),
1167  hook_bool_void_false)
1168
1169 /* Return true if volatile bitfields should use the narrowest type possible.
1170    Return false if they should use the container type.  */
1171 DEFHOOK
1172 (narrow_volatile_bitfield,
1173  "",
1174  bool, (void),
1175  hook_bool_void_false)
1176
1177 /* Set up target-specific built-in functions.  */
1178 DEFHOOK
1179 (init_builtins,
1180  "",
1181  void, (void),
1182  hook_void_void)
1183
1184 /* Initialize (if INITIALIZE_P is true) and return the target-specific
1185    built-in function decl for CODE.
1186    Return NULL if that is not possible.  Return error_mark_node if CODE
1187    is outside of the range of valid target builtin function codes.  */
1188 DEFHOOK
1189 (builtin_decl,
1190  "",
1191  tree, (unsigned code, bool initialize_p), NULL)
1192
1193 /* Expand a target-specific builtin.  */
1194 DEFHOOK
1195 (expand_builtin,
1196  "",
1197  rtx,
1198  (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore),
1199  default_expand_builtin)
1200
1201 /* Select a replacement for a target-specific builtin.  This is done
1202    *before* regular type checking, and so allows the target to
1203    implement a crude form of function overloading.  The result is a
1204    complete expression that implements the operation.  PARAMS really
1205    has type VEC(tree,gc)*, but we don't want to include tree.h here.  */
1206 DEFHOOK
1207 (resolve_overloaded_builtin,
1208  "",
1209  tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL)
1210
1211 /* Fold a target-specific builtin.  */
1212 DEFHOOK
1213 (fold_builtin,
1214  "",
1215  tree, (tree fndecl, int n_args, tree *argp, bool ignore),
1216  hook_tree_tree_int_treep_bool_null)
1217
1218 /* Returns a code for a target-specific builtin that implements
1219    reciprocal of the function, or NULL_TREE if not available.  */
1220 DEFHOOK
1221 (builtin_reciprocal,
1222  "",
1223  tree, (unsigned fn, bool md_fn, bool sqrt),
1224  default_builtin_reciprocal)
1225
1226 /* For a vendor-specific TYPE, return a pointer to a statically-allocated
1227    string containing the C++ mangling for TYPE.  In all other cases, return
1228    NULL.  */
1229 DEFHOOK
1230 (mangle_type,
1231  "",
1232  const char *, (const_tree type),
1233  hook_constcharptr_const_tree_null)
1234
1235 /* Make any adjustments to libfunc names needed for this target.  */
1236 DEFHOOK
1237 (init_libfuncs,
1238  "",
1239  void, (void),
1240  hook_void_void)
1241
1242  /* Add a __gnu_ prefix to library functions rather than just __.  */
1243 DEFHOOKPOD
1244 (libfunc_gnu_prefix,
1245  "If false (the default), internal library routines start with two\n\
1246 underscores.  If set to true, these routines start with @code{__gnu_}\n\
1247 instead.  E.g., @code{__muldi3} changes to @code{__gnu_muldi3}.  This\n\
1248 currently only affects functions defined in @file{libgcc2.c}.  If this\n\
1249 is set to true, the @file{tm.h} file must also\n\
1250 @code{#define LIBGCC2_GNU_PREFIX}.",
1251   bool, false)
1252
1253 /* Given a decl, a section name, and whether the decl initializer
1254    has relocs, choose attributes for the section.  */
1255 /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION.  */
1256 DEFHOOK
1257 (section_type_flags,
1258  "",
1259  unsigned int, (tree decl, const char *name, int reloc),
1260  default_section_type_flags)
1261
1262 /* True if new jumps cannot be created, to replace existing ones or
1263    not, at the current point in the compilation.  */
1264 DEFHOOK
1265 (cannot_modify_jumps_p,
1266  "",
1267  bool, (void),
1268  hook_bool_void_false)
1269
1270 /* Return a register class for which branch target register
1271    optimizations should be applied.  */
1272 DEFHOOK
1273 (branch_target_register_class,
1274  "",
1275  reg_class_t, (void),
1276  default_branch_target_register_class)
1277
1278 /* Return true if branch target register optimizations should include
1279    callee-saved registers that are not already live during the current
1280    function.  AFTER_PE_GEN is true if prologues and epilogues have
1281    already been generated.  */
1282 DEFHOOK
1283 (branch_target_register_callee_saved,
1284  "",
1285  bool, (bool after_prologue_epilogue_gen),
1286  hook_bool_bool_false)
1287
1288 /* Return true if the target supports conditional execution.  */
1289 DEFHOOK
1290 (have_conditional_execution,
1291  "",
1292  bool, (void),
1293  default_have_conditional_execution)
1294
1295 /* Return a new value for loop unroll size.  */
1296 DEFHOOK
1297 (loop_unroll_adjust,
1298  "",
1299  unsigned, (unsigned nunroll, struct loop *loop),
1300  NULL)
1301
1302 /* True if X is a legitimate MODE-mode immediate operand.  */
1303 DEFHOOK
1304 (legitimate_constant_p,
1305  "",
1306  bool, (enum machine_mode mode, rtx x),
1307  hook_bool_mode_rtx_true)
1308
1309 /* True if the constant X cannot be placed in the constant pool.  */
1310 DEFHOOK
1311 (cannot_force_const_mem,
1312  "",
1313  bool, (enum machine_mode mode, rtx x),
1314  hook_bool_mode_rtx_false)
1315
1316 DEFHOOK_UNDOC
1317 (cannot_copy_insn_p,
1318  "True if the insn @var{x} cannot be duplicated.",
1319  bool, (rtx), NULL)
1320
1321 /* True if X is considered to be commutative.  */
1322 DEFHOOK
1323 (commutative_p,
1324  "",
1325  bool, (const_rtx x, int outer_code),
1326  hook_bool_const_rtx_commutative_p)
1327
1328 /* True if ADDR is an address-expression whose effect depends
1329    on the mode of the memory reference it is used in.  */
1330 DEFHOOK
1331 (mode_dependent_address_p,
1332  "",
1333  bool, (const_rtx addr),
1334  default_mode_dependent_address_p)
1335
1336 /* Given an invalid address X for a given machine mode, try machine-specific
1337    ways to make it legitimate.  Return X or an invalid address on failure.  */
1338 DEFHOOK
1339 (legitimize_address,
1340  "",
1341  rtx, (rtx x, rtx oldx, enum machine_mode mode),
1342  default_legitimize_address)
1343
1344 /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS.  */
1345 DEFHOOK
1346 (delegitimize_address,
1347  "",
1348  rtx, (rtx x),
1349  delegitimize_mem_from_attrs)
1350
1351 /* Given an address RTX, say whether it is valid.  */
1352 DEFHOOK
1353 (legitimate_address_p,
1354  "",
1355  bool, (enum machine_mode mode, rtx x, bool strict),
1356  default_legitimate_address_p)
1357
1358 /* True if the given constant can be put into an object_block.  */
1359 DEFHOOK
1360 (use_blocks_for_constant_p,
1361  "",
1362  bool, (enum machine_mode mode, const_rtx x),
1363  hook_bool_mode_const_rtx_false)
1364
1365 /* The minimum and maximum byte offsets for anchored addresses.  */
1366 DEFHOOKPOD
1367 (min_anchor_offset,
1368  "",
1369  HOST_WIDE_INT, 0)
1370
1371 DEFHOOKPOD
1372 (max_anchor_offset,
1373  "",
1374  HOST_WIDE_INT, 0)
1375
1376 /* True if section anchors can be used to access the given symbol.  */
1377 DEFHOOK
1378 (use_anchors_for_symbol_p,
1379  "",
1380  bool, (const_rtx x),
1381  default_use_anchors_for_symbol_p)
1382
1383 /* True if it is OK to do sibling call optimization for the specified
1384    call expression EXP.  DECL will be the called function, or NULL if
1385    this is an indirect call.  */
1386 DEFHOOK
1387 (function_ok_for_sibcall,
1388  "",
1389  bool, (tree decl, tree exp),
1390  hook_bool_tree_tree_false)
1391
1392 /* Establish appropriate back-end context for processing the function
1393    FNDECL.  The argument might be NULL to indicate processing at top
1394    level, outside of any function scope.  */
1395 DEFHOOK
1396 (set_current_function,
1397  "",
1398  void, (tree decl), hook_void_tree)
1399
1400 /* True if EXP should be placed in a "small data" section.  */
1401 DEFHOOK
1402 (in_small_data_p,
1403  "",
1404  bool, (const_tree exp),
1405  hook_bool_const_tree_false)
1406
1407 /* True if EXP names an object for which name resolution must resolve
1408    to the current executable or shared library.  */
1409 DEFHOOK
1410 (binds_local_p,
1411  "",
1412  bool, (const_tree exp),
1413  default_binds_local_p)
1414
1415 /* Check if profiling code is before or after prologue.  */
1416 DEFHOOK
1417 (profile_before_prologue,
1418  "It returns true if target wants profile code emitted before prologue.\n\n\
1419 The default version of this hook use the target macro\n\
1420 @code{PROFILE_BEFORE_PROLOGUE}.",
1421  bool, (void),
1422  default_profile_before_prologue)
1423
1424 /* Modify and return the identifier of a DECL's external name,
1425    originally identified by ID, as required by the target,
1426    (eg, append @nn to windows32 stdcall function names).
1427    The default is to return ID without modification. */
1428 DEFHOOK
1429 (mangle_decl_assembler_name,
1430  "",
1431  tree, (tree decl, tree  id),
1432  default_mangle_decl_assembler_name)
1433
1434 /* Do something target-specific to record properties of the DECL into
1435    the associated SYMBOL_REF.  */
1436 DEFHOOK
1437 (encode_section_info,
1438  "",
1439  void, (tree decl, rtx rtl, int new_decl_p),
1440  default_encode_section_info)
1441
1442 /* Undo the effects of encode_section_info on the symbol string.  */
1443 DEFHOOK
1444 (strip_name_encoding,
1445  "",
1446  const char *, (const char *name),
1447  default_strip_name_encoding)
1448
1449 /* If shift optabs for MODE are known to always truncate the shift count,
1450    return the mask that they apply.  Return 0 otherwise.  */
1451 DEFHOOK
1452 (shift_truncation_mask,
1453  "",
1454  unsigned HOST_WIDE_INT, (enum machine_mode mode),
1455  default_shift_truncation_mask)
1456
1457 /* Return the number of divisions in the given MODE that should be present,
1458    so that it is profitable to turn the division into a multiplication by
1459    the reciprocal.  */
1460 DEFHOOK
1461 (min_divisions_for_recip_mul,
1462  "",
1463  unsigned int, (enum machine_mode mode),
1464  default_min_divisions_for_recip_mul)
1465
1466 /* If the representation of integral MODE is such that values are
1467    always sign-extended to a wider mode MODE_REP then return
1468    SIGN_EXTEND.  Return UNKNOWN otherwise.  */
1469 /* Note that the return type ought to be RTX_CODE, but that's not
1470    necessarily defined at this point.  */
1471 DEFHOOK
1472 (mode_rep_extended,
1473  "",
1474  int, (enum machine_mode mode, enum machine_mode rep_mode),
1475  default_mode_rep_extended)
1476
1477 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
1478 DEFHOOK
1479 (valid_pointer_mode,
1480  "",
1481  bool, (enum machine_mode mode),
1482  default_valid_pointer_mode)
1483
1484 /* Disambiguate with errno.  */
1485 DEFHOOK
1486 (ref_may_alias_errno,
1487  "Define this to return nonzero if the memory reference @var{ref}\
1488   may alias with the system C library errno location.  The default\
1489   version of this hook assumes the system C library errno location\
1490   is either a declaration of type int or accessed by dereferencing\
1491   a pointer to int.",
1492  bool, (struct ao_ref_s *ref),
1493  default_ref_may_alias_errno)
1494
1495 /* Support for named address spaces.  */
1496 #undef HOOK_PREFIX
1497 #define HOOK_PREFIX "TARGET_ADDR_SPACE_"
1498 HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space)
1499
1500 /* MODE to use for a pointer into another address space.  */
1501 DEFHOOK
1502 (pointer_mode,
1503  "",
1504  enum machine_mode, (addr_space_t address_space),
1505  default_addr_space_pointer_mode)
1506
1507 /* MODE to use for an address in another address space.  */
1508 DEFHOOK
1509 (address_mode,
1510  "",
1511  enum machine_mode, (addr_space_t address_space),
1512  default_addr_space_address_mode)
1513
1514 /* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
1515    in another address space.  */
1516 DEFHOOK
1517 (valid_pointer_mode,
1518  "",
1519  bool, (enum machine_mode mode, addr_space_t as),
1520  default_addr_space_valid_pointer_mode)
1521
1522 /* True if an address is a valid memory address to a given named address
1523    space for a given mode.  */
1524 DEFHOOK
1525 (legitimate_address_p,
1526  "",
1527  bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as),
1528  default_addr_space_legitimate_address_p)
1529
1530 /* Return an updated address to convert an invalid pointer to a named
1531    address space to a valid one.  If NULL_RTX is returned use machine
1532    independent methods to make the address valid.  */
1533 DEFHOOK
1534 (legitimize_address,
1535  "",
1536  rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as),
1537  default_addr_space_legitimize_address)
1538
1539 /* True if one named address space is a subset of another named address. */
1540 DEFHOOK
1541 (subset_p,
1542  "",
1543  bool, (addr_space_t subset, addr_space_t superset),
1544  default_addr_space_subset_p)
1545
1546 /* Function to convert an rtl expression from one address space to another.  */
1547 DEFHOOK
1548 (convert,
1549  "",
1550  rtx, (rtx op, tree from_type, tree to_type),
1551  default_addr_space_convert)
1552
1553 HOOK_VECTOR_END (addr_space)
1554
1555 #undef HOOK_PREFIX
1556 #define HOOK_PREFIX "TARGET_"
1557
1558 /* True if MODE is valid for the target.  By "valid", we mean able to
1559    be manipulated in non-trivial ways.  In particular, this means all
1560    the arithmetic is supported.  */
1561 DEFHOOK
1562 (scalar_mode_supported_p,
1563  "",
1564  bool, (enum machine_mode mode),
1565  default_scalar_mode_supported_p)
1566
1567 /* Similarly for vector modes.  "Supported" here is less strict.  At
1568    least some operations are supported; need to check optabs or builtins
1569    for further details.  */
1570 DEFHOOK
1571 (vector_mode_supported_p,
1572  "",
1573  bool, (enum machine_mode mode),
1574  hook_bool_mode_false)
1575
1576 /* True if we should try to use a scalar mode to represent an array,
1577    overriding the usual MAX_FIXED_MODE limit.  */
1578 DEFHOOK
1579 (array_mode_supported_p,
1580  "Return true if GCC should try to use a scalar mode to store an array\n\
1581 of @var{nelems} elements, given that each element has mode @var{mode}.\n\
1582 Returning true here overrides the usual @code{MAX_FIXED_MODE} limit\n\
1583 and allows GCC to use any defined integer mode.\n\
1584 \n\
1585 One use of this hook is to support vector load and store operations\n\
1586 that operate on several homogeneous vectors.  For example, ARM NEON\n\
1587 has operations like:\n\
1588 \n\
1589 @smallexample\n\
1590 int8x8x3_t vld3_s8 (const int8_t *)\n\
1591 @end smallexample\n\
1592 \n\
1593 where the return type is defined as:\n\
1594 \n\
1595 @smallexample\n\
1596 typedef struct int8x8x3_t\n\
1597 @{\n\
1598   int8x8_t val[3];\n\
1599 @} int8x8x3_t;\n\
1600 @end smallexample\n\
1601 \n\
1602 If this hook allows @code{val} to have a scalar mode, then\n\
1603 @code{int8x8x3_t} can have the same mode.  GCC can then store\n\
1604 @code{int8x8x3_t}s in registers rather than forcing them onto the stack.",
1605  bool, (enum machine_mode mode, unsigned HOST_WIDE_INT nelems),
1606  hook_bool_mode_uhwi_false)
1607
1608 /* Compute cost of moving data from a register of class FROM to one of
1609    TO, using MODE.  */
1610 DEFHOOK
1611 (register_move_cost,
1612  "",
1613  int, (enum machine_mode mode, reg_class_t from, reg_class_t to),
1614  default_register_move_cost)
1615
1616 /* Compute cost of moving registers to/from memory.  */
1617 /* ??? Documenting the argument types for this hook requires a GFDL
1618    license grant.  Also, the documentation uses a different name for RCLASS.  */
1619 DEFHOOK
1620 (memory_move_cost,
1621  "",
1622  int, (enum machine_mode mode, reg_class_t rclass, bool in),
1623  default_memory_move_cost)
1624
1625 /* True for MODE if the target expects that registers in this mode will
1626    be allocated to registers in a small register class.  The compiler is
1627    allowed to use registers explicitly used in the rtl as spill registers
1628    but it should prevent extending the lifetime of these registers.  */
1629 DEFHOOK
1630 (small_register_classes_for_mode_p,
1631  "",
1632  bool, (enum machine_mode mode),
1633  hook_bool_mode_false)
1634
1635 /* Register number for a flags register.  Only needs to be defined if the
1636    target is constrainted to use post-reload comparison elimination.  */
1637 DEFHOOKPOD
1638 (flags_regnum,
1639  "If the target has a dedicated flags register, and it needs to use the\
1640  post-reload comparison elimination pass, then this value should be set\
1641  appropriately.",
1642  unsigned int, INVALID_REGNUM)
1643
1644 /* Compute a (partial) cost for rtx X.  Return true if the complete
1645    cost has been computed, and false if subexpressions should be
1646    scanned.  In either case, *TOTAL contains the cost result.  */
1647 /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
1648    not necessarily defined at this point.  */
1649 DEFHOOK
1650 (rtx_costs,
1651  "",
1652  bool, (rtx x, int code, int outer_code, int opno, int *total, bool speed),
1653  hook_bool_rtx_int_int_int_intp_bool_false)
1654
1655 /* Compute the cost of X, used as an address.  Never called with
1656    invalid addresses.  */
1657 DEFHOOK
1658 (address_cost,
1659  "",
1660  int, (rtx address, bool speed),
1661  default_address_cost)
1662
1663 /* Return where to allocate pseudo for a given hard register initial value.  */
1664 DEFHOOK
1665 (allocate_initial_value,
1666  "",
1667  rtx, (rtx hard_reg), NULL)
1668
1669 /* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
1670    FLAGS has the same meaning as in rtlanal.c: may_trap_p_1.  */
1671 DEFHOOK
1672 (unspec_may_trap_p,
1673  "",
1674  int, (const_rtx x, unsigned flags),
1675  default_unspec_may_trap_p)
1676
1677 /* Given a register, this hook should return a parallel of registers
1678    to represent where to find the register pieces.  Define this hook
1679    if the register and its mode are represented in Dwarf in
1680    non-contiguous locations, or if the register should be
1681    represented in more than one register in Dwarf.  Otherwise, this
1682    hook should return NULL_RTX.  */
1683 DEFHOOK
1684 (dwarf_register_span,
1685  "",
1686  rtx, (rtx reg),
1687  hook_rtx_rtx_null)
1688
1689 /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
1690    entries not corresponding directly to registers below
1691    FIRST_PSEUDO_REGISTER, this hook should generate the necessary
1692    code, given the address of the table.  */
1693 DEFHOOK
1694 (init_dwarf_reg_sizes_extra,
1695  "",
1696  void, (tree address),
1697  hook_void_tree)
1698
1699 /* Fetch the fixed register(s) which hold condition codes, for
1700    targets where it makes sense to look for duplicate assignments to
1701    the condition codes.  This should return true if there is such a
1702    register, false otherwise.  The arguments should be set to the
1703    fixed register numbers.  Up to two condition code registers are
1704    supported.  If there is only one for this target, the int pointed
1705    at by the second argument should be set to -1.  */
1706 DEFHOOK
1707 (fixed_condition_code_regs,
1708  "",
1709  bool, (unsigned int *p1, unsigned int *p2),
1710  hook_bool_uintp_uintp_false)
1711
1712 /* If two condition code modes are compatible, return a condition
1713      code mode which is compatible with both, such that a comparison
1714      done in the returned mode will work for both of the original
1715      modes.  If the condition code modes are not compatible, return
1716      VOIDmode.  */
1717 DEFHOOK
1718 (cc_modes_compatible,
1719  "",
1720  enum machine_mode, (enum machine_mode m1, enum machine_mode m2),
1721  default_cc_modes_compatible)
1722
1723 /* Do machine-dependent code transformations.  Called just before
1724      delayed-branch scheduling.  */
1725 DEFHOOK
1726 (machine_dependent_reorg,
1727  "",
1728  void, (void), NULL)
1729
1730 /* Create the __builtin_va_list type.  */
1731 DEFHOOK
1732 (build_builtin_va_list,
1733  "",
1734  tree, (void),
1735  std_build_builtin_va_list)
1736
1737 /* Enumerate the va list variants.  */
1738 DEFHOOK
1739 (enum_va_list_p,
1740  "",
1741  int, (int idx, const char **pname, tree *ptree),
1742  NULL)
1743
1744 /* Get the cfun/fndecl calling abi __builtin_va_list type.  */
1745 DEFHOOK
1746 (fn_abi_va_list,
1747  "",
1748  tree, (tree fndecl),
1749  std_fn_abi_va_list)
1750
1751 /* Get the __builtin_va_list type dependent on input type.  */
1752 DEFHOOK
1753 (canonical_va_list_type,
1754  "",
1755  tree, (tree type),
1756  std_canonical_va_list_type)
1757
1758 /* ??? Documenting this hook requires a GFDL license grant.  */
1759 DEFHOOK_UNDOC
1760 (expand_builtin_va_start,
1761 "Expand the @code{__builtin_va_start} builtin.",
1762  void, (tree valist, rtx nextarg), NULL)
1763
1764 /* Gimplifies a VA_ARG_EXPR.  */
1765 DEFHOOK
1766 (gimplify_va_arg_expr,
1767  "",
1768  tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p),
1769  std_gimplify_va_arg_expr)
1770
1771 /* Validity-checking routines for PCH files, target-specific.
1772    get_pch_validity returns a pointer to the data to be stored,
1773    and stores the size in its argument.  pch_valid_p gets the same
1774    information back and returns NULL if the PCH is valid,
1775    or an error message if not.  */
1776 DEFHOOK
1777 (get_pch_validity,
1778  "",
1779  void *, (size_t *sz),
1780  default_get_pch_validity)
1781
1782 DEFHOOK
1783 (pch_valid_p,
1784  "",
1785  const char *, (const void *data, size_t sz),
1786  default_pch_valid_p)
1787
1788 /* If nonnull, this function checks whether a PCH file with the
1789    given set of target flags can be used.  It returns NULL if so,
1790    otherwise it returns an error message.  */
1791 DEFHOOK
1792 (check_pch_target_flags,
1793  "",
1794  const char *, (int pch_flags), NULL)
1795
1796 /* True if the compiler should give an enum type only as many
1797    bytes as it takes to represent the range of possible values of
1798    that type.  */
1799 DEFHOOK
1800 (default_short_enums,
1801  "",
1802  bool, (void),
1803  hook_bool_void_false)
1804
1805 /* This target hook returns an rtx that is used to store the address
1806    of the current frame into the built-in setjmp buffer.  */
1807 DEFHOOK
1808 (builtin_setjmp_frame_value,
1809  "",
1810  rtx, (void),
1811  default_builtin_setjmp_frame_value)
1812
1813 /* This target hook should add STRING_CST trees for any hard regs
1814    the port wishes to automatically clobber for an asm.  */
1815 DEFHOOK
1816 (md_asm_clobbers,
1817  "",
1818  tree, (tree outputs, tree inputs, tree clobbers),
1819  hook_tree_tree_tree_tree_3rd_identity)
1820
1821 /* This target hook allows the backend to specify a calling convention
1822    in the debug information.  This function actually returns an
1823    enum dwarf_calling_convention, but because of forward declarations
1824    and not wanting to include dwarf2.h everywhere target.h is included
1825    the function is being declared as an int.  */
1826 DEFHOOK
1827 (dwarf_calling_convention,
1828  "",
1829  int, (const_tree function),
1830  hook_int_const_tree_0)
1831
1832 /* This target hook allows the backend to emit frame-related insns that
1833    contain UNSPECs or UNSPEC_VOLATILEs.  The call frame debugging info
1834    engine will invoke it on insns of the form
1835      (set (reg) (unspec [...] UNSPEC_INDEX))
1836    and
1837      (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
1838    to let the backend emit the call frame instructions.  */
1839 DEFHOOK
1840 (dwarf_handle_frame_unspec,
1841  "",
1842  void, (const char *label, rtx pattern, int index), NULL)
1843
1844 /* ??? Documenting this hook requires a GFDL license grant.  */
1845 DEFHOOK_UNDOC
1846 (stdarg_optimize_hook,
1847 "Perform architecture specific checking of statements gimplified\
1848  from @code{VA_ARG_EXPR}.  @var{stmt} is the statement.  Returns true if\
1849  the statement doesn't need to be checked for @code{va_list} references.",
1850  bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
1851
1852 /* This target hook allows the operating system to override the DECL
1853    that represents the external variable that contains the stack
1854    protection guard variable.  The type of this DECL is ptr_type_node.  */
1855 DEFHOOK
1856 (stack_protect_guard,
1857  "",
1858  tree, (void),
1859  default_stack_protect_guard)
1860
1861 /* This target hook allows the operating system to override the CALL_EXPR
1862    that is invoked when a check vs the guard variable fails.  */
1863 DEFHOOK
1864 (stack_protect_fail,
1865  "",
1866  tree, (void),
1867  default_external_stack_protect_fail)
1868
1869 /* Returns NULL if target supports the insn within a doloop block,
1870    otherwise it returns an error message.  */
1871 DEFHOOK
1872 (invalid_within_doloop,
1873  "",
1874  const char *, (const_rtx insn),
1875  default_invalid_within_doloop)
1876
1877 DEFHOOK
1878 (valid_dllimport_attribute_p,
1879 "@var{decl} is a variable or function with @code{__attribute__((dllimport))}\
1880  specified.  Use this hook if the target needs to add extra validation\
1881  checks to @code{handle_dll_attribute}.",
1882  bool, (const_tree decl),
1883  hook_bool_const_tree_true)
1884
1885 /* If non-zero, align constant anchors in CSE to a multiple of this
1886    value.  */
1887 DEFHOOKPOD
1888 (const_anchor,
1889  "",
1890  unsigned HOST_WIDE_INT, 0)
1891
1892 /* Functions relating to calls - argument passing, returns, etc.  */
1893 /* Members of struct call have no special macro prefix.  */
1894 HOOK_VECTOR (TARGET_CALLS, calls)
1895
1896 DEFHOOK
1897 (promote_function_mode,
1898  "",
1899  enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp,
1900                      const_tree funtype, int for_return),
1901  default_promote_function_mode)
1902
1903 DEFHOOK
1904 (promote_prototypes,
1905  "",
1906  bool, (const_tree fntype),
1907  hook_bool_const_tree_false)
1908
1909 DEFHOOK
1910 (struct_value_rtx,
1911  "",
1912  rtx, (tree fndecl, int incoming),
1913  hook_rtx_tree_int_null)
1914 DEFHOOK
1915 (return_in_memory,
1916  "",
1917  bool, (const_tree type, const_tree fntype),
1918  default_return_in_memory)
1919
1920 DEFHOOK
1921 (return_in_msb,
1922  "",
1923  bool, (const_tree type),
1924  hook_bool_const_tree_false)
1925
1926 /* Return true if a parameter must be passed by reference.  TYPE may
1927    be null if this is a libcall.  CA may be null if this query is
1928    from __builtin_va_arg.  */
1929 DEFHOOK
1930 (pass_by_reference,
1931  "",
1932  bool,
1933  (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named),
1934  hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
1935
1936 DEFHOOK
1937 (expand_builtin_saveregs,
1938  "",
1939  rtx, (void),
1940  default_expand_builtin_saveregs)
1941
1942 /* Returns pretend_argument_size.  */
1943 DEFHOOK
1944 (setup_incoming_varargs,
1945  "",
1946  void, (cumulative_args_t args_so_far, enum machine_mode mode, tree type,
1947         int *pretend_args_size, int second_time),
1948  default_setup_incoming_varargs)
1949
1950 DEFHOOK
1951 (strict_argument_naming,
1952  "",
1953  bool, (cumulative_args_t ca),
1954  hook_bool_CUMULATIVE_ARGS_false)
1955
1956 /* Returns true if we should use
1957    targetm.calls.setup_incoming_varargs() and/or
1958    targetm.calls.strict_argument_naming().  */
1959 DEFHOOK
1960 (pretend_outgoing_varargs_named,
1961  "",
1962  bool, (cumulative_args_t ca),
1963  default_pretend_outgoing_varargs_named)
1964
1965 /* Given a complex type T, return true if a parameter of type T
1966    should be passed as two scalars.  */
1967 DEFHOOK
1968 (split_complex_arg,
1969  "",
1970  bool, (const_tree type), NULL)
1971
1972 /* Return true if type T, mode MODE, may not be passed in registers,
1973    but must be passed on the stack.  */
1974 /* ??? This predicate should be applied strictly after pass-by-reference.
1975    Need audit to verify that this is the case.  */
1976 DEFHOOK
1977 (must_pass_in_stack,
1978  "",
1979  bool, (enum machine_mode mode, const_tree type),
1980  must_pass_in_stack_var_size_or_pad)
1981
1982 /* Return true if type TYPE, mode MODE, which is passed by reference,
1983    should have the object copy generated by the callee rather than
1984    the caller.  It is never called for TYPE requiring constructors.  */
1985 DEFHOOK
1986 (callee_copies,
1987  "",
1988  bool,
1989  (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named),
1990  hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
1991
1992 /* Return zero for arguments passed entirely on the stack or entirely
1993    in registers.  If passed in both, return the number of bytes passed
1994    in registers; the balance is therefore passed on the stack.  */
1995 DEFHOOK
1996 (arg_partial_bytes,
1997  "",
1998  int, (cumulative_args_t cum, enum machine_mode mode, tree type, bool named),
1999  hook_int_CUMULATIVE_ARGS_mode_tree_bool_0)
2000
2001 /* Update the state in CA to advance past an argument in the
2002    argument list.  The values MODE, TYPE, and NAMED describe that
2003    argument.  */
2004 DEFHOOK
2005 (function_arg_advance,
2006  "",
2007  void,
2008  (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named),
2009  default_function_arg_advance)
2010
2011 /* Return zero if the argument described by the state of CA should
2012    be placed on a stack, or a hard register in which to store the
2013    argument.  The values MODE, TYPE, and NAMED describe that
2014    argument.  */
2015 DEFHOOK
2016 (function_arg,
2017  "",
2018  rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type,
2019        bool named),
2020  default_function_arg)
2021
2022 /* Likewise, but for machines with register windows.  Return the
2023    location where the argument will appear to the callee.  */
2024 DEFHOOK
2025 (function_incoming_arg,
2026  "",
2027  rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type,
2028        bool named),
2029  default_function_incoming_arg)
2030
2031 DEFHOOK
2032 (function_arg_boundary,
2033  "",
2034  unsigned int, (enum machine_mode mode, const_tree type),
2035  default_function_arg_boundary)
2036
2037 DEFHOOK
2038 (function_arg_round_boundary,
2039  "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\
2040 which is the default value for this hook.  You can define this hook to\n\
2041 return a different value if an argument size must be rounded to a larger\n\
2042 value.",
2043  unsigned int, (enum machine_mode mode, const_tree type),
2044  default_function_arg_round_boundary)
2045
2046 /* Return the diagnostic message string if function without a prototype
2047    is not allowed for this 'val' argument; NULL otherwise. */
2048 DEFHOOK
2049 (invalid_arg_for_unprototyped_fn,
2050  "",
2051  const char *, (const_tree typelist, const_tree funcdecl, const_tree val),
2052  hook_invalid_arg_for_unprototyped_fn)
2053
2054 /* Return an rtx for the return value location of the function
2055    specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
2056 DEFHOOK
2057 (function_value,
2058  "",
2059  rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
2060  default_function_value)
2061
2062 /* Return the rtx for the result of a libcall of mode MODE,
2063    calling the function FN_NAME.  */
2064 DEFHOOK
2065 (libcall_value,
2066  "",
2067  rtx, (enum machine_mode mode, const_rtx fun),
2068  default_libcall_value)
2069
2070 /* Return true if REGNO is a possible register number for
2071    a function value as seen by the caller.  */
2072 DEFHOOK
2073 (function_value_regno_p,
2074  "",
2075  bool, (const unsigned int regno),
2076  default_function_value_regno_p)
2077
2078 /* ??? Documenting this hook requires a GFDL license grant.  */
2079 DEFHOOK_UNDOC
2080 (internal_arg_pointer,
2081 "Return an rtx for the argument pointer incoming to the\
2082  current function.",
2083  rtx, (void),
2084  default_internal_arg_pointer)
2085
2086 /* Update the current function stack boundary if needed.  */
2087 DEFHOOK
2088 (update_stack_boundary,
2089  "",
2090  void, (void), NULL)
2091
2092 /* Handle stack alignment and return an rtx for Dynamic Realign
2093    Argument Pointer if necessary.  */
2094 DEFHOOK
2095 (get_drap_rtx,
2096  "",
2097  rtx, (void), NULL)
2098
2099 /* Return true if all function parameters should be spilled to the
2100    stack.  */
2101 DEFHOOK
2102 (allocate_stack_slots_for_args,
2103  "",
2104  bool, (void),
2105  hook_bool_void_true)
2106
2107 /* Return an rtx for the static chain for FNDECL.  If INCOMING_P is true,
2108        then it should be for the callee; otherwise for the caller.  */
2109 DEFHOOK
2110 (static_chain,
2111  "",
2112  rtx, (const_tree fndecl, bool incoming_p),
2113  default_static_chain)
2114
2115 /* Fill in the trampoline at MEM with a call to FNDECL and a
2116    static chain value of CHAIN.  */
2117 DEFHOOK
2118 (trampoline_init,
2119  "",
2120  void, (rtx m_tramp, tree fndecl, rtx static_chain),
2121  default_trampoline_init)
2122
2123 /* Adjust the address of the trampoline in a target-specific way.  */
2124 DEFHOOK
2125 (trampoline_adjust_address,
2126  "",
2127  rtx, (rtx addr), NULL)
2128
2129 /* Return the number of bytes of its own arguments that a function
2130    pops on returning, or 0 if the function pops no arguments and the
2131    caller must therefore pop them all after the function returns.  */
2132 /* ??? tm.texi has no types for the parameters.  */
2133 DEFHOOK
2134 (return_pops_args,
2135  "",
2136  int, (tree fundecl, tree funtype, int size),
2137  default_return_pops_args)
2138
2139 /* Return a mode wide enough to copy any function value that might be
2140    returned.  */
2141 DEFHOOK
2142 (get_raw_result_mode,
2143  "This target hook returns the mode to be used when accessing raw return\
2144  registers in @code{__builtin_return}.  Define this macro if the value\
2145  in @var{reg_raw_mode} is not correct.",
2146  enum machine_mode, (int regno),
2147  default_get_reg_raw_mode)
2148
2149 /* Return a mode wide enough to copy any argument value that might be
2150    passed.  */
2151 DEFHOOK
2152 (get_raw_arg_mode,
2153  "This target hook returns the mode to be used when accessing raw argument\
2154  registers in @code{__builtin_apply_args}.  Define this macro if the value\
2155  in @var{reg_raw_mode} is not correct.",
2156  enum machine_mode, (int regno),
2157  default_get_reg_raw_mode)
2158
2159 HOOK_VECTOR_END (calls)
2160
2161 /* Return the diagnostic message string if conversion from FROMTYPE
2162    to TOTYPE is not allowed, NULL otherwise.  */
2163 DEFHOOK
2164 (invalid_conversion,
2165  "",
2166  const char *, (const_tree fromtype, const_tree totype),
2167  hook_constcharptr_const_tree_const_tree_null)
2168
2169 /* Return the diagnostic message string if the unary operation OP is
2170    not permitted on TYPE, NULL otherwise.  */
2171 DEFHOOK
2172 (invalid_unary_op,
2173  "",
2174  const char *, (int op, const_tree type),
2175  hook_constcharptr_int_const_tree_null)
2176
2177 /* Return the diagnostic message string if the binary operation OP
2178    is not permitted on TYPE1 and TYPE2, NULL otherwise.  */
2179 DEFHOOK
2180 (invalid_binary_op,
2181  "",
2182  const char *, (int op, const_tree type1, const_tree type2),
2183  hook_constcharptr_int_const_tree_const_tree_null)
2184
2185 /* Return the diagnostic message string if TYPE is not valid as a
2186    function parameter type, NULL otherwise.  */
2187 DEFHOOK
2188 (invalid_parameter_type,
2189  "",
2190  const char *, (const_tree type),
2191  hook_constcharptr_const_tree_null)
2192
2193 /* Return the diagnostic message string if TYPE is not valid as a
2194    function return type, NULL otherwise.  */
2195 DEFHOOK
2196 (invalid_return_type,
2197  "",
2198  const char *, (const_tree type),
2199  hook_constcharptr_const_tree_null)
2200
2201 /* If values of TYPE are promoted to some other type when used in
2202    expressions (analogous to the integer promotions), return that type,
2203    or NULL_TREE otherwise.  */
2204 DEFHOOK
2205 (promoted_type,
2206  "",
2207  tree, (const_tree type),
2208  hook_tree_const_tree_null)
2209
2210 /* Convert EXPR to TYPE, if target-specific types with special conversion
2211    rules are involved.  Return the converted expression, or NULL to apply
2212    the standard conversion rules.  */
2213 DEFHOOK
2214 (convert_to_type,
2215  "",
2216  tree, (tree type, tree expr),
2217  hook_tree_tree_tree_null)
2218
2219 /* Return the class for a secondary reload, and fill in extra information.  */
2220 DEFHOOK
2221 (secondary_reload,
2222  "",
2223  reg_class_t,
2224  (bool in_p, rtx x, reg_class_t reload_class, enum machine_mode reload_mode,
2225   secondary_reload_info *sri),
2226  default_secondary_reload)
2227
2228 /* Given an rtx X being reloaded into a reg required to be in class CLASS,
2229    return the class of reg to actually use.  */
2230 DEFHOOK
2231 (preferred_reload_class,
2232  "",
2233  reg_class_t,
2234  (rtx x, reg_class_t rclass),
2235  default_preferred_reload_class)
2236
2237 /* Like TARGET_PREFERRED_RELOAD_CLASS, but for output reloads instead of
2238    input reloads.  */
2239 DEFHOOK
2240 (preferred_output_reload_class,
2241  "",
2242  reg_class_t,
2243  (rtx x, reg_class_t rclass),
2244  default_preferred_output_reload_class)
2245
2246 DEFHOOK
2247 (class_likely_spilled_p,
2248  "",
2249  bool, (reg_class_t rclass),
2250  default_class_likely_spilled_p)
2251
2252 /* Return the maximum number of consecutive registers
2253    needed to represent mode MODE in a register of class RCLASS.  */
2254 DEFHOOK
2255 (class_max_nregs,
2256  "",
2257  unsigned char, (reg_class_t rclass, enum machine_mode mode),
2258  default_class_max_nregs)
2259
2260 DEFHOOK
2261 (preferred_rename_class,
2262  "A target hook that places additional preference on the register\
2263  class to use when it is necessary to rename a register in class\
2264  @var{rclass} to another class, or perhaps @var{NO_REGS}, if no\
2265  preferred register class is found or hook @code{preferred_rename_class}\
2266  is not implemented.\
2267  Sometimes returning a more restrictive class makes better code.  For\
2268  example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\
2269  smaller than instructions using @code{GENERIC_REGS}.  By returning\
2270  @code{LO_REGS} from @code{preferred_rename_class}, code size can\
2271  be reduced.",
2272  reg_class_t, (reg_class_t rclass),
2273  default_preferred_rename_class)
2274
2275 /* This target hook allows the backend to perform additional
2276    processing while initializing for variable expansion.  */
2277 DEFHOOK
2278 (expand_to_rtl_hook,
2279  "",
2280  void, (void),
2281  hook_void_void)
2282
2283 /* This target hook allows the backend to perform additional
2284    instantiations on rtx that are not actually in insns yet,
2285    but will be later.  */
2286 DEFHOOK
2287 (instantiate_decls,
2288  "",
2289  void, (void),
2290  hook_void_void)
2291
2292 /* Return true if is OK to use a hard register REGNO as scratch register
2293    in peephole2.  */
2294 DEFHOOK
2295 (hard_regno_scratch_ok,
2296  "",
2297  bool, (unsigned int regno),
2298  default_hard_regno_scratch_ok)
2299
2300 /* Return the smallest number of different values for which it is best to
2301    use a jump-table instead of a tree of conditional branches.  */
2302 DEFHOOK
2303 (case_values_threshold,
2304  "",
2305  unsigned int, (void),
2306  default_case_values_threshold)
2307
2308 /* Retutn true if a function must have and use a frame pointer.  */
2309 DEFHOOK
2310 (frame_pointer_required,
2311  "",
2312  bool, (void),
2313  hook_bool_void_false)
2314
2315 /* Returns true if the compiler is allowed to try to replace register number
2316    from-reg with register number to-reg.  */
2317 DEFHOOK
2318 (can_eliminate,
2319  "",
2320  bool, (const int from_reg, const int to_reg),
2321  hook_bool_const_int_const_int_true)
2322
2323 /* Modify any or all of fixed_regs, call_used_regs, global_regs,
2324    reg_names, and reg_class_contents to account of the vagaries of the
2325    target.  */
2326 DEFHOOK
2327 (conditional_register_usage,
2328  "",
2329  void, (void),
2330  hook_void_void)
2331
2332 /* Functions specific to the C family of frontends.  */
2333 #undef HOOK_PREFIX
2334 #define HOOK_PREFIX "TARGET_C_"
2335 HOOK_VECTOR (TARGET_C, c)
2336
2337 /* ??? Documenting this hook requires a GFDL license grant.  */
2338 DEFHOOK_UNDOC
2339 (mode_for_suffix,
2340 "Return machine mode for non-standard constant literal suffix @var{c},\
2341  or VOIDmode if non-standard suffixes are unsupported.",
2342  enum machine_mode, (char c),
2343  default_mode_for_suffix)
2344
2345 HOOK_VECTOR_END (c)
2346
2347 /* Functions specific to the C++ frontend.  */
2348 #undef HOOK_PREFIX
2349 #define HOOK_PREFIX "TARGET_CXX_"
2350 HOOK_VECTOR (TARGET_CXX, cxx)
2351
2352 /* Return the integer type used for guard variables.  */
2353 DEFHOOK
2354 (guard_type,
2355  "",
2356  tree, (void),
2357  default_cxx_guard_type)
2358
2359 /* Return true if only the low bit of the guard should be tested.  */
2360 DEFHOOK
2361 (guard_mask_bit,
2362  "",
2363  bool, (void),
2364  hook_bool_void_false)
2365
2366 /* Returns the size of the array cookie for an array of type.  */
2367 DEFHOOK
2368 (get_cookie_size,
2369  "",
2370  tree, (tree type),
2371  default_cxx_get_cookie_size)
2372
2373 /* Returns true if the element size should be stored in the array cookie.  */
2374 DEFHOOK
2375 (cookie_has_size,
2376  "",
2377  bool, (void),
2378  hook_bool_void_false)
2379
2380 /* Allows backends to perform additional processing when
2381    deciding if a class should be exported or imported.  */
2382 DEFHOOK
2383 (import_export_class,
2384  "",
2385  int, (tree type, int import_export), NULL)
2386
2387 /* Returns true if constructors and destructors return "this".  */
2388 DEFHOOK
2389 (cdtor_returns_this,
2390  "",
2391  bool, (void),
2392  hook_bool_void_false)
2393
2394 /* Returns true if the key method for a class can be an inline
2395    function, so long as it is not declared inline in the class
2396    itself.  Returning true is the behavior required by the Itanium C++ ABI.  */
2397 DEFHOOK
2398 (key_method_may_be_inline,
2399  "",
2400  bool, (void),
2401  hook_bool_void_true)
2402
2403 DEFHOOK
2404 (determine_class_data_visibility,
2405 "@var{decl} is a virtual table, virtual table table, typeinfo object,\
2406  or other similar implicit class data object that will be emitted with\
2407  external linkage in this translation unit.  No ELF visibility has been\
2408  explicitly specified.  If the target needs to specify a visibility\
2409  other than that of the containing class, use this hook to set\
2410  @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
2411  void, (tree decl),
2412  hook_void_tree)
2413
2414 /* Returns true (the default) if virtual tables and other
2415    similar implicit class data objects are always COMDAT if they
2416    have external linkage.  If this hook returns false, then
2417    class data for classes whose virtual table will be emitted in
2418    only one translation unit will not be COMDAT.  */
2419 DEFHOOK
2420 (class_data_always_comdat,
2421  "",
2422  bool, (void),
2423  hook_bool_void_true)
2424
2425 /* Returns true (the default) if the RTTI for the basic types,
2426    which is always defined in the C++ runtime, should be COMDAT;
2427    false if it should not be COMDAT.  */
2428 DEFHOOK
2429 (library_rtti_comdat,
2430  "",
2431  bool, (void),
2432  hook_bool_void_true)
2433
2434 /* Returns true if __aeabi_atexit should be used to register static
2435    destructors.  */
2436 DEFHOOK
2437 (use_aeabi_atexit,
2438  "",
2439  bool, (void),
2440  hook_bool_void_false)
2441
2442 /* Returns true if target may use atexit in the same manner as
2443    __cxa_atexit  to register static destructors.  */
2444 DEFHOOK
2445 (use_atexit_for_cxa_atexit,
2446  "",
2447  bool, (void),
2448  hook_bool_void_false)
2449
2450 DEFHOOK
2451 (adjust_class_at_definition,
2452 "@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\
2453  been defined.  Use this hook to make adjustments to the class (eg, tweak\
2454  visibility or perform any other required target modifications).",
2455  void, (tree type),
2456  hook_void_tree)
2457
2458 DEFHOOK
2459 (decl_mangling_context,
2460  "Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.",
2461  tree, (const_tree decl),
2462  hook_tree_const_tree_null)
2463
2464 HOOK_VECTOR_END (cxx)
2465
2466 /* Functions and data for emulated TLS support.  */
2467 #undef HOOK_PREFIX
2468 #define HOOK_PREFIX "TARGET_EMUTLS_"
2469 HOOK_VECTOR (TARGET_EMUTLS, emutls)
2470
2471 /* Name of the address and common functions.  */
2472 DEFHOOKPOD
2473 (get_address,
2474  "",
2475  const char *, "__builtin___emutls_get_address")
2476
2477 DEFHOOKPOD
2478 (register_common,
2479  "",
2480  const char *, "__builtin___emutls_register_common")
2481
2482 /* Prefixes for proxy variable and template.  */
2483 DEFHOOKPOD
2484 (var_section,
2485  "",
2486  const char *, NULL)
2487
2488 DEFHOOKPOD
2489 (tmpl_section,
2490  "",
2491  const char *, NULL)
2492
2493 /* Prefixes for proxy variable and template.  */
2494 DEFHOOKPOD
2495 (var_prefix,
2496  "",
2497  const char *, NULL)
2498
2499 DEFHOOKPOD
2500 (tmpl_prefix,
2501  "",
2502  const char *, NULL)
2503
2504 /* Function to generate field definitions of the proxy variable.  */
2505 DEFHOOK
2506 (var_fields,
2507  "",
2508  tree, (tree type, tree *name),
2509  default_emutls_var_fields)
2510
2511 /* Function to initialize a proxy variable.  */
2512 DEFHOOK
2513 (var_init,
2514  "",
2515  tree, (tree var, tree decl, tree tmpl_addr),
2516  default_emutls_var_init)
2517
2518 /* Whether we are allowed to alter the usual alignment of the
2519    proxy variable.  */
2520 DEFHOOKPOD
2521 (var_align_fixed,
2522  "",
2523  bool, false)
2524
2525 /* Whether we can emit debug information for TLS vars.  */
2526 DEFHOOKPOD
2527 (debug_form_tls_address,
2528  "",
2529  bool, false)
2530
2531 HOOK_VECTOR_END (emutls)
2532
2533 #undef HOOK_PREFIX
2534 #define HOOK_PREFIX "TARGET_OPTION_"
2535 HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks)
2536
2537 /* Function to validate the attribute((option(...))) strings or NULL.  If
2538    the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
2539    be filled in in the function decl node.  */
2540 DEFHOOK
2541 (valid_attribute_p,
2542  "",
2543  bool, (tree fndecl, tree name, tree args, int flags),
2544  default_target_option_valid_attribute_p)
2545
2546 /* Function to save any extra target state in the target options structure.  */
2547 DEFHOOK
2548 (save,
2549  "",
2550  void, (struct cl_target_option *ptr), NULL)
2551
2552 /* Function to restore any extra target state from the target options
2553    structure.  */
2554 DEFHOOK
2555 (restore,
2556  "",
2557  void, (struct cl_target_option *ptr), NULL)
2558
2559 /* Function to print any extra target state from the target options
2560    structure.  */
2561 DEFHOOK
2562 (print,
2563  "",
2564  void, (FILE *file, int indent, struct cl_target_option *ptr), NULL)
2565
2566 /* Function to parse arguments to be validated for #pragma option, and to
2567    change the state if the options are valid.  If the first argument is
2568    NULL, the second argument specifies the default options to use.  Return
2569    true if the options are valid, and set the current state.  */
2570 /* ??? The documentation in tm.texi is incomplete.  */
2571 DEFHOOK
2572 (pragma_parse,
2573  "",
2574  bool, (tree args, tree pop_target),
2575  default_target_option_pragma_parse)
2576
2577 /* Do option overrides for the target.  */
2578 DEFHOOK
2579 (override,
2580  "",
2581  void, (void),
2582  hook_void_void)
2583
2584 /* Function to determine if one function can inline another function.  */
2585 #undef HOOK_PREFIX
2586 #define HOOK_PREFIX "TARGET_"
2587 DEFHOOK
2588 (can_inline_p,
2589  "",
2590  bool, (tree caller, tree callee),
2591  default_target_can_inline_p)
2592
2593 HOOK_VECTOR_END (target_option)
2594
2595 /* For targets that need to mark extra registers as live on entry to
2596    the function, they should define this target hook and set their
2597    bits in the bitmap passed in. */
2598 DEFHOOK
2599 (extra_live_on_entry,
2600  "",
2601  void, (bitmap regs),
2602  hook_void_bitmap)
2603
2604 /* Determine the type of unwind info to emit for debugging.  */
2605 DEFHOOK
2606 (debug_unwind_info,
2607  "",
2608  enum unwind_info_type, (void),
2609  default_debug_unwind_info)
2610
2611 /* Leave the boolean fields at the end.  */
2612
2613 /* True if we can create zeroed data by switching to a BSS section
2614    and then using ASM_OUTPUT_SKIP to allocate the space.  */
2615 DEFHOOKPOD
2616 (have_switchable_bss_sections,
2617  "",
2618  bool, false)
2619
2620 /* True if "native" constructors and destructors are supported,
2621    false if we're using collect2 for the job.  */
2622 DEFHOOKPOD
2623 (have_ctors_dtors,
2624  "",
2625  bool, false)
2626
2627 /* True if thread-local storage is supported.  */
2628 DEFHOOKPOD
2629 (have_tls,
2630  "",
2631  bool, false)
2632
2633 /* True if a small readonly data section is supported.  */
2634 DEFHOOKPOD
2635 (have_srodata_section,
2636  "",
2637  bool, false)
2638
2639 /* True if EH frame info sections should be zero-terminated.  */
2640 DEFHOOKPOD
2641 (terminate_dw2_eh_frame_info,
2642  "",
2643  bool, true)
2644
2645 /* True if #NO_APP should be emitted at the beginning of assembly output.  */
2646 DEFHOOKPOD
2647 (asm_file_start_app_off,
2648  "",
2649  bool, false)
2650
2651 /* True if output_file_directive should be called for main_input_filename
2652    at the beginning of assembly output.  */
2653 DEFHOOKPOD
2654 (asm_file_start_file_directive,
2655  "",
2656  bool, false)
2657
2658 DEFHOOKPOD
2659 (handle_pragma_extern_prefix,
2660 "True if @code{#pragma extern_prefix} is to be supported.",
2661  bool, 0)
2662
2663 /* True if the target is allowed to reorder memory accesses unless
2664    synchronization is explicitly requested.  */
2665 DEFHOOKPOD
2666 (relaxed_ordering,
2667  "",
2668  bool, false)
2669
2670 /* Returns true if we should generate exception tables for use with the
2671    ARM EABI.  The effects the encoding of function exception specifications.  */
2672 DEFHOOKPOD
2673 (arm_eabi_unwinder,
2674  "",
2675  bool, false)
2676
2677 DEFHOOKPOD
2678 (want_debug_pub_sections,
2679  "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\
2680  should be emitted.  These sections are not used on most platforms, and\
2681  in particular GDB does not use them.",
2682  bool, false)
2683
2684 DEFHOOKPOD
2685 (delay_sched2, "True if sched2 is not to be run at its normal place.  \
2686 This usually means it will be run as part of machine-specific reorg.",
2687 bool, false)
2688
2689 DEFHOOKPOD
2690 (delay_vartrack, "True if vartrack is not to be run at its normal place.  \
2691 This usually means it will be run as part of machine-specific reorg.",
2692 bool, false)
2693
2694 /* Leave the boolean fields at the end.  */
2695
2696 /* Close the 'struct gcc_target' definition.  */
2697 HOOK_VECTOR_END (C90_EMPTY_HACK)