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