gcc/langhooks.c

   1 /* Default language-specific hooks.
   2    Copyright (C) 2001-2020 Free Software Foundation, Inc.
   3    Contributed by Alexandre Oliva  <aoliva@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along 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
  42 void
  43 lhd_do_nothing (void)
  44 {
  45 }
  46
  47 /* Do nothing (tree).  */
  48
  49 void
  50 lhd_do_nothing_t (tree ARG_UNUSED (t))
  51 {
  52 }
  53
  54 /* Pass through (tree).  */
  55 tree
  56 lhd_pass_through_t (tree t)
  57 {
  58   return t;
  59 }
  60
  61 /* Do nothing (int, int, int).  Return NULL_TREE.  */
  62
  63 tree
  64 lhd_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
  73 void
  74 lhd_do_nothing_f (struct function * ARG_UNUSED (f))
  75 {
  76 }
  77
  78 /* Do nothing (return NULL_TREE).  */
  79
  80 tree
  81 lhd_return_null_tree (tree ARG_UNUSED (t))
  82 {
  83   return NULL_TREE;
  84 }
  85
  86 /* Do nothing (return NULL_TREE).  */
  87
  88 tree
  89 lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
  90 {
  91   return NULL_TREE;
  92 }
  93
  94 /* The default post options hook.  */
  95
  96 bool
  97 lhd_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
 107 void
 108 lhd_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
 116 bool
 117 lhd_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.  */
 133 void
 134 lhd_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.  */
 181 void
 182 lhd_overwrite_decl_assembler_name (tree decl, tree name)
 183 {
 184   DECL_ASSEMBLER_NAME_RAW (decl) = name;
 185 }
 186
 187 /* Type promotion for variable arguments.  */
 188 tree
 189 lhd_type_promotes_to (tree ARG_UNUSED (type))
 190 {
 191   gcc_unreachable ();
 192 }
 193
 194 /* Registration of machine- or os-specific builtin types.  */
 195 void
 196 lhd_register_builtin_type (tree ARG_UNUSED (type),
 197                            const char * ARG_UNUSED (name))
 198 {
 199 }
 200
 201 /* Invalid use of an incomplete type.  */
 202 void
 203 lhd_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
 213 alias_set_type
 214 lhd_get_alias_set (tree ARG_UNUSED (t))
 215 {
 216   return -1;
 217 }
 218
 219 /* This is the default decl_printable_name function.  */
 220
 221 const char *
 222 lhd_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
 230 const char *
 231 lhd_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
 242 int
 243 lhd_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
 252 bool
 253 lhd_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
 261 int
 262 lhd_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
 269 int
 270 lhd_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.  */
 280 size_t
 281 lhd_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
 289 bool
 290 lhd_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
 299 void
 300 global_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.  */
 329 void
 330 lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED)
 331 {
 332 }
 333
 334 /* Called to register dumps.  */
 335 void
 336 lhd_register_dumps (gcc::dump_manager *)
 337 {
 338 }
 339
 340 /* Called to perform language-specific options initialization.  */
 341 void
 342 lhd_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.  */
 348 bool
 349 lhd_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.  */
 355 bool
 356 lhd_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.  */
 368 void
 369 lhd_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
 472 tree
 473 lhd_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.  */
 484 tree
 485 lhd_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
 520 tree
 521 lhd_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
 566 HOST_WIDE_INT
 567 lhd_to_target_charset (HOST_WIDE_INT c)
 568 {
 569   return c;
 570 }
 571
 572 tree
 573 lhd_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
 581 enum omp_clause_default_kind
 582 lhd_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
 591 tree
 592 lhd_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
 599 void
 600 lhd_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
 607 bool
 608 lhd_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
 625 void
 626 lhd_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
 633 bool
 634 lhd_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
 645 static tree
 646 build_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
 677 tree
 678 add_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
 697 tree
 698 add_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
 719 tree
 720 simulate_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
 741 tree
 742 lhd_builtin_function (tree decl)
 743 {
 744   lang_hooks.decls.pushdecl (decl);
 745   return decl;
 746 }
 747
 748 /* Create a builtin type.  */
 749
 750 tree
 751 add_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.  */
 761 static 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
 768 void
 769 lhd_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);
 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
 788 void
 789 lhd_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
 804 void
 805 lhd_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
 816 tree
 817 lhd_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
 825 const char *
 826 lhd_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
 834 int
 835 lhd_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
 843 int
 844 lhd_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
 852 tree
 853 lhd_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
 860 bool
 861 lang_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
 869 bool
 870 lang_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
 877 bool
 878 lang_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
 886 bool
 887 lang_GNU_OBJC (void)
 888 {
 889   return strncmp (lang_hooks.name, "GNU Objective-C", 15) == 0;
 890 }