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, unsigned 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, unsigned int dep_status, 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, (unsigned 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).  The third parameter is the kind of speculation that
 854    is being performed.  */
 855 DEFHOOK
 856 (gen_spec_check,
 857  "",
 858  rtx, (rtx insn, rtx label, unsigned int ds), NULL)
 859
 860 /* The following member value is a pointer to a function controlling
 861    what insns from the ready insn queue will be considered for the
 862    multipass insn scheduling.  If the hook returns zero for the insn
 863    passed as the parameter, the insn will not be chosen to be
 864    issued.  This hook is used to discard speculative instructions,
 865    that stand at the first position of the ready list.  */
 866 DEFHOOK
 867 (first_cycle_multipass_dfa_lookahead_guard_spec,
 868  "",
 869  bool, (const_rtx insn), NULL)
 870
 871 /* The following member value is a pointer to a function that provides
 872    information about the speculation capabilities of the target.
 873    The parameter is a pointer to spec_info variable.  */
 874 DEFHOOK
 875 (set_sched_flags,
 876  "",
 877  void, (struct spec_info_def *spec_info), NULL)
 878
 879 DEFHOOK_UNDOC
 880 (get_insn_spec_ds,
 881  "Return speculation types of instruction @var{insn}.",
 882  unsigned int, (rtx insn), NULL)
 883
 884 DEFHOOK_UNDOC
 885 (get_insn_checked_ds,
 886  "Return speculation types that are checked for instruction @var{insn}",
 887  unsigned int, (rtx insn), NULL)
 888
 889 DEFHOOK_UNDOC
 890 (skip_rtx_p,
 891  "Return bool if rtx scanning should just skip current layer and\
 892  advance to the inner rtxes.",
 893  bool, (const_rtx x), NULL)
 894
 895 /* The following member value is a pointer to a function that provides
 896    information about the target resource-based lower bound which is
 897    used by the swing modulo scheduler.  The parameter is a pointer
 898    to ddg variable.  */
 899 DEFHOOK
 900 (sms_res_mii,
 901  "",
 902  int, (struct ddg *g), NULL)
 903
 904 /* The following member value is a function that initializes dispatch
 905    schedling and adds instructions to dispatch window according to its
 906    parameters.  */
 907 DEFHOOK
 908 (dispatch_do,
 909 "",
 910 void, (rtx insn, int x),
 911 hook_void_rtx_int)
 912
 913 /* The following member value is a a function that returns true is
 914    dispatch schedling is supported in hardware and condition passed
 915    as the second parameter is true.  */
 916 DEFHOOK
 917 (dispatch,
 918 "",
 919 bool, (rtx insn, int x),
 920 hook_bool_rtx_int_false)
 921
 922 DEFHOOKPOD
 923 (exposed_pipeline,
 924 "True if the processor has an exposed pipeline, which means that not just\n\
 925 the order of instructions is important for correctness when scheduling, but\n\
 926 also the latencies of operations.",
 927 bool, false)
 928
 929 /* The following member value is a function that returns number
 930    of operations reassociator should try to put in parallel for
 931    statements of the given type.  By default 1 is used.  */
 932 DEFHOOK
 933 (reassociation_width,
 934 "This hook is called by tree reassociator to determine a level of\n\
 935 parallelism required in output calculations chain.",
 936 int, (unsigned int opc, enum machine_mode mode),
 937 hook_int_uint_mode_1)
 938
 939 HOOK_VECTOR_END (sched)
 940
 941 /* Functions relating to vectorization.  */
 942 #undef HOOK_PREFIX
 943 #define HOOK_PREFIX "TARGET_VECTORIZE_"
 944 HOOK_VECTOR (TARGET_VECTORIZE, vectorize)
 945
 946 /* The following member value is a pointer to a function called
 947    by the vectorizer, and return the decl of the target builtin
 948    function.  */
 949 DEFHOOK
 950 (builtin_mask_for_load,
 951  "",
 952  tree, (void), NULL)
 953
 954 /* Returns a code for builtin that realizes vectorized version of
 955    function, or NULL_TREE if not available.  */
 956 DEFHOOK
 957 (builtin_vectorized_function,
 958  "",
 959  tree, (tree fndecl, tree vec_type_out, tree vec_type_in),
 960  default_builtin_vectorized_function)
 961
 962 /* Returns a function declaration for a builtin that realizes the
 963    vector conversion, or NULL_TREE if not available.  */
 964 DEFHOOK
 965 (builtin_conversion,
 966  "",
 967  tree, (unsigned code, tree dest_type, tree src_type),
 968  default_builtin_vectorized_conversion)
 969
 970 /* Cost of different vector/scalar statements in vectorization cost
 971    model. In case of misaligned vector loads and stores the cost depends
 972    on the data type and misalignment value.  */
 973 DEFHOOK
 974 (builtin_vectorization_cost,
 975  "",
 976  int, (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign),
 977  default_builtin_vectorization_cost)
 978
 979 /* Return true if vector alignment is reachable (by peeling N
 980    iterations) for the given type.  */
 981 DEFHOOK
 982 (vector_alignment_reachable,
 983  "",
 984  bool, (const_tree type, bool is_packed),
 985  default_builtin_vector_alignment_reachable)
 986
 987 /* Return true if a vector created for vec_perm_const is valid.
 988    A NULL indicates that all constants are valid permutations.  */
 989 DEFHOOK
 990 (vec_perm_const_ok,
 991  "",
 992  bool, (enum machine_mode, const unsigned char *sel),
 993  NULL)
 994
 995 /* Return true if the target supports misaligned store/load of a
 996    specific factor denoted in the third parameter.  The last parameter
 997    is true if the access is defined in a packed struct.  */
 998 DEFHOOK
 999 (support_vector_misalignment,
1000  "",
1001  bool,
1002  (enum machine_mode mode, const_tree type, int misalignment, bool is_packed),
1003  default_builtin_support_vector_misalignment)
1004
1005 /* Return the builtin decl needed to load a vector of TYPE.  */
1006 DEFHOOK
1007 (builtin_tm_load,
1008  "This hook should return the built-in decl needed to load a vector of the "
1009  "given type within a transaction.",
1010  tree,
1011  (tree),
1012  default_builtin_tm_load_store)
1013
1014 /* Return the builtin decl needed to store a vector of TYPE.  */
1015 DEFHOOK
1016 (builtin_tm_store,
1017  "This hook should return the built-in decl needed to store a vector of the "
1018  "given type within a transaction.",
1019  tree,
1020  (tree),
1021  default_builtin_tm_load_store)
1022
1023 /* Returns the preferred mode for SIMD operations for the specified
1024    scalar mode.  */
1025 DEFHOOK
1026 (preferred_simd_mode,
1027  "",
1028  enum machine_mode,
1029  (enum machine_mode mode),
1030  default_preferred_simd_mode)
1031
1032 /* Returns a mask of vector sizes to iterate over when auto-vectorizing
1033    after processing the preferred one derived from preferred_simd_mode.  */
1034 DEFHOOK
1035 (autovectorize_vector_sizes,
1036  "",
1037  unsigned int,
1038  (void),
1039  default_autovectorize_vector_sizes)
1040
1041 /* Target builtin that implements vector gather operation.  */
1042 DEFHOOK
1043 (builtin_gather,
1044  "",
1045  tree,
1046  (const_tree mem_vectype, const_tree index_type, int scale),
1047  NULL)
1048
1049 /* Target function to initialize the cost model for a loop or block.  */
1050 DEFHOOK
1051 (init_cost,
1052  "This hook should initialize target-specific data structures in preparation "
1053  "for modeling the costs of vectorizing a loop or basic block.  The default "
1054  "allocates three unsigned integers for accumulating costs for the prologue, "
1055  "body, and epilogue of the loop or basic block.  If @var{loop_info} is "
1056  "non-NULL, it identifies the loop being vectorized; otherwise a single block "
1057  "is being vectorized.",
1058  void *,
1059  (struct loop *loop_info),
1060  default_init_cost)
1061
1062 /* Target function to record N statements of the given kind using the
1063    given vector type within the cost model data for the current loop or
1064     block.  */
1065 DEFHOOK
1066 (add_stmt_cost,
1067  "This hook should update the target-specific @var{data} in response to "
1068  "adding @var{count} copies of the given @var{kind} of statement to a "
1069  "loop or basic block.  The default adds the builtin vectorizer cost for "
1070  "the copies of the statement to the accumulator specified by @var{where}, "
1071  "(the prologue, body, or epilogue) and returns the amount added.  The "
1072  "return value should be viewed as a tentative cost that may later be "
1073  "revised.",
1074  unsigned,
1075  (void *data, int count, enum vect_cost_for_stmt kind,
1076   struct _stmt_vec_info *stmt_info, int misalign,
1077   enum vect_cost_model_location where),
1078  default_add_stmt_cost)
1079
1080 /* Target function to calculate the total cost of the current vectorized
1081    loop or block.  */
1082 DEFHOOK
1083 (finish_cost,
1084  "This hook should complete calculations of the cost of vectorizing a loop "
1085  "or basic block based on @var{data}, and return the prologue, body, and "
1086  "epilogue costs as unsigned integers.  The default returns the value of "
1087  "the three accumulators.",
1088  void,
1089  (void *data, unsigned *prologue_cost, unsigned *body_cost,
1090   unsigned *epilogue_cost),
1091  default_finish_cost)
1092
1093 /* Function to delete target-specific cost modeling data.  */
1094 DEFHOOK
1095 (destroy_cost_data,
1096  "This hook should release @var{data} and any related data structures "
1097  "allocated by TARGET_VECTORIZE_INIT_COST.  The default releases the "
1098  "accumulator.",
1099  void,
1100  (void *data),
1101  default_destroy_cost_data)
1102
1103 HOOK_VECTOR_END (vectorize)
1104
1105 #undef HOOK_PREFIX
1106 #define HOOK_PREFIX "TARGET_"
1107
1108 /* Allow target specific overriding of option settings after options have
1109   been changed by an attribute or pragma or when it is reset at the
1110   end of the code affected by an attribute or pragma.  */
1111 DEFHOOK
1112 (override_options_after_change,
1113  "",
1114  void, (void),
1115  hook_void_void)
1116
1117 DEFHOOK_UNDOC
1118 (eh_return_filter_mode,
1119  "Return machine mode for filter value.",
1120  enum machine_mode, (void),
1121  default_eh_return_filter_mode)
1122
1123 /* Return machine mode for libgcc expanded cmp instructions.  */
1124 DEFHOOK
1125 (libgcc_cmp_return_mode,
1126  "",
1127  enum machine_mode, (void),
1128  default_libgcc_cmp_return_mode)
1129
1130 /* Return machine mode for libgcc expanded shift instructions.  */
1131 DEFHOOK
1132 (libgcc_shift_count_mode,
1133  "",
1134  enum machine_mode, (void),
1135  default_libgcc_shift_count_mode)
1136
1137 /* Return machine mode to be used for _Unwind_Word type.  */
1138 DEFHOOK
1139 (unwind_word_mode,
1140  "",
1141  enum machine_mode, (void),
1142  default_unwind_word_mode)
1143
1144 /* Given two decls, merge their attributes and return the result.  */
1145 DEFHOOK
1146 (merge_decl_attributes,
1147  "",
1148  tree, (tree olddecl, tree newdecl),
1149  merge_decl_attributes)
1150
1151 /* Given two types, merge their attributes and return the result.  */
1152 DEFHOOK
1153 (merge_type_attributes,
1154  "",
1155  tree, (tree type1, tree type2),
1156  merge_type_attributes)
1157
1158 /* Table of machine attributes and functions to handle them.
1159    Ignored if NULL.  */
1160 DEFHOOKPOD
1161 (attribute_table,
1162  "",
1163  const struct attribute_spec *, NULL)
1164
1165 /* Return true iff attribute NAME expects a plain identifier as its first
1166    argument.  */
1167 DEFHOOK
1168 (attribute_takes_identifier_p,
1169  "",
1170  bool, (const_tree name),
1171  hook_bool_const_tree_false)
1172
1173 /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
1174    one if they are compatible and two if they are nearly compatible
1175    (which causes a warning to be generated).  */
1176 DEFHOOK
1177 (comp_type_attributes,
1178  "",
1179  int, (const_tree type1, const_tree type2),
1180  hook_int_const_tree_const_tree_1)
1181
1182 /* Assign default attributes to the newly defined TYPE.  */
1183 DEFHOOK
1184 (set_default_type_attributes,
1185  "",
1186  void, (tree type),
1187  hook_void_tree)
1188
1189 /* Insert attributes on the newly created DECL.  */
1190 DEFHOOK
1191 (insert_attributes,
1192  "",
1193  void, (tree node, tree *attr_ptr),
1194  hook_void_tree_treeptr)
1195
1196 /* Return true if FNDECL (which has at least one machine attribute)
1197    can be inlined despite its machine attributes, false otherwise.  */
1198 DEFHOOK
1199 (function_attribute_inlinable_p,
1200  "",
1201  bool, (const_tree fndecl),
1202  hook_bool_const_tree_false)
1203
1204 /* Return true if bitfields in RECORD_TYPE should follow the
1205    Microsoft Visual C++ bitfield layout rules.  */
1206 DEFHOOK
1207 (ms_bitfield_layout_p,
1208  "",
1209  bool, (const_tree record_type),
1210  hook_bool_const_tree_false)
1211
1212 /* For now this is only an interface to WORDS_BIG_ENDIAN for
1213    target-independent code like the front ends, need performance testing
1214    before switching completely to the target hook.  */
1215 DEFHOOK_UNDOC
1216 (words_big_endian,
1217  "",
1218  bool, (void),
1219  targhook_words_big_endian)
1220
1221 /* Likewise for FLOAT_WORDS_BIG_ENDIAN.  */
1222 DEFHOOK_UNDOC
1223 (float_words_big_endian,
1224  "",
1225  bool, (void),
1226  targhook_float_words_big_endian)
1227
1228 /* True if the target supports decimal floating point.  */
1229 DEFHOOK
1230 (decimal_float_supported_p,
1231  "",
1232  bool, (void),
1233  default_decimal_float_supported_p)
1234
1235 /* True if the target supports fixed-point.  */
1236 DEFHOOK
1237 (fixed_point_supported_p,
1238  "",
1239  bool, (void),
1240  default_fixed_point_supported_p)
1241
1242 /* Return true if anonymous bitfields affect structure alignment.  */
1243 DEFHOOK
1244 (align_anon_bitfield,
1245  "",
1246  bool, (void),
1247  hook_bool_void_false)
1248
1249 /* Return true if volatile bitfields should use the narrowest type possible.
1250    Return false if they should use the container type.  */
1251 DEFHOOK
1252 (narrow_volatile_bitfield,
1253  "",
1254  bool, (void),
1255  hook_bool_void_false)
1256
1257 /* Set up target-specific built-in functions.  */
1258 DEFHOOK
1259 (init_builtins,
1260  "",
1261  void, (void),
1262  hook_void_void)
1263
1264 /* Initialize (if INITIALIZE_P is true) and return the target-specific
1265    built-in function decl for CODE.
1266    Return NULL if that is not possible.  Return error_mark_node if CODE
1267    is outside of the range of valid target builtin function codes.  */
1268 DEFHOOK
1269 (builtin_decl,
1270  "",
1271  tree, (unsigned code, bool initialize_p), NULL)
1272
1273 /* Expand a target-specific builtin.  */
1274 DEFHOOK
1275 (expand_builtin,
1276  "",
1277  rtx,
1278  (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore),
1279  default_expand_builtin)
1280
1281 /* Select a replacement for a target-specific builtin.  This is done
1282    *before* regular type checking, and so allows the target to
1283    implement a crude form of function overloading.  The result is a
1284    complete expression that implements the operation.  PARAMS really
1285    has type VEC(tree,gc)*, but we don't want to include tree.h here.  */
1286 DEFHOOK
1287 (resolve_overloaded_builtin,
1288  "",
1289  tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL)
1290
1291 /* Fold a target-specific builtin to a tree valid for both GIMPLE
1292    and GENERIC.  */
1293 DEFHOOK
1294 (fold_builtin,
1295  "",
1296  tree, (tree fndecl, int n_args, tree *argp, bool ignore),
1297  hook_tree_tree_int_treep_bool_null)
1298
1299 /* Fold a target-specific builtin to a valid GIMPLE tree.  */
1300 DEFHOOK
1301 (gimple_fold_builtin,
1302  "Fold a call to a machine specific built-in function that was set up\n\
1303 by @samp{TARGET_INIT_BUILTINS}.  @var{gsi} points to the gimple\n\
1304 statement holding the function call.  Returns true if any change\n\
1305 was made to the GIMPLE stream.",
1306  bool, (gimple_stmt_iterator *gsi),
1307  hook_bool_gsiptr_false)
1308
1309 /* Target hook is used to compare the target attributes in two functions to
1310    determine which function's features get higher priority.  This is used
1311    during function multi-versioning to figure out the order in which two
1312    versions must be dispatched.  A function version with a higher priority
1313    is checked for dispatching earlier.  DECL1 and DECL2 are
1314    the two function decls that will be compared. It returns positive value
1315    if DECL1 is higher priority,  negative value if DECL2 is higher priority
1316    and 0 if they are the same. */
1317 DEFHOOK
1318 (compare_version_priority,
1319  "",
1320  int, (tree decl1, tree decl2), NULL)
1321
1322 /*  Target hook is used to generate the dispatcher logic to invoke the right
1323     function version at run-time for a given set of function versions.
1324     ARG points to the callgraph node of the dispatcher function whose body
1325     must be generated.  */
1326 DEFHOOK
1327 (generate_version_dispatcher_body,
1328  "",
1329  tree, (void *arg), NULL)
1330
1331 /* Target hook is used to get the dispatcher function for a set of function
1332    versions.  The dispatcher function is called to invoke the right function
1333    version at run-time.  DECL is one version from a set of semantically
1334    identical versions.  */
1335 DEFHOOK
1336 (get_function_versions_dispatcher,
1337  "",
1338  tree, (void *decl), NULL)
1339
1340 /* Returns a code for a target-specific builtin that implements
1341    reciprocal of the function, or NULL_TREE if not available.  */
1342 DEFHOOK
1343 (builtin_reciprocal,
1344  "",
1345  tree, (unsigned fn, bool md_fn, bool sqrt),
1346  default_builtin_reciprocal)
1347
1348 /* For a vendor-specific TYPE, return a pointer to a statically-allocated
1349    string containing the C++ mangling for TYPE.  In all other cases, return
1350    NULL.  */
1351 DEFHOOK
1352 (mangle_type,
1353  "",
1354  const char *, (const_tree type),
1355  hook_constcharptr_const_tree_null)
1356
1357 /* Make any adjustments to libfunc names needed for this target.  */
1358 DEFHOOK
1359 (init_libfuncs,
1360  "",
1361  void, (void),
1362  hook_void_void)
1363
1364  /* Add a __gnu_ prefix to library functions rather than just __.  */
1365 DEFHOOKPOD
1366 (libfunc_gnu_prefix,
1367  "If false (the default), internal library routines start with two\n\
1368 underscores.  If set to true, these routines start with @code{__gnu_}\n\
1369 instead.  E.g., @code{__muldi3} changes to @code{__gnu_muldi3}.  This\n\
1370 currently only affects functions defined in @file{libgcc2.c}.  If this\n\
1371 is set to true, the @file{tm.h} file must also\n\
1372 @code{#define LIBGCC2_GNU_PREFIX}.",
1373   bool, false)
1374
1375 /* Given a decl, a section name, and whether the decl initializer
1376    has relocs, choose attributes for the section.  */
1377 /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION.  */
1378 DEFHOOK
1379 (section_type_flags,
1380  "",
1381  unsigned int, (tree decl, const char *name, int reloc),
1382  default_section_type_flags)
1383
1384 /* True if new jumps cannot be created, to replace existing ones or
1385    not, at the current point in the compilation.  */
1386 DEFHOOK
1387 (cannot_modify_jumps_p,
1388  "",
1389  bool, (void),
1390  hook_bool_void_false)
1391
1392 /* True if FOLLOWER may be modified to follow FOLLOWEE.  */
1393 DEFHOOK
1394 (can_follow_jump,
1395  "FOLLOWER and FOLLOWEE are JUMP_INSN instructions;\
1396   return true if FOLLOWER may be modified to follow FOLLOWEE;\
1397   false, if it can't.\
1398   For example, on some targets, certain kinds of branches can't be made to\
1399   follow through a hot/cold partitioning.",
1400  bool, (const_rtx follower, const_rtx followee),
1401  hook_bool_const_rtx_const_rtx_true)
1402
1403 /* Return a register class for which branch target register
1404    optimizations should be applied.  */
1405 DEFHOOK
1406 (branch_target_register_class,
1407  "",
1408  reg_class_t, (void),
1409  default_branch_target_register_class)
1410
1411 /* Return true if branch target register optimizations should include
1412    callee-saved registers that are not already live during the current
1413    function.  AFTER_PE_GEN is true if prologues and epilogues have
1414    already been generated.  */
1415 DEFHOOK
1416 (branch_target_register_callee_saved,
1417  "",
1418  bool, (bool after_prologue_epilogue_gen),
1419  hook_bool_bool_false)
1420
1421 /* Return true if the target supports conditional execution.  */
1422 DEFHOOK
1423 (have_conditional_execution,
1424  "",
1425  bool, (void),
1426  default_have_conditional_execution)
1427
1428 /* Return a new value for loop unroll size.  */
1429 DEFHOOK
1430 (loop_unroll_adjust,
1431  "",
1432  unsigned, (unsigned nunroll, struct loop *loop),
1433  NULL)
1434
1435 /* True if X is a legitimate MODE-mode immediate operand.  */
1436 DEFHOOK
1437 (legitimate_constant_p,
1438  "",
1439  bool, (enum machine_mode mode, rtx x),
1440  hook_bool_mode_rtx_true)
1441
1442 /* True if the constant X cannot be placed in the constant pool.  */
1443 DEFHOOK
1444 (cannot_force_const_mem,
1445  "",
1446  bool, (enum machine_mode mode, rtx x),
1447  hook_bool_mode_rtx_false)
1448
1449 DEFHOOK_UNDOC
1450 (cannot_copy_insn_p,
1451  "True if the insn @var{x} cannot be duplicated.",
1452  bool, (rtx), NULL)
1453
1454 /* True if X is considered to be commutative.  */
1455 DEFHOOK
1456 (commutative_p,
1457  "",
1458  bool, (const_rtx x, int outer_code),
1459  hook_bool_const_rtx_commutative_p)
1460
1461 /* True if ADDR is an address-expression whose effect depends
1462    on the mode of the memory reference it is used in.  */
1463 DEFHOOK
1464 (mode_dependent_address_p,
1465  "",
1466  bool, (const_rtx addr, addr_space_t addrspace),
1467  default_mode_dependent_address_p)
1468
1469 /* Given an invalid address X for a given machine mode, try machine-specific
1470    ways to make it legitimate.  Return X or an invalid address on failure.  */
1471 DEFHOOK
1472 (legitimize_address,
1473  "",
1474  rtx, (rtx x, rtx oldx, enum machine_mode mode),
1475  default_legitimize_address)
1476
1477 /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS.  */
1478 DEFHOOK
1479 (delegitimize_address,
1480  "",
1481  rtx, (rtx x),
1482  delegitimize_mem_from_attrs)
1483
1484 /* Given an RTX, return true if it is not ok to emit it into debug info
1485    section.  */
1486 DEFHOOK
1487 (const_not_ok_for_debug_p,
1488  "",
1489  bool, (rtx x),
1490  hook_bool_rtx_false)
1491
1492 /* Given an address RTX, say whether it is valid.  */
1493 DEFHOOK
1494 (legitimate_address_p,
1495  "",
1496  bool, (enum machine_mode mode, rtx x, bool strict),
1497  default_legitimate_address_p)
1498
1499 /* True if the given constant can be put into an object_block.  */
1500 DEFHOOK
1501 (use_blocks_for_constant_p,
1502  "",
1503  bool, (enum machine_mode mode, const_rtx x),
1504  hook_bool_mode_const_rtx_false)
1505
1506 /* True if the given decl can be put into an object_block.  */
1507 DEFHOOK
1508 (use_blocks_for_decl_p,
1509  "",
1510  bool, (const_tree decl),
1511  hook_bool_const_tree_true)
1512
1513 /* The minimum and maximum byte offsets for anchored addresses.  */
1514 DEFHOOKPOD
1515 (min_anchor_offset,
1516  "",
1517  HOST_WIDE_INT, 0)
1518
1519 DEFHOOKPOD
1520 (max_anchor_offset,
1521  "",
1522  HOST_WIDE_INT, 0)
1523
1524 /* True if section anchors can be used to access the given symbol.  */
1525 DEFHOOK
1526 (use_anchors_for_symbol_p,
1527  "",
1528  bool, (const_rtx x),
1529  default_use_anchors_for_symbol_p)
1530
1531 /* True if target supports indirect functions.  */
1532 DEFHOOK
1533 (has_ifunc_p,
1534  "It returns true if the target supports GNU indirect functions.\n\
1535 The support includes the assembler, linker and dynamic linker.\n\
1536 The default value of this hook is based on target's libc.",
1537  bool, (void),
1538  default_has_ifunc_p)
1539
1540 /* True if it is OK to do sibling call optimization for the specified
1541    call expression EXP.  DECL will be the called function, or NULL if
1542    this is an indirect call.  */
1543 DEFHOOK
1544 (function_ok_for_sibcall,
1545  "",
1546  bool, (tree decl, tree exp),
1547  hook_bool_tree_tree_false)
1548
1549 /* Establish appropriate back-end context for processing the function
1550    FNDECL.  The argument might be NULL to indicate processing at top
1551    level, outside of any function scope.  */
1552 DEFHOOK
1553 (set_current_function,
1554  "",
1555  void, (tree decl), hook_void_tree)
1556
1557 /* True if EXP should be placed in a "small data" section.  */
1558 DEFHOOK
1559 (in_small_data_p,
1560  "",
1561  bool, (const_tree exp),
1562  hook_bool_const_tree_false)
1563
1564 /* True if EXP names an object for which name resolution must resolve
1565    to the current executable or shared library.  */
1566 DEFHOOK
1567 (binds_local_p,
1568  "",
1569  bool, (const_tree exp),
1570  default_binds_local_p)
1571
1572 /* Check if profiling code is before or after prologue.  */
1573 DEFHOOK
1574 (profile_before_prologue,
1575  "It returns true if target wants profile code emitted before prologue.\n\n\
1576 The default version of this hook use the target macro\n\
1577 @code{PROFILE_BEFORE_PROLOGUE}.",
1578  bool, (void),
1579  default_profile_before_prologue)
1580
1581 /* Modify and return the identifier of a DECL's external name,
1582    originally identified by ID, as required by the target,
1583    (eg, append @nn to windows32 stdcall function names).
1584    The default is to return ID without modification. */
1585 DEFHOOK
1586 (mangle_decl_assembler_name,
1587  "",
1588  tree, (tree decl, tree  id),
1589  default_mangle_decl_assembler_name)
1590
1591 /* Do something target-specific to record properties of the DECL into
1592    the associated SYMBOL_REF.  */
1593 DEFHOOK
1594 (encode_section_info,
1595  "",
1596  void, (tree decl, rtx rtl, int new_decl_p),
1597  default_encode_section_info)
1598
1599 /* Undo the effects of encode_section_info on the symbol string.  */
1600 DEFHOOK
1601 (strip_name_encoding,
1602  "",
1603  const char *, (const char *name),
1604  default_strip_name_encoding)
1605
1606 /* If shift optabs for MODE are known to always truncate the shift count,
1607    return the mask that they apply.  Return 0 otherwise.  */
1608 DEFHOOK
1609 (shift_truncation_mask,
1610  "",
1611  unsigned HOST_WIDE_INT, (enum machine_mode mode),
1612  default_shift_truncation_mask)
1613
1614 /* Return the number of divisions in the given MODE that should be present,
1615    so that it is profitable to turn the division into a multiplication by
1616    the reciprocal.  */
1617 DEFHOOK
1618 (min_divisions_for_recip_mul,
1619  "",
1620  unsigned int, (enum machine_mode mode),
1621  default_min_divisions_for_recip_mul)
1622
1623 /* If the representation of integral MODE is such that values are
1624    always sign-extended to a wider mode MODE_REP then return
1625    SIGN_EXTEND.  Return UNKNOWN otherwise.  */
1626 /* Note that the return type ought to be RTX_CODE, but that's not
1627    necessarily defined at this point.  */
1628 DEFHOOK
1629 (mode_rep_extended,
1630  "",
1631  int, (enum machine_mode mode, enum machine_mode rep_mode),
1632  default_mode_rep_extended)
1633
1634 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
1635 DEFHOOK
1636 (valid_pointer_mode,
1637  "",
1638  bool, (enum machine_mode mode),
1639  default_valid_pointer_mode)
1640
1641 /* Disambiguate with errno.  */
1642 DEFHOOK
1643 (ref_may_alias_errno,
1644  "Define this to return nonzero if the memory reference @var{ref}\
1645   may alias with the system C library errno location.  The default\
1646   version of this hook assumes the system C library errno location\
1647   is either a declaration of type int or accessed by dereferencing\
1648   a pointer to int.",
1649  bool, (struct ao_ref_s *ref),
1650  default_ref_may_alias_errno)
1651
1652 /* Support for named address spaces.  */
1653 #undef HOOK_PREFIX
1654 #define HOOK_PREFIX "TARGET_ADDR_SPACE_"
1655 HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space)
1656
1657 /* MODE to use for a pointer into another address space.  */
1658 DEFHOOK
1659 (pointer_mode,
1660  "",
1661  enum machine_mode, (addr_space_t address_space),
1662  default_addr_space_pointer_mode)
1663
1664 /* MODE to use for an address in another address space.  */
1665 DEFHOOK
1666 (address_mode,
1667  "",
1668  enum machine_mode, (addr_space_t address_space),
1669  default_addr_space_address_mode)
1670
1671 /* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
1672    in another address space.  */
1673 DEFHOOK
1674 (valid_pointer_mode,
1675  "",
1676  bool, (enum machine_mode mode, addr_space_t as),
1677  default_addr_space_valid_pointer_mode)
1678
1679 /* True if an address is a valid memory address to a given named address
1680    space for a given mode.  */
1681 DEFHOOK
1682 (legitimate_address_p,
1683  "",
1684  bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as),
1685  default_addr_space_legitimate_address_p)
1686
1687 /* Return an updated address to convert an invalid pointer to a named
1688    address space to a valid one.  If NULL_RTX is returned use machine
1689    independent methods to make the address valid.  */
1690 DEFHOOK
1691 (legitimize_address,
1692  "",
1693  rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as),
1694  default_addr_space_legitimize_address)
1695
1696 /* True if one named address space is a subset of another named address. */
1697 DEFHOOK
1698 (subset_p,
1699  "",
1700  bool, (addr_space_t subset, addr_space_t superset),
1701  default_addr_space_subset_p)
1702
1703 /* Function to convert an rtl expression from one address space to another.  */
1704 DEFHOOK
1705 (convert,
1706  "",
1707  rtx, (rtx op, tree from_type, tree to_type),
1708  default_addr_space_convert)
1709
1710 HOOK_VECTOR_END (addr_space)
1711
1712 #undef HOOK_PREFIX
1713 #define HOOK_PREFIX "TARGET_"
1714
1715 /* True if MODE is valid for the target.  By "valid", we mean able to
1716    be manipulated in non-trivial ways.  In particular, this means all
1717    the arithmetic is supported.  */
1718 DEFHOOK
1719 (scalar_mode_supported_p,
1720  "",
1721  bool, (enum machine_mode mode),
1722  default_scalar_mode_supported_p)
1723
1724 /* Similarly for vector modes.  "Supported" here is less strict.  At
1725    least some operations are supported; need to check optabs or builtins
1726    for further details.  */
1727 DEFHOOK
1728 (vector_mode_supported_p,
1729  "",
1730  bool, (enum machine_mode mode),
1731  hook_bool_mode_false)
1732
1733 DEFHOOK
1734 (vector_alignment,
1735  "This hook can be used to define the alignment for a vector of type\n\
1736 @var{type}, in order to comply with a platform ABI.  The default is to\n\
1737 require natural alignment for vector types.  The alignment returned by\n\
1738 this hook must be a power-of-two multiple of the default alignment of\n\
1739 the vector element type.",
1740  HOST_WIDE_INT, (const_tree type),
1741  default_vector_alignment)
1742
1743 /* True if we should try to use a scalar mode to represent an array,
1744    overriding the usual MAX_FIXED_MODE limit.  */
1745 DEFHOOK
1746 (array_mode_supported_p,
1747  "Return true if GCC should try to use a scalar mode to store an array\n\
1748 of @var{nelems} elements, given that each element has mode @var{mode}.\n\
1749 Returning true here overrides the usual @code{MAX_FIXED_MODE} limit\n\
1750 and allows GCC to use any defined integer mode.\n\
1751 \n\
1752 One use of this hook is to support vector load and store operations\n\
1753 that operate on several homogeneous vectors.  For example, ARM NEON\n\
1754 has operations like:\n\
1755 \n\
1756 @smallexample\n\
1757 int8x8x3_t vld3_s8 (const int8_t *)\n\
1758 @end smallexample\n\
1759 \n\
1760 where the return type is defined as:\n\
1761 \n\
1762 @smallexample\n\
1763 typedef struct int8x8x3_t\n\
1764 @{\n\
1765   int8x8_t val[3];\n\
1766 @} int8x8x3_t;\n\
1767 @end smallexample\n\
1768 \n\
1769 If this hook allows @code{val} to have a scalar mode, then\n\
1770 @code{int8x8x3_t} can have the same mode.  GCC can then store\n\
1771 @code{int8x8x3_t}s in registers rather than forcing them onto the stack.",
1772  bool, (enum machine_mode mode, unsigned HOST_WIDE_INT nelems),
1773  hook_bool_mode_uhwi_false)
1774
1775 /* Compute cost of moving data from a register of class FROM to one of
1776    TO, using MODE.  */
1777 DEFHOOK
1778 (register_move_cost,
1779  "",
1780  int, (enum machine_mode mode, reg_class_t from, reg_class_t to),
1781  default_register_move_cost)
1782
1783 /* Compute cost of moving registers to/from memory.  */
1784 /* ??? Documenting the argument types for this hook requires a GFDL
1785    license grant.  Also, the documentation uses a different name for RCLASS.  */
1786 DEFHOOK
1787 (memory_move_cost,
1788  "",
1789  int, (enum machine_mode mode, reg_class_t rclass, bool in),
1790  default_memory_move_cost)
1791
1792 /* True for MODE if the target expects that registers in this mode will
1793    be allocated to registers in a small register class.  The compiler is
1794    allowed to use registers explicitly used in the rtl as spill registers
1795    but it should prevent extending the lifetime of these registers.  */
1796 DEFHOOK
1797 (small_register_classes_for_mode_p,
1798  "",
1799  bool, (enum machine_mode mode),
1800  hook_bool_mode_false)
1801
1802 /* Register number for a flags register.  Only needs to be defined if the
1803    target is constrainted to use post-reload comparison elimination.  */
1804 DEFHOOKPOD
1805 (flags_regnum,
1806  "If the target has a dedicated flags register, and it needs to use the\
1807  post-reload comparison elimination pass, then this value should be set\
1808  appropriately.",
1809  unsigned int, INVALID_REGNUM)
1810
1811 /* Compute a (partial) cost for rtx X.  Return true if the complete
1812    cost has been computed, and false if subexpressions should be
1813    scanned.  In either case, *TOTAL contains the cost result.  */
1814 /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
1815    not necessarily defined at this point.  */
1816 DEFHOOK
1817 (rtx_costs,
1818  "",
1819  bool, (rtx x, int code, int outer_code, int opno, int *total, bool speed),
1820  hook_bool_rtx_int_int_int_intp_bool_false)
1821
1822 /* Compute the cost of X, used as an address.  Never called with
1823    invalid addresses.  */
1824 DEFHOOK
1825 (address_cost,
1826  "",
1827  int, (rtx address, enum machine_mode mode, addr_space_t as, bool speed),
1828  default_address_cost)
1829
1830 /* Return where to allocate pseudo for a given hard register initial value.  */
1831 DEFHOOK
1832 (allocate_initial_value,
1833  "",
1834  rtx, (rtx hard_reg), NULL)
1835
1836 /* Return nonzero if evaluating UNSPEC X might cause a trap.
1837    FLAGS has the same meaning as in rtlanal.c: may_trap_p_1.  */
1838 DEFHOOK
1839 (unspec_may_trap_p,
1840  "",
1841  int, (const_rtx x, unsigned flags),
1842  default_unspec_may_trap_p)
1843
1844 /* Given a register, this hook should return a parallel of registers
1845    to represent where to find the register pieces.  Define this hook
1846    if the register and its mode are represented in Dwarf in
1847    non-contiguous locations, or if the register should be
1848    represented in more than one register in Dwarf.  Otherwise, this
1849    hook should return NULL_RTX.  */
1850 DEFHOOK
1851 (dwarf_register_span,
1852  "",
1853  rtx, (rtx reg),
1854  hook_rtx_rtx_null)
1855
1856 /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
1857    entries not corresponding directly to registers below
1858    FIRST_PSEUDO_REGISTER, this hook should generate the necessary
1859    code, given the address of the table.  */
1860 DEFHOOK
1861 (init_dwarf_reg_sizes_extra,
1862  "",
1863  void, (tree address),
1864  hook_void_tree)
1865
1866 /* Fetch the fixed register(s) which hold condition codes, for
1867    targets where it makes sense to look for duplicate assignments to
1868    the condition codes.  This should return true if there is such a
1869    register, false otherwise.  The arguments should be set to the
1870    fixed register numbers.  Up to two condition code registers are
1871    supported.  If there is only one for this target, the int pointed
1872    at by the second argument should be set to -1.  */
1873 DEFHOOK
1874 (fixed_condition_code_regs,
1875  "",
1876  bool, (unsigned int *p1, unsigned int *p2),
1877  hook_bool_uintp_uintp_false)
1878
1879 /* If two condition code modes are compatible, return a condition
1880      code mode which is compatible with both, such that a comparison
1881      done in the returned mode will work for both of the original
1882      modes.  If the condition code modes are not compatible, return
1883      VOIDmode.  */
1884 DEFHOOK
1885 (cc_modes_compatible,
1886  "",
1887  enum machine_mode, (enum machine_mode m1, enum machine_mode m2),
1888  default_cc_modes_compatible)
1889
1890 /* Do machine-dependent code transformations.  Called just before
1891      delayed-branch scheduling.  */
1892 DEFHOOK
1893 (machine_dependent_reorg,
1894  "",
1895  void, (void), NULL)
1896
1897 /* Create the __builtin_va_list type.  */
1898 DEFHOOK
1899 (build_builtin_va_list,
1900  "",
1901  tree, (void),
1902  std_build_builtin_va_list)
1903
1904 /* Enumerate the va list variants.  */
1905 DEFHOOK
1906 (enum_va_list_p,
1907  "",
1908  int, (int idx, const char **pname, tree *ptree),
1909  NULL)
1910
1911 /* Get the cfun/fndecl calling abi __builtin_va_list type.  */
1912 DEFHOOK
1913 (fn_abi_va_list,
1914  "",
1915  tree, (tree fndecl),
1916  std_fn_abi_va_list)
1917
1918 /* Get the __builtin_va_list type dependent on input type.  */
1919 DEFHOOK
1920 (canonical_va_list_type,
1921  "",
1922  tree, (tree type),
1923  std_canonical_va_list_type)
1924
1925 /* ??? Documenting this hook requires a GFDL license grant.  */
1926 DEFHOOK_UNDOC
1927 (expand_builtin_va_start,
1928 "Expand the @code{__builtin_va_start} builtin.",
1929  void, (tree valist, rtx nextarg), NULL)
1930
1931 /* Gimplifies a VA_ARG_EXPR.  */
1932 DEFHOOK
1933 (gimplify_va_arg_expr,
1934  "",
1935  tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p),
1936  std_gimplify_va_arg_expr)
1937
1938 /* Validity-checking routines for PCH files, target-specific.
1939    get_pch_validity returns a pointer to the data to be stored,
1940    and stores the size in its argument.  pch_valid_p gets the same
1941    information back and returns NULL if the PCH is valid,
1942    or an error message if not.  */
1943 DEFHOOK
1944 (get_pch_validity,
1945  "",
1946  void *, (size_t *sz),
1947  default_get_pch_validity)
1948
1949 DEFHOOK
1950 (pch_valid_p,
1951  "",
1952  const char *, (const void *data, size_t sz),
1953  default_pch_valid_p)
1954
1955 DEFHOOK
1956 (prepare_pch_save,
1957  "Called before writing out a PCH file.  If the target has some\n\
1958 garbage-collected data that needs to be in a particular state on PCH loads,\n\
1959 it can use this hook to enforce that state.  Very few targets need\n\
1960 to do anything here.",
1961  void, (void),
1962  hook_void_void)
1963
1964 /* If nonnull, this function checks whether a PCH file with the
1965    given set of target flags can be used.  It returns NULL if so,
1966    otherwise it returns an error message.  */
1967 DEFHOOK
1968 (check_pch_target_flags,
1969  "",
1970  const char *, (int pch_flags), NULL)
1971
1972 /* True if the compiler should give an enum type only as many
1973    bytes as it takes to represent the range of possible values of
1974    that type.  */
1975 DEFHOOK
1976 (default_short_enums,
1977  "",
1978  bool, (void),
1979  hook_bool_void_false)
1980
1981 /* This target hook returns an rtx that is used to store the address
1982    of the current frame into the built-in setjmp buffer.  */
1983 DEFHOOK
1984 (builtin_setjmp_frame_value,
1985  "",
1986  rtx, (void),
1987  default_builtin_setjmp_frame_value)
1988
1989 /* This target hook should add STRING_CST trees for any hard regs
1990    the port wishes to automatically clobber for an asm.  */
1991 DEFHOOK
1992 (md_asm_clobbers,
1993  "",
1994  tree, (tree outputs, tree inputs, tree clobbers),
1995  hook_tree_tree_tree_tree_3rd_identity)
1996
1997 /* This target hook allows the backend to specify a calling convention
1998    in the debug information.  This function actually returns an
1999    enum dwarf_calling_convention, but because of forward declarations
2000    and not wanting to include dwarf2.h everywhere target.h is included
2001    the function is being declared as an int.  */
2002 DEFHOOK
2003 (dwarf_calling_convention,
2004  "",
2005  int, (const_tree function),
2006  hook_int_const_tree_0)
2007
2008 /* This target hook allows the backend to emit frame-related insns that
2009    contain UNSPECs or UNSPEC_VOLATILEs.  The call frame debugging info
2010    engine will invoke it on insns of the form
2011      (set (reg) (unspec [...] UNSPEC_INDEX))
2012    and
2013      (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
2014    to let the backend emit the call frame instructions.  */
2015 DEFHOOK
2016 (dwarf_handle_frame_unspec,
2017  "",
2018  void, (const char *label, rtx pattern, int index), NULL)
2019
2020 /* ??? Documenting this hook requires a GFDL license grant.  */
2021 DEFHOOK_UNDOC
2022 (stdarg_optimize_hook,
2023 "Perform architecture specific checking of statements gimplified\
2024  from @code{VA_ARG_EXPR}.  @var{stmt} is the statement.  Returns true if\
2025  the statement doesn't need to be checked for @code{va_list} references.",
2026  bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
2027
2028 /* This target hook allows the operating system to override the DECL
2029    that represents the external variable that contains the stack
2030    protection guard variable.  The type of this DECL is ptr_type_node.  */
2031 DEFHOOK
2032 (stack_protect_guard,
2033  "",
2034  tree, (void),
2035  default_stack_protect_guard)
2036
2037 /* This target hook allows the operating system to override the CALL_EXPR
2038    that is invoked when a check vs the guard variable fails.  */
2039 DEFHOOK
2040 (stack_protect_fail,
2041  "",
2042  tree, (void),
2043  default_external_stack_protect_fail)
2044
2045 /* Returns NULL if target supports the insn within a doloop block,
2046    otherwise it returns an error message.  */
2047 DEFHOOK
2048 (invalid_within_doloop,
2049  "",
2050  const char *, (const_rtx insn),
2051  default_invalid_within_doloop)
2052
2053 /* Returns true for a legitimate combined insn.  */
2054 DEFHOOK
2055 (legitimate_combined_insn,
2056 "Take an instruction in @var{insn} and return @code{false} if the instruction\
2057  is not appropriate as a combination of two or more instructions.  The\
2058  default is to accept all instructions.",
2059  bool, (rtx insn),
2060  hook_bool_rtx_true)
2061
2062 DEFHOOK
2063 (valid_dllimport_attribute_p,
2064 "@var{decl} is a variable or function with @code{__attribute__((dllimport))}\
2065  specified.  Use this hook if the target needs to add extra validation\
2066  checks to @code{handle_dll_attribute}.",
2067  bool, (const_tree decl),
2068  hook_bool_const_tree_true)
2069
2070 /* If non-zero, align constant anchors in CSE to a multiple of this
2071    value.  */
2072 DEFHOOKPOD
2073 (const_anchor,
2074  "",
2075  unsigned HOST_WIDE_INT, 0)
2076
2077 /* Defines, which target-dependent bits (upper 16) are used by port  */
2078 DEFHOOK
2079 (memmodel_check,
2080  "",
2081  unsigned HOST_WIDE_INT, (unsigned HOST_WIDE_INT val), NULL)
2082
2083 /* Defines an offset bitwise ored into shifted address to get corresponding
2084    Address Sanitizer shadow address, or -1 if Address Sanitizer is not
2085    supported by the target.  */
2086 DEFHOOK
2087 (asan_shadow_offset,
2088  "Return the offset bitwise ored into shifted address to get corresponding\n\
2089 Address Sanitizer shadow memory address.  NULL if Address Sanitizer is not\n\
2090 supported by the target.",
2091  unsigned HOST_WIDE_INT, (void),
2092  NULL)
2093
2094 /* Functions relating to calls - argument passing, returns, etc.  */
2095 /* Members of struct call have no special macro prefix.  */
2096 HOOK_VECTOR (TARGET_CALLS, calls)
2097
2098 DEFHOOK
2099 (promote_function_mode,
2100  "",
2101  enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp,
2102                      const_tree funtype, int for_return),
2103  default_promote_function_mode)
2104
2105 DEFHOOK
2106 (promote_prototypes,
2107  "",
2108  bool, (const_tree fntype),
2109  hook_bool_const_tree_false)
2110
2111 DEFHOOK
2112 (struct_value_rtx,
2113  "",
2114  rtx, (tree fndecl, int incoming),
2115  hook_rtx_tree_int_null)
2116 DEFHOOK
2117 (return_in_memory,
2118  "",
2119  bool, (const_tree type, const_tree fntype),
2120  default_return_in_memory)
2121
2122 DEFHOOK
2123 (return_in_msb,
2124  "",
2125  bool, (const_tree type),
2126  hook_bool_const_tree_false)
2127
2128 /* Return true if a parameter must be passed by reference.  TYPE may
2129    be null if this is a libcall.  CA may be null if this query is
2130    from __builtin_va_arg.  */
2131 DEFHOOK
2132 (pass_by_reference,
2133  "",
2134  bool,
2135  (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named),
2136  hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
2137
2138 DEFHOOK
2139 (expand_builtin_saveregs,
2140  "",
2141  rtx, (void),
2142  default_expand_builtin_saveregs)
2143
2144 /* Returns pretend_argument_size.  */
2145 DEFHOOK
2146 (setup_incoming_varargs,
2147  "",
2148  void, (cumulative_args_t args_so_far, enum machine_mode mode, tree type,
2149         int *pretend_args_size, int second_time),
2150  default_setup_incoming_varargs)
2151
2152 DEFHOOK
2153 (strict_argument_naming,
2154  "",
2155  bool, (cumulative_args_t ca),
2156  hook_bool_CUMULATIVE_ARGS_false)
2157
2158 /* Returns true if we should use
2159    targetm.calls.setup_incoming_varargs() and/or
2160    targetm.calls.strict_argument_naming().  */
2161 DEFHOOK
2162 (pretend_outgoing_varargs_named,
2163  "",
2164  bool, (cumulative_args_t ca),
2165  default_pretend_outgoing_varargs_named)
2166
2167 /* Given a complex type T, return true if a parameter of type T
2168    should be passed as two scalars.  */
2169 DEFHOOK
2170 (split_complex_arg,
2171  "",
2172  bool, (const_tree type), NULL)
2173
2174 /* Return true if type T, mode MODE, may not be passed in registers,
2175    but must be passed on the stack.  */
2176 /* ??? This predicate should be applied strictly after pass-by-reference.
2177    Need audit to verify that this is the case.  */
2178 DEFHOOK
2179 (must_pass_in_stack,
2180  "",
2181  bool, (enum machine_mode mode, const_tree type),
2182  must_pass_in_stack_var_size_or_pad)
2183
2184 /* Return true if type TYPE, mode MODE, which is passed by reference,
2185    should have the object copy generated by the callee rather than
2186    the caller.  It is never called for TYPE requiring constructors.  */
2187 DEFHOOK
2188 (callee_copies,
2189  "",
2190  bool,
2191  (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named),
2192  hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
2193
2194 /* Return zero for arguments passed entirely on the stack or entirely
2195    in registers.  If passed in both, return the number of bytes passed
2196    in registers; the balance is therefore passed on the stack.  */
2197 DEFHOOK
2198 (arg_partial_bytes,
2199  "",
2200  int, (cumulative_args_t cum, enum machine_mode mode, tree type, bool named),
2201  hook_int_CUMULATIVE_ARGS_mode_tree_bool_0)
2202
2203 /* Update the state in CA to advance past an argument in the
2204    argument list.  The values MODE, TYPE, and NAMED describe that
2205    argument.  */
2206 DEFHOOK
2207 (function_arg_advance,
2208  "",
2209  void,
2210  (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named),
2211  default_function_arg_advance)
2212
2213 /* Return zero if the argument described by the state of CA should
2214    be placed on a stack, or a hard register in which to store the
2215    argument.  The values MODE, TYPE, and NAMED describe that
2216    argument.  */
2217 DEFHOOK
2218 (function_arg,
2219  "",
2220  rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type,
2221        bool named),
2222  default_function_arg)
2223
2224 /* Likewise, but for machines with register windows.  Return the
2225    location where the argument will appear to the callee.  */
2226 DEFHOOK
2227 (function_incoming_arg,
2228  "",
2229  rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type,
2230        bool named),
2231  default_function_incoming_arg)
2232
2233 DEFHOOK
2234 (function_arg_boundary,
2235  "",
2236  unsigned int, (enum machine_mode mode, const_tree type),
2237  default_function_arg_boundary)
2238
2239 DEFHOOK
2240 (function_arg_round_boundary,
2241  "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\
2242 which is the default value for this hook.  You can define this hook to\n\
2243 return a different value if an argument size must be rounded to a larger\n\
2244 value.",
2245  unsigned int, (enum machine_mode mode, const_tree type),
2246  default_function_arg_round_boundary)
2247
2248 /* Return the diagnostic message string if function without a prototype
2249    is not allowed for this 'val' argument; NULL otherwise. */
2250 DEFHOOK
2251 (invalid_arg_for_unprototyped_fn,
2252  "",
2253  const char *, (const_tree typelist, const_tree funcdecl, const_tree val),
2254  hook_invalid_arg_for_unprototyped_fn)
2255
2256 /* Return an rtx for the return value location of the function
2257    specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
2258 DEFHOOK
2259 (function_value,
2260  "",
2261  rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
2262  default_function_value)
2263
2264 /* Return the rtx for the result of a libcall of mode MODE,
2265    calling the function FN_NAME.  */
2266 DEFHOOK
2267 (libcall_value,
2268  "",
2269  rtx, (enum machine_mode mode, const_rtx fun),
2270  default_libcall_value)
2271
2272 /* Return true if REGNO is a possible register number for
2273    a function value as seen by the caller.  */
2274 DEFHOOK
2275 (function_value_regno_p,
2276  "",
2277  bool, (const unsigned int regno),
2278  default_function_value_regno_p)
2279
2280 /* ??? Documenting this hook requires a GFDL license grant.  */
2281 DEFHOOK_UNDOC
2282 (internal_arg_pointer,
2283 "Return an rtx for the argument pointer incoming to the\
2284  current function.",
2285  rtx, (void),
2286  default_internal_arg_pointer)
2287
2288 /* Update the current function stack boundary if needed.  */
2289 DEFHOOK
2290 (update_stack_boundary,
2291  "",
2292  void, (void), NULL)
2293
2294 /* Handle stack alignment and return an rtx for Dynamic Realign
2295    Argument Pointer if necessary.  */
2296 DEFHOOK
2297 (get_drap_rtx,
2298  "",
2299  rtx, (void), NULL)
2300
2301 /* Return true if all function parameters should be spilled to the
2302    stack.  */
2303 DEFHOOK
2304 (allocate_stack_slots_for_args,
2305  "",
2306  bool, (void),
2307  hook_bool_void_true)
2308
2309 /* Return an rtx for the static chain for FNDECL.  If INCOMING_P is true,
2310        then it should be for the callee; otherwise for the caller.  */
2311 DEFHOOK
2312 (static_chain,
2313  "",
2314  rtx, (const_tree fndecl, bool incoming_p),
2315  default_static_chain)
2316
2317 /* Fill in the trampoline at MEM with a call to FNDECL and a
2318    static chain value of CHAIN.  */
2319 DEFHOOK
2320 (trampoline_init,
2321  "",
2322  void, (rtx m_tramp, tree fndecl, rtx static_chain),
2323  default_trampoline_init)
2324
2325 /* Adjust the address of the trampoline in a target-specific way.  */
2326 DEFHOOK
2327 (trampoline_adjust_address,
2328  "",
2329  rtx, (rtx addr), NULL)
2330
2331 /* Return the number of bytes of its own arguments that a function
2332    pops on returning, or 0 if the function pops no arguments and the
2333    caller must therefore pop them all after the function returns.  */
2334 /* ??? tm.texi has no types for the parameters.  */
2335 DEFHOOK
2336 (return_pops_args,
2337  "",
2338  int, (tree fundecl, tree funtype, int size),
2339  default_return_pops_args)
2340
2341 /* Return a mode wide enough to copy any function value that might be
2342    returned.  */
2343 DEFHOOK
2344 (get_raw_result_mode,
2345  "This target hook returns the mode to be used when accessing raw return\
2346  registers in @code{__builtin_return}.  Define this macro if the value\
2347  in @var{reg_raw_mode} is not correct.",
2348  enum machine_mode, (int regno),
2349  default_get_reg_raw_mode)
2350
2351 /* Return a mode wide enough to copy any argument value that might be
2352    passed.  */
2353 DEFHOOK
2354 (get_raw_arg_mode,
2355  "This target hook returns the mode to be used when accessing raw argument\
2356  registers in @code{__builtin_apply_args}.  Define this macro if the value\
2357  in @var{reg_raw_mode} is not correct.",
2358  enum machine_mode, (int regno),
2359  default_get_reg_raw_mode)
2360
2361 HOOK_VECTOR_END (calls)
2362
2363 /* Return the diagnostic message string if conversion from FROMTYPE
2364    to TOTYPE is not allowed, NULL otherwise.  */
2365 DEFHOOK
2366 (invalid_conversion,
2367  "",
2368  const char *, (const_tree fromtype, const_tree totype),
2369  hook_constcharptr_const_tree_const_tree_null)
2370
2371 /* Return the diagnostic message string if the unary operation OP is
2372    not permitted on TYPE, NULL otherwise.  */
2373 DEFHOOK
2374 (invalid_unary_op,
2375  "",
2376  const char *, (int op, const_tree type),
2377  hook_constcharptr_int_const_tree_null)
2378
2379 /* Return the diagnostic message string if the binary operation OP
2380    is not permitted on TYPE1 and TYPE2, NULL otherwise.  */
2381 DEFHOOK
2382 (invalid_binary_op,
2383  "",
2384  const char *, (int op, const_tree type1, const_tree type2),
2385  hook_constcharptr_int_const_tree_const_tree_null)
2386
2387 /* Return the diagnostic message string if TYPE is not valid as a
2388    function parameter type, NULL otherwise.  */
2389 DEFHOOK
2390 (invalid_parameter_type,
2391  "",
2392  const char *, (const_tree type),
2393  hook_constcharptr_const_tree_null)
2394
2395 /* Return the diagnostic message string if TYPE is not valid as a
2396    function return type, NULL otherwise.  */
2397 DEFHOOK
2398 (invalid_return_type,
2399  "",
2400  const char *, (const_tree type),
2401  hook_constcharptr_const_tree_null)
2402
2403 /* If values of TYPE are promoted to some other type when used in
2404    expressions (analogous to the integer promotions), return that type,
2405    or NULL_TREE otherwise.  */
2406 DEFHOOK
2407 (promoted_type,
2408  "",
2409  tree, (const_tree type),
2410  hook_tree_const_tree_null)
2411
2412 /* Convert EXPR to TYPE, if target-specific types with special conversion
2413    rules are involved.  Return the converted expression, or NULL to apply
2414    the standard conversion rules.  */
2415 DEFHOOK
2416 (convert_to_type,
2417  "",
2418  tree, (tree type, tree expr),
2419  hook_tree_tree_tree_null)
2420
2421 /* Return true if we use LRA instead of reload.  */
2422 DEFHOOK
2423 (lra_p,
2424  "A target hook which returns true if we use LRA instead of reload pass.\
2425   It means that LRA was ported to the target.\
2426   \
2427   The default version of this target hook returns always false.",
2428  bool, (void),
2429  default_lra_p)
2430
2431 /* Return register priority of given hard regno for the current target.  */
2432 DEFHOOK
2433 (register_priority,
2434  "A target hook which returns the register priority number to which the\
2435   register @var{hard_regno} belongs to.  The bigger the number, the\
2436   more preferable the hard register usage (when all other conditions are\
2437   the same).  This hook can be used to prefer some hard register over\
2438   others in LRA.  For example, some x86-64 register usage needs\
2439   additional prefix which makes instructions longer.  The hook can\
2440   return lower priority number for such registers make them less favorable\
2441   and as result making the generated code smaller.\
2442   \
2443   The default version of this target hook returns always zero.",
2444  int, (int),
2445  default_register_priority)
2446
2447 /* Return true if we need register usage leveling.  */
2448 DEFHOOK
2449 (register_usage_leveling_p,
2450  "A target hook which returns true if we need register usage leveling.\
2451   That means if a few hard registers are equally good for the\
2452   assignment, we choose the least used hard register.  The register\
2453   usage leveling may be profitable for some targets.  Don't use the\
2454   usage leveling for targets with conditional execution or targets\
2455   with big register files as it hurts if-conversion and cross-jumping\
2456   optimizations.\
2457   \
2458   The default version of this target hook returns always false.",
2459  bool, (void),
2460  default_register_usage_leveling_p)
2461
2462 /* Return true if maximal address displacement can be different.  */
2463 DEFHOOK
2464 (different_addr_displacement_p,
2465  "A target hook which returns true if an address with the same structure\
2466   can have different maximal legitimate displacement.  For example, the\
2467   displacement can depend on memory mode or on operand combinations in\
2468   the insn.\
2469   \
2470   The default version of this target hook returns always false.",
2471  bool, (void),
2472  default_different_addr_displacement_p)
2473
2474 /* Determine class for spilling pseudos of given mode into registers
2475    instead of memory.  */
2476 DEFHOOK
2477 (spill_class,
2478  "This hook defines a class of registers which could be used for spilling\
2479   pseudos of the given mode and class, or @code{NO_REGS} if only memory\
2480   should be used.  Not defining this hook is equivalent to returning\
2481   @code{NO_REGS} for all inputs.",
2482  reg_class_t, (reg_class_t, enum machine_mode),
2483  NULL)
2484
2485 DEFHOOK
2486 (cstore_mode,
2487  "This hook defines the machine mode to use for the boolean result of\
2488   conditional store patterns.  The ICODE argument is the instruction code\
2489   for the cstore being performed.  Not definiting this hook is the same\
2490   as accepting the mode encoded into operand 0 of the cstore expander\
2491   patterns.",
2492   enum machine_mode, (enum insn_code icode),
2493   default_cstore_mode)
2494
2495 /* True if a structure, union or array with MODE containing FIELD should
2496    be accessed using BLKmode.  */
2497 DEFHOOK
2498 (member_type_forces_blk,
2499  "",
2500  bool, (const_tree field, enum machine_mode mode),
2501  default_member_type_forces_blk)
2502
2503 /* Return the class for a secondary reload, and fill in extra information.  */
2504 DEFHOOK
2505 (secondary_reload,
2506  "",
2507  reg_class_t,
2508  (bool in_p, rtx x, reg_class_t reload_class, enum machine_mode reload_mode,
2509   secondary_reload_info *sri),
2510  default_secondary_reload)
2511
2512 /* Given an rtx X being reloaded into a reg required to be in class CLASS,
2513    return the class of reg to actually use.  */
2514 DEFHOOK
2515 (preferred_reload_class,
2516  "",
2517  reg_class_t,
2518  (rtx x, reg_class_t rclass),
2519  default_preferred_reload_class)
2520
2521 /* Like TARGET_PREFERRED_RELOAD_CLASS, but for output reloads instead of
2522    input reloads.  */
2523 DEFHOOK
2524 (preferred_output_reload_class,
2525  "",
2526  reg_class_t,
2527  (rtx x, reg_class_t rclass),
2528  default_preferred_output_reload_class)
2529
2530 DEFHOOK
2531 (class_likely_spilled_p,
2532  "",
2533  bool, (reg_class_t rclass),
2534  default_class_likely_spilled_p)
2535
2536 /* Return the maximum number of consecutive registers
2537    needed to represent mode MODE in a register of class RCLASS.  */
2538 DEFHOOK
2539 (class_max_nregs,
2540  "",
2541  unsigned char, (reg_class_t rclass, enum machine_mode mode),
2542  default_class_max_nregs)
2543
2544 DEFHOOK
2545 (preferred_rename_class,
2546  "A target hook that places additional preference on the register\
2547  class to use when it is necessary to rename a register in class\
2548  @var{rclass} to another class, or perhaps @var{NO_REGS}, if no\
2549  preferred register class is found or hook @code{preferred_rename_class}\
2550  is not implemented.\
2551  Sometimes returning a more restrictive class makes better code.  For\
2552  example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\
2553  smaller than instructions using @code{GENERIC_REGS}.  By returning\
2554  @code{LO_REGS} from @code{preferred_rename_class}, code size can\
2555  be reduced.",
2556  reg_class_t, (reg_class_t rclass),
2557  default_preferred_rename_class)
2558
2559 /* This target hook allows the backend to perform additional
2560    processing while initializing for variable expansion.  */
2561 DEFHOOK
2562 (expand_to_rtl_hook,
2563  "",
2564  void, (void),
2565  hook_void_void)
2566
2567 /* This target hook allows the backend to perform additional
2568    instantiations on rtx that are not actually in insns yet,
2569    but will be later.  */
2570 DEFHOOK
2571 (instantiate_decls,
2572  "",
2573  void, (void),
2574  hook_void_void)
2575
2576 /* Return true if is OK to use a hard register REGNO as scratch register
2577    in peephole2.  */
2578 DEFHOOK
2579 (hard_regno_scratch_ok,
2580  "",
2581  bool, (unsigned int regno),
2582  default_hard_regno_scratch_ok)
2583
2584 /* Return the smallest number of different values for which it is best to
2585    use a jump-table instead of a tree of conditional branches.  */
2586 DEFHOOK
2587 (case_values_threshold,
2588  "",
2589  unsigned int, (void),
2590  default_case_values_threshold)
2591
2592 /* Retutn true if a function must have and use a frame pointer.  */
2593 DEFHOOK
2594 (frame_pointer_required,
2595  "",
2596  bool, (void),
2597  hook_bool_void_false)
2598
2599 /* Returns true if the compiler is allowed to try to replace register number
2600    from-reg with register number to-reg.  */
2601 DEFHOOK
2602 (can_eliminate,
2603  "",
2604  bool, (const int from_reg, const int to_reg),
2605  hook_bool_const_int_const_int_true)
2606
2607 /* Modify any or all of fixed_regs, call_used_regs, global_regs,
2608    reg_names, and reg_class_contents to account of the vagaries of the
2609    target.  */
2610 DEFHOOK
2611 (conditional_register_usage,
2612  "",
2613  void, (void),
2614  hook_void_void)
2615
2616 /* Functions specific to the C family of frontends.  */
2617 #undef HOOK_PREFIX
2618 #define HOOK_PREFIX "TARGET_C_"
2619 HOOK_VECTOR (TARGET_C, c)
2620
2621 /* ??? Documenting this hook requires a GFDL license grant.  */
2622 DEFHOOK_UNDOC
2623 (mode_for_suffix,
2624 "Return machine mode for non-standard constant literal suffix @var{c},\
2625  or VOIDmode if non-standard suffixes are unsupported.",
2626  enum machine_mode, (char c),
2627  default_mode_for_suffix)
2628
2629 HOOK_VECTOR_END (c)
2630
2631 /* Functions specific to the C++ frontend.  */
2632 #undef HOOK_PREFIX
2633 #define HOOK_PREFIX "TARGET_CXX_"
2634 HOOK_VECTOR (TARGET_CXX, cxx)
2635
2636 /* Return the integer type used for guard variables.  */
2637 DEFHOOK
2638 (guard_type,
2639  "",
2640  tree, (void),
2641  default_cxx_guard_type)
2642
2643 /* Return true if only the low bit of the guard should be tested.  */
2644 DEFHOOK
2645 (guard_mask_bit,
2646  "",
2647  bool, (void),
2648  hook_bool_void_false)
2649
2650 /* Returns the size of the array cookie for an array of type.  */
2651 DEFHOOK
2652 (get_cookie_size,
2653  "",
2654  tree, (tree type),
2655  default_cxx_get_cookie_size)
2656
2657 /* Returns true if the element size should be stored in the array cookie.  */
2658 DEFHOOK
2659 (cookie_has_size,
2660  "",
2661  bool, (void),
2662  hook_bool_void_false)
2663
2664 /* Allows backends to perform additional processing when
2665    deciding if a class should be exported or imported.  */
2666 DEFHOOK
2667 (import_export_class,
2668  "",
2669  int, (tree type, int import_export), NULL)
2670
2671 /* Returns true if constructors and destructors return "this".  */
2672 DEFHOOK
2673 (cdtor_returns_this,
2674  "",
2675  bool, (void),
2676  hook_bool_void_false)
2677
2678 /* Returns true if the key method for a class can be an inline
2679    function, so long as it is not declared inline in the class
2680    itself.  Returning true is the behavior required by the Itanium C++ ABI.  */
2681 DEFHOOK
2682 (key_method_may_be_inline,
2683  "",
2684  bool, (void),
2685  hook_bool_void_true)
2686
2687 DEFHOOK
2688 (determine_class_data_visibility,
2689 "@var{decl} is a virtual table, virtual table table, typeinfo object,\
2690  or other similar implicit class data object that will be emitted with\
2691  external linkage in this translation unit.  No ELF visibility has been\
2692  explicitly specified.  If the target needs to specify a visibility\
2693  other than that of the containing class, use this hook to set\
2694  @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
2695  void, (tree decl),
2696  hook_void_tree)
2697
2698 /* Returns true (the default) if virtual tables and other
2699    similar implicit class data objects are always COMDAT if they
2700    have external linkage.  If this hook returns false, then
2701    class data for classes whose virtual table will be emitted in
2702    only one translation unit will not be COMDAT.  */
2703 DEFHOOK
2704 (class_data_always_comdat,
2705  "",
2706  bool, (void),
2707  hook_bool_void_true)
2708
2709 /* Returns true (the default) if the RTTI for the basic types,
2710    which is always defined in the C++ runtime, should be COMDAT;
2711    false if it should not be COMDAT.  */
2712 DEFHOOK
2713 (library_rtti_comdat,
2714  "",
2715  bool, (void),
2716  hook_bool_void_true)
2717
2718 /* Returns true if __aeabi_atexit should be used to register static
2719    destructors.  */
2720 DEFHOOK
2721 (use_aeabi_atexit,
2722  "",
2723  bool, (void),
2724  hook_bool_void_false)
2725
2726 /* Returns true if target may use atexit in the same manner as
2727    __cxa_atexit  to register static destructors.  */
2728 DEFHOOK
2729 (use_atexit_for_cxa_atexit,
2730  "",
2731  bool, (void),
2732  hook_bool_void_false)
2733
2734 DEFHOOK
2735 (adjust_class_at_definition,
2736 "@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\
2737  been defined.  Use this hook to make adjustments to the class (eg, tweak\
2738  visibility or perform any other required target modifications).",
2739  void, (tree type),
2740  hook_void_tree)
2741
2742 DEFHOOK
2743 (decl_mangling_context,
2744  "Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.",
2745  tree, (const_tree decl),
2746  hook_tree_const_tree_null)
2747
2748 HOOK_VECTOR_END (cxx)
2749
2750 /* Functions and data for emulated TLS support.  */
2751 #undef HOOK_PREFIX
2752 #define HOOK_PREFIX "TARGET_EMUTLS_"
2753 HOOK_VECTOR (TARGET_EMUTLS, emutls)
2754
2755 /* Name of the address and common functions.  */
2756 DEFHOOKPOD
2757 (get_address,
2758  "",
2759  const char *, "__builtin___emutls_get_address")
2760
2761 DEFHOOKPOD
2762 (register_common,
2763  "",
2764  const char *, "__builtin___emutls_register_common")
2765
2766 /* Prefixes for proxy variable and template.  */
2767 DEFHOOKPOD
2768 (var_section,
2769  "",
2770  const char *, NULL)
2771
2772 DEFHOOKPOD
2773 (tmpl_section,
2774  "",
2775  const char *, NULL)
2776
2777 /* Prefixes for proxy variable and template.  */
2778 DEFHOOKPOD
2779 (var_prefix,
2780  "",
2781  const char *, NULL)
2782
2783 DEFHOOKPOD
2784 (tmpl_prefix,
2785  "",
2786  const char *, NULL)
2787
2788 /* Function to generate field definitions of the proxy variable.  */
2789 DEFHOOK
2790 (var_fields,
2791  "",
2792  tree, (tree type, tree *name),
2793  default_emutls_var_fields)
2794
2795 /* Function to initialize a proxy variable.  */
2796 DEFHOOK
2797 (var_init,
2798  "",
2799  tree, (tree var, tree decl, tree tmpl_addr),
2800  default_emutls_var_init)
2801
2802 /* Whether we are allowed to alter the usual alignment of the
2803    proxy variable.  */
2804 DEFHOOKPOD
2805 (var_align_fixed,
2806  "",
2807  bool, false)
2808
2809 /* Whether we can emit debug information for TLS vars.  */
2810 DEFHOOKPOD
2811 (debug_form_tls_address,
2812  "",
2813  bool, false)
2814
2815 HOOK_VECTOR_END (emutls)
2816
2817 #undef HOOK_PREFIX
2818 #define HOOK_PREFIX "TARGET_OPTION_"
2819 HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks)
2820
2821 /* Function to validate the attribute((target(...))) strings.  If
2822    the option is validated, the hook should also fill in
2823    DECL_FUNCTION_SPECIFIC_TARGET in the function decl node.  */
2824 DEFHOOK
2825 (valid_attribute_p,
2826  "",
2827  bool, (tree fndecl, tree name, tree args, int flags),
2828  default_target_option_valid_attribute_p)
2829
2830 /* Function to save any extra target state in the target options structure.  */
2831 DEFHOOK
2832 (save,
2833  "",
2834  void, (struct cl_target_option *ptr), NULL)
2835
2836 /* Function to restore any extra target state from the target options
2837    structure.  */
2838 DEFHOOK
2839 (restore,
2840  "",
2841  void, (struct cl_target_option *ptr), NULL)
2842
2843 /* Function to print any extra target state from the target options
2844    structure.  */
2845 DEFHOOK
2846 (print,
2847  "",
2848  void, (FILE *file, int indent, struct cl_target_option *ptr), NULL)
2849
2850 /* Function to parse arguments to be validated for #pragma target, and to
2851    change the state if the options are valid.  If the first argument is
2852    NULL, the second argument specifies the default options to use.  Return
2853    true if the options are valid, and set the current state.  */
2854 DEFHOOK
2855 (pragma_parse,
2856  "",
2857  bool, (tree args, tree pop_target),
2858  default_target_option_pragma_parse)
2859
2860 /* Do option overrides for the target.  */
2861 DEFHOOK
2862 (override,
2863  "",
2864  void, (void),
2865  hook_void_void)
2866
2867 /* This function returns true if DECL1 and DECL2 are versions of the same
2868    function.  DECL1 and DECL2 are function versions if and only if they
2869    have the same function signature and different target specific attributes,
2870    that is, they are compiled for different target machines.  */
2871 DEFHOOK
2872 (function_versions,
2873  "",
2874  bool, (tree decl1, tree decl2),
2875  hook_bool_tree_tree_false)
2876
2877 /* Function to determine if one function can inline another function.  */
2878 #undef HOOK_PREFIX
2879 #define HOOK_PREFIX "TARGET_"
2880 DEFHOOK
2881 (can_inline_p,
2882  "",
2883  bool, (tree caller, tree callee),
2884  default_target_can_inline_p)
2885
2886 HOOK_VECTOR_END (target_option)
2887
2888 /* For targets that need to mark extra registers as live on entry to
2889    the function, they should define this target hook and set their
2890    bits in the bitmap passed in. */
2891 DEFHOOK
2892 (extra_live_on_entry,
2893  "",
2894  void, (bitmap regs),
2895  hook_void_bitmap)
2896
2897 /* Fill in additional registers set up by prologue into a regset.  */
2898 DEFHOOK
2899 (set_up_by_prologue,
2900  "This hook should add additional registers that are computed by the prologue\
2901  to the hard regset for shrink-wrapping optimization purposes.",
2902  void, (struct hard_reg_set_container *),
2903  NULL)
2904
2905 /* For targets that have attributes that can affect whether a
2906    function's return statements need checking.  For instance a 'naked'
2907    function attribute.  */
2908 DEFHOOK
2909 (warn_func_return,
2910  "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.",
2911  bool, (tree),
2912  hook_bool_tree_true)
2913
2914 /* Determine the type of unwind info to emit for debugging.  */
2915 DEFHOOK
2916 (debug_unwind_info,
2917  "",
2918  enum unwind_info_type, (void),
2919  default_debug_unwind_info)
2920
2921 /* The code parameter should be of type enum rtx_code but this is not
2922    defined at this time.  */
2923 DEFHOOK
2924 (canonicalize_comparison,
2925  "",
2926  void, (int *code, rtx *op0, rtx *op1, bool op0_preserve_value),
2927  default_canonicalize_comparison)
2928
2929 DEFHOOKPOD
2930 (atomic_test_and_set_trueval,
2931  "This value should be set if the result written by\
2932  @code{atomic_test_and_set} is not exactly 1, i.e. the\
2933  @code{bool} @code{true}.",
2934  unsigned char, 1)
2935
2936 /* Leave the boolean fields at the end.  */
2937
2938 /* True if we can create zeroed data by switching to a BSS section
2939    and then using ASM_OUTPUT_SKIP to allocate the space.  */
2940 DEFHOOKPOD
2941 (have_switchable_bss_sections,
2942  "",
2943  bool, false)
2944
2945 /* True if "native" constructors and destructors are supported,
2946    false if we're using collect2 for the job.  */
2947 DEFHOOKPOD
2948 (have_ctors_dtors,
2949  "",
2950  bool, false)
2951
2952 /* True if thread-local storage is supported.  */
2953 DEFHOOKPOD
2954 (have_tls,
2955  "",
2956  bool, false)
2957
2958 /* True if a small readonly data section is supported.  */
2959 DEFHOOKPOD
2960 (have_srodata_section,
2961  "",
2962  bool, false)
2963
2964 /* True if EH frame info sections should be zero-terminated.  */
2965 DEFHOOKPOD
2966 (terminate_dw2_eh_frame_info,
2967  "",
2968  bool, true)
2969
2970 /* True if #NO_APP should be emitted at the beginning of assembly output.  */
2971 DEFHOOKPOD
2972 (asm_file_start_app_off,
2973  "",
2974  bool, false)
2975
2976 /* True if output_file_directive should be called for main_input_filename
2977    at the beginning of assembly output.  */
2978 DEFHOOKPOD
2979 (asm_file_start_file_directive,
2980  "",
2981  bool, false)
2982
2983 /* True if the target is allowed to reorder memory accesses unless
2984    synchronization is explicitly requested.  */
2985 DEFHOOKPOD
2986 (relaxed_ordering,
2987  "",
2988  bool, false)
2989
2990 /* Returns true if we should generate exception tables for use with the
2991    ARM EABI.  The effects the encoding of function exception specifications.  */
2992 DEFHOOKPOD
2993 (arm_eabi_unwinder,
2994  "",
2995  bool, false)
2996
2997 DEFHOOKPOD
2998 (want_debug_pub_sections,
2999  "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\
3000  should be emitted.  These sections are not used on most platforms, and\
3001  in particular GDB does not use them.",
3002  bool, false)
3003
3004 DEFHOOKPOD
3005 (force_at_comp_dir,
3006  "True if the @code{DW_AT_comp_dir} attribute should be emitted for each \
3007  compilation unit.  This attribute is required for the darwin linker \
3008  to emit debug information.",
3009  bool, false)
3010
3011 DEFHOOKPOD
3012 (delay_sched2, "True if sched2 is not to be run at its normal place.  \
3013 This usually means it will be run as part of machine-specific reorg.",
3014 bool, false)
3015
3016 DEFHOOKPOD
3017 (delay_vartrack, "True if vartrack is not to be run at its normal place.  \
3018 This usually means it will be run as part of machine-specific reorg.",
3019 bool, false)
3020
3021 /* Leave the boolean fields at the end.  */
3022
3023 /* Close the 'struct gcc_target' definition.  */
3024 HOOK_VECTOR_END (C90_EMPTY_HACK)