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