gcc/cp/lex.c

   1 /* Separate lexical analyzer for GNU C++.
   2    Copyright (C) 1987-2017 Free Software Foundation, Inc.
   3    Hacked by Michael Tiemann (tiemann@cygnus.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
  22 /* This file is the lexical analyzer for GNU C++.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "cp-tree.h"
  28 #include "stringpool.h"
  29 #include "c-family/c-pragma.h"
  30 #include "c-family/c-objc.h"
  31
  32 static int interface_strcmp (const char *);
  33 static void init_cp_pragma (void);
  34
  35 static tree parse_strconst_pragma (const char *, int);
  36 static void handle_pragma_vtable (cpp_reader *);
  37 static void handle_pragma_unit (cpp_reader *);
  38 static void handle_pragma_interface (cpp_reader *);
  39 static void handle_pragma_implementation (cpp_reader *);
  40
  41 static void init_operators (void);
  42 static void copy_lang_type (tree);
  43
  44 /* A constraint that can be tested at compile time.  */
  45 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
  46
  47 /* Functions and data structures for #pragma interface.
  48
  49    `#pragma implementation' means that the main file being compiled
  50    is considered to implement (provide) the classes that appear in
  51    its main body.  I.e., if this is file "foo.cc", and class `bar'
  52    is defined in "foo.cc", then we say that "foo.cc implements bar".
  53
  54    All main input files "implement" themselves automagically.
  55
  56    `#pragma interface' means that unless this file (of the form "foo.h"
  57    is not presently being included by file "foo.cc", the
  58    CLASSTYPE_INTERFACE_ONLY bit gets set.  The effect is that none
  59    of the vtables nor any of the inline functions defined in foo.h
  60    will ever be output.
  61
  62    There are cases when we want to link files such as "defs.h" and
  63    "main.cc".  In this case, we give "defs.h" a `#pragma interface',
  64    and "main.cc" has `#pragma implementation "defs.h"'.  */
  65
  66 struct impl_files
  67 {
  68   const char *filename;
  69   struct impl_files *next;
  70 };
  71
  72 static struct impl_files *impl_file_chain;
  73 \f
  74 void
  75 cxx_finish (void)
  76 {
  77   c_common_finish ();
  78 }
  79
  80 /* A mapping from tree codes to operator name information.  */
  81 operator_name_info_t operator_name_info[(int) MAX_TREE_CODES];
  82 /* Similar, but for assignment operators.  */
  83 operator_name_info_t assignment_operator_name_info[(int) MAX_TREE_CODES];
  84
  85 /* Initialize data structures that keep track of operator names.  */
  86
  87 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
  88  CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
  89 #include "operators.def"
  90 #undef DEF_OPERATOR
  91
  92 /* Get the name of the kind of identifier T.  */
  93
  94 const char *
  95 get_identifier_kind_name (tree id)
  96 {
  97   /* Keep in sync with cp_id_kind enumeration.  */
  98   static const char *const names[cik_max] = {
  99     "normal", "keyword", "constructor", "destructor",
 100     "assign-op", "op-assign-op", "simple-op", "conv-op", };
 101
 102   unsigned kind = 0;
 103   kind |= IDENTIFIER_KIND_BIT_2 (id) << 2;
 104   kind |= IDENTIFIER_KIND_BIT_1 (id) << 1;
 105   kind |= IDENTIFIER_KIND_BIT_0 (id) << 0;
 106
 107   return names[kind];
 108 }
 109
 110 /* Set the identifier kind, which we expect to currently be zero.  */
 111
 112 void
 113 set_identifier_kind (tree id, cp_identifier_kind kind)
 114 {
 115   gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id)
 116                        & !IDENTIFIER_KIND_BIT_1 (id)
 117                        & !IDENTIFIER_KIND_BIT_0 (id));
 118   IDENTIFIER_KIND_BIT_2 (id) |= (kind >> 2) & 1;
 119   IDENTIFIER_KIND_BIT_1 (id) |= (kind >> 1) & 1;
 120   IDENTIFIER_KIND_BIT_0 (id) |= (kind >> 0) & 1;
 121 }
 122
 123 static void
 124 init_operators (void)
 125 {
 126   tree identifier;
 127   char buffer[256];
 128   struct operator_name_info_t *oni;
 129
 130 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, KIND)                 \
 131   sprintf (buffer, "operator%s%s", !NAME[0]                             \
 132            || NAME[0] == '_' || ISALPHA (NAME[0]) ? " " : "", NAME);    \
 133   identifier = get_identifier (buffer);                                 \
 134                                                                         \
 135   if (KIND != cik_simple_op || !IDENTIFIER_ANY_OP_P (identifier))       \
 136     set_identifier_kind (identifier, KIND);                             \
 137                                                                         \
 138   oni = (KIND == cik_assign_op                                          \
 139          ? &assignment_operator_name_info[(int) CODE]                   \
 140          : &operator_name_info[(int) CODE]);                            \
 141   oni->identifier = identifier;                                         \
 142   oni->name = NAME;                                                     \
 143   oni->mangled_name = MANGLING;                                         \
 144   oni->arity = ARITY;
 145
 146 #include "operators.def"
 147 #undef DEF_OPERATOR
 148
 149   operator_name_info[(int) TYPE_EXPR] = operator_name_info[(int) CAST_EXPR];
 150   operator_name_info[(int) ERROR_MARK].identifier
 151     = get_identifier ("<invalid operator>");
 152
 153   /* Handle some special cases.  These operators are not defined in
 154      the language, but can be produced internally.  We may need them
 155      for error-reporting.  (Eventually, we should ensure that this
 156      does not happen.  Error messages involving these operators will
 157      be confusing to users.)  */
 158
 159   operator_name_info [(int) INIT_EXPR].name
 160     = operator_name_info [(int) MODIFY_EXPR].name;
 161
 162   operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
 163   operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
 164   operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
 165   operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
 166   operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
 167   operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
 168   operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
 169
 170   operator_name_info [(int) ABS_EXPR].name = "abs";
 171   operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
 172   operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
 173   operator_name_info [(int) RANGE_EXPR].name = "...";
 174   operator_name_info [(int) UNARY_PLUS_EXPR].name = "+";
 175
 176   assignment_operator_name_info [(int) EXACT_DIV_EXPR].name = "(exact /=)";
 177   assignment_operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /=)";
 178   assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /=)";
 179   assignment_operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /=)";
 180   assignment_operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %=)";
 181   assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %=)";
 182   assignment_operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %=)";
 183 }
 184
 185 /* Initialize the reserved words.  */
 186
 187 void
 188 init_reswords (void)
 189 {
 190   unsigned int i;
 191   tree id;
 192   int mask = 0;
 193
 194   if (cxx_dialect < cxx11)
 195     mask |= D_CXX11;
 196   if (!flag_concepts)
 197     mask |= D_CXX_CONCEPTS;
 198   if (!flag_tm)
 199     mask |= D_TRANSMEM;
 200   if (flag_no_asm)
 201     mask |= D_ASM | D_EXT;
 202   if (flag_no_gnu_keywords)
 203     mask |= D_EXT;
 204
 205   /* The Objective-C keywords are all context-dependent.  */
 206   mask |= D_OBJC;
 207
 208   ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
 209   for (i = 0; i < num_c_common_reswords; i++)
 210     {
 211       if (c_common_reswords[i].disable & D_CONLY)
 212         continue;
 213       id = get_identifier (c_common_reswords[i].word);
 214       C_SET_RID_CODE (id, c_common_reswords[i].rid);
 215       ridpointers [(int) c_common_reswords[i].rid] = id;
 216       if (! (c_common_reswords[i].disable & mask))
 217         set_identifier_kind (id, cik_keyword);
 218     }
 219
 220   for (i = 0; i < NUM_INT_N_ENTS; i++)
 221     {
 222       char name[50];
 223       sprintf (name, "__int%d", int_n_data[i].bitsize);
 224       id = get_identifier (name);
 225       C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
 226       set_identifier_kind (id, cik_keyword);
 227     }
 228 }
 229
 230 static void
 231 init_cp_pragma (void)
 232 {
 233   c_register_pragma (0, "vtable", handle_pragma_vtable);
 234   c_register_pragma (0, "unit", handle_pragma_unit);
 235   c_register_pragma (0, "interface", handle_pragma_interface);
 236   c_register_pragma (0, "implementation", handle_pragma_implementation);
 237   c_register_pragma ("GCC", "interface", handle_pragma_interface);
 238   c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
 239 }
 240 \f
 241 /* TRUE if a code represents a statement.  */
 242
 243 bool statement_code_p[MAX_TREE_CODES];
 244
 245 /* Initialize the C++ front end.  This function is very sensitive to
 246    the exact order that things are done here.  It would be nice if the
 247    initialization done by this routine were moved to its subroutines,
 248    and the ordering dependencies clarified and reduced.  */
 249 bool
 250 cxx_init (void)
 251 {
 252   location_t saved_loc;
 253   unsigned int i;
 254   static const enum tree_code stmt_codes[] = {
 255    CTOR_INITIALIZER,    TRY_BLOCK,      HANDLER,
 256    EH_SPEC_BLOCK,       USING_STMT,     TAG_DEFN,
 257    IF_STMT,             CLEANUP_STMT,   FOR_STMT,
 258    RANGE_FOR_STMT,      WHILE_STMT,     DO_STMT,
 259    BREAK_STMT,          CONTINUE_STMT,  SWITCH_STMT,
 260    EXPR_STMT
 261   };
 262
 263   memset (&statement_code_p, 0, sizeof (statement_code_p));
 264   for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
 265     statement_code_p[stmt_codes[i]] = true;
 266
 267   saved_loc = input_location;
 268   input_location = BUILTINS_LOCATION;
 269
 270   init_reswords ();
 271   init_tree ();
 272   init_cp_semantics ();
 273   init_operators ();
 274   init_method ();
 275
 276   current_function_decl = NULL;
 277
 278   class_type_node = ridpointers[(int) RID_CLASS];
 279
 280   cxx_init_decl_processing ();
 281
 282   if (c_common_init () == false)
 283     {
 284       input_location = saved_loc;
 285       return false;
 286     }
 287
 288   init_cp_pragma ();
 289
 290   init_repo ();
 291
 292   input_location = saved_loc;
 293   return true;
 294 }
 295 \f
 296 /* Return nonzero if S is not considered part of an
 297    INTERFACE/IMPLEMENTATION pair.  Otherwise, return 0.  */
 298
 299 static int
 300 interface_strcmp (const char* s)
 301 {
 302   /* Set the interface/implementation bits for this scope.  */
 303   struct impl_files *ifiles;
 304   const char *s1;
 305
 306   for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
 307     {
 308       const char *t1 = ifiles->filename;
 309       s1 = s;
 310
 311       if (*s1 == 0 || filename_ncmp (s1, t1, 1) != 0)
 312         continue;
 313
 314       while (*s1 != 0 && filename_ncmp (s1, t1, 1) == 0)
 315         s1++, t1++;
 316
 317       /* A match.  */
 318       if (*s1 == *t1)
 319         return 0;
 320
 321       /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc.  */
 322       if (strchr (s1, '.') || strchr (t1, '.'))
 323         continue;
 324
 325       if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
 326         continue;
 327
 328       /* A match.  */
 329       return 0;
 330     }
 331
 332   /* No matches.  */
 333   return 1;
 334 }
 335
 336 \f
 337
 338 /* Parse a #pragma whose sole argument is a string constant.
 339    If OPT is true, the argument is optional.  */
 340 static tree
 341 parse_strconst_pragma (const char* name, int opt)
 342 {
 343   tree result, x;
 344   enum cpp_ttype t;
 345
 346   t = pragma_lex (&result);
 347   if (t == CPP_STRING)
 348     {
 349       if (pragma_lex (&x) != CPP_EOF)
 350         warning (0, "junk at end of #pragma %s", name);
 351       return result;
 352     }
 353
 354   if (t == CPP_EOF && opt)
 355     return NULL_TREE;
 356
 357   error ("invalid #pragma %s", name);
 358   return error_mark_node;
 359 }
 360
 361 static void
 362 handle_pragma_vtable (cpp_reader* /*dfile*/)
 363 {
 364   parse_strconst_pragma ("vtable", 0);
 365   sorry ("#pragma vtable no longer supported");
 366 }
 367
 368 static void
 369 handle_pragma_unit (cpp_reader* /*dfile*/)
 370 {
 371   /* Validate syntax, but don't do anything.  */
 372   parse_strconst_pragma ("unit", 0);
 373 }
 374
 375 static void
 376 handle_pragma_interface (cpp_reader* /*dfile*/)
 377 {
 378   tree fname = parse_strconst_pragma ("interface", 1);
 379   struct c_fileinfo *finfo;
 380   const char *filename;
 381
 382   if (fname == error_mark_node)
 383     return;
 384   else if (fname == 0)
 385     filename = lbasename (LOCATION_FILE (input_location));
 386   else
 387     filename = TREE_STRING_POINTER (fname);
 388
 389   finfo = get_fileinfo (LOCATION_FILE (input_location));
 390
 391   if (impl_file_chain == 0)
 392     {
 393       /* If this is zero at this point, then we are
 394          auto-implementing.  */
 395       if (main_input_filename == 0)
 396         main_input_filename = LOCATION_FILE (input_location);
 397     }
 398
 399   finfo->interface_only = interface_strcmp (filename);
 400   /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
 401      a definition in another file.  */
 402   if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
 403     finfo->interface_unknown = 0;
 404 }
 405
 406 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
 407    We used to only allow this at toplevel, but that restriction was buggy
 408    in older compilers and it seems reasonable to allow it in the headers
 409    themselves, too.  It only needs to precede the matching #p interface.
 410
 411    We don't touch finfo->interface_only or finfo->interface_unknown;
 412    the user must specify a matching #p interface for this to have
 413    any effect.  */
 414
 415 static void
 416 handle_pragma_implementation (cpp_reader* /*dfile*/)
 417 {
 418   tree fname = parse_strconst_pragma ("implementation", 1);
 419   const char *filename;
 420   struct impl_files *ifiles = impl_file_chain;
 421
 422   if (fname == error_mark_node)
 423     return;
 424
 425   if (fname == 0)
 426     {
 427       if (main_input_filename)
 428         filename = main_input_filename;
 429       else
 430         filename = LOCATION_FILE (input_location);
 431       filename = lbasename (filename);
 432     }
 433   else
 434     {
 435       filename = TREE_STRING_POINTER (fname);
 436       if (cpp_included_before (parse_in, filename, input_location))
 437         warning (0, "#pragma implementation for %qs appears after "
 438                  "file is included", filename);
 439     }
 440
 441   for (; ifiles; ifiles = ifiles->next)
 442     {
 443       if (! filename_cmp (ifiles->filename, filename))
 444         break;
 445     }
 446   if (ifiles == 0)
 447     {
 448       ifiles = XNEW (struct impl_files);
 449       ifiles->filename = xstrdup (filename);
 450       ifiles->next = impl_file_chain;
 451       impl_file_chain = ifiles;
 452     }
 453 }
 454
 455 /* Issue an error message indicating that the lookup of NAME (an
 456    IDENTIFIER_NODE) failed.  Returns the ERROR_MARK_NODE.  */
 457
 458 tree
 459 unqualified_name_lookup_error (tree name, location_t loc)
 460 {
 461   if (loc == UNKNOWN_LOCATION)
 462     loc = EXPR_LOC_OR_LOC (name, input_location);
 463
 464   if (IDENTIFIER_ANY_OP_P (name))
 465     {
 466       if (name != cp_operator_id (ERROR_MARK))
 467         error_at (loc, "%qD not defined", name);
 468     }
 469   else
 470     {
 471       if (!objc_diagnose_private_ivar (name))
 472         {
 473           error_at (loc, "%qD was not declared in this scope", name);
 474           suggest_alternatives_for (loc, name, true);
 475         }
 476       /* Prevent repeated error messages by creating a VAR_DECL with
 477          this NAME in the innermost block scope.  */
 478       if (local_bindings_p ())
 479         {
 480           tree decl = build_decl (loc, VAR_DECL, name, error_mark_node);
 481           TREE_USED (decl) = true;
 482           pushdecl (decl);
 483         }
 484     }
 485
 486   return error_mark_node;
 487 }
 488
 489 /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
 490    NAME, encapsulated with its location in a CP_EXPR, used as a function.
 491    Returns an appropriate expression for NAME.  */
 492
 493 tree
 494 unqualified_fn_lookup_error (cp_expr name_expr)
 495 {
 496   tree name = name_expr.get_value ();
 497   location_t loc = name_expr.get_location ();
 498   if (loc == UNKNOWN_LOCATION)
 499     loc = input_location;
 500
 501   if (processing_template_decl)
 502     {
 503       /* In a template, it is invalid to write "f()" or "f(3)" if no
 504          declaration of "f" is available.  Historically, G++ and most
 505          other compilers accepted that usage since they deferred all name
 506          lookup until instantiation time rather than doing unqualified
 507          name lookup at template definition time; explain to the user what
 508          is going wrong.
 509
 510          Note that we have the exact wording of the following message in
 511          the manual (trouble.texi, node "Name lookup"), so they need to
 512          be kept in synch.  */
 513       permerror (loc, "there are no arguments to %qD that depend on a template "
 514                  "parameter, so a declaration of %qD must be available",
 515                  name, name);
 516
 517       if (!flag_permissive)
 518         {
 519           static bool hint;
 520           if (!hint)
 521             {
 522               inform (loc, "(if you use %<-fpermissive%>, G++ will accept your "
 523                      "code, but allowing the use of an undeclared name is "
 524                      "deprecated)");
 525               hint = true;
 526             }
 527         }
 528       return name;
 529     }
 530
 531   return unqualified_name_lookup_error (name, loc);
 532 }
 533
 534 /* Wrapper around build_lang_decl_loc(). Should gradually move to
 535    build_lang_decl_loc() and then rename build_lang_decl_loc() back to
 536    build_lang_decl().  */
 537
 538 tree
 539 build_lang_decl (enum tree_code code, tree name, tree type)
 540 {
 541   return build_lang_decl_loc (input_location, code, name, type);
 542 }
 543
 544 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
 545    DECL_LANG_SPECIFIC info to the result.  */
 546
 547 tree
 548 build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type)
 549 {
 550   tree t;
 551
 552   t = build_decl (loc, code, name, type);
 553   retrofit_lang_decl (t);
 554
 555   return t;
 556 }
 557
 558 /* Maybe add a raw lang_decl to T, a decl.  Return true if it needed
 559    one.  */
 560
 561 static bool
 562 maybe_add_lang_decl_raw (tree t, bool decomp_p)
 563 {
 564   size_t size;
 565   lang_decl_selector sel;
 566
 567   if (decomp_p)
 568     sel = lds_decomp, size = sizeof (struct lang_decl_decomp);
 569   else if (TREE_CODE (t) == FUNCTION_DECL)
 570     sel = lds_fn, size = sizeof (struct lang_decl_fn);
 571   else if (TREE_CODE (t) == NAMESPACE_DECL)
 572     sel = lds_ns, size = sizeof (struct lang_decl_ns);
 573   else if (TREE_CODE (t) == PARM_DECL)
 574     sel = lds_parm, size = sizeof (struct lang_decl_parm);
 575   else if (LANG_DECL_HAS_MIN (t))
 576     sel = lds_min, size = sizeof (struct lang_decl_min);
 577   else
 578     return false;
 579
 580   struct lang_decl *ld
 581     = (struct lang_decl *) ggc_internal_cleared_alloc (size);
 582
 583   ld->u.base.selector = sel;
 584   DECL_LANG_SPECIFIC (t) = ld;
 585
 586   if (sel == lds_ns)
 587     /* Who'd create a namespace, only to put nothing in it?  */
 588     ld->u.ns.bindings = hash_map<lang_identifier *, tree>::create_ggc (499);
 589
 590   if (GATHER_STATISTICS)
 591     {
 592       tree_node_counts[(int)lang_decl] += 1;
 593       tree_node_sizes[(int)lang_decl] += size;
 594     }
 595   return true;
 596 }
 597
 598 /* T has just had a decl_lang_specific added.  Initialize its
 599    linkage.  */
 600
 601 static void
 602 set_decl_linkage (tree t)
 603 {
 604   if (current_lang_name == lang_name_cplusplus
 605       || decl_linkage (t) == lk_none)
 606     SET_DECL_LANGUAGE (t, lang_cplusplus);
 607   else if (current_lang_name == lang_name_c)
 608     SET_DECL_LANGUAGE (t, lang_c);
 609   else
 610     gcc_unreachable ();
 611 }
 612
 613 /* T is a VAR_DECL node that needs to be a decomposition of BASE.  */
 614
 615 void
 616 fit_decomposition_lang_decl (tree t, tree base)
 617 {
 618   if (struct lang_decl *orig_ld = DECL_LANG_SPECIFIC (t))
 619     {
 620       if (orig_ld->u.base.selector == lds_min)
 621         {
 622           maybe_add_lang_decl_raw (t, true);
 623           memcpy (DECL_LANG_SPECIFIC (t), orig_ld,
 624                   sizeof (struct lang_decl_min));
 625           /* Reset selector, which will have been bashed by the
 626              memcpy.  */
 627           DECL_LANG_SPECIFIC (t)->u.base.selector = lds_decomp;
 628         }
 629       else
 630         gcc_checking_assert (orig_ld->u.base.selector == lds_decomp);
 631     }
 632   else
 633     {
 634       maybe_add_lang_decl_raw (t, true);
 635       set_decl_linkage (t);
 636     }
 637
 638   DECL_DECOMP_BASE (t) = base;
 639 }
 640
 641 /* Add DECL_LANG_SPECIFIC info to T, if it needs one.  Generally
 642    every C++ decl needs one, but C builtins etc do not.   */
 643
 644 void
 645 retrofit_lang_decl (tree t)
 646 {
 647   if (DECL_LANG_SPECIFIC (t))
 648     return;
 649
 650   if (maybe_add_lang_decl_raw (t, false))
 651     set_decl_linkage (t);
 652 }
 653
 654 void
 655 cxx_dup_lang_specific_decl (tree node)
 656 {
 657   int size;
 658
 659   if (! DECL_LANG_SPECIFIC (node))
 660     return;
 661
 662   switch (DECL_LANG_SPECIFIC (node)->u.base.selector)
 663     {
 664     case lds_min:
 665       size = sizeof (struct lang_decl_min);
 666       break;
 667     case lds_fn:
 668       size = sizeof (struct lang_decl_fn);
 669       break;
 670     case lds_ns:
 671       size = sizeof (struct lang_decl_ns);
 672       break;
 673     case lds_parm:
 674       size = sizeof (struct lang_decl_parm);
 675       break;
 676     case lds_decomp:
 677       size = sizeof (struct lang_decl_decomp);
 678       break;
 679     default:
 680       gcc_unreachable ();
 681     }
 682
 683   struct lang_decl *ld = (struct lang_decl *) ggc_internal_alloc (size);
 684   memcpy (ld, DECL_LANG_SPECIFIC (node), size);
 685   DECL_LANG_SPECIFIC (node) = ld;
 686
 687   if (GATHER_STATISTICS)
 688     {
 689       tree_node_counts[(int)lang_decl] += 1;
 690       tree_node_sizes[(int)lang_decl] += size;
 691     }
 692 }
 693
 694 /* Copy DECL, including any language-specific parts.  */
 695
 696 tree
 697 copy_decl (tree decl MEM_STAT_DECL)
 698 {
 699   tree copy;
 700
 701   copy = copy_node_stat (decl PASS_MEM_STAT);
 702   cxx_dup_lang_specific_decl (copy);
 703   return copy;
 704 }
 705
 706 /* Replace the shared language-specific parts of NODE with a new copy.  */
 707
 708 static void
 709 copy_lang_type (tree node)
 710 {
 711   if (! TYPE_LANG_SPECIFIC (node))
 712     return;
 713
 714   struct lang_type *lt
 715     = (struct lang_type *) ggc_internal_alloc (sizeof (struct lang_type));
 716
 717   memcpy (lt, TYPE_LANG_SPECIFIC (node), (sizeof (struct lang_type)));
 718   TYPE_LANG_SPECIFIC (node) = lt;
 719
 720   if (GATHER_STATISTICS)
 721     {
 722       tree_node_counts[(int)lang_type] += 1;
 723       tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 724     }
 725 }
 726
 727 /* Copy TYPE, including any language-specific parts.  */
 728
 729 tree
 730 copy_type (tree type MEM_STAT_DECL)
 731 {
 732   tree copy;
 733
 734   copy = copy_node_stat (type PASS_MEM_STAT);
 735   copy_lang_type (copy);
 736   return copy;
 737 }
 738
 739 /* Add a raw lang_type to T, a type, should it need one.  */
 740
 741 static bool
 742 maybe_add_lang_type_raw (tree t)
 743 {
 744   bool add = (RECORD_OR_UNION_CODE_P (TREE_CODE (t))
 745               || TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM);
 746   if (add)
 747     {
 748       TYPE_LANG_SPECIFIC (t)
 749         = (struct lang_type *) (ggc_internal_cleared_alloc
 750                                 (sizeof (struct lang_type)));
 751
 752       if (GATHER_STATISTICS)
 753         {
 754           tree_node_counts[(int)lang_type] += 1;
 755           tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
 756         }
 757     }
 758   return add;
 759 }
 760
 761 tree
 762 cxx_make_type (enum tree_code code)
 763 {
 764   tree t = make_node (code);
 765
 766   maybe_add_lang_type_raw (t);
 767
 768   /* Set up some flags that give proper default behavior.  */
 769   if (RECORD_OR_UNION_CODE_P (code))
 770     {
 771       struct c_fileinfo *finfo = \
 772         get_fileinfo (LOCATION_FILE (input_location));
 773       SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
 774       CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
 775     }
 776
 777   return t;
 778 }
 779
 780 tree
 781 make_class_type (enum tree_code code)
 782 {
 783   tree t = cxx_make_type (code);
 784   SET_CLASS_TYPE_P (t, 1);
 785   return t;
 786 }
 787
 788 /* Returns true if we are currently in the main source file, or in a
 789    template instantiation started from the main source file.  */
 790
 791 bool
 792 in_main_input_context (void)
 793 {
 794   struct tinst_level *tl = outermost_tinst_level();
 795
 796   if (tl)
 797     return filename_cmp (main_input_filename,
 798                          LOCATION_FILE (tl->locus)) == 0;
 799   else
 800     return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0;
 801 }