1/* Default language-specific hooks. 2 Copyright (C) 2001-2020 Free Software Foundation, Inc. 3 Contributed by Alexandre Oliva <aoliva@redhat.com> 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#include "config.h" 22#include "system.h" 23#include "coretypes.h" 24#include "target.h" 25#include "rtl.h" 26#include "tree.h" 27#include "timevar.h" 28#include "stringpool.h" 29#include "diagnostic.h" 30#include "intl.h" 31#include "toplev.h" 32#include "attribs.h" 33#include "gimplify.h" 34#include "langhooks.h" 35#include "tree-diagnostic.h" 36#include "output.h" 37#include "timevar.h" 38#include "stor-layout.h" 39 40/* Do nothing; in many cases the default hook. */ 41 42void 43lhd_do_nothing (void) 44{ 45} 46 47/* Do nothing (tree). */ 48 49void 50lhd_do_nothing_t (tree ARG_UNUSED (t)) 51{ 52} 53 54/* Pass through (tree). */ 55tree 56lhd_pass_through_t (tree t) 57{ 58 return t; 59} 60 61/* Do nothing (int, int, int). Return NULL_TREE. */ 62 63tree 64lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), 65 int ARG_UNUSED (j), 66 int ARG_UNUSED (k)) 67{ 68 return NULL_TREE; 69} 70 71/* Do nothing (function). */ 72 73void 74lhd_do_nothing_f (struct function * ARG_UNUSED (f)) 75{ 76} 77 78/* Do nothing (return NULL_TREE). */ 79 80tree 81lhd_return_null_tree (tree ARG_UNUSED (t)) 82{ 83 return NULL_TREE; 84} 85 86/* Do nothing (return NULL_TREE). */ 87 88tree 89lhd_return_null_const_tree (const_tree ARG_UNUSED (t)) 90{ 91 return NULL_TREE; 92} 93 94/* The default post options hook. */ 95 96bool 97lhd_post_options (const char ** ARG_UNUSED (pfilename)) 98{ 99 /* Excess precision other than "fast" requires front-end 100 support. */ 101 flag_excess_precision = EXCESS_PRECISION_FAST; 102 return false; 103} 104 105/* Called from by print-tree.c. */ 106 107void 108lhd_print_tree_nothing (FILE * ARG_UNUSED (file), 109 tree ARG_UNUSED (node), 110 int ARG_UNUSED (indent)) 111{ 112} 113 114/* Called from check_global_declaration. */ 115 116bool 117lhd_warn_unused_global_decl (const_tree decl) 118{ 119 /* This is what used to exist in check_global_declaration. Probably 120 not many of these actually apply to non-C languages. */ 121 122 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) 123 return false; 124 if (VAR_P (decl) && TREE_READONLY (decl)) 125 return false; 126 if (DECL_IN_SYSTEM_HEADER (decl)) 127 return false; 128 129 return true; 130} 131 132/* Set the DECL_ASSEMBLER_NAME for DECL. */ 133void 134lhd_set_decl_assembler_name (tree decl) 135{ 136 tree id; 137 138 /* set_decl_assembler_name may be called on TYPE_DECL to record ODR 139 name for C++ types. By default types have no ODR names. */ 140 if (TREE_CODE (decl) == TYPE_DECL) 141 return; 142 143 /* The language-independent code should never use the 144 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and 145 VAR_DECLs for variables with static storage duration need a real 146 DECL_ASSEMBLER_NAME. */ 147 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL 148 || (VAR_P (decl) 149 && (TREE_STATIC (decl) 150 || DECL_EXTERNAL (decl) 151 || TREE_PUBLIC (decl)))); 152 153 /* By default, assume the name to use in assembly code is the same 154 as that used in the source language. (That's correct for C, and 155 GCC used to set DECL_ASSEMBLER_NAME to the same value as 156 DECL_NAME in build_decl, so this choice provides backwards 157 compatibility with existing front-ends. This assumption is wrapped 158 in a target hook, to allow for target-specific modification of the 159 identifier. 160 161 Can't use just the variable's own name for a variable whose scope 162 is less than the whole compilation. Concatenate a distinguishing 163 number. */ 164 165 if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl)) 166 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl)); 167 else 168 { 169 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); 170 static unsigned long num; 171 char *label; 172 173 ASM_FORMAT_PRIVATE_NAME (label, name, num++); 174 id = get_identifier (label); 175 } 176 177 SET_DECL_ASSEMBLER_NAME (decl, id); 178} 179 180/* Forcibly overwrite the DECL_ASSEMBLER_NAME for DECL to NAME. */ 181void 182lhd_overwrite_decl_assembler_name (tree decl, tree name) 183{ 184 DECL_ASSEMBLER_NAME_RAW (decl) = name; 185} 186 187/* Type promotion for variable arguments. */ 188tree 189lhd_type_promotes_to (tree ARG_UNUSED (type)) 190{ 191 gcc_unreachable (); 192} 193 194/* Registration of machine- or os-specific builtin types. */ 195void 196lhd_register_builtin_type (tree ARG_UNUSED (type), 197 const char * ARG_UNUSED (name)) 198{ 199} 200 201/* Invalid use of an incomplete type. */ 202void 203lhd_incomplete_type_error (location_t ARG_UNUSED (loc), 204 const_tree ARG_UNUSED (value), const_tree type) 205{ 206 gcc_assert (TREE_CODE (type) == ERROR_MARK); 207 return; 208} 209 210/* Provide a default routine for alias sets that always returns -1. This 211 is used by languages that don't need to do anything special. */ 212 213alias_set_type 214lhd_get_alias_set (tree ARG_UNUSED (t)) 215{ 216 return -1; 217} 218 219/* This is the default decl_printable_name function. */ 220 221const char * 222lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) 223{ 224 gcc_assert (decl && DECL_NAME (decl)); 225 return IDENTIFIER_POINTER (DECL_NAME (decl)); 226} 227 228/* This is the default dwarf_name function. */ 229 230const char * 231lhd_dwarf_name (tree t, int verbosity) 232{ 233 gcc_assert (DECL_P (t)); 234 235 return lang_hooks.decl_printable_name (t, verbosity); 236} 237 238/* This compares two types for equivalence ("compatible" in C-based languages). 239 This routine should only return 1 if it is sure. It should not be used 240 in contexts where erroneously returning 0 causes problems. */ 241 242int 243lhd_types_compatible_p (tree x, tree y) 244{ 245 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); 246} 247 248/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree 249 nodes. Returns nonzero if it does not want the usual dumping of the 250 second argument. */ 251 252bool 253lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) 254{ 255 return false; 256} 257 258/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a 259 language-specific way. */ 260 261int 262lhd_tree_dump_type_quals (const_tree t) 263{ 264 return TYPE_QUALS (t); 265} 266 267/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ 268 269int 270lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, 271 gimple_seq *pre_p ATTRIBUTE_UNUSED, 272 gimple_seq *post_p ATTRIBUTE_UNUSED) 273{ 274 return GS_UNHANDLED; 275} 276 277/* lang_hooks.tree_size: Determine the size of a tree with code C, 278 which is a language-specific tree code in category tcc_constant, 279 tcc_exceptional or tcc_type. The default expects never to be called. */ 280size_t 281lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) 282{ 283 gcc_unreachable (); 284} 285 286/* Return true if decl, which is a function decl, may be called by a 287 sibcall. */ 288 289bool 290lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED) 291{ 292 return true; 293} 294 295/* Generic global declaration processing. This is meant to be called 296 by the front-ends at the end of parsing. C/C++ do their own thing, 297 but other front-ends may call this. */ 298 299void 300global_decl_processing (void) 301{ 302 tree globals, decl, *vec; 303 int len, i; 304 305 timevar_stop (TV_PHASE_PARSING); 306 timevar_start (TV_PHASE_DEFERRED); 307 /* Really define vars that have had only a tentative definition. 308 Really output inline functions that must actually be callable 309 and have not been output so far. */ 310 311 globals = lang_hooks.decls.getdecls (); 312 len = list_length (globals); 313 vec = XNEWVEC (tree, len); 314 315 /* Process the decls in reverse order--earliest first. 316 Put them into VEC from back to front, then take out from front. */ 317 318 for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl)) 319 vec[len - i - 1] = decl; 320 321 wrapup_global_declarations (vec, len); 322 timevar_stop (TV_PHASE_DEFERRED); 323 324 timevar_start (TV_PHASE_PARSING); 325 free (vec); 326} 327 328/* Called to perform language-specific initialization of CTX. */ 329void 330lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED) 331{ 332} 333 334/* Called to register dumps. */ 335void 336lhd_register_dumps (gcc::dump_manager *) 337{ 338} 339 340/* Called to perform language-specific options initialization. */ 341void 342lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED, 343 struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED) 344{ 345} 346 347/* By default, always complain about options for the wrong language. */ 348bool 349lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED) 350{ 351 return true; 352} 353 354/* By default, no language-specific options are valid. */ 355bool 356lhd_handle_option (size_t code ATTRIBUTE_UNUSED, 357 const char *arg ATTRIBUTE_UNUSED, 358 HOST_WIDE_INT value ATTRIBUTE_UNUSED, 359 int kind ATTRIBUTE_UNUSED, 360 location_t loc ATTRIBUTE_UNUSED, 361 const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED) 362{ 363 return false; 364} 365 366/* The default function to print out name of current function that caused 367 an error. */ 368void 369lhd_print_error_function (diagnostic_context *context, const char *file, 370 diagnostic_info *diagnostic) 371{ 372 if (diagnostic_last_function_changed (context, diagnostic)) 373 { 374 char *old_prefix = pp_take_prefix (context->printer); 375 tree abstract_origin = diagnostic_abstract_origin (diagnostic); 376 char *new_prefix = (file && abstract_origin == NULL) 377 ? file_name_as_prefix (context, file) : NULL; 378 379 pp_set_prefix (context->printer, new_prefix); 380 381 if (current_function_decl == NULL) 382 pp_printf (context->printer, _("At top level:")); 383 else 384 { 385 tree fndecl, ao; 386 387 if (abstract_origin) 388 { 389 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); 390 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); 391 fndecl = ao; 392 } 393 else 394 fndecl = current_function_decl; 395 396 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) 397 pp_printf 398 (context->printer, _("In member function %qs"), 399 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); 400 else 401 pp_printf 402 (context->printer, _("In function %qs"), 403 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); 404 405 while (abstract_origin) 406 { 407 location_t *locus; 408 tree block = abstract_origin; 409 410 locus = &BLOCK_SOURCE_LOCATION (block); 411 fndecl = NULL; 412 block = BLOCK_SUPERCONTEXT (block); 413 while (block && TREE_CODE (block) == BLOCK 414 && BLOCK_ABSTRACT_ORIGIN (block)) 415 { 416 ao = BLOCK_ABSTRACT_ORIGIN (block); 417 if (TREE_CODE (ao) == FUNCTION_DECL) 418 { 419 fndecl = ao; 420 break; 421 } 422 else if (TREE_CODE (ao) != BLOCK) 423 break; 424 425 block = BLOCK_SUPERCONTEXT (block); 426 } 427 if (fndecl) 428 abstract_origin = block; 429 else 430 { 431 while (block && TREE_CODE (block) == BLOCK) 432 block = BLOCK_SUPERCONTEXT (block); 433 434 if (block && TREE_CODE (block) == FUNCTION_DECL) 435 fndecl = block; 436 abstract_origin = NULL; 437 } 438 if (fndecl) 439 { 440 expanded_location s = expand_location (*locus); 441 pp_comma (context->printer); 442 pp_newline (context->printer); 443 if (s.file != NULL) 444 { 445 if (context->show_column) 446 pp_printf (context->printer, 447 _(" inlined from %qs at %r%s:%d:%d%R"), 448 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), 449 "locus", s.file, s.line, s.column); 450 else 451 pp_printf (context->printer, 452 _(" inlined from %qs at %r%s:%d%R"), 453 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), 454 "locus", s.file, s.line); 455 456 } 457 else 458 pp_printf (context->printer, _(" inlined from %qs"), 459 identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); 460 } 461 } 462 pp_colon (context->printer); 463 } 464 465 diagnostic_set_last_function (context, diagnostic); 466 pp_newline_and_flush (context->printer); 467 context->printer->prefix = old_prefix; 468 free ((char*) new_prefix); 469 } 470} 471 472tree 473lhd_make_node (enum tree_code code) 474{ 475 return make_node (code); 476} 477 478/* Default implementation of LANG_HOOKS_SIMULATE_ENUM_DECL. Assume a 479 simple int-based enumerator (which is all the hook can be used for 480 at present) and push each decl individually without any decoration. 481 482 This definition is suitable for LTO and is generic enough that it 483 might be reusable elsewhere. */ 484tree 485lhd_simulate_enum_decl (location_t loc, const char *name, 486 vec<string_int_pair> values) 487{ 488 tree enumtype = lang_hooks.types.make_type (ENUMERAL_TYPE); 489 tree enumdecl = build_decl (loc, TYPE_DECL, get_identifier (name), enumtype); 490 TYPE_STUB_DECL (enumtype) = enumdecl; 491 492 tree value_chain = NULL_TREE; 493 string_int_pair *value; 494 unsigned int i; 495 FOR_EACH_VEC_ELT (values, i, value) 496 { 497 tree value_decl = build_decl (loc, CONST_DECL, 498 get_identifier (value->first), enumtype); 499 DECL_INITIAL (value_decl) = build_int_cst (integer_type_node, 500 value->second); 501 lang_hooks.decls.pushdecl (value_decl); 502 value_chain = tree_cons (value_decl, DECL_INITIAL (value_decl), 503 value_chain); 504 } 505 506 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (integer_type_node); 507 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (integer_type_node); 508 SET_TYPE_ALIGN (enumtype, TYPE_ALIGN (integer_type_node)); 509 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); 510 layout_type (enumtype); 511 lang_hooks.decls.pushdecl (enumdecl); 512 513 return enumtype; 514} 515 516/* Default implementation of LANG_HOOKS_TYPE_FOR_SIZE. 517 Return an integer type with PRECISION bits of precision, 518 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ 519 520tree 521lhd_type_for_size (unsigned precision, int unsignedp) 522{ 523 int i; 524 525 if (precision == TYPE_PRECISION (integer_type_node)) 526 return unsignedp ? unsigned_type_node : integer_type_node; 527 528 if (precision == TYPE_PRECISION (signed_char_type_node)) 529 return unsignedp ? unsigned_char_type_node : signed_char_type_node; 530 531 if (precision == TYPE_PRECISION (short_integer_type_node)) 532 return unsignedp ? short_unsigned_type_node : short_integer_type_node; 533 534 if (precision == TYPE_PRECISION (long_integer_type_node)) 535 return unsignedp ? long_unsigned_type_node : long_integer_type_node; 536 537 if (precision == TYPE_PRECISION (long_long_integer_type_node)) 538 return unsignedp 539 ? long_long_unsigned_type_node 540 : long_long_integer_type_node; 541 542 for (i = 0; i < NUM_INT_N_ENTS; i ++) 543 if (int_n_enabled_p[i] 544 && precision == int_n_data[i].bitsize) 545 return (unsignedp ? int_n_trees[i].unsigned_type 546 : int_n_trees[i].signed_type); 547 548 if (precision <= TYPE_PRECISION (intQI_type_node)) 549 return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 550 551 if (precision <= TYPE_PRECISION (intHI_type_node)) 552 return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 553 554 if (precision <= TYPE_PRECISION (intSI_type_node)) 555 return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 556 557 if (precision <= TYPE_PRECISION (intDI_type_node)) 558 return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 559 560 if (precision <= TYPE_PRECISION (intTI_type_node)) 561 return unsignedp ? unsigned_intTI_type_node : intTI_type_node; 562 563 return NULL_TREE; 564} 565 566HOST_WIDE_INT 567lhd_to_target_charset (HOST_WIDE_INT c) 568{ 569 return c; 570} 571 572tree 573lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) 574{ 575 return expr; 576} 577 578/* Return sharing kind if OpenMP sharing attribute of DECL is 579 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ 580 581enum omp_clause_default_kind 582lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED) 583{ 584 if (DECL_ARTIFICIAL (decl)) 585 return OMP_CLAUSE_DEFAULT_SHARED; 586 return OMP_CLAUSE_DEFAULT_UNSPECIFIED; 587} 588 589/* Generate code to copy SRC to DST. */ 590 591tree 592lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) 593{ 594 return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src); 595} 596 597/* Finalize clause C. */ 598 599void 600lhd_omp_finish_clause (tree, gimple_seq *) 601{ 602} 603 604/* Return true if DECL is a scalar variable (for the purpose of 605 implicit firstprivatization). */ 606 607bool 608lhd_omp_scalar_p (tree decl) 609{ 610 tree type = TREE_TYPE (decl); 611 if (TREE_CODE (type) == REFERENCE_TYPE) 612 type = TREE_TYPE (type); 613 if (TREE_CODE (type) == COMPLEX_TYPE) 614 type = TREE_TYPE (type); 615 if (INTEGRAL_TYPE_P (type) 616 || SCALAR_FLOAT_TYPE_P (type) 617 || TREE_CODE (type) == POINTER_TYPE) 618 return true; 619 return false; 620} 621 622/* Register language specific type size variables as potentially OpenMP 623 firstprivate variables. */ 624 625void 626lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED, 627 tree t ATTRIBUTE_UNUSED) 628{ 629} 630 631/* Return true if TYPE is an OpenMP mappable type. */ 632 633bool 634lhd_omp_mappable_type (tree type) 635{ 636 /* Mappable type has to be complete. */ 637 if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 638 return false; 639 return true; 640} 641 642/* Common function for add_builtin_function, add_builtin_function_ext_scope 643 and simulate_builtin_function_decl. */ 644 645static tree 646build_builtin_function (location_t location, const char *name, tree type, 647 int function_code, enum built_in_class cl, 648 const char *library_name, tree attrs) 649{ 650 tree id = get_identifier (name); 651 tree decl = build_decl (location, FUNCTION_DECL, id, type); 652 653 TREE_PUBLIC (decl) = 1; 654 DECL_EXTERNAL (decl) = 1; 655 656 set_decl_built_in_function (decl, cl, function_code); 657 658 if (library_name) 659 { 660 tree libname = get_identifier (library_name); 661 662 libname = targetm.mangle_decl_assembler_name (decl, libname); 663 SET_DECL_ASSEMBLER_NAME (decl, libname); 664 } 665 666 /* Possibly apply some default attributes to this built-in function. */ 667 if (attrs) 668 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); 669 else 670 decl_attributes (&decl, NULL_TREE, 0); 671 672 return decl; 673} 674 675/* Create a builtin function. */ 676 677tree 678add_builtin_function (const char *name, 679 tree type, 680 int function_code, 681 enum built_in_class cl, 682 const char *library_name, 683 tree attrs) 684{ 685 tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, 686 function_code, cl, library_name, attrs); 687 return lang_hooks.builtin_function (decl); 688} 689 690/* Like add_builtin_function, but make sure the scope is the external scope. 691 This is used to delay putting in back end builtin functions until the ISA 692 that defines the builtin is declared via function specific target options, 693 which can save memory for machines like the x86_64 that have multiple ISAs. 694 If this points to the same function as builtin_function, the backend must 695 add all of the builtins at program initialization time. */ 696 697tree 698add_builtin_function_ext_scope (const char *name, 699 tree type, 700 int function_code, 701 enum built_in_class cl, 702 const char *library_name, 703 tree attrs) 704{ 705 tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, 706 function_code, cl, library_name, attrs); 707 return lang_hooks.builtin_function_ext_scope (decl); 708} 709 710/* Simulate a declaration of a target-specific built-in function at 711 location LOCATION, as though it had been declared directly in the 712 source language. NAME is the name of the function, TYPE is its function 713 type, FUNCTION_CODE is the target-specific function code, LIBRARY_NAME 714 is the name of the underlying library function (NULL if none) and 715 ATTRS is a list of function attributes. 716 717 Return the decl of the declared function. */ 718 719tree 720simulate_builtin_function_decl (location_t location, const char *name, 721 tree type, int function_code, 722 const char *library_name, tree attrs) 723{ 724 tree decl = build_builtin_function (location, name, type, 725 function_code, BUILT_IN_MD, 726 library_name, attrs); 727 tree new_decl = lang_hooks.simulate_builtin_function_decl (decl); 728 729 /* Give the front end a chance to create a new decl if necessary, 730 but if the front end discards the decl in favour of a conflicting 731 (erroneous) previous definition, return the decl that we tried but 732 failed to add. This allows the caller to process the returned decl 733 normally, even though the source code won't be able to use it. */ 734 if (TREE_CODE (new_decl) == FUNCTION_DECL 735 && fndecl_built_in_p (new_decl, function_code, BUILT_IN_MD)) 736 return new_decl; 737 738 return decl; 739} 740 741tree 742lhd_builtin_function (tree decl) 743{ 744 lang_hooks.decls.pushdecl (decl); 745 return decl; 746} 747 748/* Create a builtin type. */ 749 750tree 751add_builtin_type (const char *name, tree type) 752{ 753 tree id = get_identifier (name); 754 tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type); 755 return lang_hooks.decls.pushdecl (decl); 756} 757 758/* LTO hooks. */ 759 760/* Used to save and restore any previously active section. */ 761static section *saved_section; 762 763 764/* Begin a new LTO output section named NAME. This default implementation 765 saves the old section and emits assembly code to switch to the new 766 section. */ 767 768void 769lhd_begin_section (const char *name) 770{ 771 section *section; 772 773 /* Save the old section so we can restore it in lto_end_asm_section. */ 774 gcc_assert (!saved_section); 775 saved_section = in_section; 776 if (!saved_section) 777 saved_section = text_section; 778 779 /* Create a new section and switch to it. */ 780 section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL, true); 781 switch_to_section (section); 782} 783 784 785/* Write DATA of length LEN to the current LTO output section. This default 786 implementation just calls assemble_string. */ 787 788void 789lhd_append_data (const void *data, size_t len, void *) 790{ 791 if (data) 792 { 793 timevar_push (TV_IPA_LTO_OUTPUT); 794 assemble_string ((const char *)data, len); 795 timevar_pop (TV_IPA_LTO_OUTPUT); 796 } 797} 798 799 800/* Finish the current LTO output section. This default implementation emits 801 assembly code to switch to any section previously saved by 802 lhd_begin_section. */ 803 804void 805lhd_end_section (void) 806{ 807 if (saved_section) 808 { 809 switch_to_section (saved_section); 810 saved_section = NULL; 811 } 812} 813 814/* Default implementation of enum_underlying_base_type using type_for_size. */ 815 816tree 817lhd_enum_underlying_base_type (const_tree enum_type) 818{ 819 return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type), 820 TYPE_UNSIGNED (enum_type)); 821} 822 823/* Default implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */ 824 825const char * 826lhd_get_substring_location (const substring_loc &, location_t *) 827{ 828 return "unimplemented"; 829} 830 831/* Default implementation of LANG_HOOKS_DECL_DWARF_ATTRIBUTE. Don't add 832 any attributes. */ 833 834int 835lhd_decl_dwarf_attribute (const_tree, int) 836{ 837 return -1; 838} 839 840/* Default implementation of LANG_HOOKS_TYPE_DWARF_ATTRIBUTE. Don't add 841 any attributes. */ 842 843int 844lhd_type_dwarf_attribute (const_tree, int) 845{ 846 return -1; 847} 848 849/* Default implementation of LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING. 850 Just return TYPE_SIZE_UNIT unadjusted. */ 851 852tree 853lhd_unit_size_without_reusable_padding (tree t) 854{ 855 return TYPE_SIZE_UNIT (t); 856} 857 858/* Returns true if the current lang_hooks represents the GNU C frontend. */ 859 860bool 861lang_GNU_C (void) 862{ 863 return (strncmp (lang_hooks.name, "GNU C", 5) == 0 864 && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5]))); 865} 866 867/* Returns true if the current lang_hooks represents the GNU C++ frontend. */ 868 869bool 870lang_GNU_CXX (void) 871{ 872 return strncmp (lang_hooks.name, "GNU C++", 7) == 0; 873} 874 875/* Returns true if the current lang_hooks represents the GNU Fortran frontend. */ 876 877bool 878lang_GNU_Fortran (void) 879{ 880 return strncmp (lang_hooks.name, "GNU Fortran", 11) == 0; 881} 882 883/* Returns true if the current lang_hooks represents the GNU Objective-C 884 frontend. */ 885 886bool 887lang_GNU_OBJC (void) 888{ 889 return strncmp (lang_hooks.name, "GNU Objective-C", 15) == 0; 890} 891