1 /* Data structure definitions for a generic GCC target. 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 3 Free Software Foundation, Inc. 4 5 This program is free software; you can redistribute it and/or modify it 6 under the terms of the GNU General Public License as published by the 7 Free Software Foundation; either version 3, or (at your option) any 8 later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; see the file COPYING3. If not see 17 <http://www.gnu.org/licenses/>. 18 19 In other words, you are welcome to use, share and improve this program. 20 You are forbidden to forbid anyone else to use, share and improve 21 what you give them. Help stamp out software-hoarding! */ 22 23 24 /* This file contains a data structure that describes a GCC target. 25 At present it is incomplete, but in future it should grow to 26 contain most or all target machine and target O/S specific 27 information. 28 29 This structure has its initializer declared in target-def.h in the 30 form of large macro TARGET_INITIALIZER that expands to many smaller 31 macros. 32 33 The smaller macros each initialize one component of the structure, 34 and each has a default. Each target should have a file that 35 includes target.h and target-def.h, and overrides any inappropriate 36 defaults by undefining the relevant macro and defining a suitable 37 replacement. That file should then contain the definition of 38 "targetm" like so: 39 40 struct gcc_target targetm = TARGET_INITIALIZER; 41 42 Doing things this way allows us to bring together everything that 43 defines a GCC target. By supplying a default that is appropriate 44 to most targets, we can easily add new items without needing to 45 edit dozens of target configuration files. It should also allow us 46 to gradually reduce the amount of conditional compilation that is 47 scattered throughout GCC. */ 48 49 #ifndef GCC_TARGET_H 50 #define GCC_TARGET_H 51 52 #include "tm.h" 53 #include "insn-modes.h" 54 55 /* Types used by the record_gcc_switches() target function. */ 56 typedef enum 57 { 58 SWITCH_TYPE_PASSED, /* A switch passed on the command line. */ 59 SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */ 60 SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */ 61 SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */ 62 SWITCH_TYPE_LINE_END /* Please emit a line terminator. */ 63 } 64 print_switch_type; 65 66 typedef int (* print_switch_fn_type) (print_switch_type, const char *); 67 68 /* An example implementation for ELF targets. Defined in varasm.c */ 69 extern int elf_record_gcc_switches (print_switch_type type, const char *); 70 71 /* Some places still assume that all pointer or address modes are the 72 standard Pmode and ptr_mode. These optimizations become invalid if 73 the target actually supports multiple different modes. For now, 74 we disable such optimizations on such targets, using this function. */ 75 extern bool target_default_pointer_address_modes_p (void); 76 77 struct stdarg_info; 78 struct spec_info_def; 79 80 /* The struct used by the secondary_reload target hook. */ 81 typedef struct secondary_reload_info 82 { 83 /* icode is actually an enum insn_code, but we don't want to force every 84 file that includes target.h to include optabs.h . */ 85 int icode; 86 int extra_cost; /* Cost for using (a) scratch register(s) to be taken 87 into account by copy_cost. */ 88 /* The next two members are for the use of the backward 89 compatibility hook. */ 90 struct secondary_reload_info *prev_sri; 91 int t_icode; /* Actually an enum insn_code - see above. */ 92 } secondary_reload_info; 93 94 /* This is defined in sched-int.h . */ 95 struct _dep; 96 97 /* This is defined in ddg.h . */ 98 struct ddg; 99 100 /* Assembler instructions for creating various kinds of integer object. */ 101 102 struct asm_int_op 103 { 104 const char *hi; 105 const char *si; 106 const char *di; 107 const char *ti; 108 }; 109 110 /* The target structure. This holds all the backend hooks. */ 111 112 struct gcc_target 113 { 114 /* Functions that output assembler for the target. */ 115 struct asm_out 116 { 117 /* Opening and closing parentheses for asm expression grouping. */ 118 const char *open_paren, *close_paren; 119 120 /* Assembler instructions for creating various kinds of integer object. */ 121 const char *byte_op; 122 struct asm_int_op aligned_op, unaligned_op; 123 124 /* Try to output the assembler code for an integer object whose 125 value is given by X. SIZE is the size of the object in bytes and 126 ALIGNED_P indicates whether it is aligned. Return true if 127 successful. Only handles cases for which BYTE_OP, ALIGNED_OP 128 and UNALIGNED_OP are NULL. */ 129 bool (* integer) (rtx x, unsigned int size, int aligned_p); 130 131 /* Output code that will globalize a label. */ 132 void (* globalize_label) (FILE *, const char *); 133 134 /* Output code that will globalize a declaration. */ 135 void (* globalize_decl_name) (FILE *, tree); 136 137 /* Output code that will emit a label for unwind info, if this 138 target requires such labels. Second argument is the decl the 139 unwind info is associated with, third is a boolean: true if 140 this is for exception handling, fourth is a boolean: true if 141 this is only a placeholder for an omitted FDE. */ 142 void (* unwind_label) (FILE *, tree, int, int); 143 144 /* Output code that will emit a label to divide up the exception 145 table. */ 146 void (* except_table_label) (FILE *); 147 148 /* Emit any directives required to unwind this instruction. */ 149 void (* unwind_emit) (FILE *, rtx); 150 151 /* Output an internal label. */ 152 void (* internal_label) (FILE *, const char *, unsigned long); 153 154 /* Emit a ttype table reference to a typeinfo object. */ 155 bool (* ttype) (rtx); 156 157 /* Emit an assembler directive to set visibility for the symbol 158 associated with the tree decl. */ 159 void (* visibility) (tree, int); 160 161 /* Output the assembler code for entry to a function. */ 162 void (* function_prologue) (FILE *, HOST_WIDE_INT); 163 164 /* Output the assembler code for end of prologue. */ 165 void (* function_end_prologue) (FILE *); 166 167 /* Output the assembler code for start of epilogue. */ 168 void (* function_begin_epilogue) (FILE *); 169 170 /* Output the assembler code for function exit. */ 171 void (* function_epilogue) (FILE *, HOST_WIDE_INT); 172 173 /* Initialize target-specific sections. */ 174 void (* init_sections) (void); 175 176 /* Tell assembler to change to section NAME with attributes FLAGS. 177 If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with 178 which this section is associated. */ 179 void (* named_section) (const char *name, unsigned int flags, tree decl); 180 181 /* Return a mask describing how relocations should be treated when 182 selecting sections. Bit 1 should be set if global relocations 183 should be placed in a read-write section; bit 0 should be set if 184 local relocations should be placed in a read-write section. */ 185 int (*reloc_rw_mask) (void); 186 187 /* Return a section for EXP. It may be a DECL or a constant. RELOC 188 is nonzero if runtime relocations must be applied; bit 1 will be 189 set if the runtime relocations require non-local name resolution. 190 ALIGN is the required alignment of the data. */ 191 section *(* select_section) (tree, int, unsigned HOST_WIDE_INT); 192 193 /* Return a section for X. MODE is X's mode and ALIGN is its 194 alignment in bits. */ 195 section *(* select_rtx_section) (enum machine_mode, rtx, 196 unsigned HOST_WIDE_INT); 197 198 /* Select a unique section name for DECL. RELOC is the same as 199 for SELECT_SECTION. */ 200 void (* unique_section) (tree, int); 201 202 /* Return the readonly data section associated with function DECL. */ 203 section *(* function_rodata_section) (tree); 204 205 /* Output a constructor for a symbol with a given priority. */ 206 void (* constructor) (rtx, int); 207 208 /* Output a destructor for a symbol with a given priority. */ 209 void (* destructor) (rtx, int); 210 211 /* Output the assembler code for a thunk function. THUNK_DECL is the 212 declaration for the thunk function itself, FUNCTION is the decl for 213 the target function. DELTA is an immediate constant offset to be 214 added to THIS. If VCALL_OFFSET is nonzero, the word at 215 *(*this + vcall_offset) should be added to THIS. */ 216 void (* output_mi_thunk) (FILE *file, tree thunk_decl, 217 HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, 218 tree function_decl); 219 220 /* Determine whether output_mi_thunk would succeed. */ 221 /* ??? Ideally, this hook would not exist, and success or failure 222 would be returned from output_mi_thunk directly. But there's 223 too much undo-able setup involved in invoking output_mi_thunk. 224 Could be fixed by making output_mi_thunk emit rtl instead of 225 text to the output file. */ 226 bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta, 227 HOST_WIDE_INT vcall_offset, 228 const_tree function_decl); 229 230 /* Output any boilerplate text needed at the beginning of a 231 translation unit. */ 232 void (*file_start) (void); 233 234 /* Output any boilerplate text needed at the end of a 235 translation unit. */ 236 void (*file_end) (void); 237 238 /* Output any boilerplate text needed at the beginning of an 239 LTO output stream. */ 240 void (*lto_start) (void); 241 242 /* Output any boilerplate text needed at the end of an 243 LTO output stream. */ 244 void (*lto_end) (void); 245 246 /* Output any boilerplace text needed at the end of a 247 translation unit before debug and unwind info is emitted. */ 248 void (*code_end) (void); 249 250 /* Output an assembler pseudo-op to declare a library function name 251 external. */ 252 void (*external_libcall) (rtx); 253 254 /* Output an assembler directive to mark decl live. This instructs 255 linker to not dead code strip this symbol. */ 256 void (*mark_decl_preserved) (const char *); 257 258 /* Output a record of the command line switches that have been passed. */ 259 print_switch_fn_type record_gcc_switches; 260 /* The name of the section that the example ELF implementation of 261 record_gcc_switches will use to store the information. Target 262 specific versions of record_gcc_switches may or may not use 263 this information. */ 264 const char * record_gcc_switches_section; 265 266 /* Output the definition of a section anchor. */ 267 void (*output_anchor) (rtx); 268 269 /* Output a DTP-relative reference to a TLS symbol. */ 270 void (*output_dwarf_dtprel) (FILE *file, int size, rtx x); 271 272 /* Some target machines need to postscan each insn after it is output. */ 273 void (*final_postscan_insn) (FILE *, rtx, rtx *, int); 274 275 /* Emit the trampoline template. This hook may be NULL. */ 276 void (*trampoline_template) (FILE *); 277 } asm_out; 278 279 /* Functions relating to instruction scheduling. */ 280 struct sched 281 { 282 /* Given the current cost, COST, of an insn, INSN, calculate and 283 return a new cost based on its relationship to DEP_INSN through 284 the dependence LINK. The default is to make no adjustment. */ 285 int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost); 286 287 /* Adjust the priority of an insn as you see fit. Returns the new 288 priority. */ 289 int (* adjust_priority) (rtx, int); 290 291 /* Function which returns the maximum number of insns that can be 292 scheduled in the same machine cycle. This must be constant 293 over an entire compilation. The default is 1. */ 294 int (* issue_rate) (void); 295 296 /* Calculate how much this insn affects how many more insns we 297 can emit this cycle. Default is they all cost the same. */ 298 int (* variable_issue) (FILE *, int, rtx, int); 299 300 /* Initialize machine-dependent scheduling code. */ 301 void (* md_init) (FILE *, int, int); 302 303 /* Finalize machine-dependent scheduling code. */ 304 void (* md_finish) (FILE *, int); 305 306 /* Initialize machine-dependent function wide scheduling code. */ 307 void (* md_init_global) (FILE *, int, int); 308 309 /* Finalize machine-dependent function wide scheduling code. */ 310 void (* md_finish_global) (FILE *, int); 311 312 /* Reorder insns in a machine-dependent fashion, in two different 313 places. Default does nothing. */ 314 int (* reorder) (FILE *, int, rtx *, int *, int); 315 int (* reorder2) (FILE *, int, rtx *, int *, int); 316 317 /* The following member value is a pointer to a function called 318 after evaluation forward dependencies of insns in chain given 319 by two parameter values (head and tail correspondingly). */ 320 void (* dependencies_evaluation_hook) (rtx, rtx); 321 322 /* The values of the following four members are pointers to 323 functions used to simplify the automaton descriptions. 324 dfa_pre_cycle_insn and dfa_post_cycle_insn give functions 325 returning insns which are used to change the pipeline hazard 326 recognizer state when the new simulated processor cycle 327 correspondingly starts and finishes. The function defined by 328 init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used 329 to initialize the corresponding insns. The default values of 330 the members result in not changing the automaton state when 331 the new simulated processor cycle correspondingly starts and 332 finishes. */ 333 void (* init_dfa_pre_cycle_insn) (void); 334 rtx (* dfa_pre_cycle_insn) (void); 335 void (* init_dfa_post_cycle_insn) (void); 336 rtx (* dfa_post_cycle_insn) (void); 337 338 /* The values of the following two members are pointers to 339 functions used to simplify the automaton descriptions. 340 dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called 341 immediately before and after cycle is advanced. */ 342 void (* dfa_pre_advance_cycle) (void); 343 void (* dfa_post_advance_cycle) (void); 344 345 /* The following member value is a pointer to a function returning value 346 which defines how many insns in queue `ready' will we try for 347 multi-pass scheduling. If the member value is nonzero and the 348 function returns positive value, the DFA based scheduler will make 349 multi-pass scheduling for the first cycle. In other words, we will 350 try to choose ready insn which permits to start maximum number of 351 insns on the same cycle. */ 352 int (* first_cycle_multipass_dfa_lookahead) (void); 353 354 /* The following member value is pointer to a function controlling 355 what insns from the ready insn queue will be considered for the 356 multipass insn scheduling. If the hook returns zero for insn 357 passed as the parameter, the insn will be not chosen to be 358 issued. */ 359 int (* first_cycle_multipass_dfa_lookahead_guard) (rtx); 360 361 /* The following member value is pointer to a function called by 362 the insn scheduler before issuing insn passed as the third 363 parameter on given cycle. If the hook returns nonzero, the 364 insn is not issued on given processors cycle. Instead of that, 365 the processor cycle is advanced. If the value passed through 366 the last parameter is zero, the insn ready queue is not sorted 367 on the new cycle start as usually. The first parameter passes 368 file for debugging output. The second one passes the scheduler 369 verbose level of the debugging output. The forth and the fifth 370 parameter values are correspondingly processor cycle on which 371 the previous insn has been issued and the current processor 372 cycle. */ 373 int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *); 374 375 /* The following member value is a pointer to a function called by the 376 insn scheduler. It should return true if there exists a dependence 377 which is considered costly by the target, between the insn 378 DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is 379 the dep that represents the dependence between the two insns. The 380 second argument is the cost of the dependence as estimated by 381 the scheduler. The last argument is the distance in cycles 382 between the already scheduled insn (first parameter) and the 383 second insn (second parameter). */ 384 bool (* is_costly_dependence) (struct _dep *_dep, int, int); 385 386 /* Given the current cost, COST, of an insn, INSN, calculate and 387 return a new cost based on its relationship to DEP_INSN through the 388 dependence of type DEP_TYPE. The default is to make no adjustment. */ 389 int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw); 390 391 /* The following member value is a pointer to a function called 392 by the insn scheduler. This hook is called to notify the backend 393 that new instructions were emitted. */ 394 void (* h_i_d_extended) (void); 395 396 /* Next 5 functions are for multi-point scheduling. */ 397 398 /* Allocate memory for scheduler context. */ 399 void *(* alloc_sched_context) (void); 400 401 /* Fills the context from the local machine scheduler context. */ 402 void (* init_sched_context) (void *, bool); 403 404 /* Sets local machine scheduler context to a saved value. */ 405 void (* set_sched_context) (void *); 406 407 /* Clears a scheduler context so it becomes like after init. */ 408 void (* clear_sched_context) (void *); 409 410 /* Frees the scheduler context. */ 411 void (* free_sched_context) (void *); 412 413 /* The following member value is a pointer to a function called 414 by the insn scheduler. 415 The first parameter is an instruction, the second parameter is the type 416 of the requested speculation, and the third parameter is a pointer to the 417 speculative pattern of the corresponding type (set if return value == 1). 418 It should return 419 -1, if there is no pattern, that will satisfy the requested speculation 420 type, 421 0, if current pattern satisfies the requested speculation type, 422 1, if pattern of the instruction should be changed to the newly 423 generated one. */ 424 int (* speculate_insn) (rtx, int, rtx *); 425 426 /* The following member value is a pointer to a function called 427 by the insn scheduler. It should return true if the check instruction 428 passed as the parameter needs a recovery block. */ 429 bool (* needs_block_p) (int); 430 431 /* The following member value is a pointer to a function called 432 by the insn scheduler. It should return a pattern for the check 433 instruction. 434 The first parameter is a speculative instruction, the second parameter 435 is the label of the corresponding recovery block (or null, if it is a 436 simple check). If the mutation of the check is requested (e.g. from 437 ld.c to chk.a), the third parameter is true - in this case the first 438 parameter is the previous check. */ 439 rtx (* gen_spec_check) (rtx, rtx, int); 440 441 /* The following member value is a pointer to a function controlling 442 what insns from the ready insn queue will be considered for the 443 multipass insn scheduling. If the hook returns zero for the insn 444 passed as the parameter, the insn will not be chosen to be 445 issued. This hook is used to discard speculative instructions, 446 that stand at the first position of the ready list. */ 447 bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx); 448 449 /* The following member value is a pointer to a function that provides 450 information about the speculation capabilities of the target. 451 The parameter is a pointer to spec_info variable. */ 452 void (* set_sched_flags) (struct spec_info_def *); 453 454 /* Return speculation types of the instruction passed as the parameter. */ 455 int (* get_insn_spec_ds) (rtx); 456 457 /* Return speculation types that are checked for the instruction passed as 458 the parameter. */ 459 int (* get_insn_checked_ds) (rtx); 460 461 /* Return bool if rtx scanning should just skip current layer and 462 advance to the inner rtxes. */ 463 bool (* skip_rtx_p) (const_rtx); 464 465 /* The following member value is a pointer to a function that provides 466 information about the target resource-based lower bound which is 467 used by the swing modulo scheduler. The parameter is a pointer 468 to ddg variable. */ 469 int (* sms_res_mii) (struct ddg *); 470 } sched; 471 472 /* Functions relating to vectorization. */ 473 struct vectorize 474 { 475 /* The following member value is a pointer to a function called 476 by the vectorizer, and return the decl of the target builtin 477 function. */ 478 tree (* builtin_mask_for_load) (void); 479 480 /* Returns a code for builtin that realizes vectorized version of 481 function, or NULL_TREE if not available. */ 482 tree (* builtin_vectorized_function) (tree, tree, tree); 483 484 /* Returns a code for builtin that realizes vectorized version of 485 conversion, or NULL_TREE if not available. */ 486 tree (* builtin_conversion) (unsigned, tree); 487 488 /* Target builtin that implements vector widening multiplication. 489 builtin_mul_widen_eve computes the element-by-element products 490 for the even elements, and builtin_mul_widen_odd computes the 491 element-by-element products for the odd elements. */ 492 tree (* builtin_mul_widen_even) (tree); 493 tree (* builtin_mul_widen_odd) (tree); 494 495 /* Returns the cost to be added to the overheads involved with 496 executing the vectorized version of a loop. */ 497 int (*builtin_vectorization_cost) (bool); 498 499 /* Return true if vector alignment is reachable (by peeling N 500 iterations) for the given type. */ 501 bool (* vector_alignment_reachable) (const_tree, bool); 502 503 /* Target builtin that implements vector permute. */ 504 tree (* builtin_vec_perm) (tree, tree*); 505 506 /* Return true if a vector created for builtin_vec_perm is valid. */ 507 bool (* builtin_vec_perm_ok) (tree, tree); 508 509 /* Return true if the target supports misaligned store/load of a 510 specific factor denoted in the third parameter. The last parameter 511 is true if the access is defined in a packed struct. */ 512 bool (* builtin_support_vector_misalignment) (enum machine_mode, 513 const_tree, int, bool); 514 } vectorize; 515 516 /* The initial value of target_flags. */ 517 int default_target_flags; 518 519 /* Allow target specific overriding of option settings after options have 520 been changed by an attribute or pragma or when it is reset at the 521 end of the code affected by an attribute or pragma. */ 522 void (* override_options_after_change) (void); 523 524 /* Handle target switch CODE (an OPT_* value). ARG is the argument 525 passed to the switch; it is NULL if no argument was. VALUE is the 526 value of ARG if CODE specifies a UInteger option, otherwise it is 527 1 if the positive form of the switch was used and 0 if the negative 528 form was. Return true if the switch was valid. */ 529 bool (* handle_option) (size_t code, const char *arg, int value); 530 531 /* Display extra, target specific information in response to a 532 --target-help switch. */ 533 void (* target_help) (void); 534 535 /* Return machine mode for filter value. */ 536 enum machine_mode (* eh_return_filter_mode) (void); 537 538 /* Return machine mode for libgcc expanded cmp instructions. */ 539 enum machine_mode (* libgcc_cmp_return_mode) (void); 540 541 /* Return machine mode for libgcc expanded shift instructions. */ 542 enum machine_mode (* libgcc_shift_count_mode) (void); 543 544 /* Return machine mode to be used for _Unwind_Word type. */ 545 enum machine_mode (* unwind_word_mode) (void); 546 547 /* Given two decls, merge their attributes and return the result. */ 548 tree (* merge_decl_attributes) (tree, tree); 549 550 /* Given two types, merge their attributes and return the result. */ 551 tree (* merge_type_attributes) (tree, tree); 552 553 /* Table of machine attributes and functions to handle them. 554 Ignored if NULL. */ 555 const struct attribute_spec *attribute_table; 556 557 /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible, 558 one if they are compatible and two if they are nearly compatible 559 (which causes a warning to be generated). */ 560 int (* comp_type_attributes) (const_tree type1, const_tree type2); 561 562 /* Assign default attributes to the newly defined TYPE. */ 563 void (* set_default_type_attributes) (tree type); 564 565 /* Insert attributes on the newly created DECL. */ 566 void (* insert_attributes) (tree decl, tree *attributes); 567 568 /* Return true if FNDECL (which has at least one machine attribute) 569 can be inlined despite its machine attributes, false otherwise. */ 570 bool (* function_attribute_inlinable_p) (const_tree fndecl); 571 572 /* Return true if bitfields in RECORD_TYPE should follow the 573 Microsoft Visual C++ bitfield layout rules. */ 574 bool (* ms_bitfield_layout_p) (const_tree record_type); 575 576 /* True if the target supports decimal floating point. */ 577 bool (* decimal_float_supported_p) (void); 578 579 /* True if the target supports fixed-point. */ 580 bool (* fixed_point_supported_p) (void); 581 582 /* Return true if anonymous bitfields affect structure alignment. */ 583 bool (* align_anon_bitfield) (void); 584 585 /* Return true if volatile bitfields should use the narrowest type possible. 586 Return false if they should use the container type. */ 587 bool (* narrow_volatile_bitfield) (void); 588 589 /* Set up target-specific built-in functions. */ 590 void (* init_builtins) (void); 591 592 /* Initialize (if INITIALIZE_P is true) and return the target-specific 593 built-in function decl for CODE. 594 Return NULL if that is not possible. Return error_mark_node if CODE 595 is outside of the range of valid target builtin function codes. */ 596 tree (* builtin_decl) (unsigned code, bool initialize_p); 597 598 /* Expand a target-specific builtin. */ 599 rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget, 600 enum machine_mode mode, int ignore); 601 602 /* Select a replacement for a target-specific builtin. This is done 603 *before* regular type checking, and so allows the target to 604 implement a crude form of function overloading. The result is a 605 complete expression that implements the operation. PARAMS really 606 has type VEC(tree,gc)*, but we don't want to include tree.h 607 here. */ 608 tree (*resolve_overloaded_builtin) (unsigned int /*location_t*/, 609 tree decl, void *params); 610 611 /* Fold a target-specific builtin. */ 612 tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore); 613 614 /* Returns a code for a target-specific builtin that implements 615 reciprocal of the function, or NULL_TREE if not available. */ 616 tree (* builtin_reciprocal) (unsigned, bool, bool); 617 618 /* For a vendor-specific TYPE, return a pointer to a statically-allocated 619 string containing the C++ mangling for TYPE. In all other cases, return 620 NULL. */ 621 const char * (* mangle_type) (const_tree type); 622 623 /* Make any adjustments to libfunc names needed for this target. */ 624 void (* init_libfuncs) (void); 625 626 /* Given a decl, a section name, and whether the decl initializer 627 has relocs, choose attributes for the section. */ 628 /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */ 629 unsigned int (* section_type_flags) (tree, const char *, int); 630 631 /* True if new jumps cannot be created, to replace existing ones or 632 not, at the current point in the compilation. */ 633 bool (* cannot_modify_jumps_p) (void); 634 635 /* Return a register class for which branch target register 636 optimizations should be applied. */ 637 enum reg_class (* branch_target_register_class) (void); 638 639 /* Return true if branch target register optimizations should include 640 callee-saved registers that are not already live during the current 641 function. AFTER_PE_GEN is true if prologues and epilogues have 642 already been generated. */ 643 bool (* branch_target_register_callee_saved) (bool after_pe_gen); 644 645 /* Return true if the target supports conditional execution. */ 646 bool (* have_conditional_execution) (void); 647 648 /* True if the constant X cannot be placed in the constant pool. */ 649 bool (* cannot_force_const_mem) (rtx); 650 651 /* True if the insn X cannot be duplicated. */ 652 bool (* cannot_copy_insn_p) (rtx); 653 654 /* True if X is considered to be commutative. */ 655 bool (* commutative_p) (const_rtx, int); 656 657 /* Given an invalid address X for a given machine mode, try machine-specific 658 ways to make it legitimate. Return X or an invalid address on failure. */ 659 rtx (* legitimize_address) (rtx, rtx, enum machine_mode); 660 661 /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */ 662 rtx (* delegitimize_address) (rtx); 663 664 /* Given an address RTX, say whether it is valid. */ 665 bool (* legitimate_address_p) (enum machine_mode, rtx, bool); 666 667 /* True if the given constant can be put into an object_block. */ 668 bool (* use_blocks_for_constant_p) (enum machine_mode, const_rtx); 669 670 /* The minimum and maximum byte offsets for anchored addresses. */ 671 HOST_WIDE_INT min_anchor_offset; 672 HOST_WIDE_INT max_anchor_offset; 673 674 /* True if section anchors can be used to access the given symbol. */ 675 bool (* use_anchors_for_symbol_p) (const_rtx); 676 677 /* True if it is OK to do sibling call optimization for the specified 678 call expression EXP. DECL will be the called function, or NULL if 679 this is an indirect call. */ 680 bool (*function_ok_for_sibcall) (tree decl, tree exp); 681 682 /* Establish appropriate back-end context for processing the function 683 FNDECL. The argument might be NULL to indicate processing at top 684 level, outside of any function scope. */ 685 void (*set_current_function) (tree fndecl); 686 687 /* True if EXP should be placed in a "small data" section. */ 688 bool (* in_small_data_p) (const_tree); 689 690 /* True if EXP names an object for which name resolution must resolve 691 to the current executable or shared library. */ 692 bool (* binds_local_p) (const_tree); 693 694 /* Modify and return the identifier of a DECL's external name, 695 originally identified by ID, as required by the target, 696 (eg, append @nn to windows32 stdcall function names). 697 The default is to return ID without modification. */ 698 tree (* mangle_decl_assembler_name) (tree decl, tree id); 699 700 /* Do something target-specific to record properties of the DECL into 701 the associated SYMBOL_REF. */ 702 void (* encode_section_info) (tree, rtx, int); 703 704 /* Undo the effects of encode_section_info on the symbol string. */ 705 const char * (* strip_name_encoding) (const char *); 706 707 /* If shift optabs for MODE are known to always truncate the shift count, 708 return the mask that they apply. Return 0 otherwise. */ 709 unsigned HOST_WIDE_INT (* shift_truncation_mask) (enum machine_mode mode); 710 711 /* Return the number of divisions in the given MODE that should be present, 712 so that it is profitable to turn the division into a multiplication by 713 the reciprocal. */ 714 unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode); 715 716 /* If the representation of integral MODE is such that values are 717 always sign-extended to a wider mode MODE_REP then return 718 SIGN_EXTEND. Return UNKNOWN otherwise. */ 719 /* Note that the return type ought to be RTX_CODE, but that's not 720 necessarily defined at this point. */ 721 int (* mode_rep_extended) (enum machine_mode mode, 722 enum machine_mode mode_rep); 723 724 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */ 725 bool (* valid_pointer_mode) (enum machine_mode mode); 726 727 /* Support for named address spaces. */ 728 struct addr_space { 729 /* MODE to use for a pointer into another address space. */ 730 enum machine_mode (* pointer_mode) (addr_space_t); 731 732 /* MODE to use for an address in another address space. */ 733 enum machine_mode (* address_mode) (addr_space_t); 734 735 /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))) 736 in another address space. */ 737 bool (* valid_pointer_mode) (enum machine_mode, addr_space_t); 738 739 /* True if an address is a valid memory address to a given named address 740 space for a given mode. */ 741 bool (* legitimate_address_p) (enum machine_mode, rtx, bool, addr_space_t); 742 743 /* Return an updated address to convert an invalid pointer to a named 744 address space to a valid one. If NULL_RTX is returned use machine 745 independent methods to make the address valid. */ 746 rtx (* legitimize_address) (rtx, rtx, enum machine_mode, addr_space_t); 747 748 /* True if one named address space is a subset of another named address. */ 749 bool (* subset_p) (addr_space_t, addr_space_t); 750 751 /* Function to convert an rtl expression from one address space to 752 another. */ 753 rtx (* convert) (rtx, tree, tree); 754 755 } addr_space; 756 757 /* True if MODE is valid for the target. By "valid", we mean able to 758 be manipulated in non-trivial ways. In particular, this means all 759 the arithmetic is supported. */ 760 bool (* scalar_mode_supported_p) (enum machine_mode mode); 761 762 /* Similarly for vector modes. "Supported" here is less strict. At 763 least some operations are supported; need to check optabs or builtins 764 for further details. */ 765 bool (* vector_mode_supported_p) (enum machine_mode mode); 766 767 /* Compute a (partial) cost for rtx X. Return true if the complete 768 cost has been computed, and false if subexpressions should be 769 scanned. In either case, *TOTAL contains the cost result. */ 770 /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's 771 not necessarily defined at this point. */ 772 bool (* rtx_costs) (rtx x, int code, int outer_code, int *total, bool speed); 773 774 /* Compute the cost of X, used as an address. Never called with 775 invalid addresses. */ 776 int (* address_cost) (rtx x, bool speed); 777 778 /* Return where to allocate pseudo for a given hard register initial 779 value. */ 780 rtx (* allocate_initial_value) (rtx x); 781 782 /* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap. 783 FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */ 784 int (* unspec_may_trap_p) (const_rtx x, unsigned flags); 785 786 /* Given a register, this hook should return a parallel of registers 787 to represent where to find the register pieces. Define this hook 788 if the register and its mode are represented in Dwarf in 789 non-contiguous locations, or if the register should be 790 represented in more than one register in Dwarf. Otherwise, this 791 hook should return NULL_RTX. */ 792 rtx (* dwarf_register_span) (rtx); 793 794 /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table 795 entries not corresponding directly to registers below 796 FIRST_PSEUDO_REGISTER, this hook should generate the necessary 797 code, given the address of the table. */ 798 void (* init_dwarf_reg_sizes_extra) (tree); 799 800 /* Fetch the fixed register(s) which hold condition codes, for 801 targets where it makes sense to look for duplicate assignments to 802 the condition codes. This should return true if there is such a 803 register, false otherwise. The arguments should be set to the 804 fixed register numbers. Up to two condition code registers are 805 supported. If there is only one for this target, the int pointed 806 at by the second argument should be set to -1. */ 807 bool (* fixed_condition_code_regs) (unsigned int *, unsigned int *); 808 809 /* If two condition code modes are compatible, return a condition 810 code mode which is compatible with both, such that a comparison 811 done in the returned mode will work for both of the original 812 modes. If the condition code modes are not compatible, return 813 VOIDmode. */ 814 enum machine_mode (* cc_modes_compatible) (enum machine_mode, 815 enum machine_mode); 816 817 /* Do machine-dependent code transformations. Called just before 818 delayed-branch scheduling. */ 819 void (* machine_dependent_reorg) (void); 820 821 /* Create the __builtin_va_list type. */ 822 tree (* build_builtin_va_list) (void); 823 824 /* Get the cfun/fndecl calling abi __builtin_va_list type. */ 825 tree (* fn_abi_va_list) (tree); 826 827 /* Get the __builtin_va_list type dependent on input type. */ 828 tree (* canonical_va_list_type) (tree); 829 830 /* Expand the __builtin_va_start builtin. */ 831 void (* expand_builtin_va_start) (tree valist, rtx nextarg); 832 833 /* Gimplifies a VA_ARG_EXPR. */ 834 tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p, 835 gimple_seq *post_p); 836 837 /* Validity-checking routines for PCH files, target-specific. 838 get_pch_validity returns a pointer to the data to be stored, 839 and stores the size in its argument. pch_valid_p gets the same 840 information back and returns NULL if the PCH is valid, 841 or an error message if not. 842 */ 843 void * (* get_pch_validity) (size_t *); 844 const char * (* pch_valid_p) (const void *, size_t); 845 846 /* If nonnull, this function checks whether a PCH file with the 847 given set of target flags can be used. It returns NULL if so, 848 otherwise it returns an error message. */ 849 const char *(*check_pch_target_flags) (int); 850 851 /* True if the compiler should give an enum type only as many 852 bytes as it takes to represent the range of possible values of 853 that type. */ 854 bool (* default_short_enums) (void); 855 856 /* This target hook returns an rtx that is used to store the address 857 of the current frame into the built-in setjmp buffer. */ 858 rtx (* builtin_setjmp_frame_value) (void); 859 860 /* This target hook should add STRING_CST trees for any hard regs 861 the port wishes to automatically clobber for an asm. */ 862 tree (* md_asm_clobbers) (tree, tree, tree); 863 864 /* This target hook allows the backend to specify a calling convention 865 in the debug information. This function actually returns an 866 enum dwarf_calling_convention, but because of forward declarations 867 and not wanting to include dwarf2.h everywhere target.h is included 868 the function is being declared as an int. */ 869 int (* dwarf_calling_convention) (const_tree); 870 871 /* This target hook allows the backend to emit frame-related insns that 872 contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info 873 engine will invoke it on insns of the form 874 (set (reg) (unspec [...] UNSPEC_INDEX)) 875 and 876 (set (reg) (unspec_volatile [...] UNSPECV_INDEX)) 877 to let the backend emit the call frame instructions. */ 878 void (* dwarf_handle_frame_unspec) (const char *, rtx, int); 879 880 /* Perform architecture specific checking of statements gimplified 881 from VA_ARG_EXPR. STMT is the statement. Returns true if the statement 882 doesn't need to be checked for va_list references. */ 883 bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const_gimple stmt); 884 885 /* This target hook allows the operating system to override the DECL 886 that represents the external variable that contains the stack 887 protection guard variable. The type of this DECL is ptr_type_node. */ 888 tree (* stack_protect_guard) (void); 889 890 /* This target hook allows the operating system to override the CALL_EXPR 891 that is invoked when a check vs the guard variable fails. */ 892 tree (* stack_protect_fail) (void); 893 894 /* Returns NULL if target supports the insn within a doloop block, 895 otherwise it returns an error message. */ 896 const char * (*invalid_within_doloop) (const_rtx); 897 898 /* DECL is a variable or function with __attribute__((dllimport)) 899 specified. Use this hook if the target needs to add extra validation 900 checks to handle_dll_attribute (). */ 901 bool (* valid_dllimport_attribute_p) (const_tree decl); 902 903 /* If non-zero, align constant anchors in CSE to a multiple of this 904 value. */ 905 unsigned HOST_WIDE_INT const_anchor; 906 907 /* Functions relating to calls - argument passing, returns, etc. */ 908 struct calls { 909 enum machine_mode (*promote_function_mode) (const_tree type, 910 enum machine_mode mode, 911 int *punsignedp, 912 const_tree fntype, 913 int for_return); 914 bool (*promote_prototypes) (const_tree fntype); 915 rtx (*struct_value_rtx) (tree fndecl, int incoming); 916 bool (*return_in_memory) (const_tree type, const_tree fndecl); 917 bool (*return_in_msb) (const_tree type); 918 919 /* Return true if a parameter must be passed by reference. TYPE may 920 be null if this is a libcall. CA may be null if this query is 921 from __builtin_va_arg. */ 922 bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode, 923 const_tree type, bool named_arg); 924 925 rtx (*expand_builtin_saveregs) (void); 926 /* Returns pretend_argument_size. */ 927 void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode, 928 tree type, int *pretend_arg_size, 929 int second_time); 930 bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca); 931 /* Returns true if we should use 932 targetm.calls.setup_incoming_varargs() and/or 933 targetm.calls.strict_argument_naming(). */ 934 bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca); 935 936 /* Given a complex type T, return true if a parameter of type T 937 should be passed as two scalars. */ 938 bool (* split_complex_arg) (const_tree type); 939 940 /* Return true if type T, mode MODE, may not be passed in registers, 941 but must be passed on the stack. */ 942 /* ??? This predicate should be applied strictly after pass-by-reference. 943 Need audit to verify that this is the case. */ 944 bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t); 945 946 /* Return true if type TYPE, mode MODE, which is passed by reference, 947 should have the object copy generated by the callee rather than 948 the caller. It is never called for TYPE requiring constructors. */ 949 bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode, 950 const_tree type, bool named); 951 952 /* Return zero for arguments passed entirely on the stack or entirely 953 in registers. If passed in both, return the number of bytes passed 954 in registers; the balance is therefore passed on the stack. */ 955 int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode, 956 tree type, bool named); 957 958 /* Return the diagnostic message string if function without a prototype 959 is not allowed for this 'val' argument; NULL otherwise. */ 960 const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist, 961 const_tree funcdecl, 962 const_tree val); 963 964 /* Return an rtx for the return value location of the function 965 specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */ 966 rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type, 967 bool outgoing); 968 969 /* Return the rtx for the result of a libcall of mode MODE, 970 calling the function FN_NAME. */ 971 rtx (*libcall_value) (enum machine_mode, const_rtx); 972 973 /* Return an rtx for the argument pointer incoming to the 974 current function. */ 975 rtx (*internal_arg_pointer) (void); 976 977 /* Update the current function stack boundary if needed. */ 978 void (*update_stack_boundary) (void); 979 980 /* Handle stack alignment and return an rtx for Dynamic Realign 981 Argument Pointer if necessary. */ 982 rtx (*get_drap_rtx) (void); 983 984 /* Return true if all function parameters should be spilled to the 985 stack. */ 986 bool (*allocate_stack_slots_for_args) (void); 987 988 /* Return an rtx for the static chain for FNDECL. If INCOMING_P is true, 989 then it should be for the callee; otherwise for the caller. */ 990 rtx (*static_chain) (const_tree fndecl, bool incoming_p); 991 992 /* Fill in the trampoline at MEM with a call to FNDECL and a 993 static chain value of CHAIN. */ 994 void (*trampoline_init) (rtx mem, tree fndecl, rtx chain); 995 996 /* Adjust the address of the trampoline in a target-specific way. */ 997 rtx (*trampoline_adjust_address) (rtx addr); 998 } calls; 999 1000 /* Return the diagnostic message string if conversion from FROMTYPE 1001 to TOTYPE is not allowed, NULL otherwise. */ 1002 const char *(*invalid_conversion) (const_tree fromtype, const_tree totype); 1003 1004 /* Return the diagnostic message string if the unary operation OP is 1005 not permitted on TYPE, NULL otherwise. */ 1006 const char *(*invalid_unary_op) (int op, const_tree type); 1007 1008 /* Return the diagnostic message string if the binary operation OP 1009 is not permitted on TYPE1 and TYPE2, NULL otherwise. */ 1010 const char *(*invalid_binary_op) (int op, const_tree type1, const_tree type2); 1011 1012 /* Return the diagnostic message string if TYPE is not valid as a 1013 function parameter type, NULL otherwise. */ 1014 const char *(*invalid_parameter_type) (const_tree type); 1015 1016 /* Return the diagnostic message string if TYPE is not valid as a 1017 function return type, NULL otherwise. */ 1018 const char *(*invalid_return_type) (const_tree type); 1019 1020 /* If values of TYPE are promoted to some other type when used in 1021 expressions (analogous to the integer promotions), return that type, 1022 or NULL_TREE otherwise. */ 1023 tree (*promoted_type) (const_tree type); 1024 1025 /* Convert EXPR to TYPE, if target-specific types with special conversion 1026 rules are involved. Return the converted expression, or NULL to apply 1027 the standard conversion rules. */ 1028 tree (*convert_to_type) (tree type, tree expr); 1029 1030 /* Return the array of IRA cover classes for the current target. */ 1031 const enum reg_class *(*ira_cover_classes) (void); 1032 1033 /* Return the class for a secondary reload, and fill in extra information. */ 1034 enum reg_class (*secondary_reload) (bool, rtx, enum reg_class, 1035 enum machine_mode, 1036 secondary_reload_info *); 1037 1038 /* This target hook allows the backend to perform additional 1039 processing while initializing for variable expansion. */ 1040 void (* expand_to_rtl_hook) (void); 1041 1042 /* This target hook allows the backend to perform additional 1043 instantiations on rtx that are not actually in insns yet, 1044 but will be later. */ 1045 void (* instantiate_decls) (void); 1046 1047 /* Return true if is OK to use a hard register REGNO as scratch register 1048 in peephole2. */ 1049 bool (* hard_regno_scratch_ok) (unsigned int regno); 1050 1051 /* Return the smallest number of different values for which it is best to 1052 use a jump-table instead of a tree of conditional branches. */ 1053 unsigned int (* case_values_threshold) (void); 1054 1055 /* Retutn true if a function must have and use a frame pointer. */ 1056 bool (* frame_pointer_required) (void); 1057 1058 /* Returns true if the compiler is allowed to try to replace register number 1059 from-reg with register number to-reg. */ 1060 bool (* can_eliminate) (const int, const int); 1061 1062 /* Functions specific to the C family of frontends. */ 1063 struct c { 1064 /* Return machine mode for non-standard suffix 1065 or VOIDmode if non-standard suffixes are unsupported. */ 1066 enum machine_mode (*mode_for_suffix) (char); 1067 } c; 1068 1069 /* Functions specific to the C++ frontend. */ 1070 struct cxx { 1071 /* Return the integer type used for guard variables. */ 1072 tree (*guard_type) (void); 1073 /* Return true if only the low bit of the guard should be tested. */ 1074 bool (*guard_mask_bit) (void); 1075 /* Returns the size of the array cookie for an array of type. */ 1076 tree (*get_cookie_size) (tree); 1077 /* Returns true if the element size should be stored in the 1078 array cookie. */ 1079 bool (*cookie_has_size) (void); 1080 /* Allows backends to perform additional processing when 1081 deciding if a class should be exported or imported. */ 1082 int (*import_export_class) (tree, int); 1083 /* Returns true if constructors and destructors return "this". */ 1084 bool (*cdtor_returns_this) (void); 1085 /* Returns true if the key method for a class can be an inline 1086 function, so long as it is not declared inline in the class 1087 itself. Returning true is the behavior required by the Itanium 1088 C++ ABI. */ 1089 bool (*key_method_may_be_inline) (void); 1090 /* DECL is a virtual table, virtual table table, typeinfo object, 1091 or other similar implicit class data object that will be 1092 emitted with external linkage in this translation unit. No ELF 1093 visibility has been explicitly specified. If the target needs 1094 to specify a visibility other than that of the containing class, 1095 use this hook to set DECL_VISIBILITY and 1096 DECL_VISIBILITY_SPECIFIED. */ 1097 void (*determine_class_data_visibility) (tree decl); 1098 /* Returns true (the default) if virtual tables and other 1099 similar implicit class data objects are always COMDAT if they 1100 have external linkage. If this hook returns false, then 1101 class data for classes whose virtual table will be emitted in 1102 only one translation unit will not be COMDAT. */ 1103 bool (*class_data_always_comdat) (void); 1104 /* Returns true (the default) if the RTTI for the basic types, 1105 which is always defined in the C++ runtime, should be COMDAT; 1106 false if it should not be COMDAT. */ 1107 bool (*library_rtti_comdat) (void); 1108 /* Returns true if __aeabi_atexit should be used to register static 1109 destructors. */ 1110 bool (*use_aeabi_atexit) (void); 1111 /* Returns true if target may use atexit in the same manner as 1112 __cxa_atexit to register static destructors. */ 1113 bool (*use_atexit_for_cxa_atexit) (void); 1114 /* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that 1115 has just been defined. Use this hook to make adjustments to the 1116 class (eg, tweak visibility or perform any other required 1117 target modifications). */ 1118 void (*adjust_class_at_definition) (tree type); 1119 } cxx; 1120 1121 /* Functions and data for emulated TLS support. */ 1122 struct emutls { 1123 /* Name of the address and common functions. */ 1124 const char *get_address; 1125 const char *register_common; 1126 1127 /* Prefixes for proxy variable and template. */ 1128 const char *var_section; 1129 const char *tmpl_section; 1130 1131 /* Prefixes for proxy variable and template. */ 1132 const char *var_prefix; 1133 const char *tmpl_prefix; 1134 1135 /* Function to generate field definitions of the proxy variable. */ 1136 tree (*var_fields) (tree, tree *); 1137 1138 /* Function to initialize a proxy variable. */ 1139 tree (*var_init) (tree, tree, tree); 1140 1141 /* Whether we are allowed to alter the usual alignment of the 1142 proxy variable. */ 1143 bool var_align_fixed; 1144 1145 /* Whether we can emit debug information for TLS vars. */ 1146 bool debug_form_tls_address; 1147 } emutls; 1148 1149 struct target_option_hooks { 1150 /* Function to validate the attribute((option(...))) strings or NULL. If 1151 the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will 1152 be filled in in the function decl node. */ 1153 bool (*valid_attribute_p) (tree, tree, tree, int); 1154 1155 /* Function to save any extra target state in the target options 1156 structure. */ 1157 void (*save) (struct cl_target_option *); 1158 1159 /* Function to restore any extra target state from the target options 1160 structure. */ 1161 void (*restore) (struct cl_target_option *); 1162 1163 /* Function to print any extra target state from the target options 1164 structure. */ 1165 void (*print) (FILE *, int, struct cl_target_option *); 1166 1167 /* Function to parse arguments to be validated for #pragma option, and to 1168 change the state if the options are valid. If the first argument is 1169 NULL, the second argument specifies the default options to use. Return 1170 true if the options are valid, and set the current state. */ 1171 bool (*pragma_parse) (tree, tree); 1172 1173 /* Function to determine if one function can inline another function. */ 1174 bool (*can_inline_p) (tree, tree); 1175 } target_option; 1176 1177 /* For targets that need to mark extra registers as live on entry to 1178 the function, they should define this target hook and set their 1179 bits in the bitmap passed in. */ 1180 void (*live_on_entry) (bitmap); 1181 1182 /* True if unwinding tables should be generated by default. */ 1183 bool unwind_tables_default; 1184 1185 /* Leave the boolean fields at the end. */ 1186 1187 /* True if arbitrary sections are supported. */ 1188 bool have_named_sections; 1189 1190 /* True if we can create zeroed data by switching to a BSS section 1191 and then using ASM_OUTPUT_SKIP to allocate the space. */ 1192 bool have_switchable_bss_sections; 1193 1194 /* True if "native" constructors and destructors are supported, 1195 false if we're using collect2 for the job. */ 1196 bool have_ctors_dtors; 1197 1198 /* True if thread-local storage is supported. */ 1199 bool have_tls; 1200 1201 /* True if a small readonly data section is supported. */ 1202 bool have_srodata_section; 1203 1204 /* True if EH frame info sections should be zero-terminated. */ 1205 bool terminate_dw2_eh_frame_info; 1206 1207 /* True if #NO_APP should be emitted at the beginning of 1208 assembly output. */ 1209 bool file_start_app_off; 1210 1211 /* True if output_file_directive should be called for main_input_filename 1212 at the beginning of assembly output. */ 1213 bool file_start_file_directive; 1214 1215 /* True if #pragma extern_prefix is to be supported. */ 1216 bool handle_pragma_extern_prefix; 1217 1218 /* True if the target is allowed to reorder memory accesses unless 1219 synchronization is explicitly requested. */ 1220 bool relaxed_ordering; 1221 1222 /* Returns true if we should generate exception tables for use with the 1223 ARM EABI. The effects the encoding of function exception specifications. 1224 */ 1225 bool arm_eabi_unwinder; 1226 1227 /* Leave the boolean fields at the end. */ 1228 }; 1229 1230 extern struct gcc_target targetm; 1231 1232 struct gcc_targetcm { 1233 /* Handle target switch CODE (an OPT_* value). ARG is the argument 1234 passed to the switch; it is NULL if no argument was. VALUE is the 1235 value of ARG if CODE specifies a UInteger option, otherwise it is 1236 1 if the positive form of the switch was used and 0 if the negative 1237 form was. Return true if the switch was valid. */ 1238 bool (*handle_c_option) (size_t code, const char *arg, int value); 1239 }; 1240 1241 /* Each target can provide their own. */ 1242 extern struct gcc_targetcm targetcm; 1243 1244 #endif /* GCC_TARGET_H */ 1245