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