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 29HOOK_VECTOR (TARGET_INITIALIZER, gcc_target) 30 31/* Functions that output assembler for the target. */ 32#define HOOK_PREFIX "TARGET_ASM_" 33HOOK_VECTOR (TARGET_ASM_OUT, asm_out) 34 35/* Opening and closing parentheses for asm expression grouping. */ 36DEFHOOKPOD 37(open_paren, 38 "", 39 const char *, "(") 40DEFHOOKPODX (close_paren, const char *, ")") 41 42/* Assembler instructions for creating various kinds of integer object. */ 43DEFHOOKPOD 44(byte_op, 45 "", 46 const char *, "\t.byte\t") 47DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP) 48DEFHOOKPOD (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. */ 52DEFHOOK 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. */ 60DEFHOOK 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. */ 68DEFHOOK 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. */ 76DEFHOOK 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. */ 87DEFHOOK 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. */ 96DEFHOOK 97(globalize_label, 98 "", 99 void, (FILE *stream, const char *name), 100 default_globalize_label) 101 102/* Output code that will globalize a declaration. */ 103DEFHOOK 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. */ 113DEFHOOK 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. */ 120DEFHOOK 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. */ 127DEFHOOK 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. */ 136DEFHOOK 137(unwind_emit, 138 "", 139 void, (FILE *stream, rtx insn), 140 NULL) 141 142DEFHOOKPOD 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. */ 151DEFHOOK_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. */ 158DEFHOOK 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. */ 165DEFHOOK 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. */ 172DEFHOOK 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. */ 180DEFHOOK 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. */ 187DEFHOOK 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. */ 194DEFHOOK 195(function_end_prologue, 196 "", 197 void, (FILE *file), 198 no_asm_to_stream) 199 200/* Output the assembler code for start of epilogue. */ 201DEFHOOK 202(function_begin_epilogue, 203 "", 204 void, (FILE *file), 205 no_asm_to_stream) 206 207/* Output the assembler code for function exit. */ 208DEFHOOK 209(function_epilogue, 210 "", 211 void, (FILE *file, HOST_WIDE_INT size), 212 default_function_pro_epilogue) 213 214/* Initialize target-specific sections. */ 215DEFHOOK 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. */ 224DEFHOOK 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. */ 237DEFHOOK 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. */ 244DEFHOOK 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. */ 258DEFHOOK 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. */ 268DEFHOOK 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. */ 276DEFHOOK 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. */ 284DEFHOOK 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. */ 291DEFHOOK 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. */ 299DEFHOOKPOD 300(mergeable_rodata_prefix, 301 "Usually, the compiler uses the prefix @code{\".rodata\"} to construct\n\ 302section names for mergeable constant data. Define this macro to override\n\ 303the 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. */ 307DEFHOOK 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. */ 314DEFHOOK 315(constructor, 316 "", 317 void, (rtx symbol, int priority), NULL) 318 319/* Output a destructor for a symbol with a given priority. */ 320DEFHOOK 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. */ 330DEFHOOK 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. */ 343DEFHOOK 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. */ 352DEFHOOK 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. */ 359DEFHOOK 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. */ 367DEFHOOK 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. */ 375DEFHOOK 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. */ 383DEFHOOK 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. */ 391DEFHOOK 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. */ 399DEFHOOK 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. */ 406DEFHOOK 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. */ 416DEFHOOKPOD 417(record_gcc_switches_section, 418 "", 419 const char *, ".GCC.command.line") 420 421/* Output the definition of a section anchor. */ 422DEFHOOK 423(output_anchor, 424 "", 425 void, (rtx x), 426 default_asm_output_anchor) 427 428DEFHOOK 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. */ 438DEFHOOK 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. */ 445DEFHOOK 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. */ 452DEFHOOK 453(trampoline_template, 454 "", 455 void, (FILE *f), 456 NULL) 457 458DEFHOOK 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 469DEFHOOK 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. */ 484DEFHOOK_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. */ 493DEFHOOK_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. */ 503DEFHOOK_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. */ 511DEFHOOK 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 521HOOK_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_" 527HOOK_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. */ 532DEFHOOK 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. */ 538DEFHOOK 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. */ 546DEFHOOK 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. */ 553DEFHOOK 554(variable_issue, 555 "", 556 int, (FILE *file, int verbose, rtx insn, int more), NULL) 557 558/* Initialize machine-dependent scheduling code. */ 559DEFHOOK 560(init, 561 "", 562 void, (FILE *file, int verbose, int max_ready), NULL) 563 564/* Finalize machine-dependent scheduling code. */ 565DEFHOOK 566(finish, 567 "", 568 void, (FILE *file, int verbose), NULL) 569 570 /* Initialize machine-dependent function wide scheduling code. */ 571DEFHOOK 572(init_global, 573 "", 574 void, (FILE *file, int verbose, int old_max_uid), NULL) 575 576/* Finalize machine-dependent function wide scheduling code. */ 577DEFHOOK 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. */ 584DEFHOOK 585(reorder, 586 "", 587 int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) 588 589DEFHOOK 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). */ 597DEFHOOK 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 612DEFHOOK 613(init_dfa_pre_cycle_insn, 614 "", 615 void, (void), NULL) 616 617DEFHOOK 618(dfa_pre_cycle_insn, 619 "", 620 rtx, (void), NULL) 621 622DEFHOOK 623(init_dfa_post_cycle_insn, 624 "", 625 void, (void), NULL) 626 627DEFHOOK 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 637DEFHOOK 638(dfa_pre_advance_cycle, 639 "", 640 void, (void), NULL) 641 642DEFHOOK 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. */ 654DEFHOOK 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. */ 663DEFHOOK 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. */ 677DEFHOOK 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. */ 693DEFHOOK 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. */ 708DEFHOOK 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. */ 721DEFHOOK 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. */ 731DEFHOOK 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. */ 741DEFHOOK 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. */ 757DEFHOOK 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). */ 773DEFHOOK 774(is_costly_dependence, 775 "", 776 bool, (struct _dep *_dep, int cost, int distance), NULL) 777 778DEFHOOK_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. */ 788DEFHOOK 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. */ 796DEFHOOK 797(alloc_sched_context, 798 "", 799 void *, (void), NULL) 800 801/* Fills the context from the local machine scheduler context. */ 802DEFHOOK 803(init_sched_context, 804 "", 805 void, (void *tc, bool clean_p), NULL) 806 807/* Sets local machine scheduler context to a saved value. */ 808DEFHOOK 809(set_sched_context, 810 "", 811 void, (void *tc), NULL) 812 813/* Clears a scheduler context so it becomes like after init. */ 814DEFHOOK 815(clear_sched_context, 816 "", 817 void, (void *tc), NULL) 818 819/* Frees the scheduler context. */ 820DEFHOOK 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. */ 835DEFHOOK 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. */ 843DEFHOOK 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. */ 856DEFHOOK 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. */ 867DEFHOOK 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. */ 875DEFHOOK 876(set_sched_flags, 877 "", 878 void, (struct spec_info_def *spec_info), NULL) 879 880DEFHOOK_UNDOC 881(get_insn_spec_ds, 882 "Return speculation types of instruction @var{insn}.", 883 int, (rtx insn), NULL) 884 885DEFHOOK_UNDOC 886(get_insn_checked_ds, 887 "Return speculation types that are checked for instruction @var{insn}", 888 int, (rtx insn), NULL) 889 890DEFHOOK_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. */ 900DEFHOOK 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. */ 908DEFHOOK 909(dispatch_do, 910"", 911void, (rtx insn, int x), 912hook_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. */ 917DEFHOOK 918(dispatch, 919"", 920bool, (rtx insn, int x), 921hook_bool_rtx_int_false) 922 923DEFHOOKPOD 924(exposed_pipeline, 925"True if the processor has an exposed pipeline, which means that not just\n\ 926the order of instructions is important for correctness when scheduling, but\n\ 927also the latencies of operations.", 928bool, 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. */ 933DEFHOOK 934(reassociation_width, 935"This hook is called by tree reassociator to determine a level of\n\ 936parallelism required in output calculations chain.", 937int, (unsigned int opc, enum machine_mode mode), 938hook_int_uint_mode_1) 939 940HOOK_VECTOR_END (sched) 941 942/* Functions relating to vectorization. */ 943#undef HOOK_PREFIX 944#define HOOK_PREFIX "TARGET_VECTORIZE_" 945HOOK_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. */ 950DEFHOOK 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. */ 957DEFHOOK 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. */ 965DEFHOOK 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. */ 974DEFHOOK 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. */ 982DEFHOOK 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. */ 990DEFHOOK 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. */ 999DEFHOOK 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. */ 1007DEFHOOK 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. */ 1016DEFHOOK 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. */ 1026DEFHOOK 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. */ 1035DEFHOOK 1036(autovectorize_vector_sizes, 1037 "", 1038 unsigned int, 1039 (void), 1040 default_autovectorize_vector_sizes) 1041 1042/* Target builtin that implements vector gather operation. */ 1043DEFHOOK 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. */ 1051DEFHOOK 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. */ 1066DEFHOOK 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. */ 1083DEFHOOK 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. */ 1095DEFHOOK 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 1104HOOK_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. */ 1112DEFHOOK 1113(override_options_after_change, 1114 "", 1115 void, (void), 1116 hook_void_void) 1117 1118DEFHOOK_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. */ 1125DEFHOOK 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. */ 1132DEFHOOK 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. */ 1139DEFHOOK 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. */ 1146DEFHOOK 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. */ 1153DEFHOOK 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. */ 1161DEFHOOKPOD 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. */ 1168DEFHOOK 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). */ 1177DEFHOOK 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. */ 1184DEFHOOK 1185(set_default_type_attributes, 1186 "", 1187 void, (tree type), 1188 hook_void_tree) 1189 1190/* Insert attributes on the newly created DECL. */ 1191DEFHOOK 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. */ 1199DEFHOOK 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. */ 1207DEFHOOK 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. */ 1216DEFHOOK_UNDOC 1217(words_big_endian, 1218 "", 1219 bool, (void), 1220 targhook_words_big_endian) 1221 1222/* Likewise for FLOAT_WORDS_BIG_ENDIAN. */ 1223DEFHOOK_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. */ 1230DEFHOOK 1231(decimal_float_supported_p, 1232 "", 1233 bool, (void), 1234 default_decimal_float_supported_p) 1235 1236/* True if the target supports fixed-point. */ 1237DEFHOOK 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. */ 1244DEFHOOK 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. */ 1252DEFHOOK 1253(narrow_volatile_bitfield, 1254 "", 1255 bool, (void), 1256 hook_bool_void_false) 1257 1258/* Set up target-specific built-in functions. */ 1259DEFHOOK 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. */ 1269DEFHOOK 1270(builtin_decl, 1271 "", 1272 tree, (unsigned code, bool initialize_p), NULL) 1273 1274/* Expand a target-specific builtin. */ 1275DEFHOOK 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. */ 1287DEFHOOK 1288(resolve_overloaded_builtin, 1289 "", 1290 tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL) 1291 1292/* Fold a target-specific builtin. */ 1293DEFHOOK 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. */ 1307DEFHOOK 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. */ 1316DEFHOOK 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. */ 1325DEFHOOK 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. */ 1332DEFHOOK 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. */ 1341DEFHOOK 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. */ 1348DEFHOOK 1349(init_libfuncs, 1350 "", 1351 void, (void), 1352 hook_void_void) 1353 1354 /* Add a __gnu_ prefix to library functions rather than just __. */ 1355DEFHOOKPOD 1356(libfunc_gnu_prefix, 1357 "If false (the default), internal library routines start with two\n\ 1358underscores. If set to true, these routines start with @code{__gnu_}\n\ 1359instead. E.g., @code{__muldi3} changes to @code{__gnu_muldi3}. This\n\ 1360currently only affects functions defined in @file{libgcc2.c}. If this\n\ 1361is 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. */ 1368DEFHOOK 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. */ 1376DEFHOOK 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. */ 1383DEFHOOK 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. */ 1395DEFHOOK 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. */ 1405DEFHOOK 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. */ 1412DEFHOOK 1413(have_conditional_execution, 1414 "", 1415 bool, (void), 1416 default_have_conditional_execution) 1417 1418/* Return a new value for loop unroll size. */ 1419DEFHOOK 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. */ 1426DEFHOOK 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. */ 1433DEFHOOK 1434(cannot_force_const_mem, 1435 "", 1436 bool, (enum machine_mode mode, rtx x), 1437 hook_bool_mode_rtx_false) 1438 1439DEFHOOK_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. */ 1445DEFHOOK 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. */ 1453DEFHOOK 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. */ 1461DEFHOOK 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. */ 1468DEFHOOK 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. */ 1476DEFHOOK 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. */ 1483DEFHOOK 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. */ 1490DEFHOOK 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. */ 1497DEFHOOK 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. */ 1504DEFHOOKPOD 1505(min_anchor_offset, 1506 "", 1507 HOST_WIDE_INT, 0) 1508 1509DEFHOOKPOD 1510(max_anchor_offset, 1511 "", 1512 HOST_WIDE_INT, 0) 1513 1514/* True if section anchors can be used to access the given symbol. */ 1515DEFHOOK 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. */ 1524DEFHOOK 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. */ 1533DEFHOOK 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. */ 1539DEFHOOK 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. */ 1547DEFHOOK 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. */ 1554DEFHOOK 1555(profile_before_prologue, 1556 "It returns true if target wants profile code emitted before prologue.\n\n\ 1557The 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. */ 1566DEFHOOK 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. */ 1574DEFHOOK 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. */ 1581DEFHOOK 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. */ 1589DEFHOOK 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. */ 1598DEFHOOK 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. */ 1609DEFHOOK 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"))). */ 1616DEFHOOK 1617(valid_pointer_mode, 1618 "", 1619 bool, (enum machine_mode mode), 1620 default_valid_pointer_mode) 1621 1622/* Disambiguate with errno. */ 1623DEFHOOK 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_" 1636HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space) 1637 1638/* MODE to use for a pointer into another address space. */ 1639DEFHOOK 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. */ 1646DEFHOOK 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. */ 1654DEFHOOK 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. */ 1662DEFHOOK 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. */ 1671DEFHOOK 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. */ 1678DEFHOOK 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. */ 1685DEFHOOK 1686(convert, 1687 "", 1688 rtx, (rtx op, tree from_type, tree to_type), 1689 default_addr_space_convert) 1690 1691HOOK_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. */ 1699DEFHOOK 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. */ 1708DEFHOOK 1709(vector_mode_supported_p, 1710 "", 1711 bool, (enum machine_mode mode), 1712 hook_bool_mode_false) 1713 1714DEFHOOK 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\ 1718require natural alignment for vector types. The alignment returned by\n\ 1719this hook must be a power-of-two multiple of the default alignment of\n\ 1720the 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. */ 1726DEFHOOK 1727(array_mode_supported_p, 1728 "Return true if GCC should try to use a scalar mode to store an array\n\ 1729of @var{nelems} elements, given that each element has mode @var{mode}.\n\ 1730Returning true here overrides the usual @code{MAX_FIXED_MODE} limit\n\ 1731and allows GCC to use any defined integer mode.\n\ 1732\n\ 1733One use of this hook is to support vector load and store operations\n\ 1734that operate on several homogeneous vectors. For example, ARM NEON\n\ 1735has operations like:\n\ 1736\n\ 1737@smallexample\n\ 1738int8x8x3_t vld3_s8 (const int8_t *)\n\ 1739@end smallexample\n\ 1740\n\ 1741where the return type is defined as:\n\ 1742\n\ 1743@smallexample\n\ 1744typedef struct int8x8x3_t\n\ 1745@{\n\ 1746 int8x8_t val[3];\n\ 1747@} int8x8x3_t;\n\ 1748@end smallexample\n\ 1749\n\ 1750If 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. */ 1758DEFHOOK 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. */ 1767DEFHOOK 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. */ 1777DEFHOOK 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. */ 1785DEFHOOKPOD 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. */ 1797DEFHOOK 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. */ 1805DEFHOOK 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. */ 1812DEFHOOK 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. */ 1819DEFHOOK 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. */ 1831DEFHOOK 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. */ 1841DEFHOOK 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. */ 1854DEFHOOK 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. */ 1865DEFHOOK 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. */ 1873DEFHOOK 1874(machine_dependent_reorg, 1875 "", 1876 void, (void), NULL) 1877 1878/* Create the __builtin_va_list type. */ 1879DEFHOOK 1880(build_builtin_va_list, 1881 "", 1882 tree, (void), 1883 std_build_builtin_va_list) 1884 1885/* Enumerate the va list variants. */ 1886DEFHOOK 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. */ 1893DEFHOOK 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. */ 1900DEFHOOK 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. */ 1907DEFHOOK_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. */ 1913DEFHOOK 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. */ 1924DEFHOOK 1925(get_pch_validity, 1926 "", 1927 void *, (size_t *sz), 1928 default_get_pch_validity) 1929 1930DEFHOOK 1931(pch_valid_p, 1932 "", 1933 const char *, (const void *data, size_t sz), 1934 default_pch_valid_p) 1935 1936DEFHOOK 1937(prepare_pch_save, 1938 "Called before writing out a PCH file. If the target has some\n\ 1939garbage-collected data that needs to be in a particular state on PCH loads,\n\ 1940it can use this hook to enforce that state. Very few targets need\n\ 1941to 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. */ 1948DEFHOOK 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. */ 1956DEFHOOK 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. */ 1964DEFHOOK 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. */ 1972DEFHOOK 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. */ 1983DEFHOOK 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. */ 1996DEFHOOK 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. */ 2002DEFHOOK_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. */ 2012DEFHOOK 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. */ 2020DEFHOOK 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. */ 2028DEFHOOK 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. */ 2035DEFHOOK 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 2043DEFHOOK 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. */ 2053DEFHOOKPOD 2054(const_anchor, 2055 "", 2056 unsigned HOST_WIDE_INT, 0) 2057 2058/* Defines, which target-dependent bits (upper 16) are used by port */ 2059DEFHOOK 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. */ 2067DEFHOOK 2068(asan_shadow_offset, 2069 "Return the offset bitwise ored into shifted address to get corresponding\n\ 2070Address Sanitizer shadow memory address. NULL if Address Sanitizer is not\n\ 2071supported 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. */ 2077HOOK_VECTOR (TARGET_CALLS, calls) 2078 2079DEFHOOK 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 2086DEFHOOK 2087(promote_prototypes, 2088 "", 2089 bool, (const_tree fntype), 2090 hook_bool_const_tree_false) 2091 2092DEFHOOK 2093(struct_value_rtx, 2094 "", 2095 rtx, (tree fndecl, int incoming), 2096 hook_rtx_tree_int_null) 2097DEFHOOK 2098(return_in_memory, 2099 "", 2100 bool, (const_tree type, const_tree fntype), 2101 default_return_in_memory) 2102 2103DEFHOOK 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. */ 2112DEFHOOK 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 2119DEFHOOK 2120(expand_builtin_saveregs, 2121 "", 2122 rtx, (void), 2123 default_expand_builtin_saveregs) 2124 2125/* Returns pretend_argument_size. */ 2126DEFHOOK 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 2133DEFHOOK 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(). */ 2142DEFHOOK 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. */ 2150DEFHOOK 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. */ 2159DEFHOOK 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. */ 2168DEFHOOK 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. */ 2178DEFHOOK 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. */ 2187DEFHOOK 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. */ 2198DEFHOOK 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. */ 2207DEFHOOK 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 2214DEFHOOK 2215(function_arg_boundary, 2216 "", 2217 unsigned int, (enum machine_mode mode, const_tree type), 2218 default_function_arg_boundary) 2219 2220DEFHOOK 2221(function_arg_round_boundary, 2222 "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\ 2223which is the default value for this hook. You can define this hook to\n\ 2224return a different value if an argument size must be rounded to a larger\n\ 2225value.", 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. */ 2231DEFHOOK 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. */ 2239DEFHOOK 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. */ 2247DEFHOOK 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. */ 2255DEFHOOK 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. */ 2262DEFHOOK_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. */ 2270DEFHOOK 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. */ 2277DEFHOOK 2278(get_drap_rtx, 2279 "", 2280 rtx, (void), NULL) 2281 2282/* Return true if all function parameters should be spilled to the 2283 stack. */ 2284DEFHOOK 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. */ 2292DEFHOOK 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. */ 2300DEFHOOK 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. */ 2307DEFHOOK 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. */ 2316DEFHOOK 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. */ 2324DEFHOOK 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. */ 2334DEFHOOK 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 2342HOOK_VECTOR_END (calls) 2343 2344/* Return the diagnostic message string if conversion from FROMTYPE 2345 to TOTYPE is not allowed, NULL otherwise. */ 2346DEFHOOK 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. */ 2354DEFHOOK 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. */ 2362DEFHOOK 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. */ 2370DEFHOOK 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. */ 2378DEFHOOK 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. */ 2387DEFHOOK 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. */ 2396DEFHOOK 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. */ 2403DEFHOOK 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. */ 2413DEFHOOK 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. */ 2429DEFHOOK 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. */ 2442DEFHOOK 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. */ 2453DEFHOOK 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. */ 2460DEFHOOK 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. */ 2470DEFHOOK 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. */ 2479DEFHOOK 2480(preferred_output_reload_class, 2481 "", 2482 reg_class_t, 2483 (rtx x, reg_class_t rclass), 2484 default_preferred_output_reload_class) 2485 2486DEFHOOK 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. */ 2494DEFHOOK 2495(class_max_nregs, 2496 "", 2497 unsigned char, (reg_class_t rclass, enum machine_mode mode), 2498 default_class_max_nregs) 2499 2500DEFHOOK 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. */ 2517DEFHOOK 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. */ 2526DEFHOOK 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. */ 2534DEFHOOK 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. */ 2542DEFHOOK 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. */ 2549DEFHOOK 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. */ 2557DEFHOOK 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. */ 2566DEFHOOK 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_" 2575HOOK_VECTOR (TARGET_C, c) 2576 2577/* ??? Documenting this hook requires a GFDL license grant. */ 2578DEFHOOK_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 2585HOOK_VECTOR_END (c) 2586 2587/* Functions specific to the C++ frontend. */ 2588#undef HOOK_PREFIX 2589#define HOOK_PREFIX "TARGET_CXX_" 2590HOOK_VECTOR (TARGET_CXX, cxx) 2591 2592/* Return the integer type used for guard variables. */ 2593DEFHOOK 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. */ 2600DEFHOOK 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. */ 2607DEFHOOK 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. */ 2614DEFHOOK 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. */ 2622DEFHOOK 2623(import_export_class, 2624 "", 2625 int, (tree type, int import_export), NULL) 2626 2627/* Returns true if constructors and destructors return "this". */ 2628DEFHOOK 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. */ 2637DEFHOOK 2638(key_method_may_be_inline, 2639 "", 2640 bool, (void), 2641 hook_bool_void_true) 2642 2643DEFHOOK 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. */ 2659DEFHOOK 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. */ 2668DEFHOOK 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. */ 2676DEFHOOK 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. */ 2684DEFHOOK 2685(use_atexit_for_cxa_atexit, 2686 "", 2687 bool, (void), 2688 hook_bool_void_false) 2689 2690DEFHOOK 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 2698DEFHOOK 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 2704HOOK_VECTOR_END (cxx) 2705 2706/* Functions and data for emulated TLS support. */ 2707#undef HOOK_PREFIX 2708#define HOOK_PREFIX "TARGET_EMUTLS_" 2709HOOK_VECTOR (TARGET_EMUTLS, emutls) 2710 2711/* Name of the address and common functions. */ 2712DEFHOOKPOD 2713(get_address, 2714 "", 2715 const char *, "__builtin___emutls_get_address") 2716 2717DEFHOOKPOD 2718(register_common, 2719 "", 2720 const char *, "__builtin___emutls_register_common") 2721 2722/* Prefixes for proxy variable and template. */ 2723DEFHOOKPOD 2724(var_section, 2725 "", 2726 const char *, NULL) 2727 2728DEFHOOKPOD 2729(tmpl_section, 2730 "", 2731 const char *, NULL) 2732 2733/* Prefixes for proxy variable and template. */ 2734DEFHOOKPOD 2735(var_prefix, 2736 "", 2737 const char *, NULL) 2738 2739DEFHOOKPOD 2740(tmpl_prefix, 2741 "", 2742 const char *, NULL) 2743 2744/* Function to generate field definitions of the proxy variable. */ 2745DEFHOOK 2746(var_fields, 2747 "", 2748 tree, (tree type, tree *name), 2749 default_emutls_var_fields) 2750 2751/* Function to initialize a proxy variable. */ 2752DEFHOOK 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. */ 2760DEFHOOKPOD 2761(var_align_fixed, 2762 "", 2763 bool, false) 2764 2765/* Whether we can emit debug information for TLS vars. */ 2766DEFHOOKPOD 2767(debug_form_tls_address, 2768 "", 2769 bool, false) 2770 2771HOOK_VECTOR_END (emutls) 2772 2773#undef HOOK_PREFIX 2774#define HOOK_PREFIX "TARGET_OPTION_" 2775HOOK_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. */ 2780DEFHOOK 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. */ 2787DEFHOOK 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. */ 2794DEFHOOK 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. */ 2801DEFHOOK 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. */ 2810DEFHOOK 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. */ 2817DEFHOOK 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. */ 2827DEFHOOK 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_" 2836DEFHOOK 2837(can_inline_p, 2838 "", 2839 bool, (tree caller, tree callee), 2840 default_target_can_inline_p) 2841 2842HOOK_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. */ 2847DEFHOOK 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. */ 2854DEFHOOK 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. */ 2864DEFHOOK 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. */ 2871DEFHOOK 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. */ 2879DEFHOOK 2880(canonicalize_comparison, 2881 "", 2882 void, (int *code, rtx *op0, rtx *op1, bool op0_preserve_value), 2883 default_canonicalize_comparison) 2884 2885DEFHOOKPOD 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. */ 2896DEFHOOKPOD 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. */ 2903DEFHOOKPOD 2904(have_ctors_dtors, 2905 "", 2906 bool, false) 2907 2908/* True if thread-local storage is supported. */ 2909DEFHOOKPOD 2910(have_tls, 2911 "", 2912 bool, false) 2913 2914/* True if a small readonly data section is supported. */ 2915DEFHOOKPOD 2916(have_srodata_section, 2917 "", 2918 bool, false) 2919 2920/* True if EH frame info sections should be zero-terminated. */ 2921DEFHOOKPOD 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. */ 2927DEFHOOKPOD 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. */ 2934DEFHOOKPOD 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. */ 2941DEFHOOKPOD 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. */ 2948DEFHOOKPOD 2949(arm_eabi_unwinder, 2950 "", 2951 bool, false) 2952 2953DEFHOOKPOD 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 2960DEFHOOKPOD 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 2967DEFHOOKPOD 2968(delay_sched2, "True if sched2 is not to be run at its normal place. \ 2969This usually means it will be run as part of machine-specific reorg.", 2970bool, false) 2971 2972DEFHOOKPOD 2973(delay_vartrack, "True if vartrack is not to be run at its normal place. \ 2974This usually means it will be run as part of machine-specific reorg.", 2975bool, false) 2976 2977/* Leave the boolean fields at the end. */ 2978 2979/* Close the 'struct gcc_target' definition. */ 2980HOOK_VECTOR_END (C90_EMPTY_HACK) 2981