1 /* The lang_hooks data structure. 2 Copyright (C) 2001-2015 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 /* The following hooks are documented in langhooks.c. Must not be 38 NULL. */ 39 40 struct lang_hooks_for_tree_inlining 41 { 42 bool (*var_mod_type_p) (tree, tree); 43 }; 44 45 /* The following hooks are used by tree-dump.c. */ 46 47 struct lang_hooks_for_tree_dump 48 { 49 /* Dump language-specific parts of tree nodes. Returns nonzero if it 50 does not want the usual dumping of the second argument. */ 51 bool (*dump_tree) (void *, tree); 52 53 /* Determine type qualifiers in a language-specific way. */ 54 int (*type_quals) (const_tree); 55 }; 56 57 /* Hooks related to types. */ 58 59 struct lang_hooks_for_types 60 { 61 /* Return a new type (with the indicated CODE), doing whatever 62 language-specific processing is required. */ 63 tree (*make_type) (enum tree_code); 64 65 /* Return what kind of RECORD_TYPE this is, mainly for purposes of 66 debug information. If not defined, record types are assumed to 67 be structures. */ 68 enum classify_record (*classify_record) (tree); 69 70 /* Given MODE and UNSIGNEDP, return a suitable type-tree with that 71 mode. */ 72 tree (*type_for_mode) (machine_mode, int); 73 74 /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an 75 integer type with at least that precision. */ 76 tree (*type_for_size) (unsigned, int); 77 78 /* True if the type is an instantiation of a generic type, 79 e.g. C++ template implicit specializations. */ 80 bool (*generic_p) (const_tree); 81 82 /* Returns the TREE_VEC of elements of a given generic argument pack. */ 83 tree (*get_argument_pack_elems) (const_tree); 84 85 /* Given a type, apply default promotions to unnamed function 86 arguments and return the new type. Return the same type if no 87 change. Required by any language that supports variadic 88 arguments. The default hook dies. */ 89 tree (*type_promotes_to) (tree); 90 91 /* Register TYPE as a builtin type with the indicated NAME. The 92 TYPE is placed in the outermost lexical scope. The semantics 93 should be analogous to: 94 95 typedef TYPE NAME; 96 97 in C. The default hook ignores the declaration. */ 98 void (*register_builtin_type) (tree, const char *); 99 100 /* This routine is called in tree.c to print an error message for 101 invalid use of an incomplete type. VALUE is the expression that 102 was used (or 0 if that isn't known) and TYPE is the type that was 103 invalid. */ 104 void (*incomplete_type_error) (const_tree value, const_tree type); 105 106 /* Called from assign_temp to return the maximum size, if there is one, 107 for a type. */ 108 tree (*max_size) (const_tree); 109 110 /* Register language specific type size variables as potentially OpenMP 111 firstprivate variables. */ 112 void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree); 113 114 /* Return true if TYPE is a mappable type. */ 115 bool (*omp_mappable_type) (tree type); 116 117 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes. 118 Called only after doing all language independent checks. 119 At present, this function is only called when both TYPE1 and TYPE2 are 120 FUNCTION_TYPEs. */ 121 bool (*type_hash_eq) (const_tree, const_tree); 122 123 /* Return TRUE if TYPE uses a hidden descriptor and fills in information 124 for the debugger about the array bounds, strides, etc. */ 125 bool (*get_array_descr_info) (const_tree, struct array_descr_info *); 126 127 /* Fill in information for the debugger about the bounds of TYPE. */ 128 void (*get_subrange_bounds) (const_tree, tree *, tree *); 129 130 /* A type descriptive of TYPE's complex layout generated to help the 131 debugger to decode variable-length or self-referential constructs. 132 This is only used for the AT_GNAT_descriptive_type DWARF attribute. */ 133 tree (*descriptive_type) (const_tree); 134 135 /* If we requested a pointer to a vector, build up the pointers that 136 we stripped off while looking for the inner type. Similarly for 137 return values from functions. The argument TYPE is the top of the 138 chain, and BOTTOM is the new type which we will point to. */ 139 tree (*reconstruct_complex_type) (tree, tree); 140 141 /* Returns the tree that represents the underlying data type used to 142 implement the enumeration. The default implementation will just use 143 type_for_size. Used in dwarf2out.c to add a DW_AT_type base type 144 reference to a DW_TAG_enumeration. */ 145 tree (*enum_underlying_base_type) (const_tree); 146 }; 147 148 /* Language hooks related to decls and the symbol table. */ 149 150 struct lang_hooks_for_decls 151 { 152 /* Return true if we are in the global binding level. This hook is really 153 needed only if the language supports variable-sized types at the global 154 level, i.e. declared outside subprograms. */ 155 bool (*global_bindings_p) (void); 156 157 /* Function to add a decl to the current scope level. Takes one 158 argument, a decl to add. Returns that decl, or, if the same 159 symbol is already declared, may return a different decl for that 160 name. */ 161 tree (*pushdecl) (tree); 162 163 /* Returns the chain of decls so far in the current scope level. */ 164 tree (*getdecls) (void); 165 166 /* Returns true if DECL is explicit member function. */ 167 bool (*function_decl_explicit_p) (tree); 168 169 /* Returns true if DECL is C++11 deleted special member function. */ 170 bool (*function_decl_deleted_p) (tree); 171 172 /* Returns True if the parameter is a generic parameter decl 173 of a generic type, e.g a template template parameter for the C++ FE. */ 174 bool (*generic_generic_parameter_decl_p) (const_tree); 175 176 /* Determine if a function parameter got expanded from a 177 function parameter pack. */ 178 bool (*function_parm_expanded_from_pack_p) (tree, tree); 179 180 /* Returns the generic declaration of a generic function instantiations. */ 181 tree (*get_generic_function_decl) (const_tree); 182 183 /* Returns true when we should warn for an unused global DECL. 184 We will already have checked that it has static binding. */ 185 bool (*warn_unused_global) (const_tree); 186 187 /* Obtain a list of globals and do final output on them at end 188 of compilation */ 189 void (*final_write_globals) (void); 190 191 /* True if this decl may be called via a sibcall. */ 192 bool (*ok_for_sibcall) (const_tree); 193 194 /* True if OpenMP should privatize what this DECL points to rather 195 than the DECL itself. */ 196 bool (*omp_privatize_by_reference) (const_tree); 197 198 /* Return sharing kind if OpenMP sharing attribute of DECL is 199 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ 200 enum omp_clause_default_kind (*omp_predetermined_sharing) (tree); 201 202 /* Return decl that should be reported for DEFAULT(NONE) failure 203 diagnostics. Usually the DECL passed in. */ 204 tree (*omp_report_decl) (tree); 205 206 /* Return true if DECL's DECL_VALUE_EXPR (if any) should be 207 disregarded in OpenMP construct, because it is going to be 208 remapped during OpenMP lowering. SHARED is true if DECL 209 is going to be shared, false if it is going to be privatized. */ 210 bool (*omp_disregard_value_expr) (tree, bool); 211 212 /* Return true if DECL that is shared iff SHARED is true should 213 be put into OMP_CLAUSE_PRIVATE_DEBUG. */ 214 bool (*omp_private_debug_clause) (tree, bool); 215 216 /* Return true if DECL in private clause needs 217 OMP_CLAUSE_PRIVATE_OUTER_REF on the private clause. */ 218 bool (*omp_private_outer_ref) (tree); 219 220 /* Build and return code for a default constructor for DECL in 221 response to CLAUSE. OUTER is corresponding outer region's 222 variable if needed. Return NULL if nothing to be done. */ 223 tree (*omp_clause_default_ctor) (tree clause, tree decl, tree outer); 224 225 /* Build and return code for a copy constructor from SRC to DST. */ 226 tree (*omp_clause_copy_ctor) (tree clause, tree dst, tree src); 227 228 /* Similarly, except use an assignment operator instead. */ 229 tree (*omp_clause_assign_op) (tree clause, tree dst, tree src); 230 231 /* Build and return code for a constructor of DST that sets it to 232 SRC + ADD. */ 233 tree (*omp_clause_linear_ctor) (tree clause, tree dst, tree src, tree add); 234 235 /* Build and return code destructing DECL. Return NULL if nothing 236 to be done. */ 237 tree (*omp_clause_dtor) (tree clause, tree decl); 238 239 /* Do language specific checking on an implicitly determined clause. */ 240 void (*omp_finish_clause) (tree clause, gimple_seq *pre_p); 241 }; 242 243 /* Language hooks related to LTO serialization. */ 244 245 struct lang_hooks_for_lto 246 { 247 /* Begin a new LTO section named NAME. */ 248 void (*begin_section) (const char *name); 249 250 /* Write DATA of length LEN to the currently open LTO section. BLOCK is a 251 pointer to the dynamically allocated memory containing DATA. The 252 append_data function is responsible for freeing it when it is no longer 253 needed. */ 254 void (*append_data) (const void *data, size_t len, void *block); 255 256 /* End the previously begun LTO section. */ 257 void (*end_section) (void); 258 }; 259 260 /* Language-specific hooks. See langhooks-def.h for defaults. */ 261 262 struct lang_hooks 263 { 264 /* String identifying the front end and optionally language standard 265 version, e.g. "GNU C++98" or "GNU Java". */ 266 const char *name; 267 268 /* sizeof (struct lang_identifier), so make_node () creates 269 identifier nodes long enough for the language-specific slots. */ 270 size_t identifier_size; 271 272 /* Remove any parts of the tree that are used only by the FE. */ 273 void (*free_lang_data) (tree); 274 275 /* Determines the size of any language-specific tcc_constant or 276 tcc_exceptional nodes. Since it is called from make_node, the 277 only information available is the tree code. Expected to die 278 on unrecognized codes. */ 279 size_t (*tree_size) (enum tree_code); 280 281 /* Return the language mask used for converting argv into a sequence 282 of options. */ 283 unsigned int (*option_lang_mask) (void); 284 285 /* Initialize variables in an options structure. */ 286 void (*init_options_struct) (struct gcc_options *opts); 287 288 /* After the initialize_diagnostics hook is called, do any simple 289 initialization needed before any calls to handle_option, other 290 than that done by the init_options_struct hook. */ 291 void (*init_options) (unsigned int decoded_options_count, 292 struct cl_decoded_option *decoded_options); 293 294 /* Callback used to perform language-specific initialization for the 295 global diagnostic context structure. */ 296 void (*initialize_diagnostics) (diagnostic_context *); 297 298 /* Return true if a warning should be given about option OPTION, 299 which is for the wrong language, false if it should be quietly 300 ignored. */ 301 bool (*complain_wrong_lang_p) (const struct cl_option *option); 302 303 /* Handle the switch CODE, which has real type enum opt_code from 304 options.h. If the switch takes an argument, it is passed in ARG 305 which points to permanent storage. The handler is responsible for 306 checking whether ARG is NULL, which indicates that no argument 307 was in fact supplied. For -f and -W switches, VALUE is 1 or 0 308 for the positive and negative forms respectively. HANDLERS should 309 be passed to any recursive handle_option calls. LOC is the 310 location of the option. 311 312 Return true if the switch is valid, false if invalid. */ 313 bool (*handle_option) (size_t code, const char *arg, int value, int kind, 314 location_t loc, 315 const struct cl_option_handlers *handlers); 316 317 /* Called when all command line options have been parsed to allow 318 further processing and initialization 319 320 Should return true to indicate that a compiler back-end is 321 not required, such as with the -E option. 322 323 If errorcount is nonzero after this call the compiler exits 324 immediately and the finish hook is not called. */ 325 bool (*post_options) (const char **); 326 327 /* Called after post_options to initialize the front end. Return 328 false to indicate that no further compilation be performed, in 329 which case the finish hook is called immediately. */ 330 bool (*init) (void); 331 332 /* Called at the end of compilation, as a finalizer. */ 333 void (*finish) (void); 334 335 /* Parses the entire file. */ 336 void (*parse_file) (void); 337 338 /* Determines if it's ok for a function to have no noreturn attribute. */ 339 bool (*missing_noreturn_ok_p) (tree); 340 341 /* Called to obtain the alias set to be used for an expression or type. 342 Returns -1 if the language does nothing special for it. */ 343 alias_set_type (*get_alias_set) (tree); 344 345 /* Function to finish handling an incomplete decl at the end of 346 compilation. Default hook is does nothing. */ 347 void (*finish_incomplete_decl) (tree); 348 349 /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the 350 DECL_NODE with a newly GC-allocated copy. */ 351 void (*dup_lang_specific_decl) (tree); 352 353 /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of 354 thing that the assembler should talk about, set 355 DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE. 356 Otherwise, set it to the ERROR_MARK_NODE to ensure that the 357 assembler does not talk about it. */ 358 void (*set_decl_assembler_name) (tree); 359 360 /* The front end can add its own statistics to -fmem-report with 361 this hook. It should output to stderr. */ 362 void (*print_statistics) (void); 363 364 /* Called by print_tree when there is a tree of class tcc_exceptional 365 that it doesn't know how to display. */ 366 lang_print_tree_hook print_xnode; 367 368 /* Called to print language-dependent parts of tcc_decl, tcc_type, 369 and IDENTIFIER_NODE nodes. */ 370 lang_print_tree_hook print_decl; 371 lang_print_tree_hook print_type; 372 lang_print_tree_hook print_identifier; 373 374 /* Computes the name to use to print a declaration. DECL is the 375 non-NULL declaration in question. VERBOSITY determines what 376 information will be printed: 0: DECL_NAME, demangled as 377 necessary. 1: and scope information. 2: and any other 378 information that might be interesting, such as function parameter 379 types in C++. The name is in the internal character set and 380 needs to be converted to the locale character set of diagnostics, 381 or to the execution character set for strings such as 382 __PRETTY_FUNCTION__. */ 383 const char *(*decl_printable_name) (tree decl, int verbosity); 384 385 /* Computes the dwarf-2/3 name for a tree. VERBOSITY determines what 386 information will be printed: 0: DECL_NAME, demangled as 387 necessary. 1: and scope information. */ 388 const char *(*dwarf_name) (tree, int verbosity); 389 390 /* This compares two types for equivalence ("compatible" in C-based languages). 391 This routine should only return 1 if it is sure. It should not be used 392 in contexts where erroneously returning 0 causes problems. */ 393 int (*types_compatible_p) (tree x, tree y); 394 395 /* Called by report_error_function to print out function name. */ 396 void (*print_error_function) (diagnostic_context *, const char *, 397 struct diagnostic_info *); 398 399 /* Convert a character from the host's to the target's character 400 set. The character should be in what C calls the "basic source 401 character set" (roughly, the set of characters defined by plain 402 old ASCII). The default is to return the character unchanged, 403 which is correct in most circumstances. Note that both argument 404 and result should be sign-extended under -fsigned-char, 405 zero-extended under -fno-signed-char. */ 406 HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT); 407 408 /* Pointers to machine-independent attribute tables, for front ends 409 using attribs.c. If one is NULL, it is ignored. Respectively, a 410 table of attributes specific to the language, a table of 411 attributes common to two or more languages (to allow easy 412 sharing), and a table of attributes for checking formats. */ 413 const struct attribute_spec *attribute_table; 414 const struct attribute_spec *common_attribute_table; 415 const struct attribute_spec *format_attribute_table; 416 417 struct lang_hooks_for_tree_inlining tree_inlining; 418 419 struct lang_hooks_for_tree_dump tree_dump; 420 421 struct lang_hooks_for_decls decls; 422 423 struct lang_hooks_for_types types; 424 425 struct lang_hooks_for_lto lto; 426 427 /* Returns a TREE_VEC of the generic parameters of an instantiation of 428 a generic type or decl, e.g. C++ template instantiation. If 429 TREE_CHAIN of the return value is set, it is an INTEGER_CST 430 indicating how many of the elements are non-default. */ 431 tree (*get_innermost_generic_parms) (const_tree); 432 433 /* Returns the TREE_VEC of arguments of an instantiation 434 of a generic type of decl, e.g. C++ template instantiation. */ 435 tree (*get_innermost_generic_args) (const_tree); 436 437 /* Determine if a tree is a function parameter pack. */ 438 bool (*function_parameter_pack_p) (const_tree); 439 440 /* Perform language-specific gimplification on the argument. Returns an 441 enum gimplify_status, though we can't see that type here. */ 442 int (*gimplify_expr) (tree *, gimple_seq *, gimple_seq *); 443 444 /* Do language specific processing in the builtin function DECL */ 445 tree (*builtin_function) (tree decl); 446 447 /* Like builtin_function, but make sure the scope is the external scope. 448 This is used to delay putting in back end builtin functions until the ISA 449 that defines the builtin is declared via function specific target options, 450 which can save memory for machines like the x86_64 that have multiple 451 ISAs. If this points to the same function as builtin_function, the 452 backend must add all of the builtins at program initialization time. */ 453 tree (*builtin_function_ext_scope) (tree decl); 454 455 /* Used to set up the tree_contains_structure array for a frontend. */ 456 void (*init_ts) (void); 457 458 /* Called by recompute_tree_invariant_for_addr_expr to go from EXPR 459 to a contained expression or DECL, possibly updating *TC or *SE 460 if in the process TREE_CONSTANT or TREE_SIDE_EFFECTS need updating. */ 461 tree (*expr_to_decl) (tree expr, bool *tc, bool *se); 462 463 /* The EH personality function decl. */ 464 tree (*eh_personality) (void); 465 466 /* Map a type to a runtime object to match type. */ 467 tree (*eh_runtime_type) (tree); 468 469 /* If non-NULL, this is a function that returns a function decl to be 470 executed if an unhandled exception is propagated out of a cleanup 471 region. For example, in C++, an exception thrown by a destructor 472 during stack unwinding is required to result in a call to 473 `std::terminate', so the C++ version of this function returns a 474 FUNCTION_DECL for `std::terminate'. */ 475 tree (*eh_protect_cleanup_actions) (void); 476 477 /* Return true if a stmt can fallthru. Used by block_may_fallthru 478 to possibly handle language trees. */ 479 bool (*block_may_fallthru) (const_tree); 480 481 /* True if this language uses __cxa_end_cleanup when the ARM EABI 482 is enabled. */ 483 bool eh_use_cxa_end_cleanup; 484 485 /* True if this language requires deep unsharing of tree nodes prior to 486 gimplification. */ 487 bool deep_unsharing; 488 489 /* Whenever you add entries here, make sure you adjust langhooks-def.h 490 and langhooks.c accordingly. */ 491 }; 492 493 /* Each front end provides its own. */ 494 extern struct lang_hooks lang_hooks; 495 496 extern tree add_builtin_function (const char *name, tree type, 497 int function_code, enum built_in_class cl, 498 const char *library_name, 499 tree attrs); 500 501 extern tree add_builtin_function_ext_scope (const char *name, tree type, 502 int function_code, 503 enum built_in_class cl, 504 const char *library_name, 505 tree attrs); 506 extern tree add_builtin_type (const char *name, tree type); 507 508 /* Language helper functions. */ 509 510 extern bool lang_GNU_C (void); 511 extern bool lang_GNU_CXX (void); 512 extern bool lang_GNU_Fortran (void); 513 514 #endif /* GCC_LANG_HOOKS_H */ 515