gcc/langhooks.c

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