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