gcc/langhooks.c

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