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