gcc/target.def

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