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  default_asm_output_addr_const_extra)
 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 /* Target builtin that implements vector permute.  */
 989 DEFHOOK
 990 (builtin_vec_perm,
 991  "",
 992  tree, (tree type, tree *mask_element_type), NULL)
 993
 994 /* Return true if a vector created for builtin_vec_perm is valid.  */
 995 DEFHOOK
 996 (builtin_vec_perm_ok,
 997  "",
 998  bool, (tree vec_type, tree mask),
 999  hook_bool_tree_tree_true)
1000
1001 /* Return true if the target supports misaligned store/load of a
1002    specific factor denoted in the third parameter.  The last parameter
1003    is true if the access is defined in a packed struct.  */
1004 DEFHOOK
1005 (support_vector_misalignment,
1006  "",
1007  bool,
1008  (enum machine_mode mode, const_tree type, int misalignment, bool is_packed),
1009  default_builtin_support_vector_misalignment)
1010
1011 /* Returns the preferred mode for SIMD operations for the specified
1012    scalar mode.  */
1013 DEFHOOK
1014 (preferred_simd_mode,
1015  "",
1016  enum machine_mode,
1017  (enum machine_mode mode),
1018  default_preferred_simd_mode)
1019
1020 /* Returns a mask of vector sizes to iterate over when auto-vectorizing
1021    after processing the preferred one derived from preferred_simd_mode.  */
1022 DEFHOOK
1023 (autovectorize_vector_sizes,
1024  "",
1025  unsigned int,
1026  (void),
1027  default_autovectorize_vector_sizes)
1028
1029 HOOK_VECTOR_END (vectorize)
1030
1031 #undef HOOK_PREFIX
1032 #define HOOK_PREFIX "TARGET_"
1033
1034 /* Allow target specific overriding of option settings after options have
1035   been changed by an attribute or pragma or when it is reset at the
1036   end of the code affected by an attribute or pragma.  */
1037 DEFHOOK
1038 (override_options_after_change,
1039  "",
1040  void, (void),
1041  hook_void_void)
1042
1043 DEFHOOK_UNDOC
1044 (eh_return_filter_mode,
1045  "Return machine mode for filter value.",
1046  enum machine_mode, (void),
1047  default_eh_return_filter_mode)
1048
1049 /* Return machine mode for libgcc expanded cmp instructions.  */
1050 DEFHOOK
1051 (libgcc_cmp_return_mode,
1052  "",
1053  enum machine_mode, (void),
1054  default_libgcc_cmp_return_mode)
1055
1056 /* Return machine mode for libgcc expanded shift instructions.  */
1057 DEFHOOK
1058 (libgcc_shift_count_mode,
1059  "",
1060  enum machine_mode, (void),
1061  default_libgcc_shift_count_mode)
1062
1063 /* Return machine mode to be used for _Unwind_Word type.  */
1064 DEFHOOK
1065 (unwind_word_mode,
1066  "",
1067  enum machine_mode, (void),
1068  default_unwind_word_mode)
1069
1070 /* Given two decls, merge their attributes and return the result.  */
1071 DEFHOOK
1072 (merge_decl_attributes,
1073  "",
1074  tree, (tree olddecl, tree newdecl),
1075  merge_decl_attributes)
1076
1077 /* Given two types, merge their attributes and return the result.  */
1078 DEFHOOK
1079 (merge_type_attributes,
1080  "",
1081  tree, (tree type1, tree type2),
1082  merge_type_attributes)
1083
1084 /* Table of machine attributes and functions to handle them.
1085    Ignored if NULL.  */
1086 DEFHOOKPOD
1087 (attribute_table,
1088  "",
1089  const struct attribute_spec *, NULL)
1090
1091 /* Return true iff attribute NAME expects a plain identifier as its first
1092    argument.  */
1093 DEFHOOK
1094 (attribute_takes_identifier_p,
1095  "",
1096  bool, (const_tree name),
1097  hook_bool_const_tree_false)
1098
1099 /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
1100    one if they are compatible and two if they are nearly compatible
1101    (which causes a warning to be generated).  */
1102 DEFHOOK
1103 (comp_type_attributes,
1104  "",
1105  int, (const_tree type1, const_tree type2),
1106  hook_int_const_tree_const_tree_1)
1107
1108 /* Assign default attributes to the newly defined TYPE.  */
1109 DEFHOOK
1110 (set_default_type_attributes,
1111  "",
1112  void, (tree type),
1113  hook_void_tree)
1114
1115 /* Insert attributes on the newly created DECL.  */
1116 DEFHOOK
1117 (insert_attributes,
1118  "",
1119  void, (tree node, tree *attr_ptr),
1120  hook_void_tree_treeptr)
1121
1122 /* Return true if FNDECL (which has at least one machine attribute)
1123    can be inlined despite its machine attributes, false otherwise.  */
1124 DEFHOOK
1125 (function_attribute_inlinable_p,
1126  "",
1127  bool, (const_tree fndecl),
1128  hook_bool_const_tree_false)
1129
1130 /* Return true if bitfields in RECORD_TYPE should follow the
1131    Microsoft Visual C++ bitfield layout rules.  */
1132 DEFHOOK
1133 (ms_bitfield_layout_p,
1134  "",
1135  bool, (const_tree record_type),
1136  hook_bool_const_tree_false)
1137
1138 /* For now this is only an interface to WORDS_BIG_ENDIAN for
1139    target-independent code like the front ends, need performance testing
1140    before switching completely to the target hook.  */
1141 DEFHOOK_UNDOC
1142 (words_big_endian,
1143  "",
1144  bool, (void),
1145  targhook_words_big_endian)
1146
1147 /* Likewise for FLOAT_WORDS_BIG_ENDIAN.  */
1148 DEFHOOK_UNDOC
1149 (float_words_big_endian,
1150  "",
1151  bool, (void),
1152  targhook_float_words_big_endian)
1153
1154 /* True if the target supports decimal floating point.  */
1155 DEFHOOK
1156 (decimal_float_supported_p,
1157  "",
1158  bool, (void),
1159  default_decimal_float_supported_p)
1160
1161 /* True if the target supports fixed-point.  */
1162 DEFHOOK
1163 (fixed_point_supported_p,
1164  "",
1165  bool, (void),
1166  default_fixed_point_supported_p)
1167
1168 /* Return true if anonymous bitfields affect structure alignment.  */
1169 DEFHOOK
1170 (align_anon_bitfield,
1171  "",
1172  bool, (void),
1173  hook_bool_void_false)
1174
1175 /* Return true if volatile bitfields should use the narrowest type possible.
1176    Return false if they should use the container type.  */
1177 DEFHOOK
1178 (narrow_volatile_bitfield,
1179  "",
1180  bool, (void),
1181  hook_bool_void_false)
1182
1183 /* Set up target-specific built-in functions.  */
1184 DEFHOOK
1185 (init_builtins,
1186  "",
1187  void, (void),
1188  hook_void_void)
1189
1190 /* Initialize (if INITIALIZE_P is true) and return the target-specific
1191    built-in function decl for CODE.
1192    Return NULL if that is not possible.  Return error_mark_node if CODE
1193    is outside of the range of valid target builtin function codes.  */
1194 DEFHOOK
1195 (builtin_decl,
1196  "",
1197  tree, (unsigned code, bool initialize_p), NULL)
1198
1199 /* Expand a target-specific builtin.  */
1200 DEFHOOK
1201 (expand_builtin,
1202  "",
1203  rtx,
1204  (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore),
1205  default_expand_builtin)
1206
1207 /* Select a replacement for a target-specific builtin.  This is done
1208    *before* regular type checking, and so allows the target to
1209    implement a crude form of function overloading.  The result is a
1210    complete expression that implements the operation.  PARAMS really
1211    has type VEC(tree,gc)*, but we don't want to include tree.h here.  */
1212 DEFHOOK
1213 (resolve_overloaded_builtin,
1214  "",
1215  tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL)
1216
1217 /* Fold a target-specific builtin.  */
1218 DEFHOOK
1219 (fold_builtin,
1220  "",
1221  tree, (tree fndecl, int n_args, tree *argp, bool ignore),
1222  hook_tree_tree_int_treep_bool_null)
1223
1224 /* Returns a code for a target-specific builtin that implements
1225    reciprocal of the function, or NULL_TREE if not available.  */
1226 DEFHOOK
1227 (builtin_reciprocal,
1228  "",
1229  tree, (unsigned fn, bool md_fn, bool sqrt),
1230  default_builtin_reciprocal)
1231
1232 /* For a vendor-specific TYPE, return a pointer to a statically-allocated
1233    string containing the C++ mangling for TYPE.  In all other cases, return
1234    NULL.  */
1235 DEFHOOK
1236 (mangle_type,
1237  "",
1238  const char *, (const_tree type),
1239  hook_constcharptr_const_tree_null)
1240
1241 /* Make any adjustments to libfunc names needed for this target.  */
1242 DEFHOOK
1243 (init_libfuncs,
1244  "",
1245  void, (void),
1246  hook_void_void)
1247
1248  /* Add a __gnu_ prefix to library functions rather than just __.  */
1249 DEFHOOKPOD
1250 (libfunc_gnu_prefix,
1251  "If false (the default), internal library routines start with two\n\
1252 underscores.  If set to true, these routines start with @code{__gnu_}\n\
1253 instead.  E.g., @code{__muldi3} changes to @code{__gnu_muldi3}.  This\n\
1254 currently only affects functions defined in @file{libgcc2.c}.  If this\n\
1255 is set to true, the @file{tm.h} file must also\n\
1256 @code{#define LIBGCC2_GNU_PREFIX}.",
1257   bool, false)
1258
1259 /* Given a decl, a section name, and whether the decl initializer
1260    has relocs, choose attributes for the section.  */
1261 /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION.  */
1262 DEFHOOK
1263 (section_type_flags,
1264  "",
1265  unsigned int, (tree decl, const char *name, int reloc),
1266  default_section_type_flags)
1267
1268 /* True if new jumps cannot be created, to replace existing ones or
1269    not, at the current point in the compilation.  */
1270 DEFHOOK
1271 (cannot_modify_jumps_p,
1272  "",
1273  bool, (void),
1274  hook_bool_void_false)
1275
1276 /* Return a register class for which branch target register
1277    optimizations should be applied.  */
1278 DEFHOOK
1279 (branch_target_register_class,
1280  "",
1281  reg_class_t, (void),
1282  default_branch_target_register_class)
1283
1284 /* Return true if branch target register optimizations should include
1285    callee-saved registers that are not already live during the current
1286    function.  AFTER_PE_GEN is true if prologues and epilogues have
1287    already been generated.  */
1288 DEFHOOK
1289 (branch_target_register_callee_saved,
1290  "",
1291  bool, (bool after_prologue_epilogue_gen),
1292  hook_bool_bool_false)
1293
1294 /* Return true if the target supports conditional execution.  */
1295 DEFHOOK
1296 (have_conditional_execution,
1297  "",
1298  bool, (void),
1299  default_have_conditional_execution)
1300
1301 /* Return a new value for loop unroll size.  */
1302 DEFHOOK
1303 (loop_unroll_adjust,
1304  "",
1305  unsigned, (unsigned nunroll, struct loop *loop),
1306  NULL)
1307
1308 /* True if X is a legitimate MODE-mode immediate operand.  */
1309 DEFHOOK
1310 (legitimate_constant_p,
1311  "",
1312  bool, (enum machine_mode mode, rtx x),
1313  hook_bool_mode_rtx_true)
1314
1315 /* True if the constant X cannot be placed in the constant pool.  */
1316 DEFHOOK
1317 (cannot_force_const_mem,
1318  "",
1319  bool, (enum machine_mode mode, rtx x),
1320  hook_bool_mode_rtx_false)
1321
1322 DEFHOOK_UNDOC
1323 (cannot_copy_insn_p,
1324  "True if the insn @var{x} cannot be duplicated.",
1325  bool, (rtx), NULL)
1326
1327 /* True if X is considered to be commutative.  */
1328 DEFHOOK
1329 (commutative_p,
1330  "",
1331  bool, (const_rtx x, int outer_code),
1332  hook_bool_const_rtx_commutative_p)
1333
1334 /* True if ADDR is an address-expression whose effect depends
1335    on the mode of the memory reference it is used in.  */
1336 DEFHOOK
1337 (mode_dependent_address_p,
1338  "",
1339  bool, (const_rtx addr),
1340  default_mode_dependent_address_p)
1341
1342 /* Given an invalid address X for a given machine mode, try machine-specific
1343    ways to make it legitimate.  Return X or an invalid address on failure.  */
1344 DEFHOOK
1345 (legitimize_address,
1346  "",
1347  rtx, (rtx x, rtx oldx, enum machine_mode mode),
1348  default_legitimize_address)
1349
1350 /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS.  */
1351 DEFHOOK
1352 (delegitimize_address,
1353  "",
1354  rtx, (rtx x),
1355  delegitimize_mem_from_attrs)
1356
1357 /* Given an address RTX, say whether it is valid.  */
1358 DEFHOOK
1359 (legitimate_address_p,
1360  "",
1361  bool, (enum machine_mode mode, rtx x, bool strict),
1362  default_legitimate_address_p)
1363
1364 /* True if the given constant can be put into an object_block.  */
1365 DEFHOOK
1366 (use_blocks_for_constant_p,
1367  "",
1368  bool, (enum machine_mode mode, const_rtx x),
1369  hook_bool_mode_const_rtx_false)
1370
1371 /* The minimum and maximum byte offsets for anchored addresses.  */
1372 DEFHOOKPOD
1373 (min_anchor_offset,
1374  "",
1375  HOST_WIDE_INT, 0)
1376
1377 DEFHOOKPOD
1378 (max_anchor_offset,
1379  "",
1380  HOST_WIDE_INT, 0)
1381
1382 /* True if section anchors can be used to access the given symbol.  */
1383 DEFHOOK
1384 (use_anchors_for_symbol_p,
1385  "",
1386  bool, (const_rtx x),
1387  default_use_anchors_for_symbol_p)
1388
1389 /* True if it is OK to do sibling call optimization for the specified
1390    call expression EXP.  DECL will be the called function, or NULL if
1391    this is an indirect call.  */
1392 DEFHOOK
1393 (function_ok_for_sibcall,
1394  "",
1395  bool, (tree decl, tree exp),
1396  hook_bool_tree_tree_false)
1397
1398 /* Establish appropriate back-end context for processing the function
1399    FNDECL.  The argument might be NULL to indicate processing at top
1400    level, outside of any function scope.  */
1401 DEFHOOK
1402 (set_current_function,
1403  "",
1404  void, (tree decl), hook_void_tree)
1405
1406 /* True if EXP should be placed in a "small data" section.  */
1407 DEFHOOK
1408 (in_small_data_p,
1409  "",
1410  bool, (const_tree exp),
1411  hook_bool_const_tree_false)
1412
1413 /* True if EXP names an object for which name resolution must resolve
1414    to the current executable or shared library.  */
1415 DEFHOOK
1416 (binds_local_p,
1417  "",
1418  bool, (const_tree exp),
1419  default_binds_local_p)
1420
1421 /* Check if profiling code is before or after prologue.  */
1422 DEFHOOK
1423 (profile_before_prologue,
1424  "It returns true if target wants profile code emitted before prologue.\n\n\
1425 The default version of this hook use the target macro\n\
1426 @code{PROFILE_BEFORE_PROLOGUE}.",
1427  bool, (void),
1428  default_profile_before_prologue)
1429
1430 /* Modify and return the identifier of a DECL's external name,
1431    originally identified by ID, as required by the target,
1432    (eg, append @nn to windows32 stdcall function names).
1433    The default is to return ID without modification. */
1434 DEFHOOK
1435 (mangle_decl_assembler_name,
1436  "",
1437  tree, (tree decl, tree  id),
1438  default_mangle_decl_assembler_name)
1439
1440 /* Do something target-specific to record properties of the DECL into
1441    the associated SYMBOL_REF.  */
1442 DEFHOOK
1443 (encode_section_info,
1444  "",
1445  void, (tree decl, rtx rtl, int new_decl_p),
1446  default_encode_section_info)
1447
1448 /* Undo the effects of encode_section_info on the symbol string.  */
1449 DEFHOOK
1450 (strip_name_encoding,
1451  "",
1452  const char *, (const char *name),
1453  default_strip_name_encoding)
1454
1455 /* If shift optabs for MODE are known to always truncate the shift count,
1456    return the mask that they apply.  Return 0 otherwise.  */
1457 DEFHOOK
1458 (shift_truncation_mask,
1459  "",
1460  unsigned HOST_WIDE_INT, (enum machine_mode mode),
1461  default_shift_truncation_mask)
1462
1463 /* Return the number of divisions in the given MODE that should be present,
1464    so that it is profitable to turn the division into a multiplication by
1465    the reciprocal.  */
1466 DEFHOOK
1467 (min_divisions_for_recip_mul,
1468  "",
1469  unsigned int, (enum machine_mode mode),
1470  default_min_divisions_for_recip_mul)
1471
1472 /* If the representation of integral MODE is such that values are
1473    always sign-extended to a wider mode MODE_REP then return
1474    SIGN_EXTEND.  Return UNKNOWN otherwise.  */
1475 /* Note that the return type ought to be RTX_CODE, but that's not
1476    necessarily defined at this point.  */
1477 DEFHOOK
1478 (mode_rep_extended,
1479  "",
1480  int, (enum machine_mode mode, enum machine_mode rep_mode),
1481  default_mode_rep_extended)
1482
1483 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
1484 DEFHOOK
1485 (valid_pointer_mode,
1486  "",
1487  bool, (enum machine_mode mode),
1488  default_valid_pointer_mode)
1489
1490 /* Disambiguate with errno.  */
1491 DEFHOOK
1492 (ref_may_alias_errno,
1493  "Define this to return nonzero if the memory reference @var{ref}\
1494   may alias with the system C library errno location.  The default\
1495   version of this hook assumes the system C library errno location\
1496   is either a declaration of type int or accessed by dereferencing\
1497   a pointer to int.",
1498  bool, (struct ao_ref_s *ref),
1499  default_ref_may_alias_errno)
1500
1501 /* Support for named address spaces.  */
1502 #undef HOOK_PREFIX
1503 #define HOOK_PREFIX "TARGET_ADDR_SPACE_"
1504 HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space)
1505
1506 /* MODE to use for a pointer into another address space.  */
1507 DEFHOOK
1508 (pointer_mode,
1509  "",
1510  enum machine_mode, (addr_space_t address_space),
1511  default_addr_space_pointer_mode)
1512
1513 /* MODE to use for an address in another address space.  */
1514 DEFHOOK
1515 (address_mode,
1516  "",
1517  enum machine_mode, (addr_space_t address_space),
1518  default_addr_space_address_mode)
1519
1520 /* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
1521    in another address space.  */
1522 DEFHOOK
1523 (valid_pointer_mode,
1524  "",
1525  bool, (enum machine_mode mode, addr_space_t as),
1526  default_addr_space_valid_pointer_mode)
1527
1528 /* True if an address is a valid memory address to a given named address
1529    space for a given mode.  */
1530 DEFHOOK
1531 (legitimate_address_p,
1532  "",
1533  bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as),
1534  default_addr_space_legitimate_address_p)
1535
1536 /* Return an updated address to convert an invalid pointer to a named
1537    address space to a valid one.  If NULL_RTX is returned use machine
1538    independent methods to make the address valid.  */
1539 DEFHOOK
1540 (legitimize_address,
1541  "",
1542  rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as),
1543  default_addr_space_legitimize_address)
1544
1545 /* True if one named address space is a subset of another named address. */
1546 DEFHOOK
1547 (subset_p,
1548  "",
1549  bool, (addr_space_t subset, addr_space_t superset),
1550  default_addr_space_subset_p)
1551
1552 /* Function to convert an rtl expression from one address space to another.  */
1553 DEFHOOK
1554 (convert,
1555  "",
1556  rtx, (rtx op, tree from_type, tree to_type),
1557  default_addr_space_convert)
1558
1559 HOOK_VECTOR_END (addr_space)
1560
1561 #undef HOOK_PREFIX
1562 #define HOOK_PREFIX "TARGET_"
1563
1564 /* True if MODE is valid for the target.  By "valid", we mean able to
1565    be manipulated in non-trivial ways.  In particular, this means all
1566    the arithmetic is supported.  */
1567 DEFHOOK
1568 (scalar_mode_supported_p,
1569  "",
1570  bool, (enum machine_mode mode),
1571  default_scalar_mode_supported_p)
1572
1573 /* Similarly for vector modes.  "Supported" here is less strict.  At
1574    least some operations are supported; need to check optabs or builtins
1575    for further details.  */
1576 DEFHOOK
1577 (vector_mode_supported_p,
1578  "",
1579  bool, (enum machine_mode mode),
1580  hook_bool_mode_false)
1581
1582 /* True if we should try to use a scalar mode to represent an array,
1583    overriding the usual MAX_FIXED_MODE limit.  */
1584 DEFHOOK
1585 (array_mode_supported_p,
1586  "Return true if GCC should try to use a scalar mode to store an array\n\
1587 of @var{nelems} elements, given that each element has mode @var{mode}.\n\
1588 Returning true here overrides the usual @code{MAX_FIXED_MODE} limit\n\
1589 and allows GCC to use any defined integer mode.\n\
1590 \n\
1591 One use of this hook is to support vector load and store operations\n\
1592 that operate on several homogeneous vectors.  For example, ARM NEON\n\
1593 has operations like:\n\
1594 \n\
1595 @smallexample\n\
1596 int8x8x3_t vld3_s8 (const int8_t *)\n\
1597 @end smallexample\n\
1598 \n\
1599 where the return type is defined as:\n\
1600 \n\
1601 @smallexample\n\
1602 typedef struct int8x8x3_t\n\
1603 @{\n\
1604   int8x8_t val[3];\n\
1605 @} int8x8x3_t;\n\
1606 @end smallexample\n\
1607 \n\
1608 If this hook allows @code{val} to have a scalar mode, then\n\
1609 @code{int8x8x3_t} can have the same mode.  GCC can then store\n\
1610 @code{int8x8x3_t}s in registers rather than forcing them onto the stack.",
1611  bool, (enum machine_mode mode, unsigned HOST_WIDE_INT nelems),
1612  hook_bool_mode_uhwi_false)
1613
1614 /* Compute cost of moving data from a register of class FROM to one of
1615    TO, using MODE.  */
1616 DEFHOOK
1617 (register_move_cost,
1618  "",
1619  int, (enum machine_mode mode, reg_class_t from, reg_class_t to),
1620  default_register_move_cost)
1621
1622 /* Compute cost of moving registers to/from memory.  */
1623 /* ??? Documenting the argument types for this hook requires a GFDL
1624    license grant.  Also, the documentation uses a different name for RCLASS.  */
1625 DEFHOOK
1626 (memory_move_cost,
1627  "",
1628  int, (enum machine_mode mode, reg_class_t rclass, bool in),
1629  default_memory_move_cost)
1630
1631 /* True for MODE if the target expects that registers in this mode will
1632    be allocated to registers in a small register class.  The compiler is
1633    allowed to use registers explicitly used in the rtl as spill registers
1634    but it should prevent extending the lifetime of these registers.  */
1635 DEFHOOK
1636 (small_register_classes_for_mode_p,
1637  "",
1638  bool, (enum machine_mode mode),
1639  hook_bool_mode_false)
1640
1641 /* Register number for a flags register.  Only needs to be defined if the
1642    target is constrainted to use post-reload comparison elimination.  */
1643 DEFHOOKPOD
1644 (flags_regnum,
1645  "If the target has a dedicated flags register, and it needs to use the\
1646  post-reload comparison elimination pass, then this value should be set\
1647  appropriately.",
1648  unsigned int, INVALID_REGNUM)
1649
1650 /* Compute a (partial) cost for rtx X.  Return true if the complete
1651    cost has been computed, and false if subexpressions should be
1652    scanned.  In either case, *TOTAL contains the cost result.  */
1653 /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
1654    not necessarily defined at this point.  */
1655 DEFHOOK
1656 (rtx_costs,
1657  "",
1658  bool, (rtx x, int code, int outer_code, int opno, int *total, bool speed),
1659  hook_bool_rtx_int_int_int_intp_bool_false)
1660
1661 /* Compute the cost of X, used as an address.  Never called with
1662    invalid addresses.  */
1663 DEFHOOK
1664 (address_cost,
1665  "",
1666  int, (rtx address, bool speed),
1667  default_address_cost)
1668
1669 /* Return where to allocate pseudo for a given hard register initial value.  */
1670 DEFHOOK
1671 (allocate_initial_value,
1672  "",
1673  rtx, (rtx hard_reg), NULL)
1674
1675 /* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
1676    FLAGS has the same meaning as in rtlanal.c: may_trap_p_1.  */
1677 DEFHOOK
1678 (unspec_may_trap_p,
1679  "",
1680  int, (const_rtx x, unsigned flags),
1681  default_unspec_may_trap_p)
1682
1683 /* Given a register, this hook should return a parallel of registers
1684    to represent where to find the register pieces.  Define this hook
1685    if the register and its mode are represented in Dwarf in
1686    non-contiguous locations, or if the register should be
1687    represented in more than one register in Dwarf.  Otherwise, this
1688    hook should return NULL_RTX.  */
1689 DEFHOOK
1690 (dwarf_register_span,
1691  "",
1692  rtx, (rtx reg),
1693  hook_rtx_rtx_null)
1694
1695 /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
1696    entries not corresponding directly to registers below
1697    FIRST_PSEUDO_REGISTER, this hook should generate the necessary
1698    code, given the address of the table.  */
1699 DEFHOOK
1700 (init_dwarf_reg_sizes_extra,
1701  "",
1702  void, (tree address),
1703  hook_void_tree)
1704
1705 /* Fetch the fixed register(s) which hold condition codes, for
1706    targets where it makes sense to look for duplicate assignments to
1707    the condition codes.  This should return true if there is such a
1708    register, false otherwise.  The arguments should be set to the
1709    fixed register numbers.  Up to two condition code registers are
1710    supported.  If there is only one for this target, the int pointed
1711    at by the second argument should be set to -1.  */
1712 DEFHOOK
1713 (fixed_condition_code_regs,
1714  "",
1715  bool, (unsigned int *p1, unsigned int *p2),
1716  hook_bool_uintp_uintp_false)
1717
1718 /* If two condition code modes are compatible, return a condition
1719      code mode which is compatible with both, such that a comparison
1720      done in the returned mode will work for both of the original
1721      modes.  If the condition code modes are not compatible, return
1722      VOIDmode.  */
1723 DEFHOOK
1724 (cc_modes_compatible,
1725  "",
1726  enum machine_mode, (enum machine_mode m1, enum machine_mode m2),
1727  default_cc_modes_compatible)
1728
1729 /* Do machine-dependent code transformations.  Called just before
1730      delayed-branch scheduling.  */
1731 DEFHOOK
1732 (machine_dependent_reorg,
1733  "",
1734  void, (void), NULL)
1735
1736 /* Create the __builtin_va_list type.  */
1737 DEFHOOK
1738 (build_builtin_va_list,
1739  "",
1740  tree, (void),
1741  std_build_builtin_va_list)
1742
1743 /* Enumerate the va list variants.  */
1744 DEFHOOK
1745 (enum_va_list_p,
1746  "",
1747  int, (int idx, const char **pname, tree *ptree),
1748  NULL)
1749
1750 /* Get the cfun/fndecl calling abi __builtin_va_list type.  */
1751 DEFHOOK
1752 (fn_abi_va_list,
1753  "",
1754  tree, (tree fndecl),
1755  std_fn_abi_va_list)
1756
1757 /* Get the __builtin_va_list type dependent on input type.  */
1758 DEFHOOK
1759 (canonical_va_list_type,
1760  "",
1761  tree, (tree type),
1762  std_canonical_va_list_type)
1763
1764 /* ??? Documenting this hook requires a GFDL license grant.  */
1765 DEFHOOK_UNDOC
1766 (expand_builtin_va_start,
1767 "Expand the @code{__builtin_va_start} builtin.",
1768  void, (tree valist, rtx nextarg), NULL)
1769
1770 /* Gimplifies a VA_ARG_EXPR.  */
1771 DEFHOOK
1772 (gimplify_va_arg_expr,
1773  "",
1774  tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p),
1775  std_gimplify_va_arg_expr)
1776
1777 /* Validity-checking routines for PCH files, target-specific.
1778    get_pch_validity returns a pointer to the data to be stored,
1779    and stores the size in its argument.  pch_valid_p gets the same
1780    information back and returns NULL if the PCH is valid,
1781    or an error message if not.  */
1782 DEFHOOK
1783 (get_pch_validity,
1784  "",
1785  void *, (size_t *sz),
1786  default_get_pch_validity)
1787
1788 DEFHOOK
1789 (pch_valid_p,
1790  "",
1791  const char *, (const void *data, size_t sz),
1792  default_pch_valid_p)
1793
1794 /* If nonnull, this function checks whether a PCH file with the
1795    given set of target flags can be used.  It returns NULL if so,
1796    otherwise it returns an error message.  */
1797 DEFHOOK
1798 (check_pch_target_flags,
1799  "",
1800  const char *, (int pch_flags), NULL)
1801
1802 /* True if the compiler should give an enum type only as many
1803    bytes as it takes to represent the range of possible values of
1804    that type.  */
1805 DEFHOOK
1806 (default_short_enums,
1807  "",
1808  bool, (void),
1809  hook_bool_void_false)
1810
1811 /* This target hook returns an rtx that is used to store the address
1812    of the current frame into the built-in setjmp buffer.  */
1813 DEFHOOK
1814 (builtin_setjmp_frame_value,
1815  "",
1816  rtx, (void),
1817  default_builtin_setjmp_frame_value)
1818
1819 /* This target hook should add STRING_CST trees for any hard regs
1820    the port wishes to automatically clobber for an asm.  */
1821 DEFHOOK
1822 (md_asm_clobbers,
1823  "",
1824  tree, (tree outputs, tree inputs, tree clobbers),
1825  hook_tree_tree_tree_tree_3rd_identity)
1826
1827 /* This target hook allows the backend to specify a calling convention
1828    in the debug information.  This function actually returns an
1829    enum dwarf_calling_convention, but because of forward declarations
1830    and not wanting to include dwarf2.h everywhere target.h is included
1831    the function is being declared as an int.  */
1832 DEFHOOK
1833 (dwarf_calling_convention,
1834  "",
1835  int, (const_tree function),
1836  hook_int_const_tree_0)
1837
1838 /* This target hook allows the backend to emit frame-related insns that
1839    contain UNSPECs or UNSPEC_VOLATILEs.  The call frame debugging info
1840    engine will invoke it on insns of the form
1841      (set (reg) (unspec [...] UNSPEC_INDEX))
1842    and
1843      (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
1844    to let the backend emit the call frame instructions.  */
1845 DEFHOOK
1846 (dwarf_handle_frame_unspec,
1847  "",
1848  void, (const char *label, rtx pattern, int index), NULL)
1849
1850 /* ??? Documenting this hook requires a GFDL license grant.  */
1851 DEFHOOK_UNDOC
1852 (stdarg_optimize_hook,
1853 "Perform architecture specific checking of statements gimplified\
1854  from @code{VA_ARG_EXPR}.  @var{stmt} is the statement.  Returns true if\
1855  the statement doesn't need to be checked for @code{va_list} references.",
1856  bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
1857
1858 /* This target hook allows the operating system to override the DECL
1859    that represents the external variable that contains the stack
1860    protection guard variable.  The type of this DECL is ptr_type_node.  */
1861 DEFHOOK
1862 (stack_protect_guard,
1863  "",
1864  tree, (void),
1865  default_stack_protect_guard)
1866
1867 /* This target hook allows the operating system to override the CALL_EXPR
1868    that is invoked when a check vs the guard variable fails.  */
1869 DEFHOOK
1870 (stack_protect_fail,
1871  "",
1872  tree, (void),
1873  default_external_stack_protect_fail)
1874
1875 /* Returns NULL if target supports the insn within a doloop block,
1876    otherwise it returns an error message.  */
1877 DEFHOOK
1878 (invalid_within_doloop,
1879  "",
1880  const char *, (const_rtx insn),
1881  default_invalid_within_doloop)
1882
1883 DEFHOOK
1884 (valid_dllimport_attribute_p,
1885 "@var{decl} is a variable or function with @code{__attribute__((dllimport))}\
1886  specified.  Use this hook if the target needs to add extra validation\
1887  checks to @code{handle_dll_attribute}.",
1888  bool, (const_tree decl),
1889  hook_bool_const_tree_true)
1890
1891 /* If non-zero, align constant anchors in CSE to a multiple of this
1892    value.  */
1893 DEFHOOKPOD
1894 (const_anchor,
1895  "",
1896  unsigned HOST_WIDE_INT, 0)
1897
1898 /* Functions relating to calls - argument passing, returns, etc.  */
1899 /* Members of struct call have no special macro prefix.  */
1900 HOOK_VECTOR (TARGET_CALLS, calls)
1901
1902 DEFHOOK
1903 (promote_function_mode,
1904  "",
1905  enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp,
1906                      const_tree funtype, int for_return),
1907  default_promote_function_mode)
1908
1909 DEFHOOK
1910 (promote_prototypes,
1911  "",
1912  bool, (const_tree fntype),
1913  hook_bool_const_tree_false)
1914
1915 DEFHOOK
1916 (struct_value_rtx,
1917  "",
1918  rtx, (tree fndecl, int incoming),
1919  hook_rtx_tree_int_null)
1920 DEFHOOK
1921 (return_in_memory,
1922  "",
1923  bool, (const_tree type, const_tree fntype),
1924  default_return_in_memory)
1925
1926 DEFHOOK
1927 (return_in_msb,
1928  "",
1929  bool, (const_tree type),
1930  hook_bool_const_tree_false)
1931
1932 /* Return true if a parameter must be passed by reference.  TYPE may
1933    be null if this is a libcall.  CA may be null if this query is
1934    from __builtin_va_arg.  */
1935 DEFHOOK
1936 (pass_by_reference,
1937  "",
1938  bool,
1939  (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named),
1940  hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
1941
1942 DEFHOOK
1943 (expand_builtin_saveregs,
1944  "",
1945  rtx, (void),
1946  default_expand_builtin_saveregs)
1947
1948 /* Returns pretend_argument_size.  */
1949 DEFHOOK
1950 (setup_incoming_varargs,
1951  "",
1952  void, (cumulative_args_t args_so_far, enum machine_mode mode, tree type,
1953         int *pretend_args_size, int second_time),
1954  default_setup_incoming_varargs)
1955
1956 DEFHOOK
1957 (strict_argument_naming,
1958  "",
1959  bool, (cumulative_args_t ca),
1960  hook_bool_CUMULATIVE_ARGS_false)
1961
1962 /* Returns true if we should use
1963    targetm.calls.setup_incoming_varargs() and/or
1964    targetm.calls.strict_argument_naming().  */
1965 DEFHOOK
1966 (pretend_outgoing_varargs_named,
1967  "",
1968  bool, (cumulative_args_t ca),
1969  default_pretend_outgoing_varargs_named)
1970
1971 /* Given a complex type T, return true if a parameter of type T
1972    should be passed as two scalars.  */
1973 DEFHOOK
1974 (split_complex_arg,
1975  "",
1976  bool, (const_tree type), NULL)
1977
1978 /* Return true if type T, mode MODE, may not be passed in registers,
1979    but must be passed on the stack.  */
1980 /* ??? This predicate should be applied strictly after pass-by-reference.
1981    Need audit to verify that this is the case.  */
1982 DEFHOOK
1983 (must_pass_in_stack,
1984  "",
1985  bool, (enum machine_mode mode, const_tree type),
1986  must_pass_in_stack_var_size_or_pad)
1987
1988 /* Return true if type TYPE, mode MODE, which is passed by reference,
1989    should have the object copy generated by the callee rather than
1990    the caller.  It is never called for TYPE requiring constructors.  */
1991 DEFHOOK
1992 (callee_copies,
1993  "",
1994  bool,
1995  (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named),
1996  hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
1997
1998 /* Return zero for arguments passed entirely on the stack or entirely
1999    in registers.  If passed in both, return the number of bytes passed
2000    in registers; the balance is therefore passed on the stack.  */
2001 DEFHOOK
2002 (arg_partial_bytes,
2003  "",
2004  int, (cumulative_args_t cum, enum machine_mode mode, tree type, bool named),
2005  hook_int_CUMULATIVE_ARGS_mode_tree_bool_0)
2006
2007 /* Update the state in CA to advance past an argument in the
2008    argument list.  The values MODE, TYPE, and NAMED describe that
2009    argument.  */
2010 DEFHOOK
2011 (function_arg_advance,
2012  "",
2013  void,
2014  (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named),
2015  default_function_arg_advance)
2016
2017 /* Return zero if the argument described by the state of CA should
2018    be placed on a stack, or a hard register in which to store the
2019    argument.  The values MODE, TYPE, and NAMED describe that
2020    argument.  */
2021 DEFHOOK
2022 (function_arg,
2023  "",
2024  rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type,
2025        bool named),
2026  default_function_arg)
2027
2028 /* Likewise, but for machines with register windows.  Return the
2029    location where the argument will appear to the callee.  */
2030 DEFHOOK
2031 (function_incoming_arg,
2032  "",
2033  rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type,
2034        bool named),
2035  default_function_incoming_arg)
2036
2037 DEFHOOK
2038 (function_arg_boundary,
2039  "",
2040  unsigned int, (enum machine_mode mode, const_tree type),
2041  default_function_arg_boundary)
2042
2043 DEFHOOK
2044 (function_arg_round_boundary,
2045  "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\
2046 which is the default value for this hook.  You can define this hook to\n\
2047 return a different value if an argument size must be rounded to a larger\n\
2048 value.",
2049  unsigned int, (enum machine_mode mode, const_tree type),
2050  default_function_arg_round_boundary)
2051
2052 /* Return the diagnostic message string if function without a prototype
2053    is not allowed for this 'val' argument; NULL otherwise. */
2054 DEFHOOK
2055 (invalid_arg_for_unprototyped_fn,
2056  "",
2057  const char *, (const_tree typelist, const_tree funcdecl, const_tree val),
2058  hook_invalid_arg_for_unprototyped_fn)
2059
2060 /* Return an rtx for the return value location of the function
2061    specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
2062 DEFHOOK
2063 (function_value,
2064  "",
2065  rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
2066  default_function_value)
2067
2068 /* Return the rtx for the result of a libcall of mode MODE,
2069    calling the function FN_NAME.  */
2070 DEFHOOK
2071 (libcall_value,
2072  "",
2073  rtx, (enum machine_mode mode, const_rtx fun),
2074  default_libcall_value)
2075
2076 /* Return true if REGNO is a possible register number for
2077    a function value as seen by the caller.  */
2078 DEFHOOK
2079 (function_value_regno_p,
2080  "",
2081  bool, (const unsigned int regno),
2082  default_function_value_regno_p)
2083
2084 /* ??? Documenting this hook requires a GFDL license grant.  */
2085 DEFHOOK_UNDOC
2086 (internal_arg_pointer,
2087 "Return an rtx for the argument pointer incoming to the\
2088  current function.",
2089  rtx, (void),
2090  default_internal_arg_pointer)
2091
2092 /* Update the current function stack boundary if needed.  */
2093 DEFHOOK
2094 (update_stack_boundary,
2095  "",
2096  void, (void), NULL)
2097
2098 /* Handle stack alignment and return an rtx for Dynamic Realign
2099    Argument Pointer if necessary.  */
2100 DEFHOOK
2101 (get_drap_rtx,
2102  "",
2103  rtx, (void), NULL)
2104
2105 /* Return true if all function parameters should be spilled to the
2106    stack.  */
2107 DEFHOOK
2108 (allocate_stack_slots_for_args,
2109  "",
2110  bool, (void),
2111  hook_bool_void_true)
2112
2113 /* Return an rtx for the static chain for FNDECL.  If INCOMING_P is true,
2114        then it should be for the callee; otherwise for the caller.  */
2115 DEFHOOK
2116 (static_chain,
2117  "",
2118  rtx, (const_tree fndecl, bool incoming_p),
2119  default_static_chain)
2120
2121 /* Fill in the trampoline at MEM with a call to FNDECL and a
2122    static chain value of CHAIN.  */
2123 DEFHOOK
2124 (trampoline_init,
2125  "",
2126  void, (rtx m_tramp, tree fndecl, rtx static_chain),
2127  default_trampoline_init)
2128
2129 /* Adjust the address of the trampoline in a target-specific way.  */
2130 DEFHOOK
2131 (trampoline_adjust_address,
2132  "",
2133  rtx, (rtx addr), NULL)
2134
2135 /* Return the number of bytes of its own arguments that a function
2136    pops on returning, or 0 if the function pops no arguments and the
2137    caller must therefore pop them all after the function returns.  */
2138 /* ??? tm.texi has no types for the parameters.  */
2139 DEFHOOK
2140 (return_pops_args,
2141  "",
2142  int, (tree fundecl, tree funtype, int size),
2143  default_return_pops_args)
2144
2145 /* Return a mode wide enough to copy any function value that might be
2146    returned.  */
2147 DEFHOOK
2148 (get_raw_result_mode,
2149  "This target hook returns the mode to be used when accessing raw return\
2150  registers in @code{__builtin_return}.  Define this macro if the value\
2151  in @var{reg_raw_mode} is not correct.",
2152  enum machine_mode, (int regno),
2153  default_get_reg_raw_mode)
2154
2155 /* Return a mode wide enough to copy any argument value that might be
2156    passed.  */
2157 DEFHOOK
2158 (get_raw_arg_mode,
2159  "This target hook returns the mode to be used when accessing raw argument\
2160  registers in @code{__builtin_apply_args}.  Define this macro if the value\
2161  in @var{reg_raw_mode} is not correct.",
2162  enum machine_mode, (int regno),
2163  default_get_reg_raw_mode)
2164
2165 HOOK_VECTOR_END (calls)
2166
2167 /* Return the diagnostic message string if conversion from FROMTYPE
2168    to TOTYPE is not allowed, NULL otherwise.  */
2169 DEFHOOK
2170 (invalid_conversion,
2171  "",
2172  const char *, (const_tree fromtype, const_tree totype),
2173  hook_constcharptr_const_tree_const_tree_null)
2174
2175 /* Return the diagnostic message string if the unary operation OP is
2176    not permitted on TYPE, NULL otherwise.  */
2177 DEFHOOK
2178 (invalid_unary_op,
2179  "",
2180  const char *, (int op, const_tree type),
2181  hook_constcharptr_int_const_tree_null)
2182
2183 /* Return the diagnostic message string if the binary operation OP
2184    is not permitted on TYPE1 and TYPE2, NULL otherwise.  */
2185 DEFHOOK
2186 (invalid_binary_op,
2187  "",
2188  const char *, (int op, const_tree type1, const_tree type2),
2189  hook_constcharptr_int_const_tree_const_tree_null)
2190
2191 /* Return the diagnostic message string if TYPE is not valid as a
2192    function parameter type, NULL otherwise.  */
2193 DEFHOOK
2194 (invalid_parameter_type,
2195  "",
2196  const char *, (const_tree type),
2197  hook_constcharptr_const_tree_null)
2198
2199 /* Return the diagnostic message string if TYPE is not valid as a
2200    function return type, NULL otherwise.  */
2201 DEFHOOK
2202 (invalid_return_type,
2203  "",
2204  const char *, (const_tree type),
2205  hook_constcharptr_const_tree_null)
2206
2207 /* If values of TYPE are promoted to some other type when used in
2208    expressions (analogous to the integer promotions), return that type,
2209    or NULL_TREE otherwise.  */
2210 DEFHOOK
2211 (promoted_type,
2212  "",
2213  tree, (const_tree type),
2214  hook_tree_const_tree_null)
2215
2216 /* Convert EXPR to TYPE, if target-specific types with special conversion
2217    rules are involved.  Return the converted expression, or NULL to apply
2218    the standard conversion rules.  */
2219 DEFHOOK
2220 (convert_to_type,
2221  "",
2222  tree, (tree type, tree expr),
2223  hook_tree_tree_tree_null)
2224
2225 /* Return the class for a secondary reload, and fill in extra information.  */
2226 DEFHOOK
2227 (secondary_reload,
2228  "",
2229  reg_class_t,
2230  (bool in_p, rtx x, reg_class_t reload_class, enum machine_mode reload_mode,
2231   secondary_reload_info *sri),
2232  default_secondary_reload)
2233
2234 /* Given an rtx X being reloaded into a reg required to be in class CLASS,
2235    return the class of reg to actually use.  */
2236 DEFHOOK
2237 (preferred_reload_class,
2238  "",
2239  reg_class_t,
2240  (rtx x, reg_class_t rclass),
2241  default_preferred_reload_class)
2242
2243 /* Like TARGET_PREFERRED_RELOAD_CLASS, but for output reloads instead of
2244    input reloads.  */
2245 DEFHOOK
2246 (preferred_output_reload_class,
2247  "",
2248  reg_class_t,
2249  (rtx x, reg_class_t rclass),
2250  default_preferred_output_reload_class)
2251
2252 DEFHOOK
2253 (class_likely_spilled_p,
2254  "",
2255  bool, (reg_class_t rclass),
2256  default_class_likely_spilled_p)
2257
2258 /* Return the maximum number of consecutive registers
2259    needed to represent mode MODE in a register of class RCLASS.  */
2260 DEFHOOK
2261 (class_max_nregs,
2262  "",
2263  unsigned char, (reg_class_t rclass, enum machine_mode mode),
2264  default_class_max_nregs)
2265
2266 DEFHOOK
2267 (preferred_rename_class,
2268  "A target hook that places additional preference on the register\
2269  class to use when it is necessary to rename a register in class\
2270  @var{rclass} to another class, or perhaps @var{NO_REGS}, if no\
2271  preferred register class is found or hook @code{preferred_rename_class}\
2272  is not implemented.\
2273  Sometimes returning a more restrictive class makes better code.  For\
2274  example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\
2275  smaller than instructions using @code{GENERIC_REGS}.  By returning\
2276  @code{LO_REGS} from @code{preferred_rename_class}, code size can\
2277  be reduced.",
2278  reg_class_t, (reg_class_t rclass),
2279  default_preferred_rename_class)
2280
2281 /* This target hook allows the backend to perform additional
2282    processing while initializing for variable expansion.  */
2283 DEFHOOK
2284 (expand_to_rtl_hook,
2285  "",
2286  void, (void),
2287  hook_void_void)
2288
2289 /* This target hook allows the backend to perform additional
2290    instantiations on rtx that are not actually in insns yet,
2291    but will be later.  */
2292 DEFHOOK
2293 (instantiate_decls,
2294  "",
2295  void, (void),
2296  hook_void_void)
2297
2298 /* Return true if is OK to use a hard register REGNO as scratch register
2299    in peephole2.  */
2300 DEFHOOK
2301 (hard_regno_scratch_ok,
2302  "",
2303  bool, (unsigned int regno),
2304  default_hard_regno_scratch_ok)
2305
2306 /* Return the smallest number of different values for which it is best to
2307    use a jump-table instead of a tree of conditional branches.  */
2308 DEFHOOK
2309 (case_values_threshold,
2310  "",
2311  unsigned int, (void),
2312  default_case_values_threshold)
2313
2314 /* Retutn true if a function must have and use a frame pointer.  */
2315 DEFHOOK
2316 (frame_pointer_required,
2317  "",
2318  bool, (void),
2319  hook_bool_void_false)
2320
2321 /* Returns true if the compiler is allowed to try to replace register number
2322    from-reg with register number to-reg.  */
2323 DEFHOOK
2324 (can_eliminate,
2325  "",
2326  bool, (const int from_reg, const int to_reg),
2327  hook_bool_const_int_const_int_true)
2328
2329 /* Modify any or all of fixed_regs, call_used_regs, global_regs,
2330    reg_names, and reg_class_contents to account of the vagaries of the
2331    target.  */
2332 DEFHOOK
2333 (conditional_register_usage,
2334  "",
2335  void, (void),
2336  hook_void_void)
2337
2338 /* Functions specific to the C family of frontends.  */
2339 #undef HOOK_PREFIX
2340 #define HOOK_PREFIX "TARGET_C_"
2341 HOOK_VECTOR (TARGET_C, c)
2342
2343 /* ??? Documenting this hook requires a GFDL license grant.  */
2344 DEFHOOK_UNDOC
2345 (mode_for_suffix,
2346 "Return machine mode for non-standard constant literal suffix @var{c},\
2347  or VOIDmode if non-standard suffixes are unsupported.",
2348  enum machine_mode, (char c),
2349  default_mode_for_suffix)
2350
2351 HOOK_VECTOR_END (c)
2352
2353 /* Functions specific to the C++ frontend.  */
2354 #undef HOOK_PREFIX
2355 #define HOOK_PREFIX "TARGET_CXX_"
2356 HOOK_VECTOR (TARGET_CXX, cxx)
2357
2358 /* Return the integer type used for guard variables.  */
2359 DEFHOOK
2360 (guard_type,
2361  "",
2362  tree, (void),
2363  default_cxx_guard_type)
2364
2365 /* Return true if only the low bit of the guard should be tested.  */
2366 DEFHOOK
2367 (guard_mask_bit,
2368  "",
2369  bool, (void),
2370  hook_bool_void_false)
2371
2372 /* Returns the size of the array cookie for an array of type.  */
2373 DEFHOOK
2374 (get_cookie_size,
2375  "",
2376  tree, (tree type),
2377  default_cxx_get_cookie_size)
2378
2379 /* Returns true if the element size should be stored in the array cookie.  */
2380 DEFHOOK
2381 (cookie_has_size,
2382  "",
2383  bool, (void),
2384  hook_bool_void_false)
2385
2386 /* Allows backends to perform additional processing when
2387    deciding if a class should be exported or imported.  */
2388 DEFHOOK
2389 (import_export_class,
2390  "",
2391  int, (tree type, int import_export), NULL)
2392
2393 /* Returns true if constructors and destructors return "this".  */
2394 DEFHOOK
2395 (cdtor_returns_this,
2396  "",
2397  bool, (void),
2398  hook_bool_void_false)
2399
2400 /* Returns true if the key method for a class can be an inline
2401    function, so long as it is not declared inline in the class
2402    itself.  Returning true is the behavior required by the Itanium C++ ABI.  */
2403 DEFHOOK
2404 (key_method_may_be_inline,
2405  "",
2406  bool, (void),
2407  hook_bool_void_true)
2408
2409 DEFHOOK
2410 (determine_class_data_visibility,
2411 "@var{decl} is a virtual table, virtual table table, typeinfo object,\
2412  or other similar implicit class data object that will be emitted with\
2413  external linkage in this translation unit.  No ELF visibility has been\
2414  explicitly specified.  If the target needs to specify a visibility\
2415  other than that of the containing class, use this hook to set\
2416  @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
2417  void, (tree decl),
2418  hook_void_tree)
2419
2420 /* Returns true (the default) if virtual tables and other
2421    similar implicit class data objects are always COMDAT if they
2422    have external linkage.  If this hook returns false, then
2423    class data for classes whose virtual table will be emitted in
2424    only one translation unit will not be COMDAT.  */
2425 DEFHOOK
2426 (class_data_always_comdat,
2427  "",
2428  bool, (void),
2429  hook_bool_void_true)
2430
2431 /* Returns true (the default) if the RTTI for the basic types,
2432    which is always defined in the C++ runtime, should be COMDAT;
2433    false if it should not be COMDAT.  */
2434 DEFHOOK
2435 (library_rtti_comdat,
2436  "",
2437  bool, (void),
2438  hook_bool_void_true)
2439
2440 /* Returns true if __aeabi_atexit should be used to register static
2441    destructors.  */
2442 DEFHOOK
2443 (use_aeabi_atexit,
2444  "",
2445  bool, (void),
2446  hook_bool_void_false)
2447
2448 /* Returns true if target may use atexit in the same manner as
2449    __cxa_atexit  to register static destructors.  */
2450 DEFHOOK
2451 (use_atexit_for_cxa_atexit,
2452  "",
2453  bool, (void),
2454  hook_bool_void_false)
2455
2456 DEFHOOK
2457 (adjust_class_at_definition,
2458 "@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\
2459  been defined.  Use this hook to make adjustments to the class (eg, tweak\
2460  visibility or perform any other required target modifications).",
2461  void, (tree type),
2462  hook_void_tree)
2463
2464 DEFHOOK
2465 (decl_mangling_context,
2466  "Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.",
2467  tree, (const_tree decl),
2468  hook_tree_const_tree_null)
2469
2470 HOOK_VECTOR_END (cxx)
2471
2472 /* Functions and data for emulated TLS support.  */
2473 #undef HOOK_PREFIX
2474 #define HOOK_PREFIX "TARGET_EMUTLS_"
2475 HOOK_VECTOR (TARGET_EMUTLS, emutls)
2476
2477 /* Name of the address and common functions.  */
2478 DEFHOOKPOD
2479 (get_address,
2480  "",
2481  const char *, "__builtin___emutls_get_address")
2482
2483 DEFHOOKPOD
2484 (register_common,
2485  "",
2486  const char *, "__builtin___emutls_register_common")
2487
2488 /* Prefixes for proxy variable and template.  */
2489 DEFHOOKPOD
2490 (var_section,
2491  "",
2492  const char *, NULL)
2493
2494 DEFHOOKPOD
2495 (tmpl_section,
2496  "",
2497  const char *, NULL)
2498
2499 /* Prefixes for proxy variable and template.  */
2500 DEFHOOKPOD
2501 (var_prefix,
2502  "",
2503  const char *, NULL)
2504
2505 DEFHOOKPOD
2506 (tmpl_prefix,
2507  "",
2508  const char *, NULL)
2509
2510 /* Function to generate field definitions of the proxy variable.  */
2511 DEFHOOK
2512 (var_fields,
2513  "",
2514  tree, (tree type, tree *name),
2515  default_emutls_var_fields)
2516
2517 /* Function to initialize a proxy variable.  */
2518 DEFHOOK
2519 (var_init,
2520  "",
2521  tree, (tree var, tree decl, tree tmpl_addr),
2522  default_emutls_var_init)
2523
2524 /* Whether we are allowed to alter the usual alignment of the
2525    proxy variable.  */
2526 DEFHOOKPOD
2527 (var_align_fixed,
2528  "",
2529  bool, false)
2530
2531 /* Whether we can emit debug information for TLS vars.  */
2532 DEFHOOKPOD
2533 (debug_form_tls_address,
2534  "",
2535  bool, false)
2536
2537 HOOK_VECTOR_END (emutls)
2538
2539 #undef HOOK_PREFIX
2540 #define HOOK_PREFIX "TARGET_OPTION_"
2541 HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks)
2542
2543 /* Function to validate the attribute((option(...))) strings or NULL.  If
2544    the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
2545    be filled in in the function decl node.  */
2546 DEFHOOK
2547 (valid_attribute_p,
2548  "",
2549  bool, (tree fndecl, tree name, tree args, int flags),
2550  default_target_option_valid_attribute_p)
2551
2552 /* Function to save any extra target state in the target options structure.  */
2553 DEFHOOK
2554 (save,
2555  "",
2556  void, (struct cl_target_option *ptr), NULL)
2557
2558 /* Function to restore any extra target state from the target options
2559    structure.  */
2560 DEFHOOK
2561 (restore,
2562  "",
2563  void, (struct cl_target_option *ptr), NULL)
2564
2565 /* Function to print any extra target state from the target options
2566    structure.  */
2567 DEFHOOK
2568 (print,
2569  "",
2570  void, (FILE *file, int indent, struct cl_target_option *ptr), NULL)
2571
2572 /* Function to parse arguments to be validated for #pragma option, and to
2573    change the state if the options are valid.  If the first argument is
2574    NULL, the second argument specifies the default options to use.  Return
2575    true if the options are valid, and set the current state.  */
2576 /* ??? The documentation in tm.texi is incomplete.  */
2577 DEFHOOK
2578 (pragma_parse,
2579  "",
2580  bool, (tree args, tree pop_target),
2581  default_target_option_pragma_parse)
2582
2583 /* Do option overrides for the target.  */
2584 DEFHOOK
2585 (override,
2586  "",
2587  void, (void),
2588  hook_void_void)
2589
2590 /* Function to determine if one function can inline another function.  */
2591 #undef HOOK_PREFIX
2592 #define HOOK_PREFIX "TARGET_"
2593 DEFHOOK
2594 (can_inline_p,
2595  "",
2596  bool, (tree caller, tree callee),
2597  default_target_can_inline_p)
2598
2599 HOOK_VECTOR_END (target_option)
2600
2601 /* For targets that need to mark extra registers as live on entry to
2602    the function, they should define this target hook and set their
2603    bits in the bitmap passed in. */
2604 DEFHOOK
2605 (extra_live_on_entry,
2606  "",
2607  void, (bitmap regs),
2608  hook_void_bitmap)
2609
2610 /* Determine the type of unwind info to emit for debugging.  */
2611 DEFHOOK
2612 (debug_unwind_info,
2613  "",
2614  enum unwind_info_type, (void),
2615  default_debug_unwind_info)
2616
2617 /* Leave the boolean fields at the end.  */
2618
2619 /* True if we can create zeroed data by switching to a BSS section
2620    and then using ASM_OUTPUT_SKIP to allocate the space.  */
2621 DEFHOOKPOD
2622 (have_switchable_bss_sections,
2623  "",
2624  bool, false)
2625
2626 /* True if "native" constructors and destructors are supported,
2627    false if we're using collect2 for the job.  */
2628 DEFHOOKPOD
2629 (have_ctors_dtors,
2630  "",
2631  bool, false)
2632
2633 /* True if thread-local storage is supported.  */
2634 DEFHOOKPOD
2635 (have_tls,
2636  "",
2637  bool, false)
2638
2639 /* True if a small readonly data section is supported.  */
2640 DEFHOOKPOD
2641 (have_srodata_section,
2642  "",
2643  bool, false)
2644
2645 /* True if EH frame info sections should be zero-terminated.  */
2646 DEFHOOKPOD
2647 (terminate_dw2_eh_frame_info,
2648  "",
2649  bool, true)
2650
2651 /* True if #NO_APP should be emitted at the beginning of assembly output.  */
2652 DEFHOOKPOD
2653 (asm_file_start_app_off,
2654  "",
2655  bool, false)
2656
2657 /* True if output_file_directive should be called for main_input_filename
2658    at the beginning of assembly output.  */
2659 DEFHOOKPOD
2660 (asm_file_start_file_directive,
2661  "",
2662  bool, false)
2663
2664 DEFHOOKPOD
2665 (handle_pragma_extern_prefix,
2666 "True if @code{#pragma extern_prefix} is to be supported.",
2667  bool, 0)
2668
2669 /* True if the target is allowed to reorder memory accesses unless
2670    synchronization is explicitly requested.  */
2671 DEFHOOKPOD
2672 (relaxed_ordering,
2673  "",
2674  bool, false)
2675
2676 /* Returns true if we should generate exception tables for use with the
2677    ARM EABI.  The effects the encoding of function exception specifications.  */
2678 DEFHOOKPOD
2679 (arm_eabi_unwinder,
2680  "",
2681  bool, false)
2682
2683 DEFHOOKPOD
2684 (want_debug_pub_sections,
2685  "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\
2686  should be emitted.  These sections are not used on most platforms, and\
2687  in particular GDB does not use them.",
2688  bool, false)
2689
2690 DEFHOOKPOD
2691 (delay_sched2, "True if sched2 is not to be run at its normal place.  \
2692 This usually means it will be run as part of machine-specific reorg.",
2693 bool, false)
2694
2695 DEFHOOKPOD
2696 (delay_vartrack, "True if vartrack is not to be run at its normal place.  \
2697 This usually means it will be run as part of machine-specific reorg.",
2698 bool, false)
2699
2700 /* Leave the boolean fields at the end.  */
2701
2702 /* Close the 'struct gcc_target' definition.  */
2703 HOOK_VECTOR_END (C90_EMPTY_HACK)