gcc/langhooks.c

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