gcc/target.def

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