1 /* The lang_hooks data structure. 2 Copyright (C) 2001-2022 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GCC is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_LANG_HOOKS_H 21 #define GCC_LANG_HOOKS_H 22 23 /* FIXME: This file should be #include-d after tree.h (for enum tree_code). */ 24 25 struct diagnostic_info; 26 27 struct gimplify_omp_ctx; 28 29 struct array_descr_info; 30 31 /* A print hook for print_tree (). */ 32 typedef void (*lang_print_tree_hook) (FILE *, tree, int indent); 33 34 enum classify_record 35 { RECORD_IS_STRUCT, RECORD_IS_CLASS, RECORD_IS_INTERFACE }; 36 37 class substring_loc; 38 39 /* The following hooks are documented in langhooks.cc. Must not be 40 NULL. */ 41 42 struct lang_hooks_for_tree_inlining 43 { 44 bool (*var_mod_type_p) (tree, tree); 45 }; 46 47 /* The following hooks are used by tree-dump.cc. */ 48 49 struct lang_hooks_for_tree_dump 50 { 51 /* Dump language-specific parts of tree nodes. Returns nonzero if it 52 does not want the usual dumping of the second argument. */ 53 bool (*dump_tree) (void *, tree); 54 55 /* Determine type qualifiers in a language-specific way. */ 56 int (*type_quals) (const_tree); 57 }; 58 59 /* Hooks related to types. */ 60 61 struct lang_hooks_for_types 62 { 63 /* Return a new type (with the indicated CODE), doing whatever 64 language-specific processing is required. */ 65 tree (*make_type) (enum tree_code); 66 67 /* Make an enum type with the given name and values, associating 68 them all with the given source location. */ 69 tree (*simulate_enum_decl) (location_t, const char *, vec<string_int_pair> *); 70 71 /* Do the equivalent of: 72 73 typedef struct NAME { FIELDS; } NAME; 74 75 associating it with location LOC. Return the associated RECORD_TYPE. 76 77 FIELDS is a list of FIELD_DECLs, in layout order. */ 78 tree (*simulate_record_decl) (location_t loc, const char *name, 79 array_slice<const tree> fields); 80 81 /* Return what kind of RECORD_TYPE this is, mainly for purposes of 82 debug information. If not defined, record types are assumed to 83 be structures. */ 84 enum classify_record (*classify_record) (tree); 85 86 /* Given MODE and UNSIGNEDP, return a suitable type-tree with that 87 mode. */ 88 tree (*type_for_mode) (machine_mode, int); 89 90 /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an 91 integer type with at least that precision. */ 92 tree (*type_for_size) (unsigned, int); 93 94 /* True if the type is an instantiation of a generic type, 95 e.g. C++ template implicit specializations. */ 96 bool (*generic_p) (const_tree); 97 98 /* Returns the TREE_VEC of elements of a given generic argument pack. */ 99 tree (*get_argument_pack_elems) (const_tree); 100 101 /* Given a type, apply default promotions to unnamed function 102 arguments and return the new type. Return the same type if no 103 change. Required by any language that supports variadic 104 arguments. The default hook dies. */ 105 tree (*type_promotes_to) (tree); 106 107 /* Register TYPE as a builtin type with the indicated NAME. The 108 TYPE is placed in the outermost lexical scope. The semantics 109 should be analogous to: 110 111 typedef TYPE NAME; 112 113 in C. The default hook ignores the declaration. */ 114 void (*register_builtin_type) (tree, const char *); 115 116 /* This routine is called in tree.cc to print an error message for 117 invalid use of an incomplete type. VALUE is the expression that 118 was used (or 0 if that isn't known) and TYPE is the type that was 119 invalid. LOC is the location of the use. */ 120 void (*incomplete_type_error) (location_t loc, const_tree value, 121 const_tree type); 122 123 /* Called from assign_temp to return the maximum size, if there is one, 124 for a type. */ 125 tree (*max_size) (const_tree); 126 127 /* Register language specific type size variables as potentially OpenMP 128 firstprivate variables. */ 129 void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree); 130 131 /* Return true if TYPE is a mappable type. */ 132 bool (*omp_mappable_type) (tree type); 133 134 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes. 135 Called only after doing all language independent checks. 136 At present, this function is only called when both TYPE1 and TYPE2 are 137 FUNCTION_TYPE or METHOD_TYPE. */ 138 bool (*type_hash_eq) (const_tree, const_tree); 139 140 /* If non-NULL, return TYPE1 with any language-specific modifiers copied from 141 TYPE2. */ 142 tree (*copy_lang_qualifiers) (const_tree, const_tree); 143 144 /* Return TRUE if TYPE uses a hidden descriptor and fills in information 145 for the debugger about the array bounds, strides, etc. */ 146 bool (*get_array_descr_info) (const_tree, struct array_descr_info *); 147 148 /* Fill in information for the debugger about the bounds of TYPE. */ 149 void (*get_subrange_bounds) (const_tree, tree *, tree *); 150 151 /* Called on INTEGER_TYPEs. Return NULL_TREE for non-biased types. For 152 biased types, return as an INTEGER_CST node the value that is represented 153 by a physical zero. */ 154 tree (*get_type_bias) (const_tree); 155 156 /* A type descriptive of TYPE's complex layout generated to help the 157 debugger to decode variable-length or self-referential constructs. 158 This is only used for the AT_GNAT_descriptive_type DWARF attribute. */ 159 tree (*descriptive_type) (const_tree); 160 161 /* If we requested a pointer to a vector, build up the pointers that 162 we stripped off while looking for the inner type. Similarly for 163 return values from functions. The argument TYPE is the top of the 164 chain, and BOTTOM is the new type which we will point to. */ 165 tree (*reconstruct_complex_type) (tree, tree); 166 167 /* Returns the tree that represents the underlying data type used to 168 implement the enumeration. The default implementation will just use 169 type_for_size. Used in dwarf2out.cc to add a DW_AT_type base type 170 reference to a DW_TAG_enumeration. */ 171 tree (*enum_underlying_base_type) (const_tree); 172 173 /* Return a type to use in the debug info instead of TYPE, or NULL_TREE to 174 keep TYPE. This is useful to keep a single "source type" when the 175 middle-end uses specialized types, for instance constrained discriminated 176 types in Ada. */ 177 tree (*get_debug_type) (const_tree); 178 179 /* Return TRUE if TYPE implements a fixed point type and fills in information 180 for the debugger about scale factor, etc. */ 181 bool (*get_fixed_point_type_info) (const_tree, 182 struct fixed_point_type_info *); 183 184 /* Returns -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute 185 value otherwise. */ 186 int (*type_dwarf_attribute) (const_tree, int); 187 188 /* Returns a tree for the unit size of T excluding tail padding that 189 might be used by objects inheriting from T. */ 190 tree (*unit_size_without_reusable_padding) (tree); 191 192 /* Returns type corresponding to FIELD's type when FIELD is a C++ base class 193 i.e., type without virtual base classes or tail padding. Returns 194 NULL_TREE otherwise. */ 195 tree (*classtype_as_base) (const_tree); 196 }; 197 198 /* Language hooks related to decls and the symbol table. */ 199 200 struct lang_hooks_for_decls 201 { 202 /* Return true if we are in the global binding level. This hook is really 203 needed only if the language supports variable-sized types at the global 204 level, i.e. declared outside subprograms. */ 205 bool (*global_bindings_p) (void); 206 207 /* Function to add a decl to the current scope level. Takes one 208 argument, a decl to add. Returns that decl, or, if the same 209 symbol is already declared, may return a different decl for that 210 name. */ 211 tree (*pushdecl) (tree); 212 213 /* Returns the chain of decls so far in the current scope level. */ 214 tree (*getdecls) (void); 215 216 /* Returns -1 if dwarf ATTR shouldn't be added for DECL, or the attribute 217 value otherwise. */ 218 int (*decl_dwarf_attribute) (const_tree, int); 219 220 /* Returns True if the parameter is a generic parameter decl 221 of a generic type, e.g a template template parameter for the C++ FE. */ 222 bool (*generic_generic_parameter_decl_p) (const_tree); 223 224 /* Determine if a function parameter got expanded from a 225 function parameter pack. */ 226 bool (*function_parm_expanded_from_pack_p) (tree, tree); 227 228 /* Returns the generic declaration of a generic function instantiations. */ 229 tree (*get_generic_function_decl) (const_tree); 230 231 /* Returns true when we should warn for an unused global DECL. 232 We will already have checked that it has static binding. */ 233 bool (*warn_unused_global) (const_tree); 234 235 /* Perform any post compilation-proper parser cleanups and 236 processing. This is currently only needed for the C++ parser, 237 which hopefully can be cleaned up so this hook is no longer 238 necessary. */ 239 void (*post_compilation_parsing_cleanups) (void); 240 241 /* True if this decl may be called via a sibcall. */ 242 bool (*ok_for_sibcall) (const_tree); 243 244 /* Return a tree for the actual data of an array descriptor - or NULL_TREE 245 if original tree is not an array descriptor. If the second argument 246 is true, only the TREE_TYPE is returned without generating a new tree. */ 247 tree (*omp_array_data) (tree, bool); 248 249 /* True if OpenMP should regard this DECL as being a scalar which has Fortran's 250 allocatable or pointer attribute. */ 251 bool (*omp_is_allocatable_or_ptr) (const_tree); 252 253 /* Check whether this DECL belongs to a Fortran optional argument. 254 With 'for_present_check' set to false, decls which are optional parameters 255 themselve are returned as tree - or a NULL_TREE otherwise. Those decls are 256 always pointers. With 'for_present_check' set to true, the decl for 257 checking whether an argument is present is returned; for arguments with 258 value attribute this is the hidden argument and of BOOLEAN_TYPE. If the 259 decl is unrelated to optional arguments, NULL_TREE is returned. */ 260 tree (*omp_check_optional_argument) (tree, bool); 261 262 /* True if OpenMP should privatize what this DECL points to rather 263 than the DECL itself. */ 264 bool (*omp_privatize_by_reference) (const_tree); 265 266 /* Return sharing kind if OpenMP sharing attribute of DECL is 267 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ 268 enum omp_clause_default_kind (*omp_predetermined_sharing) (tree); 269 270 /* Return mapping kind if OpenMP mapping attribute of DECL is 271 predetermined, OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED otherwise. */ 272 enum omp_clause_defaultmap_kind (*omp_predetermined_mapping) (tree); 273 274 /* Return decl that should be reported for DEFAULT(NONE) failure 275 diagnostics. Usually the DECL passed in. */ 276 tree (*omp_report_decl) (tree); 277 278 /* Return true if DECL's DECL_VALUE_EXPR (if any) should be 279 disregarded in OpenMP construct, because it is going to be 280 remapped during OpenMP lowering. SHARED is true if DECL 281 is going to be shared, false if it is going to be privatized. */ 282 bool (*omp_disregard_value_expr) (tree, bool); 283 284 /* Return true if DECL that is shared iff SHARED is true should 285 be put into OMP_CLAUSE_PRIVATE_DEBUG. */ 286 bool (*omp_private_debug_clause) (tree, bool); 287 288 /* Return true if DECL in private clause needs 289 OMP_CLAUSE_PRIVATE_OUTER_REF on the private clause. */ 290 bool (*omp_private_outer_ref) (tree); 291 292 /* Build and return code for a default constructor for DECL in 293 response to CLAUSE. OUTER is corresponding outer region's 294 variable if needed. Return NULL if nothing to be done. */ 295 tree (*omp_clause_default_ctor) (tree clause, tree decl, tree outer); 296 297 /* Build and return code for a copy constructor from SRC to DST. */ 298 tree (*omp_clause_copy_ctor) (tree clause, tree dst, tree src); 299 300 /* Similarly, except use an assignment operator instead. */ 301 tree (*omp_clause_assign_op) (tree clause, tree dst, tree src); 302 303 /* Build and return code for a constructor of DST that sets it to 304 SRC + ADD. */ 305 tree (*omp_clause_linear_ctor) (tree clause, tree dst, tree src, tree add); 306 307 /* Build and return code destructing DECL. Return NULL if nothing 308 to be done. */ 309 tree (*omp_clause_dtor) (tree clause, tree decl); 310 311 /* Do language specific checking on an implicitly determined clause. */ 312 void (*omp_finish_clause) (tree clause, gimple_seq *pre_p, bool); 313 314 /* Return true if DECL is an allocatable variable (for the purpose of 315 implicit mapping). */ 316 bool (*omp_allocatable_p) (tree decl); 317 318 /* Return true if DECL is a scalar variable (for the purpose of 319 implicit firstprivatization). If 'ptr_or', pointers and 320 allocatables are also permitted. */ 321 bool (*omp_scalar_p) (tree decl, bool ptr_ok); 322 323 /* Return true if DECL is a scalar variable with Fortran target but not 324 allocatable or pointer attribute (for the purpose of implicit mapping). */ 325 bool (*omp_scalar_target_p) (tree decl); 326 327 /* Return a pointer to the tree representing the initializer 328 expression for the non-local variable DECL. Return NULL if 329 DECL is not initialized. */ 330 tree *(*omp_get_decl_init) (tree decl); 331 332 /* Free any extra memory used to hold initializer information for 333 variable declarations. omp_get_decl_init must not be called 334 after calling this. */ 335 void (*omp_finish_decl_inits) (void); 336 }; 337 338 /* Language hooks related to LTO serialization. */ 339 340 struct lang_hooks_for_lto 341 { 342 /* Begin a new LTO section named NAME. */ 343 void (*begin_section) (const char *name); 344 345 /* Write DATA of length LEN to the currently open LTO section. BLOCK is a 346 pointer to the dynamically allocated memory containing DATA. The 347 append_data function is responsible for freeing it when it is no longer 348 needed. */ 349 void (*append_data) (const void *data, size_t len, void *block); 350 351 /* End the previously begun LTO section. */ 352 void (*end_section) (void); 353 }; 354 355 /* Language-specific hooks. See langhooks-def.h for defaults. */ 356 357 struct lang_hooks 358 { 359 /* String identifying the front end and optionally language standard 360 version, e.g. "GNU C++98". */ 361 const char *name; 362 363 /* sizeof (struct lang_identifier), so make_node () creates 364 identifier nodes long enough for the language-specific slots. */ 365 size_t identifier_size; 366 367 /* Remove any parts of the tree that are used only by the FE. */ 368 void (*free_lang_data) (tree); 369 370 /* Determines the size of any language-specific tcc_constant, 371 tcc_exceptional or tcc_type nodes. Since it is called from 372 make_node, the only information available is the tree code. 373 Expected to die on unrecognized codes. */ 374 size_t (*tree_size) (enum tree_code); 375 376 /* Return the language mask used for converting argv into a sequence 377 of options. */ 378 unsigned int (*option_lang_mask) (void); 379 380 /* Initialize variables in an options structure. */ 381 void (*init_options_struct) (struct gcc_options *opts); 382 383 /* After the initialize_diagnostics hook is called, do any simple 384 initialization needed before any calls to handle_option, other 385 than that done by the init_options_struct hook. */ 386 void (*init_options) (unsigned int decoded_options_count, 387 struct cl_decoded_option *decoded_options); 388 389 /* Callback used to perform language-specific initialization for the 390 global diagnostic context structure. */ 391 void (*initialize_diagnostics) (diagnostic_context *); 392 393 /* Beginning the main source file. */ 394 void (*preprocess_main_file) (cpp_reader *, line_maps *, 395 const line_map_ordinary *); 396 397 /* Adjust libcpp options and callbacks. */ 398 void (*preprocess_options) (cpp_reader *); 399 400 /* Undefining a macro. */ 401 void (*preprocess_undef) (cpp_reader *, location_t, cpp_hashnode *); 402 403 /* Observer for preprocessing stream. */ 404 uintptr_t (*preprocess_token) (cpp_reader *, const cpp_token *, uintptr_t); 405 /* Various flags it can return about the token. */ 406 enum PT_flags 407 { 408 PT_begin_pragma = 1 << 0 409 }; 410 411 /* Register language-specific dumps. */ 412 void (*register_dumps) (gcc::dump_manager *); 413 414 /* Return true if a warning should be given about option OPTION, 415 which is for the wrong language, false if it should be quietly 416 ignored. */ 417 bool (*complain_wrong_lang_p) (const struct cl_option *option); 418 419 /* Handle the switch CODE, which has real type enum opt_code from 420 options.h. If the switch takes an argument, it is passed in ARG 421 which points to permanent storage. The handler is responsible for 422 checking whether ARG is NULL, which indicates that no argument 423 was in fact supplied. For -f and -W switches, VALUE is 1 or 0 424 for the positive and negative forms respectively. HANDLERS should 425 be passed to any recursive handle_option calls. LOC is the 426 location of the option. 427 428 Return true if the switch is valid, false if invalid. */ 429 bool (*handle_option) (size_t code, const char *arg, HOST_WIDE_INT value, 430 int kind, location_t loc, 431 const struct cl_option_handlers *handlers); 432 433 /* Called when all command line options have been parsed to allow 434 further processing and initialization 435 436 Should return true to indicate that a compiler back-end is 437 not required, such as with the -E option. 438 439 If errorcount is nonzero after this call the compiler exits 440 immediately and the finish hook is not called. */ 441 bool (*post_options) (const char **); 442 443 /* Called after post_options to initialize the front end. Return 444 false to indicate that no further compilation be performed, in 445 which case the finish hook is called immediately. */ 446 bool (*init) (void); 447 448 /* Called at the end of compilation, as a finalizer. */ 449 void (*finish) (void); 450 451 /* Parses the entire file. */ 452 void (*parse_file) (void); 453 454 /* Determines if it's ok for a function to have no noreturn attribute. */ 455 bool (*missing_noreturn_ok_p) (tree); 456 457 /* Called to obtain the alias set to be used for an expression or type. 458 Returns -1 if the language does nothing special for it. */ 459 alias_set_type (*get_alias_set) (tree); 460 461 /* Function to finish handling an incomplete decl at the end of 462 compilation. Default hook is does nothing. */ 463 void (*finish_incomplete_decl) (tree); 464 465 /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the 466 DECL_NODE with a newly GC-allocated copy. */ 467 void (*dup_lang_specific_decl) (tree); 468 469 /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of 470 thing that the assembler should talk about, set 471 DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE. 472 Otherwise, set it to the ERROR_MARK_NODE to ensure that the 473 assembler does not talk about it. */ 474 void (*set_decl_assembler_name) (tree); 475 476 /* Overwrite the DECL_ASSEMBLER_NAME for a node. The name is being 477 changed (including to or from NULL_TREE). */ 478 void (*overwrite_decl_assembler_name) (tree, tree); 479 480 /* The front end can add its own statistics to -fmem-report with 481 this hook. It should output to stderr. */ 482 void (*print_statistics) (void); 483 484 /* Called by print_tree when there is a tree of class tcc_exceptional 485 or tcc_constant that it doesn't know how to display. */ 486 lang_print_tree_hook print_xnode; 487 488 /* Called to print language-dependent parts of tcc_decl, tcc_type, 489 and IDENTIFIER_NODE nodes. */ 490 lang_print_tree_hook print_decl; 491 lang_print_tree_hook print_type; 492 lang_print_tree_hook print_identifier; 493 494 /* Computes the name to use to print a declaration. DECL is the 495 non-NULL declaration in question. VERBOSITY determines what 496 information will be printed: 0: DECL_NAME, demangled as 497 necessary. 1: and scope information. 2: and any other 498 information that might be interesting, such as function parameter 499 types in C++. The name is in the internal character set and 500 needs to be converted to the locale character set of diagnostics, 501 or to the execution character set for strings such as 502 __PRETTY_FUNCTION__. */ 503 const char *(*decl_printable_name) (tree decl, int verbosity); 504 505 /* Computes the dwarf-2/3 name for a tree. VERBOSITY determines what 506 information will be printed: 0: DECL_NAME, demangled as 507 necessary. 1: and scope information. */ 508 const char *(*dwarf_name) (tree, int verbosity); 509 510 /* This compares two types for equivalence ("compatible" in C-based languages). 511 This routine should only return 1 if it is sure. It should not be used 512 in contexts where erroneously returning 0 causes problems. */ 513 int (*types_compatible_p) (tree x, tree y); 514 515 /* Called by report_error_function to print out function name. */ 516 void (*print_error_function) (diagnostic_context *, const char *, 517 struct diagnostic_info *); 518 519 /* Convert a character from the host's to the target's character 520 set. The character should be in what C calls the "basic source 521 character set" (roughly, the set of characters defined by plain 522 old ASCII). The default is to return the character unchanged, 523 which is correct in most circumstances. Note that both argument 524 and result should be sign-extended under -fsigned-char, 525 zero-extended under -fno-signed-char. */ 526 HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT); 527 528 /* Pointers to machine-independent attribute tables, for front ends 529 using attribs.cc. If one is NULL, it is ignored. Respectively, a 530 table of attributes specific to the language, a table of 531 attributes common to two or more languages (to allow easy 532 sharing), and a table of attributes for checking formats. */ 533 const struct attribute_spec *attribute_table; 534 const struct attribute_spec *common_attribute_table; 535 const struct attribute_spec *format_attribute_table; 536 537 struct lang_hooks_for_tree_inlining tree_inlining; 538 539 struct lang_hooks_for_tree_dump tree_dump; 540 541 struct lang_hooks_for_decls decls; 542 543 struct lang_hooks_for_types types; 544 545 struct lang_hooks_for_lto lto; 546 547 /* Returns a TREE_VEC of the generic parameters of an instantiation of 548 a generic type or decl, e.g. C++ template instantiation. If 549 TREE_CHAIN of the return value is set, it is an INTEGER_CST 550 indicating how many of the elements are non-default. */ 551 tree (*get_innermost_generic_parms) (const_tree); 552 553 /* Returns the TREE_VEC of arguments of an instantiation 554 of a generic type of decl, e.g. C++ template instantiation. */ 555 tree (*get_innermost_generic_args) (const_tree); 556 557 /* Determine if a tree is a function parameter pack. */ 558 bool (*function_parameter_pack_p) (const_tree); 559 560 /* Perform language-specific gimplification on the argument. Returns an 561 enum gimplify_status, though we can't see that type here. */ 562 int (*gimplify_expr) (tree *, gimple_seq *, gimple_seq *); 563 564 /* Do language specific processing in the builtin function DECL */ 565 tree (*builtin_function) (tree decl); 566 567 /* Like builtin_function, but make sure the scope is the external scope. 568 This is used to delay putting in back end builtin functions until the ISA 569 that defines the builtin is declared via function specific target options, 570 which can save memory for machines like the x86_64 that have multiple 571 ISAs. If this points to the same function as builtin_function, the 572 backend must add all of the builtins at program initialization time. */ 573 tree (*builtin_function_ext_scope) (tree decl); 574 575 /* Do language-specific processing for target-specific built-in 576 function DECL, so that it is defined in the global scope (only) 577 and is available without needing to be explicitly declared. 578 579 This is intended for targets that want to inject declarations of 580 built-in functions into the source language (such as in response 581 to a pragma) rather than providing them in the source language itself. */ 582 tree (*simulate_builtin_function_decl) (tree decl); 583 584 /* Used to set up the tree_contains_structure array for a frontend. */ 585 void (*init_ts) (void); 586 587 /* Called by recompute_tree_invariant_for_addr_expr to go from EXPR 588 to a contained expression or DECL, possibly updating *TC or *SE 589 if in the process TREE_CONSTANT or TREE_SIDE_EFFECTS need updating. */ 590 tree (*expr_to_decl) (tree expr, bool *tc, bool *se); 591 592 /* The EH personality function decl. */ 593 tree (*eh_personality) (void); 594 595 /* Map a type to a runtime object to match type. */ 596 tree (*eh_runtime_type) (tree); 597 598 /* If non-NULL, this is a function that returns a function decl to be 599 executed if an unhandled exception is propagated out of a cleanup 600 region. For example, in C++, an exception thrown by a destructor 601 during stack unwinding is required to result in a call to 602 `std::terminate', so the C++ version of this function returns a 603 FUNCTION_DECL for `std::terminate'. */ 604 tree (*eh_protect_cleanup_actions) (void); 605 606 /* Return true if a stmt can fallthru. Used by block_may_fallthru 607 to possibly handle language trees. */ 608 bool (*block_may_fallthru) (const_tree); 609 610 /* True if this language uses __cxa_end_cleanup when the ARM EABI 611 is enabled. */ 612 bool eh_use_cxa_end_cleanup; 613 614 /* True if this language requires deep unsharing of tree nodes prior to 615 gimplification. */ 616 bool deep_unsharing; 617 618 /* True if this language may use custom descriptors for nested functions 619 instead of trampolines. */ 620 bool custom_function_descriptors; 621 622 /* True if this language emits begin stmt notes. */ 623 bool emits_begin_stmt; 624 625 /* Run all lang-specific selftests. */ 626 void (*run_lang_selftests) (void); 627 628 /* Attempt to determine the source location of the substring. 629 If successful, return NULL and write the source location to *OUT_LOC. 630 Otherwise return an error message. Error messages are intended 631 for GCC developers (to help debugging) rather than for end-users. */ 632 const char *(*get_substring_location) (const substring_loc &, 633 location_t *out_loc); 634 635 /* Invoked before the early_finish debug hook is invoked. */ 636 void (*finalize_early_debug) (void); 637 638 /* Whenever you add entries here, make sure you adjust langhooks-def.h 639 and langhooks.cc accordingly. */ 640 }; 641 642 /* Each front end provides its own. */ 643 extern struct lang_hooks lang_hooks; 644 645 extern tree add_builtin_function (const char *name, tree type, 646 int function_code, enum built_in_class cl, 647 const char *library_name, 648 tree attrs); 649 650 extern tree add_builtin_function_ext_scope (const char *name, tree type, 651 int function_code, 652 enum built_in_class cl, 653 const char *library_name, 654 tree attrs); 655 extern tree simulate_builtin_function_decl (location_t, const char *, tree, 656 int, const char *, tree); 657 extern tree add_builtin_type (const char *name, tree type); 658 659 /* Language helper functions. */ 660 661 extern bool lang_GNU_C (void); 662 extern bool lang_GNU_CXX (void); 663 extern bool lang_GNU_Fortran (void); 664 extern bool lang_GNU_OBJC (void); 665 666 #endif /* GCC_LANG_HOOKS_H */ 667