gcc/cp/decl.c

   1 /* Process declarations and variables for C++ compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004  Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C++ front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "coretypes.h"
  34 #include "tm.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "tree-inline.h"
  41 #include "decl.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "hashtab.h"
  46 #include "tm_p.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49 #include "c-pragma.h"
  50 #include "diagnostic.h"
  51 #include "debug.h"
  52 #include "timevar.h"
  53 #include "tree-flow.h"
  54
  55 static tree grokparms (cp_parameter_declarator *, tree *);
  56 static const char *redeclaration_error_message (tree, tree);
  57
  58 static int decl_jump_unsafe (tree);
  59 static void require_complete_types_for_parms (tree);
  60 static int ambi_op_p (enum tree_code);
  61 static int unary_op_p (enum tree_code);
  62 static void push_local_name (tree);
  63 static tree grok_reference_init (tree, tree, tree, tree *);
  64 static tree grokfndecl (tree, tree, tree, tree, tree, int,
  65                         enum overload_flags, cp_cv_quals,
  66                         tree, int, int, int, int, int, int, tree);
  67 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
  68                          int, int, tree);
  69 static void record_unknown_type (tree, const char *);
  70 static tree builtin_function_1 (const char *, tree, tree, int,
  71                                 enum built_in_class, const char *,
  72                                 tree);
  73 static tree build_library_fn_1 (tree, enum tree_code, tree);
  74 static int member_function_or_else (tree, tree, enum overload_flags);
  75 static void bad_specifiers (tree, const char *, int, int, int, int,
  76                             int);
  77 static void check_for_uninitialized_const_var (tree);
  78 static hashval_t typename_hash (const void *);
  79 static int typename_compare (const void *, const void *);
  80 static tree local_variable_p_walkfn (tree *, int *, void *);
  81 static tree record_builtin_java_type (const char *, int);
  82 static const char *tag_name (enum tag_types code);
  83 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
  84 static int walk_globals_r (tree, void*);
  85 static int walk_vtables_r (tree, void*);
  86 static tree make_label_decl (tree, int);
  87 static void use_label (tree);
  88 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
  89                                    const location_t *);
  90 static void check_previous_goto (struct named_label_use_list *);
  91 static void check_switch_goto (struct cp_binding_level *);
  92 static void check_previous_gotos (tree);
  93 static void pop_label (tree, tree);
  94 static void pop_labels (tree);
  95 static void maybe_deduce_size_from_array_init (tree, tree);
  96 static void layout_var_decl (tree);
  97 static void maybe_commonize_var (tree);
  98 static tree check_initializer (tree, tree, int, tree *);
  99 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
 100 static void save_function_data (tree);
 101 static void check_function_type (tree, tree);
 102 static void begin_constructor_body (void);
 103 static void finish_constructor_body (void);
 104 static void begin_destructor_body (void);
 105 static void finish_destructor_body (void);
 106 static tree create_array_type_for_decl (tree, tree, tree);
 107 static tree get_atexit_node (void);
 108 static tree get_dso_handle_node (void);
 109 static tree start_cleanup_fn (void);
 110 static void end_cleanup_fn (void);
 111 static tree cp_make_fname_decl (tree, int);
 112 static void initialize_predefined_identifiers (void);
 113 static tree check_special_function_return_type
 114         (special_function_kind, tree, tree);
 115 static tree push_cp_library_fn (enum tree_code, tree);
 116 static tree build_cp_library_fn (tree, enum tree_code, tree);
 117 static void store_parm_decls (tree);
 118 static void initialize_local_var (tree, tree);
 119 static void expand_static_init (tree, tree);
 120 static tree next_initializable_field (tree);
 121 static tree reshape_init (tree, tree *);
 122 static tree build_typename_type (tree, tree, tree);
 123
 124 /* Erroneous argument lists can use this *IFF* they do not modify it.  */
 125 tree error_mark_list;
 126
 127 /* The following symbols are subsumed in the cp_global_trees array, and
 128    listed here individually for documentation purposes.
 129
 130    C++ extensions
 131         tree wchar_decl_node;
 132
 133         tree vtable_entry_type;
 134         tree delta_type_node;
 135         tree __t_desc_type_node;
 136         tree ti_desc_type_node;
 137         tree bltn_desc_type_node, ptr_desc_type_node;
 138         tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
 139         tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
 140         tree ptm_desc_type_node;
 141         tree base_desc_type_node;
 142
 143         tree class_type_node;
 144         tree unknown_type_node;
 145
 146    Array type `vtable_entry_type[]'
 147
 148         tree vtbl_type_node;
 149         tree vtbl_ptr_type_node;
 150
 151    Namespaces,
 152
 153         tree std_node;
 154         tree abi_node;
 155
 156    A FUNCTION_DECL which can call `abort'.  Not necessarily the
 157    one that the user will declare, but sufficient to be called
 158    by routines that want to abort the program.
 159
 160         tree abort_fndecl;
 161
 162    The FUNCTION_DECL for the default `::operator delete'.
 163
 164         tree global_delete_fndecl;
 165
 166    Used by RTTI
 167         tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
 168         tree tinfo_var_id;
 169
 170 */
 171
 172 tree cp_global_trees[CPTI_MAX];
 173
 174 /* Indicates that there is a type value in some namespace, although
 175    that is not necessarily in scope at the moment.  */
 176
 177 tree global_type_node;
 178
 179 /* The node that holds the "name" of the global scope.  */
 180 tree global_scope_name;
 181
 182 /* Used only for jumps to as-yet undefined labels, since jumps to
 183    defined labels can have their validity checked immediately.  */
 184
 185 struct named_label_use_list GTY(())
 186 {
 187   struct cp_binding_level *binding_level;
 188   tree names_in_scope;
 189   tree label_decl;
 190   location_t o_goto_locus;
 191   struct named_label_use_list *next;
 192 };
 193
 194 #define named_label_uses cp_function_chain->x_named_label_uses
 195
 196 #define local_names cp_function_chain->x_local_names
 197
 198 /* A list of objects which have constructors or destructors
 199    which reside in the global scope.  The decl is stored in
 200    the TREE_VALUE slot and the initializer is stored
 201    in the TREE_PURPOSE slot.  */
 202 tree static_aggregates;
 203
 204 /* -- end of C++ */
 205
 206 /* A node for the integer constants 2, and 3.  */
 207
 208 tree integer_two_node, integer_three_node;
 209
 210 /* A list of all LABEL_DECLs in the function that have names.  Here so
 211    we can clear out their names' definitions at the end of the
 212    function, and so we can check the validity of jumps to these labels.  */
 213
 214 struct named_label_list GTY(())
 215 {
 216   struct cp_binding_level *binding_level;
 217   tree names_in_scope;
 218   tree old_value;
 219   tree label_decl;
 220   tree bad_decls;
 221   struct named_label_list *next;
 222   unsigned int in_try_scope : 1;
 223   unsigned int in_catch_scope : 1;
 224 };
 225
 226 #define named_labels cp_function_chain->x_named_labels
 227 \f
 228 /* The number of function bodies which we are currently processing.
 229    (Zero if we are at namespace scope, one inside the body of a
 230    function, two inside the body of a function in a local class, etc.)  */
 231 int function_depth;
 232
 233 /* States indicating how grokdeclarator() should handle declspecs marked
 234    with __attribute__((deprecated)).  An object declared as
 235    __attribute__((deprecated)) suppresses warnings of uses of other
 236    deprecated items.  */
 237
 238 enum deprecated_states {
 239   DEPRECATED_NORMAL,
 240   DEPRECATED_SUPPRESS
 241 };
 242
 243 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
 244
 245 /* True if a declaration with an `extern' linkage specifier is being
 246    processed.  */
 247 bool have_extern_spec;
 248
 249 \f
 250 /* A TREE_LIST of VAR_DECLs.  The TREE_PURPOSE is a RECORD_TYPE or
 251    UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type.  At the
 252    time the VAR_DECL was declared, the type was incomplete.  */
 253
 254 static GTY(()) tree incomplete_vars;
 255 \f
 256 /* Returns the kind of template specialization we are currently
 257    processing, given that it's declaration contained N_CLASS_SCOPES
 258    explicit scope qualifications.  */
 259
 260 tmpl_spec_kind
 261 current_tmpl_spec_kind (int n_class_scopes)
 262 {
 263   int n_template_parm_scopes = 0;
 264   int seen_specialization_p = 0;
 265   int innermost_specialization_p = 0;
 266   struct cp_binding_level *b;
 267
 268   /* Scan through the template parameter scopes.  */
 269   for (b = current_binding_level;
 270        b->kind == sk_template_parms;
 271        b = b->level_chain)
 272     {
 273       /* If we see a specialization scope inside a parameter scope,
 274          then something is wrong.  That corresponds to a declaration
 275          like:
 276
 277             template <class T> template <> ...
 278
 279          which is always invalid since [temp.expl.spec] forbids the
 280          specialization of a class member template if the enclosing
 281          class templates are not explicitly specialized as well.  */
 282       if (b->explicit_spec_p)
 283         {
 284           if (n_template_parm_scopes == 0)
 285             innermost_specialization_p = 1;
 286           else
 287             seen_specialization_p = 1;
 288         }
 289       else if (seen_specialization_p == 1)
 290         return tsk_invalid_member_spec;
 291
 292       ++n_template_parm_scopes;
 293     }
 294
 295   /* Handle explicit instantiations.  */
 296   if (processing_explicit_instantiation)
 297     {
 298       if (n_template_parm_scopes != 0)
 299         /* We've seen a template parameter list during an explicit
 300            instantiation.  For example:
 301
 302              template <class T> template void f(int);
 303
 304            This is erroneous.  */
 305         return tsk_invalid_expl_inst;
 306       else
 307         return tsk_expl_inst;
 308     }
 309
 310   if (n_template_parm_scopes < n_class_scopes)
 311     /* We've not seen enough template headers to match all the
 312        specialized classes present.  For example:
 313
 314          template <class T> void R<T>::S<T>::f(int);
 315
 316        This is invalid; there needs to be one set of template
 317        parameters for each class.  */
 318     return tsk_insufficient_parms;
 319   else if (n_template_parm_scopes == n_class_scopes)
 320     /* We're processing a non-template declaration (even though it may
 321        be a member of a template class.)  For example:
 322
 323          template <class T> void S<T>::f(int);
 324
 325        The `class T' maches the `S<T>', leaving no template headers
 326        corresponding to the `f'.  */
 327     return tsk_none;
 328   else if (n_template_parm_scopes > n_class_scopes + 1)
 329     /* We've got too many template headers.  For example:
 330
 331          template <> template <class T> void f (T);
 332
 333        There need to be more enclosing classes.  */
 334     return tsk_excessive_parms;
 335   else
 336     /* This must be a template.  It's of the form:
 337
 338          template <class T> template <class U> void S<T>::f(U);
 339
 340        This is a specialization if the innermost level was a
 341        specialization; otherwise it's just a definition of the
 342        template.  */
 343     return innermost_specialization_p ? tsk_expl_spec : tsk_template;
 344 }
 345
 346 /* Exit the current scope.  */
 347
 348 void
 349 finish_scope (void)
 350 {
 351   poplevel (0, 0, 0);
 352 }
 353
 354 /* When a label goes out of scope, check to see if that label was used
 355    in a valid manner, and issue any appropriate warnings or errors.  */
 356
 357 static void
 358 pop_label (tree label, tree old_value)
 359 {
 360   if (!processing_template_decl)
 361     {
 362       if (DECL_INITIAL (label) == NULL_TREE)
 363         {
 364           location_t location;
 365
 366           cp_error_at ("label `%D' used but not defined", label);
 367 #ifdef USE_MAPPED_LOCATION
 368           location = input_location; /* FIXME want (input_filename, (line)0) */
 369 #else
 370           location.file = input_filename;
 371           location.line = 0;
 372 #endif
 373           /* Avoid crashing later.  */
 374           define_label (location, DECL_NAME (label));
 375         }
 376       else if (warn_unused_label && !TREE_USED (label))
 377         cp_warning_at ("label `%D' defined but not used", label);
 378     }
 379
 380   SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
 381 }
 382
 383 /* At the end of a function, all labels declared within the function
 384    go out of scope.  BLOCK is the top-level block for the
 385    function.  */
 386
 387 static void
 388 pop_labels (tree block)
 389 {
 390   struct named_label_list *link;
 391
 392   /* Clear out the definitions of all label names, since their scopes
 393      end here.  */
 394   for (link = named_labels; link; link = link->next)
 395     {
 396       pop_label (link->label_decl, link->old_value);
 397       /* Put the labels into the "variables" of the top-level block,
 398          so debugger can see them.  */
 399       TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
 400       BLOCK_VARS (block) = link->label_decl;
 401     }
 402
 403   named_labels = NULL;
 404 }
 405
 406 /* Exit a binding level.
 407    Pop the level off, and restore the state of the identifier-decl mappings
 408    that were in effect when this level was entered.
 409
 410    If KEEP == 1, this level had explicit declarations, so
 411    and create a "block" (a BLOCK node) for the level
 412    to record its declarations and subblocks for symbol table output.
 413
 414    If FUNCTIONBODY is nonzero, this level is the body of a function,
 415    so create a block as if KEEP were set and also clear out all
 416    label names.
 417
 418    If REVERSE is nonzero, reverse the order of decls before putting
 419    them into the BLOCK.  */
 420
 421 tree
 422 poplevel (int keep, int reverse, int functionbody)
 423 {
 424   tree link;
 425   /* The chain of decls was accumulated in reverse order.
 426      Put it into forward order, just for cleanliness.  */
 427   tree decls;
 428   int tmp = functionbody;
 429   int real_functionbody;
 430   tree subblocks;
 431   tree block;
 432   tree decl;
 433   int leaving_for_scope;
 434   scope_kind kind;
 435
 436   timevar_push (TV_NAME_LOOKUP);
 437  restart:
 438
 439   block = NULL_TREE;
 440
 441   my_friendly_assert (current_binding_level->kind != sk_class, 19990916);
 442
 443   real_functionbody = (current_binding_level->kind == sk_cleanup
 444                        ? ((functionbody = 0), tmp) : functionbody);
 445   subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
 446
 447   my_friendly_assert (VEC_length(cp_class_binding,
 448                                  current_binding_level->class_shadowed) == 0,
 449                       19990414);
 450
 451   /* We used to use KEEP == 2 to indicate that the new block should go
 452      at the beginning of the list of blocks at this binding level,
 453      rather than the end.  This hack is no longer used.  */
 454   my_friendly_assert (keep == 0 || keep == 1, 0);
 455
 456   if (current_binding_level->keep)
 457     keep = 1;
 458
 459   /* Any uses of undefined labels, and any defined labels, now operate
 460      under constraints of next binding contour.  */
 461   if (cfun && !functionbody)
 462     {
 463       struct cp_binding_level *level_chain;
 464       level_chain = current_binding_level->level_chain;
 465       if (level_chain)
 466         {
 467           struct named_label_use_list *uses;
 468           struct named_label_list *labels;
 469           for (labels = named_labels; labels; labels = labels->next)
 470             if (labels->binding_level == current_binding_level)
 471               {
 472                 tree decl;
 473                 if (current_binding_level->kind == sk_try)
 474                   labels->in_try_scope = 1;
 475                 if (current_binding_level->kind == sk_catch)
 476                   labels->in_catch_scope = 1;
 477                 for (decl = labels->names_in_scope; decl;
 478                      decl = TREE_CHAIN (decl))
 479                   if (decl_jump_unsafe (decl))
 480                     labels->bad_decls = tree_cons (NULL_TREE, decl,
 481                                                    labels->bad_decls);
 482                 labels->binding_level = level_chain;
 483                 labels->names_in_scope = level_chain->names;
 484               }
 485
 486           for (uses = named_label_uses; uses; uses = uses->next)
 487             if (uses->binding_level == current_binding_level)
 488               {
 489                 uses->binding_level = level_chain;
 490                 uses->names_in_scope = level_chain->names;
 491               }
 492         }
 493     }
 494
 495   /* Get the decls in the order they were written.
 496      Usually current_binding_level->names is in reverse order.
 497      But parameter decls were previously put in forward order.  */
 498
 499   if (reverse)
 500     current_binding_level->names
 501       = decls = nreverse (current_binding_level->names);
 502   else
 503     decls = current_binding_level->names;
 504
 505   /* When not in function-at-a-time mode, expand_end_bindings will
 506      warn about unused variables.  But, in function-at-a-time mode
 507      expand_end_bindings is not passed the list of variables in the
 508      current scope, and therefore no warning is emitted.  So, we
 509      explicitly warn here.  */
 510   if (!processing_template_decl)
 511     warn_about_unused_variables (getdecls ());
 512
 513   /* If there were any declarations or structure tags in that level,
 514      or if this level is a function body,
 515      create a BLOCK to record them for the life of this function.  */
 516   block = NULL_TREE;
 517   if (keep == 1 || functionbody)
 518     block = make_node (BLOCK);
 519   if (block != NULL_TREE)
 520     {
 521       BLOCK_VARS (block) = decls;
 522       BLOCK_SUBBLOCKS (block) = subblocks;
 523     }
 524
 525   /* In each subblock, record that this is its superior.  */
 526   if (keep >= 0)
 527     for (link = subblocks; link; link = TREE_CHAIN (link))
 528       BLOCK_SUPERCONTEXT (link) = block;
 529
 530   /* We still support the old for-scope rules, whereby the variables
 531      in a for-init statement were in scope after the for-statement
 532      ended.  We only use the new rules if flag_new_for_scope is
 533      nonzero.  */
 534   leaving_for_scope
 535     = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
 536
 537   /* Remove declarations for all the DECLs in this level.  */
 538   for (link = decls; link; link = TREE_CHAIN (link))
 539     {
 540       if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
 541           && DECL_NAME (link))
 542         {
 543           cxx_binding *outer_binding
 544             = IDENTIFIER_BINDING (DECL_NAME (link))->previous;
 545           tree ns_binding;
 546
 547           if (!outer_binding)
 548             ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
 549           else
 550             ns_binding = NULL_TREE;
 551
 552           if (outer_binding
 553               && outer_binding->scope == current_binding_level->level_chain)
 554             /* We have something like:
 555
 556                  int i;
 557                  for (int i; ;);
 558
 559                and we are leaving the `for' scope.  There's no reason to
 560                keep the binding of the inner `i' in this case.  */
 561             pop_binding (DECL_NAME (link), link);
 562           else if ((outer_binding
 563                     && (TREE_CODE (outer_binding->value) == TYPE_DECL))
 564                    || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
 565             /* Here, we have something like:
 566
 567                  typedef int I;
 568
 569                  void f () {
 570                    for (int I; ;);
 571                  }
 572
 573                We must pop the for-scope binding so we know what's a
 574                type and what isn't.  */
 575             pop_binding (DECL_NAME (link), link);
 576           else
 577             {
 578               /* Mark this VAR_DECL as dead so that we can tell we left it
 579                  there only for backward compatibility.  */
 580               DECL_DEAD_FOR_LOCAL (link) = 1;
 581
 582               /* Keep track of what should have happened when we
 583                  popped the binding.  */
 584               if (outer_binding && outer_binding->value)
 585                 DECL_SHADOWED_FOR_VAR (link) = outer_binding->value;
 586
 587               /* Add it to the list of dead variables in the next
 588                  outermost binding to that we can remove these when we
 589                  leave that binding.  */
 590               current_binding_level->level_chain->dead_vars_from_for
 591                 = tree_cons (NULL_TREE, link,
 592                              current_binding_level->level_chain->
 593                              dead_vars_from_for);
 594
 595               /* Although we don't pop the cxx_binding, we do clear
 596                  its SCOPE since the scope is going away now.  */
 597               IDENTIFIER_BINDING (DECL_NAME (link))->scope = NULL;
 598             }
 599         }
 600       else
 601         {
 602           /* Remove the binding.  */
 603           decl = link;
 604           if (TREE_CODE (decl) == TREE_LIST)
 605             decl = TREE_VALUE (decl);
 606           if (DECL_P (decl))
 607             pop_binding (DECL_NAME (decl), decl);
 608           else if (TREE_CODE (decl) == OVERLOAD)
 609             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
 610           else
 611             abort ();
 612         }
 613     }
 614
 615   /* Remove declarations for any `for' variables from inner scopes
 616      that we kept around.  */
 617   for (link = current_binding_level->dead_vars_from_for;
 618        link; link = TREE_CHAIN (link))
 619     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
 620
 621   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
 622   for (link = current_binding_level->type_shadowed;
 623        link; link = TREE_CHAIN (link))
 624     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
 625
 626   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
 627   for (link = current_binding_level->shadowed_labels;
 628        link;
 629        link = TREE_CHAIN (link))
 630     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
 631
 632   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
 633      list if a `using' declaration put them there.  The debugging
 634      back-ends won't understand OVERLOAD, so we remove them here.
 635      Because the BLOCK_VARS are (temporarily) shared with
 636      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
 637      popped all the bindings.  */
 638   if (block)
 639     {
 640       tree* d;
 641
 642       for (d = &BLOCK_VARS (block); *d; )
 643         {
 644           if (TREE_CODE (*d) == TREE_LIST)
 645             *d = TREE_CHAIN (*d);
 646           else
 647             d = &TREE_CHAIN (*d);
 648         }
 649     }
 650
 651   /* If the level being exited is the top level of a function,
 652      check over all the labels.  */
 653   if (functionbody)
 654     {
 655       /* Since this is the top level block of a function, the vars are
 656          the function's parameters.  Don't leave them in the BLOCK
 657          because they are found in the FUNCTION_DECL instead.  */
 658       BLOCK_VARS (block) = 0;
 659       pop_labels (block);
 660     }
 661
 662   kind = current_binding_level->kind;
 663   if (kind == sk_cleanup)
 664     {
 665       tree stmt;
 666
 667       /* If this is a temporary binding created for a cleanup, then we'll
 668          have pushed a statement list level.  Pop that, create a new
 669          BIND_EXPR for the block, and insert it into the stream.  */
 670       stmt = pop_stmt_list (current_binding_level->statement_list);
 671       stmt = c_build_bind_expr (block, stmt);
 672       add_stmt (stmt);
 673     }
 674
 675   leave_scope ();
 676   if (functionbody)
 677     DECL_INITIAL (current_function_decl) = block;
 678   else if (block)
 679     current_binding_level->blocks
 680       = chainon (current_binding_level->blocks, block);
 681
 682   /* If we did not make a block for the level just exited,
 683      any blocks made for inner levels
 684      (since they cannot be recorded as subblocks in that level)
 685      must be carried forward so they will later become subblocks
 686      of something else.  */
 687   else if (subblocks)
 688     current_binding_level->blocks
 689       = chainon (current_binding_level->blocks, subblocks);
 690
 691   /* Each and every BLOCK node created here in `poplevel' is important
 692      (e.g. for proper debugging information) so if we created one
 693      earlier, mark it as "used".  */
 694   if (block)
 695     TREE_USED (block) = 1;
 696
 697   /* All temporary bindings created for cleanups are popped silently.  */
 698   if (kind == sk_cleanup)
 699     goto restart;
 700
 701   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
 702 }
 703
 704 /* Delete the node BLOCK from the current binding level.
 705    This is used for the block inside a stmt expr ({...})
 706    so that the block can be reinserted where appropriate.  */
 707
 708 void
 709 delete_block (tree block)
 710 {
 711   tree t;
 712   if (current_binding_level->blocks == block)
 713     current_binding_level->blocks = TREE_CHAIN (block);
 714   for (t = current_binding_level->blocks; t;)
 715     {
 716       if (TREE_CHAIN (t) == block)
 717         TREE_CHAIN (t) = TREE_CHAIN (block);
 718       else
 719         t = TREE_CHAIN (t);
 720     }
 721   TREE_CHAIN (block) = NULL_TREE;
 722   /* Clear TREE_USED which is always set by poplevel.
 723      The flag is set again if insert_block is called.  */
 724   TREE_USED (block) = 0;
 725 }
 726
 727 /* Insert BLOCK at the end of the list of subblocks of the
 728    current binding level.  This is used when a BIND_EXPR is expanded,
 729    to handle the BLOCK node inside the BIND_EXPR.  */
 730
 731 void
 732 insert_block (tree block)
 733 {
 734   TREE_USED (block) = 1;
 735   current_binding_level->blocks
 736     = chainon (current_binding_level->blocks, block);
 737 }
 738
 739 /* Returns nonzero if T is a virtual function table.  */
 740
 741 int
 742 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
 743 {
 744   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
 745 }
 746
 747 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
 748    functions.  */
 749
 750 int
 751 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
 752 {
 753   return (TREE_CODE (t) == TYPE_DECL
 754           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
 755           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
 756 }
 757
 758 struct walk_globals_data {
 759   walk_globals_pred p;
 760   walk_globals_fn f;
 761   void *data;
 762 };
 763
 764 /* Walk the vtable declarations in NAMESPACE.  Whenever one is found
 765    for which P returns nonzero, call F with its address.  If any call
 766    to F returns a nonzero value, return a nonzero value.  */
 767
 768 static int
 769 walk_vtables_r (tree namespace, void* data)
 770 {
 771   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
 772   walk_globals_fn f = wgd->f;
 773   void *d = wgd->data;
 774   tree decl = NAMESPACE_LEVEL (namespace)->vtables;
 775   int result = 0;
 776
 777   for (; decl ; decl = TREE_CHAIN (decl))
 778     result |= (*f) (&decl, d);
 779
 780   return result;
 781 }
 782
 783 /* Walk the vtable declarations.  Whenever one is found for which P
 784    returns nonzero, call F with its address.  If any call to F
 785    returns a nonzero value, return a nonzero value.  */
 786 bool
 787 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
 788 {
 789   struct walk_globals_data wgd;
 790   wgd.p = p;
 791   wgd.f = f;
 792   wgd.data = data;
 793
 794   return walk_namespaces (walk_vtables_r, &wgd);
 795 }
 796
 797 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
 798    itself, calling F for each.  The DATA is passed to F as well.  */
 799
 800 static int
 801 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
 802 {
 803   int result = 0;
 804   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
 805
 806   result |= (*f) (namespace, data);
 807
 808   for (; current; current = TREE_CHAIN (current))
 809     result |= walk_namespaces_r (current, f, data);
 810
 811   return result;
 812 }
 813
 814 /* Walk all the namespaces, calling F for each.  The DATA is passed to
 815    F as well.  */
 816
 817 int
 818 walk_namespaces (walk_namespaces_fn f, void* data)
 819 {
 820   return walk_namespaces_r (global_namespace, f, data);
 821 }
 822
 823 /* Walk the global declarations in NAMESPACE.  Whenever one is found
 824    for which P returns nonzero, call F with its address.  If any call
 825    to F returns a nonzero value, return a nonzero value.  */
 826
 827 static int
 828 walk_globals_r (tree namespace, void* data)
 829 {
 830   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
 831   walk_globals_pred p = wgd->p;
 832   walk_globals_fn f = wgd->f;
 833   void *d = wgd->data;
 834   tree *t;
 835   int result = 0;
 836
 837   t = &NAMESPACE_LEVEL (namespace)->names;
 838
 839   while (*t)
 840     {
 841       tree glbl = *t;
 842
 843       if ((*p) (glbl, d))
 844         result |= (*f) (t, d);
 845
 846       /* If F changed *T, then *T still points at the next item to
 847          examine.  */
 848       if (*t == glbl)
 849         t = &TREE_CHAIN (*t);
 850     }
 851
 852   return result;
 853 }
 854
 855 /* Walk the global declarations.  Whenever one is found for which P
 856    returns true, call F with its address.  If any call to F
 857    returns true, return true.  */
 858
 859 bool
 860 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
 861 {
 862   struct walk_globals_data wgd;
 863   wgd.p = p;
 864   wgd.f = f;
 865   wgd.data = data;
 866
 867   return walk_namespaces (walk_globals_r, &wgd);
 868 }
 869
 870 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
 871    DATA is non-NULL, this is the last time we will call
 872    wrapup_global_declarations for this NAMESPACE.  */
 873
 874 int
 875 wrapup_globals_for_namespace (tree namespace, void* data)
 876 {
 877   struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
 878   varray_type statics = level->static_decls;
 879   tree *vec = &VARRAY_TREE (statics, 0);
 880   int len = VARRAY_ACTIVE_SIZE (statics);
 881   int last_time = (data != 0);
 882
 883   if (last_time)
 884     {
 885       check_global_declarations (vec, len);
 886       return 0;
 887     }
 888
 889   /* Write out any globals that need to be output.  */
 890   return wrapup_global_declarations (vec, len);
 891 }
 892
 893 \f
 894 /* In C++, you don't have to write `struct S' to refer to `S'; you
 895    can just use `S'.  We accomplish this by creating a TYPE_DECL as
 896    if the user had written `typedef struct S S'.  Create and return
 897    the TYPE_DECL for TYPE.  */
 898
 899 tree
 900 create_implicit_typedef (tree name, tree type)
 901 {
 902   tree decl;
 903
 904   decl = build_decl (TYPE_DECL, name, type);
 905   DECL_ARTIFICIAL (decl) = 1;
 906   /* There are other implicit type declarations, like the one *within*
 907      a class that allows you to write `S::S'.  We must distinguish
 908      amongst these.  */
 909   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
 910   TYPE_NAME (type) = decl;
 911
 912   return decl;
 913 }
 914
 915 /* Remember a local name for name-mangling purposes.  */
 916
 917 static void
 918 push_local_name (tree decl)
 919 {
 920   size_t i, nelts;
 921   tree t, name;
 922
 923   timevar_push (TV_NAME_LOOKUP);
 924   if (!local_names)
 925     VARRAY_TREE_INIT (local_names, 8, "local_names");
 926
 927   name = DECL_NAME (decl);
 928
 929   nelts = VARRAY_ACTIVE_SIZE (local_names);
 930   for (i = 0; i < nelts; i++)
 931     {
 932       t = VARRAY_TREE (local_names, i);
 933       if (DECL_NAME (t) == name)
 934         {
 935           if (!DECL_LANG_SPECIFIC (decl))
 936             retrofit_lang_decl (decl);
 937           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
 938           if (DECL_LANG_SPECIFIC (t))
 939             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
 940           else
 941             DECL_DISCRIMINATOR (decl) = 1;
 942
 943           VARRAY_TREE (local_names, i) = decl;
 944           timevar_pop (TV_NAME_LOOKUP);
 945           return;
 946         }
 947     }
 948
 949   VARRAY_PUSH_TREE (local_names, decl);
 950   timevar_pop (TV_NAME_LOOKUP);
 951 }
 952 \f
 953 /* Subroutine of duplicate_decls: return truthvalue of whether
 954    or not types of these decls match.
 955
 956    For C++, we must compare the parameter list so that `int' can match
 957    `int&' in a parameter position, but `int&' is not confused with
 958    `const int&'.  */
 959
 960 int
 961 decls_match (tree newdecl, tree olddecl)
 962 {
 963   int types_match;
 964
 965   if (newdecl == olddecl)
 966     return 1;
 967
 968   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
 969     /* If the two DECLs are not even the same kind of thing, we're not
 970        interested in their types.  */
 971     return 0;
 972
 973   if (TREE_CODE (newdecl) == FUNCTION_DECL)
 974     {
 975       tree f1 = TREE_TYPE (newdecl);
 976       tree f2 = TREE_TYPE (olddecl);
 977       tree p1 = TYPE_ARG_TYPES (f1);
 978       tree p2 = TYPE_ARG_TYPES (f2);
 979
 980       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
 981           && ! (DECL_EXTERN_C_P (newdecl)
 982                 && DECL_EXTERN_C_P (olddecl)))
 983         return 0;
 984
 985       if (TREE_CODE (f1) != TREE_CODE (f2))
 986         return 0;
 987
 988       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
 989         {
 990           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
 991               && (DECL_BUILT_IN (olddecl)
 992 #ifndef NO_IMPLICIT_EXTERN_C
 993                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
 994                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
 995 #endif
 996               ))
 997             {
 998               types_match = self_promoting_args_p (p1);
 999               if (p1 == void_list_node)
1000                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1001             }
1002 #ifndef NO_IMPLICIT_EXTERN_C
1003           else if (p1 == NULL_TREE
1004                    && (DECL_EXTERN_C_P (olddecl)
1005                        && DECL_IN_SYSTEM_HEADER (olddecl)
1006                        && !DECL_CLASS_SCOPE_P (olddecl))
1007                    && (DECL_EXTERN_C_P (newdecl)
1008                        && DECL_IN_SYSTEM_HEADER (newdecl)
1009                        && !DECL_CLASS_SCOPE_P (newdecl)))
1010             {
1011               types_match = self_promoting_args_p (p2);
1012               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1013             }
1014 #endif
1015           else
1016             types_match = compparms (p1, p2);
1017         }
1018       else
1019         types_match = 0;
1020     }
1021   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1022     {
1023       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1024           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1025         return 0;
1026
1027       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1028                                 DECL_TEMPLATE_PARMS (olddecl)))
1029         return 0;
1030
1031       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1032         types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1033                                    TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1034       else
1035         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1036                                    DECL_TEMPLATE_RESULT (newdecl));
1037     }
1038   else
1039     {
1040       if (TREE_TYPE (newdecl) == error_mark_node)
1041         types_match = TREE_TYPE (olddecl) == error_mark_node;
1042       else if (TREE_TYPE (olddecl) == NULL_TREE)
1043         types_match = TREE_TYPE (newdecl) == NULL_TREE;
1044       else if (TREE_TYPE (newdecl) == NULL_TREE)
1045         types_match = 0;
1046       else
1047         types_match = comptypes (TREE_TYPE (newdecl),
1048                                  TREE_TYPE (olddecl),
1049                                  COMPARE_REDECLARATION);
1050     }
1051
1052   return types_match;
1053 }
1054
1055 /* If NEWDECL is `static' and an `extern' was seen previously,
1056    warn about it.  OLDDECL is the previous declaration.
1057
1058    Note that this does not apply to the C++ case of declaring
1059    a variable `extern const' and then later `const'.
1060
1061    Don't complain about built-in functions, since they are beyond
1062    the user's control.  */
1063
1064 void
1065 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1066 {
1067   tree name;
1068
1069   if (TREE_CODE (newdecl) == TYPE_DECL
1070       || TREE_CODE (newdecl) == TEMPLATE_DECL
1071       || TREE_CODE (newdecl) == CONST_DECL
1072       || TREE_CODE (newdecl) == NAMESPACE_DECL)
1073     return;
1074
1075   /* Don't get confused by static member functions; that's a different
1076      use of `static'.  */
1077   if (TREE_CODE (newdecl) == FUNCTION_DECL
1078       && DECL_STATIC_FUNCTION_P (newdecl))
1079     return;
1080
1081   /* If the old declaration was `static', or the new one isn't, then
1082      then everything is OK.  */
1083   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1084     return;
1085
1086   /* It's OK to declare a builtin function as `static'.  */
1087   if (TREE_CODE (olddecl) == FUNCTION_DECL
1088       && DECL_ARTIFICIAL (olddecl))
1089     return;
1090
1091   name = DECL_ASSEMBLER_NAME (newdecl);
1092   pedwarn ("`%D' was declared `extern' and later `static'", newdecl);
1093   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
1094 }
1095
1096 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1097    If the redeclaration is invalid, a diagnostic is issued, and the
1098    error_mark_node is returned.  Otherwise, OLDDECL is returned.
1099
1100    If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1101    returned.  */
1102
1103 tree
1104 duplicate_decls (tree newdecl, tree olddecl)
1105 {
1106   unsigned olddecl_uid = DECL_UID (olddecl);
1107   int olddecl_friend = 0, types_match = 0;
1108   int new_defines_function = 0;
1109
1110   if (newdecl == olddecl)
1111     return olddecl;
1112
1113   types_match = decls_match (newdecl, olddecl);
1114
1115   /* If either the type of the new decl or the type of the old decl is an
1116      error_mark_node, then that implies that we have already issued an
1117      error (earlier) for some bogus type specification, and in that case,
1118      it is rather pointless to harass the user with yet more error message
1119      about the same declaration, so just pretend the types match here.  */
1120   if (TREE_TYPE (newdecl) == error_mark_node
1121       || TREE_TYPE (olddecl) == error_mark_node)
1122     types_match = 1;
1123
1124   if (DECL_P (olddecl)
1125       && TREE_CODE (newdecl) == FUNCTION_DECL
1126       && TREE_CODE (olddecl) == FUNCTION_DECL
1127       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1128     {
1129       if (DECL_DECLARED_INLINE_P (newdecl)
1130           && DECL_UNINLINABLE (newdecl)
1131           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1132         /* Already warned elsewhere.  */;
1133       else if (DECL_DECLARED_INLINE_P (olddecl)
1134                && DECL_UNINLINABLE (olddecl)
1135                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1136         /* Already warned.  */;
1137       else if (DECL_DECLARED_INLINE_P (newdecl)
1138                && DECL_UNINLINABLE (olddecl)
1139                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1140         {
1141           warning ("%Jfunction '%D' redeclared as inline", newdecl, newdecl);
1142           warning ("%Jprevious declaration of '%D' with attribute noinline",
1143                    olddecl, olddecl);
1144         }
1145       else if (DECL_DECLARED_INLINE_P (olddecl)
1146                && DECL_UNINLINABLE (newdecl)
1147                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1148         {
1149           warning ("%Jfunction '%D' redeclared with attribute noinline",
1150                    newdecl, newdecl);
1151           warning ("%Jprevious declaration of '%D' was inline",
1152                    olddecl, olddecl);
1153         }
1154     }
1155
1156   /* Check for redeclaration and other discrepancies.  */
1157   if (TREE_CODE (olddecl) == FUNCTION_DECL
1158       && DECL_ARTIFICIAL (olddecl))
1159     {
1160       if (TREE_CODE (newdecl) != FUNCTION_DECL)
1161         {
1162           /* Avoid warnings redeclaring anticipated built-ins.  */
1163           if (DECL_ANTICIPATED (olddecl))
1164             return NULL_TREE;
1165
1166           /* If you declare a built-in or predefined function name as static,
1167              the old definition is overridden, but optionally warn this was a
1168              bad choice of name.  */
1169           if (! TREE_PUBLIC (newdecl))
1170             {
1171               if (warn_shadow)
1172                 warning ("shadowing %s function `%#D'",
1173                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1174                             olddecl);
1175               /* Discard the old built-in function.  */
1176               return NULL_TREE;
1177             }
1178           /* If the built-in is not ansi, then programs can override
1179              it even globally without an error.  */
1180           else if (! DECL_BUILT_IN (olddecl))
1181             warning ("library function `%#D' redeclared as non-function `%#D'",
1182                         olddecl, newdecl);
1183           else
1184             {
1185               error ("declaration of `%#D'", newdecl);
1186               error ("conflicts with built-in declaration `%#D'",
1187                         olddecl);
1188             }
1189           return NULL_TREE;
1190         }
1191       else if (!types_match)
1192         {
1193           /* Avoid warnings redeclaring anticipated built-ins.  */
1194           if (DECL_ANTICIPATED (olddecl))
1195             {
1196               /* Deal with fileptr_type_node.  FILE type is not known
1197                  at the time we create the builtins.  */
1198               tree t1, t2;
1199
1200               for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1201                    t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1202                    t1 || t2;
1203                    t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1204                 if (!t1 || !t2)
1205                   break;
1206                 else if (TREE_VALUE (t2) == fileptr_type_node)
1207                   {
1208                     tree t = TREE_VALUE (t1);
1209
1210                     if (TREE_CODE (t) == POINTER_TYPE
1211                         && TYPE_NAME (TREE_TYPE (t))
1212                         && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1213                            == get_identifier ("FILE")
1214                         && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1215                       {
1216                         tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1217
1218                         TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1219                           = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1220                         types_match = decls_match (newdecl, olddecl);
1221                         if (types_match)
1222                           return duplicate_decls (newdecl, olddecl);
1223                         TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1224                       }
1225                   }
1226                 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1227                   break;
1228             }
1229           else if ((DECL_EXTERN_C_P (newdecl)
1230                     && DECL_EXTERN_C_P (olddecl))
1231                    || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1232                                  TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1233             {
1234               /* A near match; override the builtin.  */
1235
1236               if (TREE_PUBLIC (newdecl))
1237                 {
1238                   warning ("new declaration `%#D'", newdecl);
1239                   warning ("ambiguates built-in declaration `%#D'",
1240                               olddecl);
1241                 }
1242               else if (warn_shadow)
1243                 warning ("shadowing %s function `%#D'",
1244                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1245                             olddecl);
1246             }
1247           else
1248             /* Discard the old built-in function.  */
1249             return NULL_TREE;
1250
1251           /* Replace the old RTL to avoid problems with inlining.  */
1252           COPY_DECL_RTL (newdecl, olddecl);
1253         }
1254       /* Even if the types match, prefer the new declarations type
1255          for anticipated built-ins, for exception lists, etc...  */
1256       else if (DECL_ANTICIPATED (olddecl))
1257         {
1258           tree type = TREE_TYPE (newdecl);
1259           tree attribs = (*targetm.merge_type_attributes)
1260             (TREE_TYPE (olddecl), type);
1261
1262           type = cp_build_type_attribute_variant (type, attribs);
1263           TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1264         }
1265
1266       /* Whether or not the builtin can throw exceptions has no
1267          bearing on this declarator.  */
1268       TREE_NOTHROW (olddecl) = 0;
1269
1270       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1271         {
1272           /* If a builtin function is redeclared as `static', merge
1273              the declarations, but make the original one static.  */
1274           DECL_THIS_STATIC (olddecl) = 1;
1275           TREE_PUBLIC (olddecl) = 0;
1276
1277           /* Make the old declaration consistent with the new one so
1278              that all remnants of the builtin-ness of this function
1279              will be banished.  */
1280           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1281           COPY_DECL_RTL (newdecl, olddecl);
1282         }
1283     }
1284   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1285     {
1286       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1287            && TREE_CODE (newdecl) != TYPE_DECL
1288            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1289                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1290           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1291               && TREE_CODE (olddecl) != TYPE_DECL
1292               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1293                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1294                         == TYPE_DECL))))
1295         {
1296           /* We do nothing special here, because C++ does such nasty
1297              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
1298              get shadowed, and know that if we need to find a TYPE_DECL
1299              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1300              slot of the identifier.  */
1301           return NULL_TREE;
1302         }
1303
1304       if ((TREE_CODE (newdecl) == FUNCTION_DECL
1305            && DECL_FUNCTION_TEMPLATE_P (olddecl))
1306           || (TREE_CODE (olddecl) == FUNCTION_DECL
1307               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1308         return NULL_TREE;
1309
1310       error ("`%#D' redeclared as different kind of symbol", newdecl);
1311       if (TREE_CODE (olddecl) == TREE_LIST)
1312         olddecl = TREE_VALUE (olddecl);
1313       cp_error_at ("previous declaration of `%#D'", olddecl);
1314
1315       return error_mark_node;
1316     }
1317   else if (!types_match)
1318     {
1319       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1320         /* These are certainly not duplicate declarations; they're
1321            from different scopes.  */
1322         return NULL_TREE;
1323
1324       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1325         {
1326           /* The name of a class template may not be declared to refer to
1327              any other template, class, function, object, namespace, value,
1328              or type in the same scope.  */
1329           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1330               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1331             {
1332               error ("declaration of template `%#D'", newdecl);
1333               cp_error_at ("conflicts with previous declaration `%#D'",
1334                            olddecl);
1335             }
1336           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1337                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1338                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1339                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1340                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1341                                            DECL_TEMPLATE_PARMS (olddecl))
1342                    /* Template functions can be disambiguated by
1343                       return type.  */
1344                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1345                                    TREE_TYPE (TREE_TYPE (olddecl))))
1346             {
1347               error ("new declaration `%#D'", newdecl);
1348               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1349             }
1350           return NULL_TREE;
1351         }
1352       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1353         {
1354           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1355             {
1356               error ("declaration of C function `%#D' conflicts with",
1357                         newdecl);
1358               cp_error_at ("previous declaration `%#D' here", olddecl);
1359             }
1360           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1361                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1362             {
1363               error ("new declaration `%#D'", newdecl);
1364               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1365             }
1366           else
1367             return NULL_TREE;
1368         }
1369       else
1370         {
1371           error ("conflicting declaration '%#D'", newdecl);
1372           cp_error_at ("'%D' has a previous declaration as `%#D'",
1373                        olddecl, olddecl);
1374           return NULL_TREE;
1375         }
1376     }
1377   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1378             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1379                  && (!DECL_TEMPLATE_INFO (newdecl)
1380                      || (DECL_TI_TEMPLATE (newdecl)
1381                          != DECL_TI_TEMPLATE (olddecl))))
1382                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1383                     && (!DECL_TEMPLATE_INFO (olddecl)
1384                         || (DECL_TI_TEMPLATE (olddecl)
1385                             != DECL_TI_TEMPLATE (newdecl))))))
1386     /* It's OK to have a template specialization and a non-template
1387        with the same type, or to have specializations of two
1388        different templates with the same type.  Note that if one is a
1389        specialization, and the other is an instantiation of the same
1390        template, that we do not exit at this point.  That situation
1391        can occur if we instantiate a template class, and then
1392        specialize one of its methods.  This situation is valid, but
1393        the declarations must be merged in the usual way.  */
1394     return NULL_TREE;
1395   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1396            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1397                 && !DECL_USE_TEMPLATE (newdecl))
1398                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1399                    && !DECL_USE_TEMPLATE (olddecl))))
1400     /* One of the declarations is a template instantiation, and the
1401        other is not a template at all.  That's OK.  */
1402     return NULL_TREE;
1403   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
1404            && DECL_NAMESPACE_ALIAS (newdecl)
1405            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
1406     /* In [namespace.alias] we have:
1407
1408          In a declarative region, a namespace-alias-definition can be
1409          used to redefine a namespace-alias declared in that declarative
1410          region to refer only to the namespace to which it already
1411          refers.
1412
1413       Therefore, if we encounter a second alias directive for the same
1414       alias, we can just ignore the second directive.  */
1415     return olddecl;
1416   else
1417     {
1418       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1419       if (errmsg)
1420         {
1421           error (errmsg, newdecl);
1422           if (DECL_NAME (olddecl) != NULL_TREE)
1423             cp_error_at ((DECL_INITIAL (olddecl)
1424                           && namespace_bindings_p ())
1425                          ? "`%#D' previously defined here"
1426                          : "`%#D' previously declared here", olddecl);
1427           return error_mark_node;
1428         }
1429       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1430                && DECL_INITIAL (olddecl) != NULL_TREE
1431                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1432                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1433         {
1434           /* Prototype decl follows defn w/o prototype.  */
1435           cp_warning_at ("prototype for `%#D'", newdecl);
1436           warning ("%Jfollows non-prototype definition here", olddecl);
1437         }
1438       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1439                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1440         {
1441           /* extern "C" int foo ();
1442              int foo () { bar (); }
1443              is OK.  */
1444           if (current_lang_depth () == 0)
1445             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1446           else
1447             {
1448               cp_error_at ("previous declaration of `%#D' with %L linkage",
1449                            olddecl, DECL_LANGUAGE (olddecl));
1450               error ("conflicts with new declaration with %L linkage",
1451                         DECL_LANGUAGE (newdecl));
1452             }
1453         }
1454
1455       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1456         ;
1457       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1458         {
1459           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1460           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1461           int i = 1;
1462
1463           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1464             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1465
1466           for (; t1 && t1 != void_list_node;
1467                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1468             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1469               {
1470                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1471                                            TREE_PURPOSE (t2)))
1472                   {
1473                     pedwarn ("default argument given for parameter %d of `%#D'",
1474                              i, newdecl);
1475                     cp_pedwarn_at ("after previous specification in `%#D'",
1476                                    olddecl);
1477                   }
1478                 else
1479                   {
1480                     error ("default argument given for parameter %d of `%#D'",
1481                               i, newdecl);
1482                     cp_error_at ("after previous specification in `%#D'",
1483                                  olddecl);
1484                   }
1485               }
1486
1487           if (DECL_DECLARED_INLINE_P (newdecl)
1488               && ! DECL_DECLARED_INLINE_P (olddecl)
1489               && TREE_ADDRESSABLE (olddecl) && warn_inline)
1490             {
1491               warning ("`%#D' was used before it was declared inline", newdecl);
1492               warning ("%Jprevious non-inline declaration here", olddecl);
1493             }
1494         }
1495     }
1496
1497   /* Do not merge an implicit typedef with an explicit one.  In:
1498
1499        class A;
1500        ...
1501        typedef class A A __attribute__ ((foo));
1502
1503      the attribute should apply only to the typedef.  */
1504   if (TREE_CODE (olddecl) == TYPE_DECL
1505       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1506           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1507     return NULL_TREE;
1508
1509   /* If new decl is `static' and an `extern' was seen previously,
1510      warn about it.  */
1511   warn_extern_redeclared_static (newdecl, olddecl);
1512
1513   /* We have committed to returning 1 at this point.  */
1514   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1515     {
1516       /* Now that functions must hold information normally held
1517          by field decls, there is extra work to do so that
1518          declaration information does not get destroyed during
1519          definition.  */
1520       if (DECL_VINDEX (olddecl))
1521         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1522       if (DECL_CONTEXT (olddecl))
1523         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1524       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1525       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1526       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1527       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1528       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
1529       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1530       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1531         SET_OVERLOADED_OPERATOR_CODE
1532           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1533       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1534
1535       /* Optionally warn about more than one declaration for the same
1536          name, but don't warn about a function declaration followed by a
1537          definition.  */
1538       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1539           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1540           /* Don't warn about extern decl followed by definition.  */
1541           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1542           /* Don't warn about friends, let add_friend take care of it.  */
1543           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
1544         {
1545           warning ("redundant redeclaration of `%D' in same scope", newdecl);
1546           cp_warning_at ("previous declaration of `%D'", olddecl);
1547         }
1548     }
1549
1550   /* Deal with C++: must preserve virtual function table size.  */
1551   if (TREE_CODE (olddecl) == TYPE_DECL)
1552     {
1553       tree newtype = TREE_TYPE (newdecl);
1554       tree oldtype = TREE_TYPE (olddecl);
1555
1556       if (newtype != error_mark_node && oldtype != error_mark_node
1557           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1558         CLASSTYPE_FRIEND_CLASSES (newtype)
1559           = CLASSTYPE_FRIEND_CLASSES (oldtype);
1560
1561       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1562     }
1563
1564   /* Copy all the DECL_... slots specified in the new decl
1565      except for any that we copy here from the old type.  */
1566   DECL_ATTRIBUTES (newdecl)
1567     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1568
1569   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1570     {
1571       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
1572       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1573         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1574                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1575
1576       /* If the new declaration is a definition, update the file and
1577          line information on the declaration.  */
1578       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
1579           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
1580         {
1581           DECL_SOURCE_LOCATION (olddecl)
1582             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
1583             = DECL_SOURCE_LOCATION (newdecl);
1584           if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1585             DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl))
1586               = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl));
1587         }
1588
1589       if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1590         {
1591           DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl))
1592             |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl));
1593           DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl))
1594             |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl));
1595         }
1596
1597       return olddecl;
1598     }
1599
1600   if (types_match)
1601     {
1602       /* Automatically handles default parameters.  */
1603       tree oldtype = TREE_TYPE (olddecl);
1604       tree newtype;
1605
1606       /* Merge the data types specified in the two decls.  */
1607       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1608
1609       /* If merge_types produces a non-typedef type, just use the old type.  */
1610       if (TREE_CODE (newdecl) == TYPE_DECL
1611           && newtype == DECL_ORIGINAL_TYPE (newdecl))
1612         newtype = oldtype;
1613
1614       if (TREE_CODE (newdecl) == VAR_DECL)
1615         {
1616           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1617           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1618           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1619             |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1620         }
1621
1622       /* Do this after calling `merge_types' so that default
1623          parameters don't confuse us.  */
1624       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1625           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
1626               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
1627         {
1628           TREE_TYPE (newdecl) = build_exception_variant (newtype,
1629                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
1630           TREE_TYPE (olddecl) = build_exception_variant (newtype,
1631                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
1632
1633           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
1634               && ! DECL_IS_BUILTIN (olddecl)
1635               && flag_exceptions
1636               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
1637                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
1638             {
1639               error ("declaration of `%F' throws different exceptions",
1640                         newdecl);
1641               cp_error_at ("than previous declaration `%F'", olddecl);
1642             }
1643         }
1644       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1645
1646       /* Lay the type out, unless already done.  */
1647       if (! same_type_p (newtype, oldtype)
1648           && TREE_TYPE (newdecl) != error_mark_node
1649           && !(processing_template_decl && uses_template_parms (newdecl)))
1650         layout_type (TREE_TYPE (newdecl));
1651
1652       if ((TREE_CODE (newdecl) == VAR_DECL
1653            || TREE_CODE (newdecl) == PARM_DECL
1654            || TREE_CODE (newdecl) == RESULT_DECL
1655            || TREE_CODE (newdecl) == FIELD_DECL
1656            || TREE_CODE (newdecl) == TYPE_DECL)
1657           && !(processing_template_decl && uses_template_parms (newdecl)))
1658         layout_decl (newdecl, 0);
1659
1660       /* Merge the type qualifiers.  */
1661       if (TREE_READONLY (newdecl))
1662         TREE_READONLY (olddecl) = 1;
1663       if (TREE_THIS_VOLATILE (newdecl))
1664         TREE_THIS_VOLATILE (olddecl) = 1;
1665
1666       /* Merge the initialization information.  */
1667       if (DECL_INITIAL (newdecl) == NULL_TREE
1668           && DECL_INITIAL (olddecl) != NULL_TREE)
1669         {
1670           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1671           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1672           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1673               && DECL_LANG_SPECIFIC (newdecl)
1674               && DECL_LANG_SPECIFIC (olddecl))
1675             {
1676               DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1677               DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1678             }
1679         }
1680
1681       /* Merge the section attribute.
1682          We want to issue an error if the sections conflict but that must be
1683          done later in decl_attributes since we are called before attributes
1684          are assigned.  */
1685       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1686         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1687
1688       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1689         {
1690           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1691             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1692           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1693           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1694           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1695           TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1696           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1697           DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1698           /* Keep the old RTL.  */
1699           COPY_DECL_RTL (olddecl, newdecl);
1700         }
1701       else if (TREE_CODE (newdecl) == VAR_DECL
1702                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1703         {
1704           /* Keep the old RTL.  We cannot keep the old RTL if the old
1705              declaration was for an incomplete object and the new
1706              declaration is not since many attributes of the RTL will
1707              change.  */
1708           COPY_DECL_RTL (olddecl, newdecl);
1709         }
1710     }
1711   /* If cannot merge, then use the new type and qualifiers,
1712      and don't preserve the old rtl.  */
1713   else
1714     {
1715       /* Clean out any memory we had of the old declaration.  */
1716       tree oldstatic = value_member (olddecl, static_aggregates);
1717       if (oldstatic)
1718         TREE_VALUE (oldstatic) = error_mark_node;
1719
1720       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1721       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1722       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1723       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1724     }
1725
1726   /* Merge the storage class information.  */
1727   merge_weak (newdecl, olddecl);
1728
1729   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1730   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1731   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1732   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1733   if (! DECL_EXTERNAL (olddecl))
1734     DECL_EXTERNAL (newdecl) = 0;
1735
1736   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1737     {
1738       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1739       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1740       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1741       DECL_TEMPLATE_INSTANTIATED (newdecl)
1742         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1743       /* Don't really know how much of the language-specific
1744          values we should copy from old to new.  */
1745       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1746       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1747         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1748       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1749       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1750       DECL_INITIALIZED_IN_CLASS_P (newdecl)
1751         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1752       olddecl_friend = DECL_FRIEND_P (olddecl);
1753
1754       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
1755       if (TREE_CODE (newdecl) == FUNCTION_DECL
1756           || DECL_FUNCTION_TEMPLATE_P (newdecl))
1757         {
1758           DECL_BEFRIENDING_CLASSES (newdecl)
1759             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1760                        DECL_BEFRIENDING_CLASSES (olddecl));
1761           /* DECL_THUNKS is only valid for virtual functions,
1762              otherwise it is a DECL_FRIEND_CONTEXT.  */
1763           if (DECL_VIRTUAL_P (newdecl))
1764             DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1765         }
1766     }
1767
1768   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1769     {
1770       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1771           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1772         {
1773           /* If newdecl is not a specialization, then it is not a
1774              template-related function at all.  And that means that we
1775              should have exited above, returning 0.  */
1776           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
1777                               0);
1778
1779           if (TREE_USED (olddecl))
1780             /* From [temp.expl.spec]:
1781
1782                If a template, a member template or the member of a class
1783                template is explicitly specialized then that
1784                specialization shall be declared before the first use of
1785                that specialization that would cause an implicit
1786                instantiation to take place, in every translation unit in
1787                which such a use occurs.  */
1788             error ("explicit specialization of %D after first use",
1789                       olddecl);
1790
1791           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1792
1793           /* [temp.expl.spec/14] We don't inline explicit specialization
1794              just because the primary template says so.  */
1795         }
1796       else
1797         {
1798           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1799             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1800
1801           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1802
1803           /* If either decl says `inline', this fn is inline, unless
1804              its definition was passed already.  */
1805           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1806             DECL_INLINE (olddecl) = 1;
1807           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1808
1809           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1810             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1811         }
1812
1813       /* Preserve abstractness on cloned [cd]tors.  */
1814       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1815
1816       if (! types_match)
1817         {
1818           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1819           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1820           COPY_DECL_RTL (newdecl, olddecl);
1821         }
1822       if (! types_match || new_defines_function)
1823         {
1824           /* These need to be copied so that the names are available.
1825              Note that if the types do match, we'll preserve inline
1826              info and other bits, but if not, we won't.  */
1827           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1828           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1829         }
1830       if (new_defines_function)
1831         /* If defining a function declared with other language
1832            linkage, use the previously declared language linkage.  */
1833         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1834       else if (types_match)
1835         {
1836           /* If redeclaring a builtin function, and not a definition,
1837              it stays built in.  */
1838           if (DECL_BUILT_IN (olddecl))
1839             {
1840               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1841               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1842               /* If we're keeping the built-in definition, keep the rtl,
1843                  regardless of declaration matches.  */
1844               COPY_DECL_RTL (olddecl, newdecl);
1845             }
1846
1847           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1848           /* Don't clear out the arguments if we're redefining a function.  */
1849           if (DECL_ARGUMENTS (olddecl))
1850             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1851         }
1852     }
1853   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1854     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1855
1856   /* Now preserve various other info from the definition.  */
1857   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1858   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1859   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1860   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1861
1862   /* If either declaration has a nondefault visibility, use it.  */
1863   if (DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT)
1864     {
1865       if (DECL_VISIBILITY (newdecl) != VISIBILITY_DEFAULT
1866           && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1867         {
1868           warning ("%J'%D': visibility attribute ignored because it",
1869                    newdecl, newdecl);
1870           warning ("%Jconflicts with previous declaration here", olddecl);
1871         }
1872       DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1873     }
1874
1875   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1876     {
1877       int function_size;
1878
1879       function_size = sizeof (struct tree_decl);
1880
1881       memcpy ((char *) olddecl + sizeof (struct tree_common),
1882               (char *) newdecl + sizeof (struct tree_common),
1883               function_size - sizeof (struct tree_common));
1884
1885       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
1886         /* If newdecl is a template instantiation, it is possible that
1887            the following sequence of events has occurred:
1888
1889            o A friend function was declared in a class template.  The
1890            class template was instantiated.
1891
1892            o The instantiation of the friend declaration was
1893            recorded on the instantiation list, and is newdecl.
1894
1895            o Later, however, instantiate_class_template called pushdecl
1896            on the newdecl to perform name injection.  But, pushdecl in
1897            turn called duplicate_decls when it discovered that another
1898            declaration of a global function with the same name already
1899            existed.
1900
1901            o Here, in duplicate_decls, we decided to clobber newdecl.
1902
1903            If we're going to do that, we'd better make sure that
1904            olddecl, and not newdecl, is on the list of
1905            instantiations so that if we try to do the instantiation
1906            again we won't get the clobbered declaration.  */
1907         reregister_specialization (newdecl,
1908                                    DECL_TI_TEMPLATE (newdecl),
1909                                    olddecl);
1910     }
1911   else
1912     {
1913       memcpy ((char *) olddecl + sizeof (struct tree_common),
1914               (char *) newdecl + sizeof (struct tree_common),
1915               sizeof (struct tree_decl) - sizeof (struct tree_common)
1916               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1917     }
1918
1919   DECL_UID (olddecl) = olddecl_uid;
1920   if (olddecl_friend)
1921     DECL_FRIEND_P (olddecl) = 1;
1922
1923   /* NEWDECL contains the merged attribute lists.
1924      Update OLDDECL to be the same.  */
1925   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1926
1927   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1928     so that encode_section_info has a chance to look at the new decl
1929     flags and attributes.  */
1930   if (DECL_RTL_SET_P (olddecl)
1931       && (TREE_CODE (olddecl) == FUNCTION_DECL
1932           || (TREE_CODE (olddecl) == VAR_DECL
1933               && TREE_STATIC (olddecl))))
1934     make_decl_rtl (olddecl, NULL);
1935
1936   return olddecl;
1937 }
1938 \f
1939 /* Return zero if the declaration NEWDECL is valid
1940    when the declaration OLDDECL (assumed to be for the same name)
1941    has already been seen.
1942    Otherwise return an error message format string with a %s
1943    where the identifier should go.  */
1944
1945 static const char *
1946 redeclaration_error_message (tree newdecl, tree olddecl)
1947 {
1948   if (TREE_CODE (newdecl) == TYPE_DECL)
1949     {
1950       /* Because C++ can put things into name space for free,
1951          constructs like "typedef struct foo { ... } foo"
1952          would look like an erroneous redeclaration.  */
1953       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
1954         return 0;
1955       else
1956         return "redefinition of `%#D'";
1957     }
1958   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1959     {
1960       /* If this is a pure function, its olddecl will actually be
1961          the original initialization to `0' (which we force to call
1962          abort()).  Don't complain about redefinition in this case.  */
1963       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
1964         return 0;
1965
1966       /* If both functions come from different namespaces, this is not
1967          a redeclaration - this is a conflict with a used function.  */
1968       if (DECL_NAMESPACE_SCOPE_P (olddecl)
1969           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
1970         return "`%D' conflicts with used function";
1971
1972       /* We'll complain about linkage mismatches in
1973          warn_extern_redeclared_static.  */
1974
1975       /* Defining the same name twice is no good.  */
1976       if (DECL_INITIAL (olddecl) != NULL_TREE
1977           && DECL_INITIAL (newdecl) != NULL_TREE)
1978         {
1979           if (DECL_NAME (olddecl) == NULL_TREE)
1980             return "`%#D' not declared in class";
1981           else
1982             return "redefinition of `%#D'";
1983         }
1984       return 0;
1985     }
1986   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1987     {
1988       tree nt, ot;
1989
1990       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1991         {
1992           if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
1993               && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
1994             return "redefinition of `%#D'";
1995           return NULL;
1996         }
1997
1998       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
1999           || (DECL_TEMPLATE_RESULT (newdecl)
2000               == DECL_TEMPLATE_RESULT (olddecl)))
2001         return NULL;
2002
2003       nt = DECL_TEMPLATE_RESULT (newdecl);
2004       if (DECL_TEMPLATE_INFO (nt))
2005         nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2006       ot = DECL_TEMPLATE_RESULT (olddecl);
2007       if (DECL_TEMPLATE_INFO (ot))
2008         ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2009       if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2010         return "redefinition of `%#D'";
2011
2012       return NULL;
2013     }
2014   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2015     {
2016       /* Objects declared at top level:  */
2017       /* If at least one is a reference, it's ok.  */
2018       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2019         return 0;
2020       /* Reject two definitions.  */
2021       return "redefinition of `%#D'";
2022     }
2023   else
2024     {
2025       /* Objects declared with block scope:  */
2026       /* Reject two definitions, and reject a definition
2027          together with an external reference.  */
2028       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2029         return "redeclaration of `%#D'";
2030       return 0;
2031     }
2032 }
2033 \f
2034 /* Create a new label, named ID.  */
2035
2036 static tree
2037 make_label_decl (tree id, int local_p)
2038 {
2039   tree decl;
2040
2041   decl = build_decl (LABEL_DECL, id, void_type_node);
2042
2043   DECL_CONTEXT (decl) = current_function_decl;
2044   DECL_MODE (decl) = VOIDmode;
2045   C_DECLARED_LABEL_FLAG (decl) = local_p;
2046
2047   /* Say where one reference is to the label, for the sake of the
2048      error if it is not defined.  */
2049   DECL_SOURCE_LOCATION (decl) = input_location;
2050
2051   /* Record the fact that this identifier is bound to this label.  */
2052   SET_IDENTIFIER_LABEL_VALUE (id, decl);
2053
2054   return decl;
2055 }
2056
2057 /* Record this label on the list of used labels so that we can check
2058    at the end of the function to see whether or not the label was
2059    actually defined, and so we can check when the label is defined whether
2060    this use is valid.  */
2061
2062 static void
2063 use_label (tree decl)
2064 {
2065   if (named_label_uses == NULL
2066       || named_label_uses->names_in_scope != current_binding_level->names
2067       || named_label_uses->label_decl != decl)
2068     {
2069       struct named_label_use_list *new_ent;
2070       new_ent = ggc_alloc (sizeof (struct named_label_use_list));
2071       new_ent->label_decl = decl;
2072       new_ent->names_in_scope = current_binding_level->names;
2073       new_ent->binding_level = current_binding_level;
2074       new_ent->o_goto_locus = input_location;
2075       new_ent->next = named_label_uses;
2076       named_label_uses = new_ent;
2077     }
2078 }
2079
2080 /* Look for a label named ID in the current function.  If one cannot
2081    be found, create one.  (We keep track of used, but undefined,
2082    labels, and complain about them at the end of a function.)  */
2083
2084 tree
2085 lookup_label (tree id)
2086 {
2087   tree decl;
2088   struct named_label_list *ent;
2089
2090   timevar_push (TV_NAME_LOOKUP);
2091   /* You can't use labels at global scope.  */
2092   if (current_function_decl == NULL_TREE)
2093     {
2094       error ("label `%E' referenced outside of any function", id);
2095       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2096     }
2097
2098   /* See if we've already got this label.  */
2099   decl = IDENTIFIER_LABEL_VALUE (id);
2100   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2101     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2102
2103   /* Record this label on the list of labels used in this function.
2104      We do this before calling make_label_decl so that we get the
2105      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
2106   ent = ggc_alloc_cleared (sizeof (struct named_label_list));
2107   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2108   ent->next = named_labels;
2109   named_labels = ent;
2110
2111   /* We need a new label.  */
2112   decl = make_label_decl (id, /*local_p=*/0);
2113
2114   /* Now fill in the information we didn't have before.  */
2115   ent->label_decl = decl;
2116
2117   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2118 }
2119
2120 /* Declare a local label named ID.  */
2121
2122 tree
2123 declare_local_label (tree id)
2124 {
2125   tree decl;
2126
2127   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2128      this scope we can restore the old value of
2129      IDENTIFIER_TYPE_VALUE.  */
2130   current_binding_level->shadowed_labels
2131     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2132                  current_binding_level->shadowed_labels);
2133   /* Look for the label.  */
2134   decl = make_label_decl (id, /*local_p=*/1);
2135   /* Now fill in the information we didn't have before.  */
2136   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2137
2138   return decl;
2139 }
2140
2141 /* Returns nonzero if it is ill-formed to jump past the declaration of
2142    DECL.  Returns 2 if it's also a real problem.  */
2143
2144 static int
2145 decl_jump_unsafe (tree decl)
2146 {
2147   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
2148     return 0;
2149
2150   if (DECL_INITIAL (decl) == NULL_TREE
2151       && pod_type_p (TREE_TYPE (decl)))
2152     return 0;
2153
2154   /* This is really only important if we're crossing an initialization.
2155      The POD stuff is just pedantry; why should it matter if the class
2156      contains a field of pointer to member type?  */
2157   if (DECL_INITIAL (decl)
2158       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
2159     return 2;
2160   return 1;
2161 }
2162
2163 /* Check that a single previously seen jump to a newly defined label
2164    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2165    the jump context; NAMES are the names in scope in LEVEL at the jump
2166    context; FILE and LINE are the source position of the jump or 0.  */
2167
2168 static void
2169 check_previous_goto_1 (tree decl,
2170                        struct cp_binding_level* level,
2171                        tree names, const location_t *locus)
2172 {
2173   int identified = 0;
2174   int saw_eh = 0;
2175   struct cp_binding_level *b = current_binding_level;
2176   for (; b; b = b->level_chain)
2177     {
2178       tree new_decls = b->names;
2179       tree old_decls = (b == level ? names : NULL_TREE);
2180       for (; new_decls != old_decls;
2181            new_decls = TREE_CHAIN (new_decls))
2182         {
2183           int problem = decl_jump_unsafe (new_decls);
2184           if (! problem)
2185             continue;
2186
2187           if (! identified)
2188             {
2189               if (decl)
2190                 pedwarn ("jump to label `%D'", decl);
2191               else
2192                 pedwarn ("jump to case label");
2193
2194               if (locus)
2195                 pedwarn ("%H  from here", locus);
2196               identified = 1;
2197             }
2198
2199           if (problem > 1)
2200             cp_error_at ("  crosses initialization of `%#D'",
2201                          new_decls);
2202           else
2203             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
2204                            new_decls);
2205         }
2206
2207       if (b == level)
2208         break;
2209       if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2210         {
2211           if (! identified)
2212             {
2213               if (decl)
2214                 pedwarn ("jump to label `%D'", decl);
2215               else
2216                 pedwarn ("jump to case label");
2217
2218               if (locus)
2219                 pedwarn ("%H  from here", locus);
2220               identified = 1;
2221             }
2222           if (b->kind == sk_try)
2223             error ("  enters try block");
2224           else
2225             error ("  enters catch block");
2226           saw_eh = 1;
2227         }
2228     }
2229 }
2230
2231 static void
2232 check_previous_goto (struct named_label_use_list* use)
2233 {
2234   check_previous_goto_1 (use->label_decl, use->binding_level,
2235                          use->names_in_scope, &use->o_goto_locus);
2236 }
2237
2238 static void
2239 check_switch_goto (struct cp_binding_level* level)
2240 {
2241   check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2242 }
2243
2244 /* Check that any previously seen jumps to a newly defined label DECL
2245    are OK.  Called by define_label.  */
2246
2247 static void
2248 check_previous_gotos (tree decl)
2249 {
2250   struct named_label_use_list **usep;
2251
2252   if (! TREE_USED (decl))
2253     return;
2254
2255   for (usep = &named_label_uses; *usep; )
2256     {
2257       struct named_label_use_list *use = *usep;
2258       if (use->label_decl == decl)
2259         {
2260           check_previous_goto (use);
2261           *usep = use->next;
2262         }
2263       else
2264         usep = &(use->next);
2265     }
2266 }
2267
2268 /* Check that a new jump to a label DECL is OK.  Called by
2269    finish_goto_stmt.  */
2270
2271 void
2272 check_goto (tree decl)
2273 {
2274   int identified = 0;
2275   tree bad;
2276   struct named_label_list *lab;
2277
2278   /* We can't know where a computed goto is jumping.  So we assume
2279      that it's OK.  */
2280   if (! DECL_P (decl))
2281     return;
2282
2283   /* If the label hasn't been defined yet, defer checking.  */
2284   if (! DECL_INITIAL (decl))
2285     {
2286       use_label (decl);
2287       return;
2288     }
2289
2290   for (lab = named_labels; lab; lab = lab->next)
2291     if (decl == lab->label_decl)
2292       break;
2293
2294   /* If the label is not on named_labels it's a gcc local label, so
2295      it must be in an outer scope, so jumping to it is always OK.  */
2296   if (lab == 0)
2297     return;
2298
2299   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2300       && !identified)
2301     {
2302       cp_pedwarn_at ("jump to label `%D'", decl);
2303       pedwarn ("  from here");
2304       identified = 1;
2305     }
2306
2307   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2308     {
2309       tree b = TREE_VALUE (bad);
2310       int u = decl_jump_unsafe (b);
2311
2312       if (u > 1 && DECL_ARTIFICIAL (b))
2313         /* Can't skip init of __exception_info.  */
2314         error ("%J  enters catch block", b);
2315       else if (u > 1)
2316         cp_error_at ("  skips initialization of `%#D'", b);
2317       else
2318         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
2319     }
2320
2321   if (lab->in_try_scope)
2322     error ("  enters try block");
2323   else if (lab->in_catch_scope)
2324     error ("  enters catch block");
2325 }
2326
2327 /* Define a label, specifying the location in the source file.
2328    Return the LABEL_DECL node for the label.  */
2329
2330 tree
2331 define_label (location_t location, tree name)
2332 {
2333   tree decl = lookup_label (name);
2334   struct named_label_list *ent;
2335   struct cp_binding_level *p;
2336
2337   timevar_push (TV_NAME_LOOKUP);
2338   for (ent = named_labels; ent; ent = ent->next)
2339     if (ent->label_decl == decl)
2340       break;
2341
2342   /* After labels, make any new cleanups in the function go into their
2343      own new (temporary) binding contour.  */
2344   for (p = current_binding_level;
2345        p->kind != sk_function_parms;
2346        p = p->level_chain)
2347     p->more_cleanups_ok = 0;
2348
2349   if (name == get_identifier ("wchar_t"))
2350     pedwarn ("label named wchar_t");
2351
2352   if (DECL_INITIAL (decl) != NULL_TREE)
2353     error ("duplicate label `%D'", decl);
2354   else
2355     {
2356       /* Mark label as having been defined.  */
2357       DECL_INITIAL (decl) = error_mark_node;
2358       /* Say where in the source.  */
2359       DECL_SOURCE_LOCATION (decl) = location;
2360       if (ent)
2361         {
2362           ent->names_in_scope = current_binding_level->names;
2363           ent->binding_level = current_binding_level;
2364         }
2365       check_previous_gotos (decl);
2366     }
2367
2368   timevar_pop (TV_NAME_LOOKUP);
2369   return decl;
2370 }
2371
2372 struct cp_switch
2373 {
2374   struct cp_binding_level *level;
2375   struct cp_switch *next;
2376   /* The SWITCH_STMT being built.  */
2377   tree switch_stmt;
2378   /* A splay-tree mapping the low element of a case range to the high
2379      element, or NULL_TREE if there is no high element.  Used to
2380      determine whether or not a new case label duplicates an old case
2381      label.  We need a tree, rather than simply a hash table, because
2382      of the GNU case range extension.  */
2383   splay_tree cases;
2384 };
2385
2386 /* A stack of the currently active switch statements.  The innermost
2387    switch statement is on the top of the stack.  There is no need to
2388    mark the stack for garbage collection because it is only active
2389    during the processing of the body of a function, and we never
2390    collect at that point.  */
2391
2392 static struct cp_switch *switch_stack;
2393
2394 /* Called right after a switch-statement condition is parsed.
2395    SWITCH_STMT is the switch statement being parsed.  */
2396
2397 void
2398 push_switch (tree switch_stmt)
2399 {
2400   struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2401   p->level = current_binding_level;
2402   p->next = switch_stack;
2403   p->switch_stmt = switch_stmt;
2404   p->cases = splay_tree_new (case_compare, NULL, NULL);
2405   switch_stack = p;
2406 }
2407
2408 void
2409 pop_switch (void)
2410 {
2411   struct cp_switch *cs = switch_stack;
2412
2413   /* Emit warnings as needed.  */
2414   c_do_switch_warnings (cs->cases, cs->switch_stmt);
2415
2416   splay_tree_delete (cs->cases);
2417   switch_stack = switch_stack->next;
2418   free (cs);
2419 }
2420
2421 /* Note that we've seen a definition of a case label, and complain if this
2422    is a bad place for one.  */
2423
2424 tree
2425 finish_case_label (tree low_value, tree high_value)
2426 {
2427   tree cond, r;
2428   struct cp_binding_level *p;
2429
2430   if (processing_template_decl)
2431     {
2432       tree label;
2433
2434       /* For templates, just add the case label; we'll do semantic
2435          analysis at instantiation-time.  */
2436       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2437       return add_stmt (build_case_label (low_value, high_value, label));
2438     }
2439
2440   /* Find the condition on which this switch statement depends.  */
2441   cond = SWITCH_COND (switch_stack->switch_stmt);
2442   if (cond && TREE_CODE (cond) == TREE_LIST)
2443     cond = TREE_VALUE (cond);
2444
2445   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
2446
2447   check_switch_goto (switch_stack->level);
2448
2449   /* After labels, make any new cleanups in the function go into their
2450      own new (temporary) binding contour.  */
2451   for (p = current_binding_level;
2452        p->kind != sk_function_parms;
2453        p = p->level_chain)
2454     p->more_cleanups_ok = 0;
2455
2456   return r;
2457 }
2458 \f
2459 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
2460
2461 static hashval_t
2462 typename_hash (const void* k)
2463 {
2464   hashval_t hash;
2465   tree t = (tree) k;
2466
2467   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2468           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2469
2470   return hash;
2471 }
2472
2473 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
2474
2475 static int
2476 typename_compare (const void * k1, const void * k2)
2477 {
2478   tree t1;
2479   tree t2;
2480   tree d1;
2481   tree d2;
2482
2483   t1 = (tree) k1;
2484   t2 = (tree) k2;
2485   d1 = TYPE_NAME (t1);
2486   d2 = TYPE_NAME (t2);
2487
2488   return (DECL_NAME (d1) == DECL_NAME (d2)
2489           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
2490           && ((TREE_TYPE (t1) != NULL_TREE)
2491               == (TREE_TYPE (t2) != NULL_TREE))
2492           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2493           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
2494 }
2495
2496 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
2497    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
2498    is non-NULL, this type is being created by the implicit typename
2499    extension, and BASE_TYPE is a type named `t' in some base class of
2500    `T' which depends on template parameters.
2501
2502    Returns the new TYPENAME_TYPE.  */
2503
2504 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2505
2506 static tree
2507 build_typename_type (tree context, tree name, tree fullname)
2508 {
2509   tree t;
2510   tree d;
2511   void **e;
2512
2513   if (typename_htab == NULL)
2514     {
2515       typename_htab = htab_create_ggc (61, &typename_hash,
2516                                        &typename_compare, NULL);
2517     }
2518
2519   /* Build the TYPENAME_TYPE.  */
2520   t = make_aggr_type (TYPENAME_TYPE);
2521   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2522   TYPENAME_TYPE_FULLNAME (t) = fullname;
2523
2524   /* Build the corresponding TYPE_DECL.  */
2525   d = build_decl (TYPE_DECL, name, t);
2526   TYPE_NAME (TREE_TYPE (d)) = d;
2527   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2528   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2529   DECL_ARTIFICIAL (d) = 1;
2530
2531   /* See if we already have this type.  */
2532   e = htab_find_slot (typename_htab, t, INSERT);
2533   if (*e)
2534     t = (tree) *e;
2535   else
2536     *e = t;
2537
2538   return t;
2539 }
2540
2541 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
2542    unless an error occurs, in which case error_mark_node is returned.
2543    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2544    set, we return that, rather than the _TYPE it corresponds to, in
2545    other cases we look through the type decl.  If TF_ERROR is set,
2546    complain about errors, otherwise be quiet.  */
2547
2548 tree
2549 make_typename_type (tree context, tree name, tsubst_flags_t complain)
2550 {
2551   tree fullname;
2552
2553   if (name == error_mark_node
2554       || context == NULL_TREE
2555       || context == error_mark_node)
2556     return error_mark_node;
2557
2558   if (TYPE_P (name))
2559     {
2560       if (!(TYPE_LANG_SPECIFIC (name)
2561             && (CLASSTYPE_IS_TEMPLATE (name)
2562                 || CLASSTYPE_USE_TEMPLATE (name))))
2563         name = TYPE_IDENTIFIER (name);
2564       else
2565         /* Create a TEMPLATE_ID_EXPR for the type.  */
2566         name = build_nt (TEMPLATE_ID_EXPR,
2567                          CLASSTYPE_TI_TEMPLATE (name),
2568                          CLASSTYPE_TI_ARGS (name));
2569     }
2570   else if (TREE_CODE (name) == TYPE_DECL)
2571     name = DECL_NAME (name);
2572
2573   fullname = name;
2574
2575   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2576     {
2577       name = TREE_OPERAND (name, 0);
2578       if (TREE_CODE (name) == TEMPLATE_DECL)
2579         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2580     }
2581   if (TREE_CODE (name) == TEMPLATE_DECL)
2582     {
2583       error ("`%D' used without template parameters", name);
2584       return error_mark_node;
2585     }
2586   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802);
2587
2588   if (TREE_CODE (context) == NAMESPACE_DECL)
2589     {
2590       /* We can get here from typename_sub0 in the explicit_template_type
2591          expansion.  Just fail.  */
2592       if (complain & tf_error)
2593         error ("no class template named `%#T' in `%#T'",
2594                   name, context);
2595       return error_mark_node;
2596     }
2597
2598   if (!dependent_type_p (context)
2599       || currently_open_class (context))
2600     {
2601       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2602         {
2603           tree tmpl = NULL_TREE;
2604           if (IS_AGGR_TYPE (context))
2605             tmpl = lookup_field (context, name, 0, false);
2606           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2607             {
2608               if (complain & tf_error)
2609                 error ("no class template named `%#T' in `%#T'",
2610                           name, context);
2611               return error_mark_node;
2612             }
2613
2614           if (complain & tf_error)
2615             perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2616
2617           return lookup_template_class (tmpl,
2618                                         TREE_OPERAND (fullname, 1),
2619                                         NULL_TREE, context,
2620                                         /*entering_scope=*/0,
2621                                         tf_error | tf_warning | tf_user);
2622         }
2623       else
2624         {
2625           tree t;
2626
2627           if (!IS_AGGR_TYPE (context))
2628             {
2629               if (complain & tf_error)
2630                 error ("no type named `%#T' in `%#T'", name, context);
2631               return error_mark_node;
2632             }
2633
2634           t = lookup_field (context, name, 0, true);
2635           if (t)
2636             {
2637               if (TREE_CODE (t) != TYPE_DECL)
2638                 {
2639                   if (complain & tf_error)
2640                     error ("no type named `%#T' in `%#T'", name, context);
2641                   return error_mark_node;
2642                 }
2643
2644               if (complain & tf_error)
2645                 perform_or_defer_access_check (TYPE_BINFO (context), t);
2646
2647               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2648                 t = TREE_TYPE (t);
2649
2650               return t;
2651             }
2652         }
2653     }
2654
2655   /* If the CONTEXT is not a template type, then either the field is
2656      there now or its never going to be.  */
2657   if (!dependent_type_p (context))
2658     {
2659       if (complain & tf_error)
2660         error ("no type named `%#T' in `%#T'", name, context);
2661       return error_mark_node;
2662     }
2663
2664   return build_typename_type (context, name, fullname);
2665 }
2666
2667 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
2668    unless an error occurs, in which case error_mark_node is returned.
2669    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2670    corresponds to.  If COMPLAIN zero, don't complain about any errors
2671    that occur.  */
2672
2673 tree
2674 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
2675 {
2676   tree t;
2677   tree d;
2678
2679   if (TYPE_P (name))
2680     name = TYPE_IDENTIFIER (name);
2681   else if (DECL_P (name))
2682     name = DECL_NAME (name);
2683   if (TREE_CODE (name) != IDENTIFIER_NODE)
2684     abort ();
2685
2686   if (!dependent_type_p (context)
2687       || currently_open_class (context))
2688     {
2689       tree tmpl = NULL_TREE;
2690
2691       if (IS_AGGR_TYPE (context))
2692         tmpl = lookup_field (context, name, 0, false);
2693
2694       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2695         {
2696           if (complain & tf_error)
2697             error ("no class template named `%#T' in `%#T'", name, context);
2698           return error_mark_node;
2699         }
2700
2701       if (complain & tf_error)
2702         perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2703
2704       return tmpl;
2705     }
2706
2707   /* Build the UNBOUND_CLASS_TEMPLATE.  */
2708   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2709   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2710   TREE_TYPE (t) = NULL_TREE;
2711
2712   /* Build the corresponding TEMPLATE_DECL.  */
2713   d = build_decl (TEMPLATE_DECL, name, t);
2714   TYPE_NAME (TREE_TYPE (d)) = d;
2715   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2716   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2717   DECL_ARTIFICIAL (d) = 1;
2718
2719   return t;
2720 }
2721
2722 \f
2723
2724 /* Push the declarations of builtin types into the namespace.
2725    RID_INDEX is the index of the builtin type in the array
2726    RID_POINTERS.  NAME is the name used when looking up the builtin
2727    type.  TYPE is the _TYPE node for the builtin type.  */
2728
2729 void
2730 record_builtin_type (enum rid rid_index,
2731                      const char* name,
2732                      tree type)
2733 {
2734   tree rname = NULL_TREE, tname = NULL_TREE;
2735   tree tdecl = NULL_TREE;
2736
2737   if ((int) rid_index < (int) RID_MAX)
2738     rname = ridpointers[(int) rid_index];
2739   if (name)
2740     tname = get_identifier (name);
2741
2742   /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2743      eliminated.  Built-in types should not be looked up name; their
2744      names are keywords that the parser can recognize.  However, there
2745      is code in c-common.c that uses identifier_global_value to look
2746      up built-in types by name.  */
2747   if (tname)
2748     {
2749       tdecl = build_decl (TYPE_DECL, tname, type);
2750       DECL_ARTIFICIAL (tdecl) = 1;
2751       SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2752     }
2753   if (rname)
2754     {
2755       if (!tdecl)
2756         {
2757           tdecl = build_decl (TYPE_DECL, rname, type);
2758           DECL_ARTIFICIAL (tdecl) = 1;
2759         }
2760       SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2761     }
2762
2763   if (!TYPE_NAME (type))
2764     TYPE_NAME (type) = tdecl;
2765
2766   if (tdecl)
2767     debug_hooks->type_decl (tdecl, 0);
2768 }
2769
2770 /* Record one of the standard Java types.
2771  * Declare it as having the given NAME.
2772  * If SIZE > 0, it is the size of one of the integral types;
2773  * otherwise it is the negative of the size of one of the other types.  */
2774
2775 static tree
2776 record_builtin_java_type (const char* name, int size)
2777 {
2778   tree type, decl;
2779   if (size > 0)
2780     type = make_signed_type (size);
2781   else if (size > -32)
2782     { /* "__java_char" or ""__java_boolean".  */
2783       type = make_unsigned_type (-size);
2784       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2785     }
2786   else
2787     { /* "__java_float" or ""__java_double".  */
2788       type = make_node (REAL_TYPE);
2789       TYPE_PRECISION (type) = - size;
2790       layout_type (type);
2791     }
2792   record_builtin_type (RID_MAX, name, type);
2793   decl = TYPE_NAME (type);
2794
2795   /* Suppress generate debug symbol entries for these types,
2796      since for normal C++ they are just clutter.
2797      However, push_lang_context undoes this if extern "Java" is seen.  */
2798   DECL_IGNORED_P (decl) = 1;
2799
2800   TYPE_FOR_JAVA (type) = 1;
2801   return type;
2802 }
2803
2804 /* Push a type into the namespace so that the back-ends ignore it.  */
2805
2806 static void
2807 record_unknown_type (tree type, const char* name)
2808 {
2809   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2810   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
2811   DECL_IGNORED_P (decl) = 1;
2812   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2813   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2814   TYPE_ALIGN (type) = 1;
2815   TYPE_USER_ALIGN (type) = 0;
2816   TYPE_MODE (type) = TYPE_MODE (void_type_node);
2817 }
2818
2819 /* An string for which we should create an IDENTIFIER_NODE at
2820    startup.  */
2821
2822 typedef struct predefined_identifier
2823 {
2824   /* The name of the identifier.  */
2825   const char *const name;
2826   /* The place where the IDENTIFIER_NODE should be stored.  */
2827   tree *const node;
2828   /* Nonzero if this is the name of a constructor or destructor.  */
2829   const int ctor_or_dtor_p;
2830 } predefined_identifier;
2831
2832 /* Create all the predefined identifiers.  */
2833
2834 static void
2835 initialize_predefined_identifiers (void)
2836 {
2837   const predefined_identifier *pid;
2838
2839   /* A table of identifiers to create at startup.  */
2840   static const predefined_identifier predefined_identifiers[] = {
2841     { "C++", &lang_name_cplusplus, 0 },
2842     { "C", &lang_name_c, 0 },
2843     { "Java", &lang_name_java, 0 },
2844     { CTOR_NAME, &ctor_identifier, 1 },
2845     { "__base_ctor", &base_ctor_identifier, 1 },
2846     { "__comp_ctor", &complete_ctor_identifier, 1 },
2847     { DTOR_NAME, &dtor_identifier, 1 },
2848     { "__comp_dtor", &complete_dtor_identifier, 1 },
2849     { "__base_dtor", &base_dtor_identifier, 1 },
2850     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
2851     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2852     { "nelts", &nelts_identifier, 0 },
2853     { THIS_NAME, &this_identifier, 0 },
2854     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2855     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2856     { "_vptr", &vptr_identifier, 0 },
2857     { "__vtt_parm", &vtt_parm_identifier, 0 },
2858     { "::", &global_scope_name, 0 },
2859     { "std", &std_identifier, 0 },
2860     { NULL, NULL, 0 }
2861   };
2862
2863   for (pid = predefined_identifiers; pid->name; ++pid)
2864     {
2865       *pid->node = get_identifier (pid->name);
2866       if (pid->ctor_or_dtor_p)
2867         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2868     }
2869 }
2870
2871 /* Create the predefined scalar types of C,
2872    and some nodes representing standard constants (0, 1, (void *)0).
2873    Initialize the global binding level.
2874    Make definitions for built-in primitive functions.  */
2875
2876 void
2877 cxx_init_decl_processing (void)
2878 {
2879   tree void_ftype;
2880   tree void_ftype_ptr;
2881
2882   build_common_tree_nodes (flag_signed_char);
2883
2884   /* Create all the identifiers we need.  */
2885   initialize_predefined_identifiers ();
2886
2887   /* Create the global variables.  */
2888   push_to_top_level ();
2889
2890   current_function_decl = NULL_TREE;
2891   current_binding_level = NULL;
2892   /* Enter the global namespace.  */
2893   my_friendly_assert (global_namespace == NULL_TREE, 375);
2894   global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2895                                       void_type_node);
2896   begin_scope (sk_namespace, global_namespace);
2897
2898   current_lang_name = NULL_TREE;
2899
2900   /* Adjust various flags based on command-line settings.  */
2901   if (!flag_permissive)
2902     flag_pedantic_errors = 1;
2903   if (!flag_no_inline)
2904     {
2905       flag_inline_trees = 1;
2906       flag_no_inline = 1;
2907     }
2908   if (flag_inline_functions)
2909     {
2910       flag_inline_trees = 2;
2911       flag_inline_functions = 0;
2912     }
2913
2914   /* Force minimum function alignment if using the least significant
2915      bit of function pointers to store the virtual bit.  */
2916   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2917       && force_align_functions_log < 1)
2918     force_align_functions_log = 1;
2919
2920   /* Initially, C.  */
2921   current_lang_name = lang_name_c;
2922
2923   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2924   TREE_TYPE (error_mark_list) = error_mark_node;
2925
2926   /* Create the `std' namespace.  */
2927   push_namespace (std_identifier);
2928   std_node = current_namespace;
2929   pop_namespace ();
2930
2931   c_common_nodes_and_builtins ();
2932
2933   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2934   java_short_type_node = record_builtin_java_type ("__java_short", 16);
2935   java_int_type_node = record_builtin_java_type ("__java_int", 32);
2936   java_long_type_node = record_builtin_java_type ("__java_long", 64);
2937   java_float_type_node = record_builtin_java_type ("__java_float", -32);
2938   java_double_type_node = record_builtin_java_type ("__java_double", -64);
2939   java_char_type_node = record_builtin_java_type ("__java_char", -16);
2940   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2941
2942   integer_two_node = build_int_2 (2, 0);
2943   TREE_TYPE (integer_two_node) = integer_type_node;
2944   integer_three_node = build_int_2 (3, 0);
2945   TREE_TYPE (integer_three_node) = integer_type_node;
2946
2947   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2948   truthvalue_type_node = boolean_type_node;
2949   truthvalue_false_node = boolean_false_node;
2950   truthvalue_true_node = boolean_true_node;
2951
2952   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
2953
2954 #if 0
2955   record_builtin_type (RID_MAX, NULL, string_type_node);
2956 #endif
2957
2958   delta_type_node = ptrdiff_type_node;
2959   vtable_index_type = ptrdiff_type_node;
2960
2961   vtt_parm_type = build_pointer_type (const_ptr_type_node);
2962   void_ftype = build_function_type (void_type_node, void_list_node);
2963   void_ftype_ptr = build_function_type (void_type_node,
2964                                         tree_cons (NULL_TREE,
2965                                                    ptr_type_node,
2966                                                    void_list_node));
2967   void_ftype_ptr
2968     = build_exception_variant (void_ftype_ptr, empty_except_spec);
2969
2970   /* C++ extensions */
2971
2972   unknown_type_node = make_node (UNKNOWN_TYPE);
2973   record_unknown_type (unknown_type_node, "unknown type");
2974
2975   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
2976   TREE_TYPE (unknown_type_node) = unknown_type_node;
2977
2978   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
2979      result.  */
2980   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
2981   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
2982
2983   {
2984     /* Make sure we get a unique function type, so we can give
2985        its pointer type a name.  (This wins for gdb.) */
2986     tree vfunc_type = make_node (FUNCTION_TYPE);
2987     TREE_TYPE (vfunc_type) = integer_type_node;
2988     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
2989     layout_type (vfunc_type);
2990
2991     vtable_entry_type = build_pointer_type (vfunc_type);
2992   }
2993   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
2994
2995   vtbl_type_node
2996     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
2997   layout_type (vtbl_type_node);
2998   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
2999   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3000   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3001   layout_type (vtbl_ptr_type_node);
3002   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3003
3004   push_namespace (get_identifier ("__cxxabiv1"));
3005   abi_node = current_namespace;
3006   pop_namespace ();
3007
3008   global_type_node = make_node (LANG_TYPE);
3009   record_unknown_type (global_type_node, "global type");
3010
3011   /* Now, C++.  */
3012   current_lang_name = lang_name_cplusplus;
3013
3014   {
3015     tree bad_alloc_id;
3016     tree bad_alloc_type_node;
3017     tree bad_alloc_decl;
3018     tree newtype, deltype;
3019     tree ptr_ftype_sizetype;
3020
3021     push_namespace (std_identifier);
3022     bad_alloc_id = get_identifier ("bad_alloc");
3023     bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3024     TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3025     bad_alloc_decl
3026       = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3027     DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3028     TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3029     pop_namespace ();
3030
3031     ptr_ftype_sizetype
3032       = build_function_type (ptr_type_node,
3033                              tree_cons (NULL_TREE,
3034                                         size_type_node,
3035                                         void_list_node));
3036     newtype = build_exception_variant
3037       (ptr_ftype_sizetype, add_exception_specifier
3038        (NULL_TREE, bad_alloc_type_node, -1));
3039     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3040     push_cp_library_fn (NEW_EXPR, newtype);
3041     push_cp_library_fn (VEC_NEW_EXPR, newtype);
3042     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3043     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3044   }
3045
3046   abort_fndecl
3047     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3048
3049   /* Perform other language dependent initializations.  */
3050   init_class_processing ();
3051   init_rtti_processing ();
3052
3053   if (flag_exceptions)
3054     init_exception_processing ();
3055
3056   if (! supports_one_only ())
3057     flag_weak = 0;
3058
3059   make_fname_decl = cp_make_fname_decl;
3060   start_fname_decls ();
3061
3062   /* Show we use EH for cleanups.  */
3063   if (flag_exceptions)
3064     using_eh_for_cleanups ();
3065 }
3066
3067 /* Generate an initializer for a function naming variable from
3068    NAME. NAME may be NULL, to indicate a dependent name.  TYPE_P is
3069    filled in with the type of the init.  */
3070
3071 tree
3072 cp_fname_init (const char* name, tree *type_p)
3073 {
3074   tree domain = NULL_TREE;
3075   tree type;
3076   tree init = NULL_TREE;
3077   size_t length = 0;
3078
3079   if (name)
3080     {
3081       length = strlen (name);
3082       domain = build_index_type (size_int (length));
3083       init = build_string (length + 1, name);
3084     }
3085
3086   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3087   type = build_cplus_array_type (type, domain);
3088
3089   *type_p = type;
3090
3091   if (init)
3092     TREE_TYPE (init) = type;
3093   else
3094     init = error_mark_node;
3095
3096   return init;
3097 }
3098
3099 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3100    decl, NAME is the initialization string and TYPE_DEP indicates whether
3101    NAME depended on the type of the function. We make use of that to detect
3102    __PRETTY_FUNCTION__ inside a template fn. This is being done
3103    lazily at the point of first use, so we mustn't push the decl now.  */
3104
3105 static tree
3106 cp_make_fname_decl (tree id, int type_dep)
3107 {
3108   const char *const name = (type_dep && processing_template_decl
3109                             ? NULL : fname_as_string (type_dep));
3110   tree type;
3111   tree init = cp_fname_init (name, &type);
3112   tree decl = build_decl (VAR_DECL, id, type);
3113
3114   if (name)
3115     free ((char *) name);
3116
3117   /* As we're using pushdecl_with_scope, we must set the context.  */
3118   DECL_CONTEXT (decl) = current_function_decl;
3119   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3120
3121   TREE_STATIC (decl) = 1;
3122   TREE_READONLY (decl) = 1;
3123   DECL_ARTIFICIAL (decl) = 1;
3124   DECL_INITIAL (decl) = init;
3125
3126   TREE_USED (decl) = 1;
3127
3128   if (current_function_decl)
3129     {
3130       struct cp_binding_level *b = current_binding_level;
3131       while (b->level_chain->kind != sk_function_parms)
3132         b = b->level_chain;
3133       pushdecl_with_scope (decl, b);
3134       cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3135     }
3136   else
3137     pushdecl_top_level_and_finish (decl, init);
3138
3139   return decl;
3140 }
3141
3142 /* Make a definition for a builtin function named NAME in the current
3143    namespace, whose data type is TYPE and whose context is CONTEXT.
3144    TYPE should be a function type with argument types.
3145
3146    CLASS and CODE tell later passes how to compile calls to this function.
3147    See tree.h for possible values.
3148
3149    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3150    the name to be called if we can't opencode the function.
3151    If ATTRS is nonzero, use that for the function's attribute
3152    list.  */
3153
3154 static tree
3155 builtin_function_1 (const char* name,
3156                     tree type,
3157                     tree context,
3158                     int code,
3159                     enum built_in_class class,
3160                     const char* libname,
3161                     tree attrs)
3162 {
3163   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3164   DECL_BUILT_IN_CLASS (decl) = class;
3165   DECL_FUNCTION_CODE (decl) = code;
3166   DECL_CONTEXT (decl) = context;
3167
3168   pushdecl (decl);
3169
3170   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3171      we cannot change DECL_ASSEMBLER_NAME until we have installed this
3172      function in the namespace.  */
3173   if (libname)
3174     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3175
3176   /* Warn if a function in the namespace for users
3177      is used without an occasion to consider it declared.  */
3178   if (name[0] != '_' || name[1] != '_')
3179     DECL_ANTICIPATED (decl) = 1;
3180
3181   /* Possibly apply some default attributes to this built-in function.  */
3182   if (attrs)
3183     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3184   else
3185     decl_attributes (&decl, NULL_TREE, 0);
3186
3187   return decl;
3188 }
3189
3190 /* Entry point for the benefit of c_common_nodes_and_builtins.
3191
3192    Make a definition for a builtin function named NAME and whose data type
3193    is TYPE.  TYPE should be a function type with argument types.  This
3194    function places the anticipated declaration in the global namespace
3195    and additionally in the std namespace if appropriate.
3196
3197    CLASS and CODE tell later passes how to compile calls to this function.
3198    See tree.h for possible values.
3199
3200    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3201    the name to be called if we can't opencode the function.
3202
3203    If ATTRS is nonzero, use that for the function's attribute
3204    list.  */
3205
3206 tree
3207 builtin_function (const char* name,
3208                   tree type,
3209                   int code,
3210                   enum built_in_class class,
3211                   const char* libname,
3212                   tree attrs)
3213 {
3214   /* All builtins that don't begin with an '_' should additionally
3215      go in the 'std' namespace.  */
3216   if (name[0] != '_')
3217     {
3218       push_namespace (std_identifier);
3219       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
3220       pop_namespace ();
3221     }
3222
3223   return builtin_function_1 (name, type, NULL_TREE, code,
3224                              class, libname, attrs);
3225 }
3226
3227 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3228    function.  Not called directly.  */
3229
3230 static tree
3231 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3232 {
3233   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3234   DECL_EXTERNAL (fn) = 1;
3235   TREE_PUBLIC (fn) = 1;
3236   DECL_ARTIFICIAL (fn) = 1;
3237   TREE_NOTHROW (fn) = 1;
3238   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3239   SET_DECL_LANGUAGE (fn, lang_c);
3240   return fn;
3241 }
3242
3243 /* Returns the _DECL for a library function with C linkage.
3244    We assume that such functions never throw; if this is incorrect,
3245    callers should unset TREE_NOTHROW.  */
3246
3247 tree
3248 build_library_fn (tree name, tree type)
3249 {
3250   return build_library_fn_1 (name, ERROR_MARK, type);
3251 }
3252
3253 /* Returns the _DECL for a library function with C++ linkage.  */
3254
3255 static tree
3256 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3257 {
3258   tree fn = build_library_fn_1 (name, operator_code, type);
3259   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3260   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3261   SET_DECL_LANGUAGE (fn, lang_cplusplus);
3262   return fn;
3263 }
3264
3265 /* Like build_library_fn, but takes a C string instead of an
3266    IDENTIFIER_NODE.  */
3267
3268 tree
3269 build_library_fn_ptr (const char* name, tree type)
3270 {
3271   return build_library_fn (get_identifier (name), type);
3272 }
3273
3274 /* Like build_cp_library_fn, but takes a C string instead of an
3275    IDENTIFIER_NODE.  */
3276
3277 tree
3278 build_cp_library_fn_ptr (const char* name, tree type)
3279 {
3280   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3281 }
3282
3283 /* Like build_library_fn, but also pushes the function so that we will
3284    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
3285
3286 tree
3287 push_library_fn (tree name, tree type)
3288 {
3289   tree fn = build_library_fn (name, type);
3290   pushdecl_top_level (fn);
3291   return fn;
3292 }
3293
3294 /* Like build_cp_library_fn, but also pushes the function so that it
3295    will be found by normal lookup.  */
3296
3297 static tree
3298 push_cp_library_fn (enum tree_code operator_code, tree type)
3299 {
3300   tree fn = build_cp_library_fn (ansi_opname (operator_code),
3301                                  operator_code,
3302                                  type);
3303   pushdecl (fn);
3304   return fn;
3305 }
3306
3307 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3308    a FUNCTION_TYPE.  */
3309
3310 tree
3311 push_void_library_fn (tree name, tree parmtypes)
3312 {
3313   tree type = build_function_type (void_type_node, parmtypes);
3314   return push_library_fn (name, type);
3315 }
3316
3317 /* Like push_library_fn, but also note that this function throws
3318    and does not return.  Used for __throw_foo and the like.  */
3319
3320 tree
3321 push_throw_library_fn (tree name, tree type)
3322 {
3323   tree fn = push_library_fn (name, type);
3324   TREE_THIS_VOLATILE (fn) = 1;
3325   TREE_NOTHROW (fn) = 0;
3326   return fn;
3327 }
3328 \f
3329 /* When we call finish_struct for an anonymous union, we create
3330    default copy constructors and such.  But, an anonymous union
3331    shouldn't have such things; this function undoes the damage to the
3332    anonymous union type T.
3333
3334    (The reason that we create the synthesized methods is that we don't
3335    distinguish `union { int i; }' from `typedef union { int i; } U'.
3336    The first is an anonymous union; the second is just an ordinary
3337    union type.)  */
3338
3339 void
3340 fixup_anonymous_aggr (tree t)
3341 {
3342   tree *q;
3343
3344   /* Wipe out memory of synthesized methods.  */
3345   TYPE_HAS_CONSTRUCTOR (t) = 0;
3346   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3347   TYPE_HAS_INIT_REF (t) = 0;
3348   TYPE_HAS_CONST_INIT_REF (t) = 0;
3349   TYPE_HAS_ASSIGN_REF (t) = 0;
3350   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3351
3352   /* Splice the implicitly generated functions out of the TYPE_METHODS
3353      list.  */
3354   q = &TYPE_METHODS (t);
3355   while (*q)
3356     {
3357       if (DECL_ARTIFICIAL (*q))
3358         *q = TREE_CHAIN (*q);
3359       else
3360         q = &TREE_CHAIN (*q);
3361     }
3362
3363   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
3364   if (TYPE_METHODS (t))
3365     error ("%Jan anonymous union cannot have function members",
3366            TYPE_MAIN_DECL (t));
3367
3368   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3369      assignment operators (because they cannot have these methods themselves).
3370      For anonymous unions this is already checked because they are not allowed
3371      in any union, otherwise we have to check it.  */
3372   if (TREE_CODE (t) != UNION_TYPE)
3373     {
3374       tree field, type;
3375
3376       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3377         if (TREE_CODE (field) == FIELD_DECL)
3378           {
3379             type = TREE_TYPE (field);
3380             if (CLASS_TYPE_P (type))
3381               {
3382                 if (TYPE_NEEDS_CONSTRUCTING (type))
3383                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3384                                field);
3385                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3386                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3387                                field);
3388                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3389                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3390                                field);
3391               }
3392           }
3393     }
3394 }
3395
3396 /* Make sure that a declaration with no declarator is well-formed, i.e.
3397    just declares a tagged type or anonymous union.
3398
3399    Returns the type declared; or NULL_TREE if none.  */
3400
3401 tree
3402 check_tag_decl (cp_decl_specifier_seq *declspecs)
3403 {
3404   int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3405   int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3406   /* If a class, struct, or enum type is declared by the DECLSPECS
3407      (i.e, if a class-specifier, enum-specifier, or non-typename
3408      elaborated-type-specifier appears in the DECLSPECS),
3409      DECLARED_TYPE is set to the corresponding type.  */
3410   tree declared_type = NULL_TREE;
3411   bool error_p = false;
3412
3413   if (declspecs->multiple_types_p)
3414     error ("multiple types in one declaration");
3415   else if (declspecs->redefined_builtin_type)
3416     {
3417       if (!in_system_header)
3418         pedwarn ("redeclaration of C++ built-in type %qT",
3419                  declspecs->redefined_builtin_type);
3420       return NULL_TREE;
3421     }
3422
3423   if (TYPE_P (declspecs->type)
3424       && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3425            && IS_AGGR_TYPE (declspecs->type))
3426           || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3427     declared_type = declspecs->type;
3428   else if (declspecs->type == error_mark_node)
3429     error_p = true;
3430   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3431     pedwarn ("declaration does not declare anything");
3432   /* Check for an anonymous union.  */
3433   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3434            && TYPE_ANONYMOUS_P (declared_type))
3435     {
3436       /* 7/3 In a simple-declaration, the optional init-declarator-list
3437          can be omitted only when declaring a class (clause 9) or
3438          enumeration (7.2), that is, when the decl-specifier-seq contains
3439          either a class-specifier, an elaborated-type-specifier with
3440          a class-key (9.1), or an enum-specifier.  In these cases and
3441          whenever a class-specifier or enum-specifier is present in the
3442          decl-specifier-seq, the identifiers in these specifiers are among
3443          the names being declared by the declaration (as class-name,
3444          enum-names, or enumerators, depending on the syntax).  In such
3445          cases, and except for the declaration of an unnamed bit-field (9.6),
3446          the decl-specifier-seq shall introduce one or more names into the
3447          program, or shall redeclare a name introduced by a previous
3448          declaration.  [Example:
3449              enum { };            // ill-formed
3450              typedef class { };   // ill-formed
3451          --end example]  */
3452       if (saw_typedef)
3453         {
3454           error ("missing type-name in typedef-declaration");
3455           return NULL_TREE;
3456         }
3457       /* Anonymous unions are objects, so they can have specifiers.  */;
3458       SET_ANON_AGGR_TYPE_P (declared_type);
3459
3460       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3461           && !in_system_header)
3462         pedwarn ("ISO C++ prohibits anonymous structs");
3463     }
3464
3465   else
3466     {
3467       if (declspecs->specs[(int)ds_inline]
3468           || declspecs->specs[(int)ds_virtual])
3469         error ("`%s' can only be specified for functions",
3470                declspecs->specs[(int)ds_inline]
3471                ? "inline" : "virtual");
3472       else if (saw_friend
3473                && (!current_class_type
3474                    || current_scope () != current_class_type))
3475         error ("`friend' can only be specified inside a class");
3476       else if (declspecs->specs[(int)ds_explicit])
3477         error ("`explicit' can only be specified for constructors");
3478       else if (declspecs->storage_class)
3479         error ("a storage class can only be specified for objects "
3480                "and functions");
3481       else if (declspecs->specs[(int)ds_const]
3482                || declspecs->specs[(int)ds_volatile]
3483                || declspecs->specs[(int)ds_restrict]
3484                || declspecs->specs[(int)ds_thread])
3485         error ("qualifiers can only be specified for objects "
3486                "and functions");
3487     }
3488
3489   return declared_type;
3490 }
3491
3492 /* Called when a declaration is seen that contains no names to declare.
3493    If its type is a reference to a structure, union or enum inherited
3494    from a containing scope, shadow that tag name for the current scope
3495    with a forward reference.
3496    If its type defines a new named structure or union
3497    or defines an enum, it is valid but we need not do anything here.
3498    Otherwise, it is an error.
3499
3500    C++: may have to grok the declspecs to learn about static,
3501    complain for anonymous unions.
3502
3503    Returns the TYPE declared -- or NULL_TREE if none.  */
3504
3505 tree
3506 shadow_tag (cp_decl_specifier_seq *declspecs)
3507 {
3508   tree t = check_tag_decl (declspecs);
3509
3510   if (!t)
3511     return NULL_TREE;
3512
3513   maybe_process_partial_specialization (t);
3514
3515   /* This is where the variables in an anonymous union are
3516      declared.  An anonymous union declaration looks like:
3517      union { ... } ;
3518      because there is no declarator after the union, the parser
3519      sends that declaration here.  */
3520   if (ANON_AGGR_TYPE_P (t))
3521     {
3522       fixup_anonymous_aggr (t);
3523
3524       if (TYPE_FIELDS (t))
3525         {
3526           tree decl = grokdeclarator (/*declarator=*/NULL,
3527                                       declspecs, NORMAL, 0, NULL);
3528           finish_anon_union (decl);
3529         }
3530     }
3531
3532   return t;
3533 }
3534 \f
3535 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3536
3537 tree
3538 groktypename (cp_decl_specifier_seq *type_specifiers,
3539               const cp_declarator *declarator)
3540 {
3541   tree attrs;
3542   tree type;
3543   attrs = type_specifiers->attributes;
3544   type_specifiers->attributes = NULL_TREE;
3545   type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3546   if (attrs)
3547     cplus_decl_attributes (&type, attrs, 0);
3548   return type;
3549 }
3550
3551 /* Decode a declarator in an ordinary declaration or data definition.
3552    This is called as soon as the type information and variable name
3553    have been parsed, before parsing the initializer if any.
3554    Here we create the ..._DECL node, fill in its type,
3555    and put it on the list of decls for the current context.
3556    The ..._DECL node is returned as the value.
3557
3558    Exception: for arrays where the length is not specified,
3559    the type is left null, to be filled in by `cp_finish_decl'.
3560
3561    Function definitions do not come here; they go to start_function
3562    instead.  However, external and forward declarations of functions
3563    do go through here.  Structure field declarations are done by
3564    grokfield and not through here.  */
3565
3566 tree
3567 start_decl (const cp_declarator *declarator,
3568             cp_decl_specifier_seq *declspecs,
3569             int initialized,
3570             tree attributes,
3571             tree prefix_attributes)
3572 {
3573   tree decl;
3574   tree type, tem;
3575   tree context;
3576
3577   /* This should only be done once on the top most decl.  */
3578   if (have_extern_spec)
3579     {
3580       declspecs->storage_class = sc_extern;
3581       have_extern_spec = false;
3582     }
3583
3584   /* An object declared as __attribute__((deprecated)) suppresses
3585      warnings of uses of other deprecated items.  */
3586   if (lookup_attribute ("deprecated", attributes))
3587     deprecated_state = DEPRECATED_SUPPRESS;
3588
3589   attributes = chainon (attributes, prefix_attributes);
3590
3591   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3592                          &attributes);
3593
3594   deprecated_state = DEPRECATED_NORMAL;
3595
3596   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3597     return NULL_TREE;
3598
3599   type = TREE_TYPE (decl);
3600
3601   if (type == error_mark_node)
3602     return NULL_TREE;
3603
3604   context = DECL_CONTEXT (decl);
3605
3606   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
3607       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
3608     {
3609       /* When parsing the initializer, lookup should use the object's
3610          namespace.  */
3611       push_decl_namespace (context);
3612     }
3613
3614   /* We are only interested in class contexts, later.  */
3615   if (context && TREE_CODE (context) == NAMESPACE_DECL)
3616     context = NULL_TREE;
3617
3618   if (initialized)
3619     /* Is it valid for this decl to have an initializer at all?
3620        If not, set INITIALIZED to zero, which will indirectly
3621        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3622     switch (TREE_CODE (decl))
3623       {
3624       case TYPE_DECL:
3625         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
3626         initialized = 0;
3627         break;
3628
3629       case FUNCTION_DECL:
3630         error ("function `%#D' is initialized like a variable", decl);
3631         initialized = 0;
3632         break;
3633
3634       default:
3635         break;
3636       }
3637
3638   if (initialized)
3639     {
3640       if (! toplevel_bindings_p ()
3641           && DECL_EXTERNAL (decl))
3642         warning ("declaration of `%#D' has `extern' and is initialized",
3643                     decl);
3644       DECL_EXTERNAL (decl) = 0;
3645       if (toplevel_bindings_p ())
3646         TREE_STATIC (decl) = 1;
3647
3648       /* Tell `pushdecl' this is an initialized decl
3649          even though we don't yet have the initializer expression.
3650          Also tell `cp_finish_decl' it may store the real initializer.  */
3651       DECL_INITIAL (decl) = error_mark_node;
3652     }
3653
3654   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3655   cplus_decl_attributes (&decl, attributes, 0);
3656
3657   /* If #pragma weak was used, mark the decl weak now.  */
3658   if (global_scope_p (current_binding_level))
3659     maybe_apply_pragma_weak (decl);
3660
3661   if (TREE_CODE (decl) == FUNCTION_DECL
3662       && DECL_DECLARED_INLINE_P (decl)
3663       && DECL_UNINLINABLE (decl)
3664       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3665     warning ("%Jinline function '%D' given attribute noinline", decl, decl);
3666
3667   if (context && COMPLETE_TYPE_P (complete_type (context)))
3668     {
3669       push_nested_class (context);
3670
3671       if (TREE_CODE (decl) == VAR_DECL)
3672         {
3673           tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3674           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3675             error ("`%#D' is not a static member of `%#T'", decl, context);
3676           else
3677             {
3678               if (DECL_CONTEXT (field) != context)
3679                 {
3680                   if (!same_type_p (DECL_CONTEXT (field), context))
3681                     pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3682                              DECL_CONTEXT (field), DECL_NAME (decl),
3683                              context, DECL_NAME (decl));
3684                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3685                 }
3686               /* Static data member are tricky; an in-class initialization
3687                  still doesn't provide a definition, so the in-class
3688                  declaration will have DECL_EXTERNAL set, but will have an
3689                  initialization.  Thus, duplicate_decls won't warn
3690                  about this situation, and so we check here.  */
3691               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3692                 error ("duplicate initialization of %D", decl);
3693               if (duplicate_decls (decl, field))
3694                 decl = field;
3695             }
3696         }
3697       else
3698         {
3699           tree field = check_classfn (context, decl,
3700                                       (processing_template_decl
3701                                        > template_class_depth (context))
3702                                       ? current_template_parms
3703                                       : NULL_TREE);
3704           if (field && duplicate_decls (decl, field))
3705             decl = field;
3706         }
3707
3708       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
3709       DECL_IN_AGGR_P (decl) = 0;
3710       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3711           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3712         {
3713           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3714           /* [temp.expl.spec] An explicit specialization of a static data
3715              member of a template is a definition if the declaration
3716              includes an initializer; otherwise, it is a declaration.
3717
3718              We check for processing_specialization so this only applies
3719              to the new specialization syntax.  */
3720           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3721             DECL_EXTERNAL (decl) = 1;
3722         }
3723
3724       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3725         pedwarn ("declaration of `%#D' outside of class is not definition",
3726                     decl);
3727     }
3728
3729   /* Enter this declaration into the symbol table.  */
3730   tem = maybe_push_decl (decl);
3731
3732   if (processing_template_decl)
3733     tem = push_template_decl (tem);
3734   if (tem == error_mark_node)
3735     return error_mark_node;
3736
3737 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3738   /* Tell the back-end to use or not use .common as appropriate.  If we say
3739      -fconserve-space, we want this to save .data space, at the expense of
3740      wrong semantics.  If we say -fno-conserve-space, we want this to
3741      produce errors about redefs; to do this we force variables into the
3742      data segment.  */
3743   DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3744                         || !DECL_THREAD_LOCAL (tem))
3745                        && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3746 #endif
3747
3748   if (! processing_template_decl)
3749     start_decl_1 (tem);
3750
3751   return tem;
3752 }
3753
3754 void
3755 start_decl_1 (tree decl)
3756 {
3757   tree type = TREE_TYPE (decl);
3758   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3759
3760   if (type == error_mark_node)
3761     return;
3762
3763   if (initialized)
3764     /* Is it valid for this decl to have an initializer at all?
3765        If not, set INITIALIZED to zero, which will indirectly
3766        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3767     {
3768       /* Don't allow initializations for incomplete types except for
3769          arrays which might be completed by the initialization.  */
3770       if (COMPLETE_TYPE_P (complete_type (type)))
3771         ;                       /* A complete type is ok.  */
3772       else if (TREE_CODE (type) != ARRAY_TYPE)
3773         {
3774           error ("variable `%#D' has initializer but incomplete type",
3775                     decl);
3776           initialized = 0;
3777           type = TREE_TYPE (decl) = error_mark_node;
3778         }
3779       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3780         {
3781           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3782             error ("elements of array `%#D' have incomplete type", decl);
3783           /* else we already gave an error in start_decl.  */
3784           initialized = 0;
3785         }
3786     }
3787
3788   if (!initialized
3789       && TREE_CODE (decl) != TYPE_DECL
3790       && TREE_CODE (decl) != TEMPLATE_DECL
3791       && type != error_mark_node
3792       && IS_AGGR_TYPE (type)
3793       && ! DECL_EXTERNAL (decl))
3794     {
3795       if ((! processing_template_decl || ! uses_template_parms (type))
3796           && !COMPLETE_TYPE_P (complete_type (type)))
3797         {
3798           error ("aggregate `%#D' has incomplete type and cannot be defined",
3799                  decl);
3800           /* Change the type so that assemble_variable will give
3801              DECL an rtl we can live with: (mem (const_int 0)).  */
3802           type = TREE_TYPE (decl) = error_mark_node;
3803         }
3804       else
3805         {
3806           /* If any base type in the hierarchy of TYPE needs a constructor,
3807              then we set initialized to 1.  This way any nodes which are
3808              created for the purposes of initializing this aggregate
3809              will live as long as it does.  This is necessary for global
3810              aggregates which do not have their initializers processed until
3811              the end of the file.  */
3812           initialized = TYPE_NEEDS_CONSTRUCTING (type);
3813         }
3814     }
3815
3816   if (! initialized)
3817     DECL_INITIAL (decl) = NULL_TREE;
3818
3819   /* Create a new scope to hold this declaration if necessary.
3820      Whether or not a new scope is necessary cannot be determined
3821      until after the type has been completed; if the type is a
3822      specialization of a class template it is not until after
3823      instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3824      will be set correctly.  */
3825   maybe_push_cleanup_level (type);
3826 }
3827
3828 /* Handle initialization of references.  DECL, TYPE, and INIT have the
3829    same meaning as in cp_finish_decl.  *CLEANUP must be NULL on entry,
3830    but will be set to a new CLEANUP_STMT if a temporary is created
3831    that must be destroyed subsequently.
3832
3833    Returns an initializer expression to use to initialize DECL, or
3834    NULL if the initialization can be performed statically.
3835
3836    Quotes on semantics can be found in ARM 8.4.3.  */
3837
3838 static tree
3839 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3840 {
3841   tree tmp;
3842
3843   if (init == NULL_TREE)
3844     {
3845       if ((DECL_LANG_SPECIFIC (decl) == 0
3846            || DECL_IN_AGGR_P (decl) == 0)
3847           && ! DECL_THIS_EXTERN (decl))
3848         error ("`%D' declared as reference but not initialized", decl);
3849       return NULL_TREE;
3850     }
3851
3852   if (TREE_CODE (init) == CONSTRUCTOR)
3853     {
3854       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
3855       return NULL_TREE;
3856     }
3857
3858   if (TREE_CODE (init) == TREE_LIST)
3859     init = build_x_compound_expr_from_list (init, "initializer");
3860
3861   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
3862     init = convert_from_reference (init);
3863
3864   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3865       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3866     /* Note: default conversion is only called in very special cases.  */
3867     init = decay_conversion (init);
3868
3869   /* Convert INIT to the reference type TYPE.  This may involve the
3870      creation of a temporary, whose lifetime must be the same as that
3871      of the reference.  If so, a DECL_EXPR for the temporary will be
3872      added just after the DECL_EXPR for DECL.  That's why we don't set
3873      DECL_INITIAL for local references (instead assigning to them
3874      explicitly); we need to allow the temporary to be initialized
3875      first.  */
3876   tmp = initialize_reference (type, init, decl, cleanup);
3877
3878   if (tmp == error_mark_node)
3879     return NULL_TREE;
3880   else if (tmp == NULL_TREE)
3881     {
3882       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
3883       return NULL_TREE;
3884     }
3885
3886   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3887     return tmp;
3888
3889   DECL_INITIAL (decl) = tmp;
3890
3891   return NULL_TREE;
3892 }
3893
3894 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3895    array until we finish parsing the initializer.  If that's the
3896    situation we're in, update DECL accordingly.  */
3897
3898 static void
3899 maybe_deduce_size_from_array_init (tree decl, tree init)
3900 {
3901   tree type = TREE_TYPE (decl);
3902
3903   if (TREE_CODE (type) == ARRAY_TYPE
3904       && TYPE_DOMAIN (type) == NULL_TREE
3905       && TREE_CODE (decl) != TYPE_DECL)
3906     {
3907       /* do_default is really a C-ism to deal with tentative definitions.
3908          But let's leave it here to ease the eventual merge.  */
3909       int do_default = !DECL_EXTERNAL (decl);
3910       tree initializer = init ? init : DECL_INITIAL (decl);
3911       int failure = complete_array_type (type, initializer, do_default);
3912
3913       if (failure == 1)
3914         error ("initializer fails to determine size of `%D'", decl);
3915
3916       if (failure == 2)
3917         {
3918           if (do_default)
3919             error ("array size missing in `%D'", decl);
3920           /* If a `static' var's size isn't known, make it extern as
3921              well as static, so it does not get allocated.  If it's not
3922              `static', then don't mark it extern; finish_incomplete_decl
3923              will give it a default size and it will get allocated.  */
3924           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3925             DECL_EXTERNAL (decl) = 1;
3926         }
3927
3928       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
3929           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3930                               integer_zero_node))
3931         error ("zero-size array `%D'", decl);
3932
3933       layout_decl (decl, 0);
3934     }
3935 }
3936
3937 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3938    any appropriate error messages regarding the layout.  */
3939
3940 static void
3941 layout_var_decl (tree decl)
3942 {
3943   tree type = TREE_TYPE (decl);
3944 #if 0
3945   tree ttype = target_type (type);
3946 #endif
3947
3948   /* If we haven't already layed out this declaration, do so now.
3949      Note that we must not call complete type for an external object
3950      because it's type might involve templates that we are not
3951      supposed to instantiate yet.  (And it's perfectly valid to say
3952      `extern X x' for some incomplete type `X'.)  */
3953   if (!DECL_EXTERNAL (decl))
3954     complete_type (type);
3955   if (!DECL_SIZE (decl)
3956       && TREE_TYPE (decl) != error_mark_node
3957       && (COMPLETE_TYPE_P (type)
3958           || (TREE_CODE (type) == ARRAY_TYPE
3959               && !TYPE_DOMAIN (type)
3960               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
3961     layout_decl (decl, 0);
3962
3963   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
3964     {
3965       /* An automatic variable with an incomplete type: that is an error.
3966          Don't talk about array types here, since we took care of that
3967          message in grokdeclarator.  */
3968       error ("storage size of `%D' isn't known", decl);
3969       TREE_TYPE (decl) = error_mark_node;
3970     }
3971 #if 0
3972   /* Keep this code around in case we later want to control debug info
3973      based on whether a type is "used".  (jason 1999-11-11) */
3974
3975   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
3976     /* Let debugger know it should output info for this type.  */
3977     note_debug_info_needed (ttype);
3978
3979   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
3980     note_debug_info_needed (DECL_CONTEXT (decl));
3981 #endif
3982
3983   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3984       && DECL_SIZE (decl) != NULL_TREE
3985       && ! TREE_CONSTANT (DECL_SIZE (decl)))
3986     {
3987       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3988         constant_expression_warning (DECL_SIZE (decl));
3989       else
3990         error ("storage size of `%D' isn't constant", decl);
3991     }
3992
3993   if (TREE_STATIC (decl)
3994       && !DECL_ARTIFICIAL (decl)
3995       && current_function_decl
3996       && DECL_CONTEXT (decl) == current_function_decl)
3997     push_local_name (decl);
3998 }
3999
4000 /* If a local static variable is declared in an inline function, or if
4001    we have a weak definition, we must endeavor to create only one
4002    instance of the variable at link-time.  */
4003
4004 static void
4005 maybe_commonize_var (tree decl)
4006 {
4007   /* Static data in a function with comdat linkage also has comdat
4008      linkage.  */
4009   if (TREE_STATIC (decl)
4010       /* Don't mess with __FUNCTION__.  */
4011       && ! DECL_ARTIFICIAL (decl)
4012       && DECL_FUNCTION_SCOPE_P (decl)
4013       /* Unfortunately, import_export_decl has not always been called
4014          before the function is processed, so we cannot simply check
4015          DECL_COMDAT.  */
4016       && (DECL_COMDAT (DECL_CONTEXT (decl))
4017           || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4018                || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4019               && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4020     {
4021       if (flag_weak)
4022         {
4023           /* With weak symbols, we simply make the variable COMDAT;
4024              that will cause copies in multiple translations units to
4025              be merged.  */
4026           comdat_linkage (decl);
4027         }
4028       else
4029         {
4030           if (DECL_INITIAL (decl) == NULL_TREE
4031               || DECL_INITIAL (decl) == error_mark_node)
4032             {
4033               /* Without weak symbols, we can use COMMON to merge
4034                  uninitialized variables.  */
4035               TREE_PUBLIC (decl) = 1;
4036               DECL_COMMON (decl) = 1;
4037             }
4038           else
4039             {
4040               /* While for initialized variables, we must use internal
4041                  linkage -- which means that multiple copies will not
4042                  be merged.  */
4043               TREE_PUBLIC (decl) = 0;
4044               DECL_COMMON (decl) = 0;
4045               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
4046               warning ("%J  you can work around this by removing the initializer",
4047                        decl);
4048             }
4049         }
4050     }
4051   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4052     /* Set it up again; we might have set DECL_INITIAL since the last
4053        time.  */
4054     comdat_linkage (decl);
4055 }
4056
4057 /* Issue an error message if DECL is an uninitialized const variable.  */
4058
4059 static void
4060 check_for_uninitialized_const_var (tree decl)
4061 {
4062   tree type = TREE_TYPE (decl);
4063
4064   /* ``Unless explicitly declared extern, a const object does not have
4065      external linkage and must be initialized. ($8.4; $12.1)'' ARM
4066      7.1.6 */
4067   if (TREE_CODE (decl) == VAR_DECL
4068       && TREE_CODE (type) != REFERENCE_TYPE
4069       && CP_TYPE_CONST_P (type)
4070       && !TYPE_NEEDS_CONSTRUCTING (type)
4071       && !DECL_INITIAL (decl))
4072     error ("uninitialized const `%D'", decl);
4073 }
4074
4075 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
4076    returned is the next FIELD_DECL (possibly FIELD itself) that can be
4077    initialized.  If there are no more such fields, the return value
4078    will be NULL.  */
4079
4080 static tree
4081 next_initializable_field (tree field)
4082 {
4083   while (field
4084          && (TREE_CODE (field) != FIELD_DECL
4085              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4086              || DECL_ARTIFICIAL (field)))
4087     field = TREE_CHAIN (field);
4088
4089   return field;
4090 }
4091
4092 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4093    brace-enclosed aggregate initializer.
4094
4095    *INITP is one of a list of initializers describing a brace-enclosed
4096    initializer for an entity of the indicated aggregate TYPE.  It may
4097    not presently match the shape of the TYPE; for example:
4098
4099      struct S { int a; int b; };
4100      struct S a[] = { 1, 2, 3, 4 };
4101
4102    Here *INITP will point to TREE_LIST of four elements, rather than a
4103    list of two elements, each itself a list of two elements.  This
4104    routine transforms INIT from the former form into the latter.  The
4105    revised initializer is returned.  */
4106
4107 static tree
4108 reshape_init (tree type, tree *initp)
4109 {
4110   tree inits;
4111   tree old_init;
4112   tree old_init_value;
4113   tree new_init;
4114   bool brace_enclosed_p;
4115
4116   old_init = *initp;
4117   old_init_value = (TREE_CODE (*initp) == TREE_LIST
4118                     ? TREE_VALUE (*initp) : old_init);
4119
4120   my_friendly_assert (old_init_value, 20030723);
4121
4122   /* If the initializer is brace-enclosed, pull initializers from the
4123      enclosed elements.  Advance past the brace-enclosed initializer
4124      now.  */
4125   if (TREE_CODE (old_init_value) == CONSTRUCTOR
4126       && BRACE_ENCLOSED_INITIALIZER_P (old_init_value))
4127     {
4128       *initp = TREE_CHAIN (old_init);
4129       TREE_CHAIN (old_init) = NULL_TREE;
4130       inits = CONSTRUCTOR_ELTS (old_init_value);
4131       initp = &inits;
4132       brace_enclosed_p = true;
4133     }
4134   else
4135     {
4136       inits = NULL_TREE;
4137       brace_enclosed_p = false;
4138     }
4139
4140   /* A non-aggregate type is always initialized with a single
4141      initializer.  */
4142   if (!CP_AGGREGATE_TYPE_P (type))
4143       {
4144         *initp = TREE_CHAIN (old_init);
4145         TREE_CHAIN (old_init) = NULL_TREE;
4146         /* It is invalid to initialize a non-aggregate type with a
4147            brace-enclosed initializer.  */
4148         if (brace_enclosed_p)
4149           {
4150             error ("brace-enclosed initializer used to initialize `%T'",
4151                    type);
4152             if (TREE_CODE (old_init) == TREE_LIST)
4153               TREE_VALUE (old_init) = error_mark_node;
4154             else
4155               old_init = error_mark_node;
4156           }
4157
4158         return old_init;
4159       }
4160
4161   /* [dcl.init.aggr]
4162
4163      All implicit type conversions (clause _conv_) are considered when
4164      initializing the aggregate member with an initializer from an
4165      initializer-list.  If the initializer can initialize a member,
4166      the member is initialized.  Otherwise, if the member is itself a
4167      non-empty subaggregate, brace elision is assumed and the
4168      initializer is considered for the initialization of the first
4169      member of the subaggregate.  */
4170   if (!brace_enclosed_p
4171       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4172     {
4173       *initp = TREE_CHAIN (old_init);
4174       TREE_CHAIN (old_init) = NULL_TREE;
4175       return old_init;
4176     }
4177
4178   if (TREE_CODE (old_init_value) == STRING_CST
4179       && TREE_CODE (type) == ARRAY_TYPE
4180       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4181     {
4182       /* [dcl.init.string]
4183
4184          A char array (whether plain char, signed char, or unsigned char)
4185          can be initialized by a string-literal (optionally enclosed in
4186          braces); a wchar_t array can be initialized by a wide
4187          string-literal (optionally enclosed in braces).  */
4188       new_init = old_init;
4189       /* Move past the initializer.  */
4190       *initp = TREE_CHAIN (old_init);
4191       TREE_CHAIN (old_init) = NULL_TREE;
4192     }
4193   else
4194     {
4195       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
4196       new_init = build_constructor (NULL_TREE, NULL_TREE);
4197
4198       if (CLASS_TYPE_P (type))
4199         {
4200           tree field;
4201
4202           field = next_initializable_field (TYPE_FIELDS (type));
4203
4204           if (!field)
4205             {
4206               /* [dcl.init.aggr]
4207
4208                  An initializer for an aggregate member that is an
4209                  empty class shall have the form of an empty
4210                  initializer-list {}.  */
4211               if (!brace_enclosed_p)
4212                 {
4213                   error ("initializer for `%T' must be brace-enclosed",
4214                          type);
4215                   return error_mark_node;
4216                 }
4217             }
4218           else
4219             {
4220               /* Loop through the initializable fields, gathering
4221                  initializers.  */
4222               while (*initp)
4223                 {
4224                   tree field_init;
4225
4226                   /* Handle designated initializers, as an extension.  */
4227                   if (TREE_PURPOSE (*initp))
4228                     {
4229                       if (pedantic)
4230                         pedwarn ("ISO C++ does not allow designated initializers");
4231                       field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4232                                               /*want_type=*/false);
4233                       if (!field || TREE_CODE (field) != FIELD_DECL)
4234                         error ("`%T' has no non-static data member named `%D'",
4235                                type, TREE_PURPOSE (*initp));
4236                     }
4237                   if (!field)
4238                     break;
4239
4240                   field_init = reshape_init (TREE_TYPE (field), initp);
4241                   if (field_init == error_mark_node)
4242                     return error_mark_node;
4243                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4244                   CONSTRUCTOR_ELTS (new_init) = field_init;
4245                   /* [dcl.init.aggr]
4246
4247                      When a union  is  initialized with a brace-enclosed
4248                      initializer, the braces shall only contain an
4249                      initializer for the first member of the union.  */
4250                   if (TREE_CODE (type) == UNION_TYPE)
4251                     break;
4252                   field = next_initializable_field (TREE_CHAIN (field));
4253                 }
4254             }
4255         }
4256       else if (TREE_CODE (type) == ARRAY_TYPE
4257                || TREE_CODE (type) == VECTOR_TYPE)
4258         {
4259           tree index;
4260           tree max_index;
4261
4262           /* If the bound of the array is known, take no more initializers
4263              than are allowed.  */
4264           max_index = NULL_TREE;
4265           if (TREE_CODE (type) == ARRAY_TYPE)
4266             {
4267               if (TYPE_DOMAIN (type))
4268                 max_index = array_type_nelts (type);
4269             }
4270           else
4271             {
4272               /* For a vector, the representation type is a struct
4273                  containing a single member which is an array of the
4274                  appropriate size.  */
4275               tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4276               if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4277                 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4278             }
4279
4280           /* Loop through the array elements, gathering initializers.  */
4281           for (index = size_zero_node;
4282                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
4283                index = size_binop (PLUS_EXPR, index, size_one_node))
4284             {
4285               tree element_init;
4286
4287               element_init = reshape_init (TREE_TYPE (type), initp);
4288               if (element_init == error_mark_node)
4289                 return error_mark_node;
4290               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4291               CONSTRUCTOR_ELTS (new_init) = element_init;
4292               if (TREE_PURPOSE (element_init))
4293                 {
4294                   tree next_index = TREE_PURPOSE (element_init);
4295                   if (TREE_CODE (next_index) == IDENTIFIER_NODE)
4296                     {
4297                       error ("name `%D' used in a GNU-style designated "
4298                              "initializer for an array", next_index);
4299                       TREE_PURPOSE (element_init) = NULL_TREE;
4300                     }
4301                   else
4302                     index = next_index;
4303                 }
4304             }
4305         }
4306       else
4307         abort ();
4308
4309       /* The initializers were placed in reverse order in the
4310          CONSTRUCTOR.  */
4311       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4312
4313       if (TREE_CODE (old_init) == TREE_LIST)
4314         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4315     }
4316
4317   /* If this was a brace-enclosed initializer and all of the
4318      initializers were not used up, there is a problem.  */
4319   if (brace_enclosed_p && *initp)
4320     error ("too many initializers for `%T'", type);
4321
4322   return new_init;
4323 }
4324
4325 /* Verify INIT (the initializer for DECL), and record the
4326    initialization in DECL_INITIAL, if appropriate.  CLEANUP is as for
4327    grok_reference_init.
4328
4329    If the return value is non-NULL, it is an expression that must be
4330    evaluated dynamically to initialize DECL.  */
4331
4332 static tree
4333 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4334 {
4335   tree type = TREE_TYPE (decl);
4336   tree init_code = NULL;
4337
4338   /* If `start_decl' didn't like having an initialization, ignore it now.  */
4339   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4340     init = NULL_TREE;
4341
4342   /* If an initializer is present, DECL_INITIAL has been
4343      error_mark_node, to indicate that an as-of-yet unevaluated
4344      initialization will occur.  From now on, DECL_INITIAL reflects
4345      the static initialization -- if any -- of DECL.  */
4346   DECL_INITIAL (decl) = NULL_TREE;
4347
4348   /* Things that are going to be initialized need to have complete
4349      type.  */
4350   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4351
4352   if (type == error_mark_node)
4353     /* We will have already complained.  */
4354     init = NULL_TREE;
4355   else if (init && COMPLETE_TYPE_P (type)
4356            && !TREE_CONSTANT (TYPE_SIZE (type)))
4357     {
4358       error ("variable-sized object `%D' may not be initialized", decl);
4359       init = NULL_TREE;
4360     }
4361   else if (TREE_CODE (type) == ARRAY_TYPE
4362            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4363     {
4364       error ("elements of array `%#D' have incomplete type", decl);
4365       init = NULL_TREE;
4366     }
4367   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4368     {
4369       error ("`%D' has incomplete type", decl);
4370       TREE_TYPE (decl) = error_mark_node;
4371       init = NULL_TREE;
4372     }
4373
4374   if (TREE_CODE (decl) == CONST_DECL)
4375     {
4376       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
4377
4378       DECL_INITIAL (decl) = init;
4379
4380       my_friendly_assert (init != NULL_TREE, 149);
4381       init = NULL_TREE;
4382     }
4383   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4384     init = grok_reference_init (decl, type, init, cleanup);
4385   else if (init)
4386     {
4387       if (TREE_CODE (init) == CONSTRUCTOR
4388           && BRACE_ENCLOSED_INITIALIZER_P (init))
4389         {
4390           /* [dcl.init] paragraph 13,
4391              If T is a scalar type, then a declaration of the form
4392              T x = { a };
4393              is equivalent to
4394              T x = a;
4395
4396              reshape_init will complain about the extra braces,
4397              and doesn't do anything useful in the case where TYPE is
4398              scalar, so just don't call it.  */
4399           if (CP_AGGREGATE_TYPE_P (type))
4400             init = reshape_init (type, &init);
4401
4402           if ((*targetm.vector_opaque_p) (type))
4403             {
4404               error ("opaque vector types cannot be initialized");
4405               init = error_mark_node;
4406             }
4407         }
4408
4409       /* If DECL has an array type without a specific bound, deduce the
4410          array size from the initializer.  */
4411       maybe_deduce_size_from_array_init (decl, init);
4412       type = TREE_TYPE (decl);
4413
4414       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4415         {
4416           if (TREE_CODE (type) == ARRAY_TYPE)
4417             goto initialize_aggr;
4418           else if (TREE_CODE (init) == CONSTRUCTOR
4419                    && BRACE_ENCLOSED_INITIALIZER_P (init))
4420             {
4421               if (TYPE_NON_AGGREGATE_CLASS (type))
4422                 {
4423                   error ("`%D' must be initialized by constructor, not by `{...}'",
4424                          decl);
4425                   init = error_mark_node;
4426                 }
4427               else
4428                 goto dont_use_constructor;
4429             }
4430           else
4431             {
4432               int saved_stmts_are_full_exprs_p;
4433
4434             initialize_aggr:
4435               saved_stmts_are_full_exprs_p = 0;
4436               if (building_stmt_tree ())
4437                 {
4438                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4439                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4440                 }
4441               init = build_aggr_init (decl, init, flags);
4442               if (building_stmt_tree ())
4443                 current_stmt_tree ()->stmts_are_full_exprs_p =
4444                   saved_stmts_are_full_exprs_p;
4445               return init;
4446             }
4447         }
4448       else
4449         {
4450         dont_use_constructor:
4451           if (TREE_CODE (init) != TREE_VEC)
4452             {
4453               init_code = store_init_value (decl, init);
4454               init = NULL;
4455             }
4456         }
4457     }
4458   else if (DECL_EXTERNAL (decl))
4459     ;
4460   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4461     goto initialize_aggr;
4462   else if (IS_AGGR_TYPE (type))
4463     {
4464       tree core_type = strip_array_types (type);
4465
4466       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4467         error ("structure `%D' with uninitialized const members", decl);
4468       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4469         error ("structure `%D' with uninitialized reference members",
4470                decl);
4471
4472       check_for_uninitialized_const_var (decl);
4473     }
4474   else
4475     check_for_uninitialized_const_var (decl);
4476
4477   if (init && init != error_mark_node)
4478     init_code = build (INIT_EXPR, type, decl, init);
4479
4480   return init_code;
4481 }
4482
4483 /* If DECL is not a local variable, give it RTL.  */
4484
4485 static void
4486 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4487 {
4488   int toplev = toplevel_bindings_p ();
4489   int defer_p;
4490
4491   /* Handle non-variables up front.  */
4492   if (TREE_CODE (decl) != VAR_DECL)
4493     {
4494       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4495       return;
4496     }
4497
4498   /* If we see a class member here, it should be a static data
4499      member.  */
4500   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4501     {
4502       my_friendly_assert (TREE_STATIC (decl), 19990828);
4503       /* An in-class declaration of a static data member should be
4504          external; it is only a declaration, and not a definition.  */
4505       if (init == NULL_TREE)
4506         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
4507     }
4508
4509   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
4510   if (asmspec)
4511     {
4512       change_decl_assembler_name (decl, get_identifier (asmspec));
4513       /* The `register' keyword, when used together with an
4514          asm-specification, indicates that the variable should be
4515          placed in a particular register.  */
4516       if (DECL_REGISTER (decl))
4517         DECL_HARD_REGISTER (decl) = 1;
4518     }
4519
4520   /* We don't create any RTL for local variables.  */
4521   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4522     return;
4523
4524   /* We defer emission of local statics until the corresponding
4525      DECL_EXPR is expanded.  */
4526   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4527
4528   /* We try to defer namespace-scope static constants so that they are
4529      not emitted into the object file unnecessarily.  */
4530   if (!DECL_VIRTUAL_P (decl)
4531       && TREE_READONLY (decl)
4532       && DECL_INITIAL (decl) != NULL_TREE
4533       && DECL_INITIAL (decl) != error_mark_node
4534       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4535       && toplev
4536       && !TREE_PUBLIC (decl))
4537     {
4538       /* Fool with the linkage of static consts according to #pragma
4539          interface.  */
4540       if (!interface_unknown && !TREE_PUBLIC (decl))
4541         {
4542           TREE_PUBLIC (decl) = 1;
4543           DECL_EXTERNAL (decl) = interface_only;
4544         }
4545
4546       defer_p = 1;
4547     }
4548   /* Likewise for template instantiations.  */
4549   else if (DECL_COMDAT (decl))
4550     defer_p = 1;
4551
4552   /* If we're deferring the variable, we only need to make RTL if
4553      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
4554      we need it.  (There's no way to lazily create RTL for things that
4555      have assembly specs because the information about the specifier
4556      isn't stored in the tree, yet)  */
4557   if (defer_p && asmspec)
4558     make_decl_rtl (decl, asmspec);
4559   /* If we're not deferring, go ahead and assemble the variable.  */
4560   else if (!defer_p)
4561     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4562 }
4563
4564 /* Generate code to initialize DECL (a local variable).  */
4565
4566 static void
4567 initialize_local_var (tree decl, tree init)
4568 {
4569   tree type = TREE_TYPE (decl);
4570   tree cleanup;
4571
4572   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
4573                       || TREE_CODE (decl) == RESULT_DECL,
4574                       20021010);
4575   my_friendly_assert (!TREE_STATIC (decl), 20021010);
4576
4577   if (DECL_SIZE (decl) == NULL_TREE)
4578     {
4579       /* If we used it already as memory, it must stay in memory.  */
4580       DECL_INITIAL (decl) = NULL_TREE;
4581       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4582     }
4583
4584   if (DECL_SIZE (decl) && type != error_mark_node)
4585     {
4586       int already_used;
4587
4588       /* Compute and store the initial value.  */
4589       already_used = TREE_USED (decl) || TREE_USED (type);
4590
4591       /* Perform the initialization.  */
4592       if (init)
4593         {
4594           int saved_stmts_are_full_exprs_p;
4595
4596           my_friendly_assert (building_stmt_tree (), 20000906);
4597           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4598           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4599           finish_expr_stmt (init);
4600           current_stmt_tree ()->stmts_are_full_exprs_p =
4601             saved_stmts_are_full_exprs_p;
4602         }
4603
4604       /* Set this to 0 so we can tell whether an aggregate which was
4605          initialized was ever used.  Don't do this if it has a
4606          destructor, so we don't complain about the 'resource
4607          allocation is initialization' idiom.  Now set
4608          attribute((unused)) on types so decls of that type will be
4609          marked used. (see TREE_USED, above.)  */
4610       if (TYPE_NEEDS_CONSTRUCTING (type)
4611           && ! already_used
4612           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4613           && DECL_NAME (decl))
4614         TREE_USED (decl) = 0;
4615       else if (already_used)
4616         TREE_USED (decl) = 1;
4617     }
4618
4619   /* Generate a cleanup, if necessary.  */
4620   cleanup = cxx_maybe_build_cleanup (decl);
4621   if (DECL_SIZE (decl) && cleanup)
4622     finish_decl_cleanup (decl, cleanup);
4623 }
4624
4625 /* Finish processing of a declaration;
4626    install its line number and initial value.
4627    If the length of an array type is not known before,
4628    it must be determined now, from the initial value, or it is an error.
4629
4630    INIT holds the value of an initializer that should be allowed to escape
4631    the normal rules.
4632
4633    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4634    if the (init) syntax was used.  */
4635
4636 void
4637 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4638 {
4639   tree type;
4640   tree ttype = NULL_TREE;
4641   tree cleanup;
4642   const char *asmspec = NULL;
4643   int was_readonly = 0;
4644
4645   if (decl == error_mark_node)
4646     return;
4647   else if (! decl)
4648     {
4649       if (init)
4650         error ("assignment (not initialization) in declaration");
4651       return;
4652     }
4653
4654   my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);
4655
4656   /* Assume no cleanup is required.  */
4657   cleanup = NULL_TREE;
4658
4659   /* If a name was specified, get the string.  */
4660   if (global_scope_p (current_binding_level))
4661     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4662   if (asmspec_tree)
4663     asmspec = TREE_STRING_POINTER (asmspec_tree);
4664
4665   if (init && TREE_CODE (init) == NAMESPACE_DECL)
4666     {
4667       error ("cannot initialize `%D' to namespace `%D'",
4668                 decl, init);
4669       init = NULL_TREE;
4670     }
4671
4672   if (current_class_type
4673       && CP_DECL_CONTEXT (decl) == current_class_type
4674       && TYPE_BEING_DEFINED (current_class_type)
4675       && (DECL_INITIAL (decl) || init))
4676     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4677
4678   if (TREE_CODE (decl) == VAR_DECL
4679       && DECL_CONTEXT (decl)
4680       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
4681       && DECL_CONTEXT (decl) != current_namespace
4682       && init)
4683     {
4684       /* Leave the namespace of the object.  */
4685       pop_decl_namespace ();
4686     }
4687
4688   type = TREE_TYPE (decl);
4689
4690   if (type == error_mark_node)
4691     goto finish_end0;
4692
4693   if (TYPE_HAS_MUTABLE_P (type))
4694     TREE_READONLY (decl) = 0;
4695
4696   if (processing_template_decl)
4697     {
4698       /* Add this declaration to the statement-tree.  */
4699       if (at_function_scope_p ())
4700         add_decl_expr (decl);
4701
4702       if (init && DECL_INITIAL (decl))
4703         DECL_INITIAL (decl) = init;
4704       if (TREE_CODE (decl) == VAR_DECL
4705           && !DECL_PRETTY_FUNCTION_P (decl)
4706           && !dependent_type_p (TREE_TYPE (decl)))
4707         maybe_deduce_size_from_array_init (decl, init);
4708       goto finish_end0;
4709     }
4710
4711   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
4712   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
4713
4714   /* Take care of TYPE_DECLs up front.  */
4715   if (TREE_CODE (decl) == TYPE_DECL)
4716     {
4717       if (type != error_mark_node
4718           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4719         {
4720           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4721             warning ("shadowing previous type declaration of `%#D'", decl);
4722           set_identifier_type_value (DECL_NAME (decl), decl);
4723         }
4724
4725       /* If we have installed this as the canonical typedef for this
4726          type, and that type has not been defined yet, delay emitting
4727          the debug information for it, as we will emit it later.  */
4728       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4729           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4730         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4731
4732       rest_of_decl_compilation (decl, NULL,
4733                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
4734       goto finish_end;
4735     }
4736
4737   if (TREE_CODE (decl) != FUNCTION_DECL)
4738     ttype = target_type (type);
4739
4740
4741   /* Currently, GNU C++ puts constants in text space, making them
4742      impossible to initialize.  In the future, one would hope for
4743      an operating system which understood the difference between
4744      initialization and the running of a program.  */
4745   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl))
4746     {
4747       was_readonly = 1;
4748       if (TYPE_NEEDS_CONSTRUCTING (type)
4749           || TREE_CODE (type) == REFERENCE_TYPE)
4750         TREE_READONLY (decl) = 0;
4751     }
4752
4753   if (TREE_CODE (decl) == VAR_DECL)
4754     {
4755       /* Only PODs can have thread-local storage.  Other types may require
4756          various kinds of non-trivial initialization.  */
4757       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4758         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4759                decl, TREE_TYPE (decl));
4760       /* Convert the initializer to the type of DECL, if we have not
4761          already initialized DECL.  */
4762       if (!DECL_INITIALIZED_P (decl)
4763           /* If !DECL_EXTERNAL then DECL is being defined.  In the
4764              case of a static data member initialized inside the
4765              class-specifier, there can be an initializer even if DECL
4766              is *not* defined.  */
4767           && (!DECL_EXTERNAL (decl) || init))
4768         {
4769           init = check_initializer (decl, init, flags, &cleanup);
4770           /* Thread-local storage cannot be dynamically initialized.  */
4771           if (DECL_THREAD_LOCAL (decl) && init)
4772             {
4773               error ("`%D' is thread-local and so cannot be dynamically "
4774                      "initialized", decl);
4775               init = NULL_TREE;
4776             }
4777           /* Handle:
4778
4779              [dcl.init]
4780
4781              The memory occupied by any object of static storage
4782              duration is zero-initialized at program startup before
4783              any other initialization takes place.
4784
4785              We cannot create an appropriate initializer until after
4786              the type of DECL is finalized.  If DECL_INITIAL is set,
4787              then the DECL is statically initialized, and any
4788              necessary zero-initialization has already been performed.  */
4789           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4790             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4791                                                    /*nelts=*/NULL_TREE,
4792                                                    /*static_storage_p=*/true);
4793           /* Remember that the initialization for this variable has
4794              taken place.  */
4795           DECL_INITIALIZED_P (decl) = 1;
4796         }
4797       /* If the variable has an array type, lay out the type, even if
4798          there is no initializer.  It is valid to index through the
4799          array, and we must get TYPE_ALIGN set correctly on the array
4800          type.  */
4801       else if (TREE_CODE (type) == ARRAY_TYPE)
4802         layout_type (type);
4803     }
4804
4805   /* Add this declaration to the statement-tree.  This needs to happen
4806      after the call to check_initializer so that the DECL_EXPR for a
4807      reference temp is added before the DECL_EXPR for the reference itself.  */
4808   if (at_function_scope_p ())
4809     add_decl_expr (decl);
4810
4811   if (TREE_CODE (decl) == VAR_DECL)
4812     layout_var_decl (decl);
4813
4814   /* Output the assembler code and/or RTL code for variables and functions,
4815      unless the type is an undefined structure or union.
4816      If not, it will get done when the type is completed.  */
4817   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4818     {
4819       if (TREE_CODE (decl) == VAR_DECL)
4820         maybe_commonize_var (decl);
4821
4822       make_rtl_for_nonlocal_decl (decl, init, asmspec);
4823
4824       /* Check for abstractness of the type. Notice that there is no
4825          need to strip array types here since the check for those types
4826          is already done within create_array_type_for_decl.  */
4827       if (TREE_CODE (type) == FUNCTION_TYPE
4828           || TREE_CODE (type) == METHOD_TYPE)
4829         abstract_virtuals_error (decl, TREE_TYPE (type));
4830       else
4831         abstract_virtuals_error (decl, type);
4832
4833       if (TREE_CODE (decl) == FUNCTION_DECL
4834           || TREE_TYPE (decl) == error_mark_node)
4835         /* No initialization required.  */
4836         ;
4837       else if (DECL_EXTERNAL (decl)
4838                && ! (DECL_LANG_SPECIFIC (decl)
4839                      && DECL_NOT_REALLY_EXTERN (decl)))
4840         {
4841           if (init)
4842             DECL_INITIAL (decl) = init;
4843         }
4844       else
4845         {
4846           /* A variable definition.  */
4847           if (DECL_FUNCTION_SCOPE_P (decl))
4848             {
4849               /* This is a local declaration.  */
4850               maybe_inject_for_scope_var (decl);
4851               /* Initialize the local variable.  */
4852               if (processing_template_decl)
4853                 {
4854                   if (init || DECL_INITIAL (decl) == error_mark_node)
4855                     DECL_INITIAL (decl) = init;
4856                 }
4857               else if (!TREE_STATIC (decl))
4858                 initialize_local_var (decl, init);
4859             }
4860
4861           if (TREE_STATIC (decl))
4862             expand_static_init (decl, init);
4863         }
4864     finish_end0:
4865
4866       /* Undo call to `pushclass' that was done in `start_decl'
4867          due to initialization of qualified member variable.
4868          I.e., Foo::x = 10;  */
4869       {
4870         tree context = CP_DECL_CONTEXT (decl);
4871         if (context
4872             && TYPE_P (context)
4873             && (TREE_CODE (decl) == VAR_DECL
4874                 /* We also have a pushclass done that we need to undo here
4875                    if we're at top level and declare a method.  */
4876                 || TREE_CODE (decl) == FUNCTION_DECL)
4877             /* If size hasn't been set, we're still defining it,
4878                and therefore inside the class body; don't pop
4879                the binding level..  */
4880             && COMPLETE_TYPE_P (context)
4881             && context == current_class_type)
4882           pop_nested_class ();
4883       }
4884     }
4885
4886   /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4887      reference, insert it in the statement-tree now.  */
4888   if (cleanup)
4889     push_cleanup (decl, cleanup, false);
4890
4891  finish_end:
4892
4893   if (was_readonly)
4894     TREE_READONLY (decl) = 1;
4895
4896   /* If this was marked 'used', be sure it will be output.  */
4897   if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
4898     mark_decl_referenced (decl);
4899 }
4900
4901 /* This is here for a midend callback from c-common.c.  */
4902
4903 void
4904 finish_decl (tree decl, tree init, tree asmspec_tree)
4905 {
4906   cp_finish_decl (decl, init, asmspec_tree, 0);
4907 }
4908
4909 /* Returns a declaration for a VAR_DECL as if:
4910
4911      extern "C" TYPE NAME;
4912
4913    had been seen.  Used to create compiler-generated global
4914    variables.  */
4915
4916 tree
4917 declare_global_var (tree name, tree type)
4918 {
4919   tree decl;
4920
4921   push_to_top_level ();
4922   decl = build_decl (VAR_DECL, name, type);
4923   TREE_PUBLIC (decl) = 1;
4924   DECL_EXTERNAL (decl) = 1;
4925   DECL_ARTIFICIAL (decl) = 1;
4926   pushdecl (decl);
4927   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
4928   pop_from_top_level ();
4929
4930   return decl;
4931 }
4932
4933 /* Returns a pointer to the `atexit' function.  Note that if
4934    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4935    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
4936
4937 static tree
4938 get_atexit_node (void)
4939 {
4940   tree atexit_fndecl;
4941   tree arg_types;
4942   tree fn_type;
4943   tree fn_ptr_type;
4944   const char *name;
4945
4946   if (atexit_node)
4947     return atexit_node;
4948
4949   if (flag_use_cxa_atexit)
4950     {
4951       /* The declaration for `__cxa_atexit' is:
4952
4953            int __cxa_atexit (void (*)(void *), void *, void *)
4954
4955          We build up the argument types and then then function type
4956          itself.  */
4957
4958       /* First, build the pointer-to-function type for the first
4959          argument.  */
4960       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
4961       fn_type = build_function_type (void_type_node, arg_types);
4962       fn_ptr_type = build_pointer_type (fn_type);
4963       /* Then, build the rest of the argument types.  */
4964       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
4965       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
4966       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
4967       /* And the final __cxa_atexit type.  */
4968       fn_type = build_function_type (integer_type_node, arg_types);
4969       fn_ptr_type = build_pointer_type (fn_type);
4970       name = "__cxa_atexit";
4971     }
4972   else
4973     {
4974       /* The declaration for `atexit' is:
4975
4976            int atexit (void (*)());
4977
4978          We build up the argument types and then then function type
4979          itself.  */
4980       fn_type = build_function_type (void_type_node, void_list_node);
4981       fn_ptr_type = build_pointer_type (fn_type);
4982       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
4983       /* Build the final atexit type.  */
4984       fn_type = build_function_type (integer_type_node, arg_types);
4985       name = "atexit";
4986     }
4987
4988   /* Now, build the function declaration.  */
4989   push_lang_context (lang_name_c);
4990   atexit_fndecl = build_library_fn_ptr (name, fn_type);
4991   mark_used (atexit_fndecl);
4992   pop_lang_context ();
4993   atexit_node = decay_conversion (atexit_fndecl);
4994
4995   return atexit_node;
4996 }
4997
4998 /* Returns the __dso_handle VAR_DECL.  */
4999
5000 static tree
5001 get_dso_handle_node (void)
5002 {
5003   if (dso_handle_node)
5004     return dso_handle_node;
5005
5006   /* Declare the variable.  */
5007   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5008                                         ptr_type_node);
5009
5010   return dso_handle_node;
5011 }
5012
5013 /* Begin a new function with internal linkage whose job will be simply
5014    to destroy some particular variable.  */
5015
5016 static GTY(()) int start_cleanup_cnt;
5017
5018 static tree
5019 start_cleanup_fn (void)
5020 {
5021   int old_interface_only = interface_only;
5022   int old_interface_unknown = interface_unknown;
5023   char name[32];
5024   tree parmtypes;
5025   tree fntype;
5026   tree fndecl;
5027
5028   push_to_top_level ();
5029
5030   /* No need to mangle this.  */
5031   push_lang_context (lang_name_c);
5032
5033   interface_only = 0;
5034   interface_unknown = 1;
5035
5036   /* Build the parameter-types.  */
5037   parmtypes = void_list_node;
5038   /* Functions passed to __cxa_atexit take an additional parameter.
5039      We'll just ignore it.  After we implement the new calling
5040      convention for destructors, we can eliminate the use of
5041      additional cleanup functions entirely in the -fnew-abi case.  */
5042   if (flag_use_cxa_atexit)
5043     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5044   /* Build the function type itself.  */
5045   fntype = build_function_type (void_type_node, parmtypes);
5046   /* Build the name of the function.  */
5047   sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5048   /* Build the function declaration.  */
5049   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5050   /* It's a function with internal linkage, generated by the
5051      compiler.  */
5052   TREE_PUBLIC (fndecl) = 0;
5053   DECL_ARTIFICIAL (fndecl) = 1;
5054   /* Make the function `inline' so that it is only emitted if it is
5055      actually needed.  It is unlikely that it will be inlined, since
5056      it is only called via a function pointer, but we avoid unnecessary
5057      emissions this way.  */
5058   DECL_INLINE (fndecl) = 1;
5059   DECL_DECLARED_INLINE_P (fndecl) = 1;
5060   DECL_INTERFACE_KNOWN (fndecl) = 1;
5061   /* Build the parameter.  */
5062   if (flag_use_cxa_atexit)
5063     {
5064       tree parmdecl;
5065
5066       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5067       DECL_CONTEXT (parmdecl) = fndecl;
5068       TREE_USED (parmdecl) = 1;
5069       DECL_ARGUMENTS (fndecl) = parmdecl;
5070     }
5071
5072   pushdecl (fndecl);
5073   start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5074
5075   interface_unknown = old_interface_unknown;
5076   interface_only = old_interface_only;
5077
5078   pop_lang_context ();
5079
5080   return current_function_decl;
5081 }
5082
5083 /* Finish the cleanup function begun by start_cleanup_fn.  */
5084
5085 static void
5086 end_cleanup_fn (void)
5087 {
5088   expand_or_defer_fn (finish_function (0));
5089
5090   pop_from_top_level ();
5091 }
5092
5093 /* Generate code to handle the destruction of DECL, an object with
5094    static storage duration.  */
5095
5096 void
5097 register_dtor_fn (tree decl)
5098 {
5099   tree cleanup;
5100   tree compound_stmt;
5101   tree args;
5102   tree fcall;
5103
5104   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5105     return;
5106
5107   /* Call build_cleanup before we enter the anonymous function so that
5108      any access checks will be done relative to the current scope,
5109      rather than the scope of the anonymous function.  */
5110   build_cleanup (decl);
5111
5112   /* Now start the function.  */
5113   cleanup = start_cleanup_fn ();
5114
5115   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
5116      to the original function, rather than the anonymous one.  That
5117      will make the back-end think that nested functions are in use,
5118      which causes confusion.  */
5119
5120   push_deferring_access_checks (dk_no_check);
5121   fcall = build_cleanup (decl);
5122   pop_deferring_access_checks ();
5123
5124   /* Create the body of the anonymous function.  */
5125   compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5126   finish_expr_stmt (fcall);
5127   finish_compound_stmt (compound_stmt);
5128   end_cleanup_fn ();
5129
5130   /* Call atexit with the cleanup function.  */
5131   cxx_mark_addressable (cleanup);
5132   mark_used (cleanup);
5133   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5134   if (flag_use_cxa_atexit)
5135     {
5136       args = tree_cons (NULL_TREE,
5137                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5138                         NULL_TREE);
5139       args = tree_cons (NULL_TREE, null_pointer_node, args);
5140       args = tree_cons (NULL_TREE, cleanup, args);
5141     }
5142   else
5143     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5144   finish_expr_stmt (build_function_call (get_atexit_node (), args));
5145 }
5146
5147 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
5148    is its initializer.  Generate code to handle the construction
5149    and destruction of DECL.  */
5150
5151 static void
5152 expand_static_init (tree decl, tree init)
5153 {
5154   my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
5155   my_friendly_assert (TREE_STATIC (decl), 20021010);
5156
5157   /* Some variables require no initialization.  */
5158   if (!init
5159       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5160       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5161     return;
5162
5163   if (! toplevel_bindings_p ())
5164     {
5165       /* Emit code to perform this initialization but once.  */
5166       tree if_stmt;
5167       tree then_clause;
5168       tree assignment;
5169       tree guard;
5170       tree guard_init;
5171
5172       /* Emit code to perform this initialization but once.  This code
5173          looks like:
5174
5175            static int guard = 0;
5176            if (!guard) {
5177              // Do initialization.
5178              guard = 1;
5179              // Register variable for destruction at end of program.
5180            }
5181
5182          Note that the `temp' variable is only set to 1 *after* the
5183          initialization is complete.  This ensures that an exception,
5184          thrown during the construction, will cause the variable to
5185          reinitialized when we pass through this code again, as per:
5186
5187            [stmt.dcl]
5188
5189            If the initialization exits by throwing an exception, the
5190            initialization is not complete, so it will be tried again
5191            the next time control enters the declaration.
5192
5193          In theory, this process should be thread-safe, too; multiple
5194          threads should not be able to initialize the variable more
5195          than once.  We don't yet attempt to ensure thread-safety.  */
5196
5197       /* Create the guard variable.  */
5198       guard = get_guard (decl);
5199
5200       /* Begin the conditional initialization.  */
5201       if_stmt = begin_if_stmt ();
5202       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5203       then_clause = begin_compound_stmt (0);
5204
5205       /* Do the initialization itself.  */
5206       assignment = init ? init : NULL_TREE;
5207
5208       /* Once the assignment is complete, set TEMP to 1.  Since the
5209          construction of the static object is complete at this point,
5210          we want to make sure TEMP is set to 1 even if a temporary
5211          constructed during the initialization throws an exception
5212          when it is destroyed.  So, we combine the initialization and
5213          the assignment to TEMP into a single expression, ensuring
5214          that when we call finish_expr_stmt the cleanups will not be
5215          run until after TEMP is set to 1.  */
5216       guard_init = set_guard (guard);
5217       if (assignment)
5218         assignment = build_compound_expr (assignment, guard_init);
5219       else
5220         assignment = guard_init;
5221       finish_expr_stmt (assignment);
5222
5223       /* Use atexit to register a function for destroying this static
5224          variable.  */
5225       register_dtor_fn (decl);
5226
5227       finish_compound_stmt (then_clause);
5228       finish_then_clause (if_stmt);
5229       finish_if_stmt (if_stmt);
5230     }
5231   else
5232     static_aggregates = tree_cons (init, decl, static_aggregates);
5233 }
5234
5235 \f
5236 /* Make TYPE a complete type based on INITIAL_VALUE.
5237    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5238    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
5239
5240 int
5241 complete_array_type (tree type, tree initial_value, int do_default)
5242 {
5243   tree maxindex = NULL_TREE;
5244   int value = 0;
5245
5246   if (initial_value)
5247     {
5248       /* An array of character type can be initialized from a
5249          brace-enclosed string constant.  */
5250       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
5251           && TREE_CODE (initial_value) == CONSTRUCTOR
5252           && CONSTRUCTOR_ELTS (initial_value)
5253           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
5254               == STRING_CST)
5255           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
5256         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
5257
5258       /* Note MAXINDEX is really the maximum index, one less than the
5259          size.  */
5260       if (TREE_CODE (initial_value) == STRING_CST)
5261         {
5262           int eltsize
5263             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5264           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
5265                                    / eltsize) - 1, 0);
5266         }
5267       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5268         {
5269           tree elts = CONSTRUCTOR_ELTS (initial_value);
5270
5271           maxindex = ssize_int (-1);
5272           for (; elts; elts = TREE_CHAIN (elts))
5273             {
5274               if (TREE_PURPOSE (elts))
5275                 maxindex = TREE_PURPOSE (elts);
5276               else
5277                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
5278             }
5279           maxindex = copy_node (maxindex);
5280         }
5281       else
5282         {
5283           /* Make an error message unless that happened already.  */
5284           if (initial_value != error_mark_node)
5285             value = 1;
5286           else
5287             initial_value = NULL_TREE;
5288
5289           /* Prevent further error messages.  */
5290           maxindex = build_int_2 (0, 0);
5291         }
5292     }
5293
5294   if (!maxindex)
5295     {
5296       if (do_default)
5297         maxindex = build_int_2 (0, 0);
5298       value = 2;
5299     }
5300
5301   if (maxindex)
5302     {
5303       tree itype;
5304       tree domain;
5305       tree elt_type;
5306
5307       domain = build_index_type (maxindex);
5308       TYPE_DOMAIN (type) = domain;
5309
5310       if (! TREE_TYPE (maxindex))
5311         TREE_TYPE (maxindex) = domain;
5312       if (initial_value)
5313         itype = TREE_TYPE (initial_value);
5314       else
5315         itype = NULL;
5316       if (itype && !TYPE_DOMAIN (itype))
5317         TYPE_DOMAIN (itype) = domain;
5318       /* The type of the main variant should never be used for arrays
5319          of different sizes.  It should only ever be completed with the
5320          size of the array.  */
5321       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
5322         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
5323
5324       elt_type = TREE_TYPE (type);
5325       TYPE_NEEDS_CONSTRUCTING (type)
5326         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
5327       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5328         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
5329     }
5330
5331   /* Lay out the type now that we can get the real answer.  */
5332
5333   layout_type (type);
5334
5335   return value;
5336 }
5337 \f
5338 /* Return zero if something is declared to be a member of type
5339    CTYPE when in the context of CUR_TYPE.  STRING is the error
5340    message to print in that case.  Otherwise, quietly return 1.  */
5341
5342 static int
5343 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5344 {
5345   if (ctype && ctype != cur_type)
5346     {
5347       if (flags == DTOR_FLAG)
5348         error ("destructor for alien class `%T' cannot be a member",
5349                   ctype);
5350       else
5351         error ("constructor for alien class `%T' cannot be a member",
5352                   ctype);
5353       return 0;
5354     }
5355   return 1;
5356 }
5357 \f
5358 /* Subroutine of `grokdeclarator'.  */
5359
5360 /* Generate errors possibly applicable for a given set of specifiers.
5361    This is for ARM $7.1.2.  */
5362
5363 static void
5364 bad_specifiers (tree object,
5365                 const char* type,
5366                 int virtualp,
5367                 int quals,
5368                 int inlinep,
5369                 int friendp,
5370                 int raises)
5371 {
5372   if (virtualp)
5373     error ("`%D' declared as a `virtual' %s", object, type);
5374   if (inlinep)
5375     error ("`%D' declared as an `inline' %s", object, type);
5376   if (quals)
5377     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5378               object, type);
5379   if (friendp)
5380     cp_error_at ("`%D' declared as a friend", object);
5381   if (raises
5382       && (TREE_CODE (object) == TYPE_DECL
5383           || (!TYPE_PTRFN_P (TREE_TYPE (object))
5384               && !TYPE_REFFN_P (TREE_TYPE (object))
5385               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5386     cp_error_at ("`%D' declared with an exception specification", object);
5387 }
5388
5389 /* CTYPE is class type, or null if non-class.
5390    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5391    or METHOD_TYPE.
5392    DECLARATOR is the function's name.
5393    PARMS is a chain of PARM_DECLs for the function.
5394    VIRTUALP is truthvalue of whether the function is virtual or not.
5395    FLAGS are to be passed through to `grokclassfn'.
5396    QUALS are qualifiers indicating whether the function is `const'
5397    or `volatile'.
5398    RAISES is a list of exceptions that this function can raise.
5399    CHECK is 1 if we must find this method in CTYPE, 0 if we should
5400    not look, and -1 if we should not call `grokclassfn' at all.
5401
5402    Returns `NULL_TREE' if something goes wrong, after issuing
5403    applicable error messages.  */
5404
5405 static tree
5406 grokfndecl (tree ctype,
5407             tree type,
5408             tree declarator,
5409             tree parms,
5410             tree orig_declarator,
5411             int virtualp,
5412             enum overload_flags flags,
5413             cp_cv_quals quals,
5414             tree raises,
5415             int check,
5416             int friendp,
5417             int publicp,
5418             int inlinep,
5419             int funcdef_flag,
5420             int template_count,
5421             tree in_namespace)
5422 {
5423   tree decl;
5424   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5425   int has_default_arg = 0;
5426   tree t;
5427
5428   if (raises)
5429     type = build_exception_variant (type, raises);
5430
5431   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5432   DECL_ARGUMENTS (decl) = parms;
5433   /* Propagate volatile out from type to decl.  */
5434   if (TYPE_VOLATILE (type))
5435     TREE_THIS_VOLATILE (decl) = 1;
5436
5437   /* If this decl has namespace scope, set that up.  */
5438   if (in_namespace)
5439     set_decl_namespace (decl, in_namespace, friendp);
5440   else if (!ctype)
5441     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5442
5443   /* `main' and builtins have implicit 'C' linkage.  */
5444   if ((MAIN_NAME_P (declarator)
5445        || (IDENTIFIER_LENGTH (declarator) > 10
5446            && IDENTIFIER_POINTER (declarator)[0] == '_'
5447            && IDENTIFIER_POINTER (declarator)[1] == '_'
5448            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5449       && current_lang_name == lang_name_cplusplus
5450       && ctype == NULL_TREE
5451       /* NULL_TREE means global namespace.  */
5452       && DECL_CONTEXT (decl) == NULL_TREE)
5453     SET_DECL_LANGUAGE (decl, lang_c);
5454
5455   /* Should probably propagate const out from type to decl I bet (mrs).  */
5456   if (staticp)
5457     {
5458       DECL_STATIC_FUNCTION_P (decl) = 1;
5459       DECL_CONTEXT (decl) = ctype;
5460     }
5461
5462   if (ctype)
5463     DECL_CONTEXT (decl) = ctype;
5464
5465   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5466     {
5467       if (processing_template_decl)
5468         error ("cannot declare `::main' to be a template");
5469       if (inlinep)
5470         error ("cannot declare `::main' to be inline");
5471       if (!publicp)
5472         error ("cannot declare `::main' to be static");
5473       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5474                         integer_type_node))
5475         error ("`main' must return `int'");
5476       inlinep = 0;
5477       publicp = 1;
5478     }
5479
5480   /* Members of anonymous types and local classes have no linkage; make
5481      them internal.  If a typedef is made later, this will be changed.  */
5482   if (ctype && (TYPE_ANONYMOUS_P (ctype)
5483                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5484     publicp = 0;
5485
5486   if (publicp)
5487     {
5488       /* [basic.link]: A name with no linkage (notably, the name of a class
5489          or enumeration declared in a local scope) shall not be used to
5490          declare an entity with linkage.
5491
5492          Only check this for public decls for now.  See core 319, 389.  */
5493       t = no_linkage_check (TREE_TYPE (decl));
5494       if (t)
5495         {
5496           if (TYPE_ANONYMOUS_P (t))
5497             {
5498               if (DECL_EXTERN_C_P (decl))
5499                 /* Allow this; it's pretty common in C.  */;
5500               else
5501                 {
5502                   pedwarn ("non-local function `%#D' uses anonymous type",
5503                               decl);
5504                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5505                     cp_pedwarn_at ("\
5506 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5507                                 TYPE_NAME (t));
5508                 }
5509             }
5510           else
5511             pedwarn ("non-local function `%#D' uses local type `%T'",
5512                         decl, t);
5513         }
5514     }
5515
5516   TREE_PUBLIC (decl) = publicp;
5517   if (! publicp)
5518     {
5519       DECL_INTERFACE_KNOWN (decl) = 1;
5520       DECL_NOT_REALLY_EXTERN (decl) = 1;
5521     }
5522
5523   /* If the declaration was declared inline, mark it as such.  */
5524   if (inlinep)
5525     DECL_DECLARED_INLINE_P (decl) = 1;
5526   /* We inline functions that are explicitly declared inline, or, when
5527      the user explicitly asks us to, all functions.  */
5528   if (DECL_DECLARED_INLINE_P (decl)
5529       || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5530     DECL_INLINE (decl) = 1;
5531
5532   DECL_EXTERNAL (decl) = 1;
5533   if (quals && TREE_CODE (type) == FUNCTION_TYPE)
5534     {
5535       error ("%smember function `%D' cannot have cv-qualifier",
5536              (ctype ? "static " : "non-"), decl);
5537       quals = TYPE_UNQUALIFIED;
5538     }
5539
5540   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5541     grok_op_properties (decl, friendp, /*complain=*/true);
5542
5543   if (ctype && decl_function_context (decl))
5544     DECL_NO_STATIC_CHAIN (decl) = 1;
5545
5546   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5547     if (TREE_PURPOSE (t)
5548         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5549       {
5550         has_default_arg = 1;
5551         break;
5552       }
5553
5554   if (friendp
5555       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5556     {
5557       if (funcdef_flag)
5558         error
5559           ("defining explicit specialization `%D' in friend declaration",
5560            orig_declarator);
5561       else
5562         {
5563           tree fns = TREE_OPERAND (orig_declarator, 0);
5564           tree args = TREE_OPERAND (orig_declarator, 1);
5565
5566           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5567             {
5568               /* Something like `template <class T> friend void f<T>()'.  */
5569               error ("invalid use of template-id `%D' in declaration of primary template",
5570                         orig_declarator);
5571               return NULL_TREE;
5572             }
5573
5574
5575           /* A friend declaration of the form friend void f<>().  Record
5576              the information in the TEMPLATE_ID_EXPR.  */
5577           SET_DECL_IMPLICIT_INSTANTIATION (decl);
5578
5579           if (TREE_CODE (fns) == COMPONENT_REF)
5580             {
5581               /* Due to bison parser ickiness, we will have already looked
5582                  up an operator_name or PFUNCNAME within the current class
5583                  (see template_id in parse.y). If the current class contains
5584                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
5585
5586               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5587                                   == current_class_type, 20001120);
5588               fns = TREE_OPERAND (fns, 1);
5589             }
5590           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5591                               || TREE_CODE (fns) == OVERLOAD, 20001120);
5592           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5593
5594           if (has_default_arg)
5595             {
5596               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
5597                         decl);
5598               return NULL_TREE;
5599             }
5600
5601           if (inlinep)
5602             {
5603               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
5604                         decl);
5605               return NULL_TREE;
5606             }
5607         }
5608     }
5609
5610   if (funcdef_flag)
5611     /* Make the init_value nonzero so pushdecl knows this is not
5612        tentative.  error_mark_node is replaced later with the BLOCK.  */
5613     DECL_INITIAL (decl) = error_mark_node;
5614
5615   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5616     TREE_NOTHROW (decl) = 1;
5617
5618   /* Caller will do the rest of this.  */
5619   if (check < 0)
5620     return decl;
5621
5622   if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
5623     DECL_CONSTRUCTOR_P (decl) = 1;
5624
5625   /* Function gets the ugly name, field gets the nice one.  This call
5626      may change the type of the function (because of default
5627      parameters)!  */
5628   if (ctype != NULL_TREE)
5629     grokclassfn (ctype, decl, flags, quals);
5630
5631   decl = check_explicit_specialization (orig_declarator, decl,
5632                                         template_count,
5633                                         2 * (funcdef_flag != 0) +
5634                                         4 * (friendp != 0));
5635   if (decl == error_mark_node)
5636     return NULL_TREE;
5637
5638   if (ctype != NULL_TREE
5639       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5640       && check)
5641     {
5642       tree old_decl;
5643
5644       old_decl = check_classfn (ctype, decl,
5645                                 (processing_template_decl
5646                                  > template_class_depth (ctype))
5647                                 ? current_template_parms
5648                                 : NULL_TREE);
5649
5650       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5651         /* Because grokfndecl is always supposed to return a
5652            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5653            here.  We depend on our callers to figure out that its
5654            really a template that's being returned.  */
5655         old_decl = DECL_TEMPLATE_RESULT (old_decl);
5656
5657       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5658           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5659         /* Remove the `this' parm added by grokclassfn.
5660            XXX Isn't this done in start_function, too?  */
5661         revert_static_member_fn (decl);
5662       if (old_decl && DECL_ARTIFICIAL (old_decl))
5663         error ("definition of implicitly-declared `%D'", old_decl);
5664
5665       if (old_decl)
5666         {
5667           tree ok;
5668           bool pop_p;
5669
5670           /* Since we've smashed OLD_DECL to its
5671              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
5672           if (TREE_CODE (decl) == TEMPLATE_DECL)
5673             decl = DECL_TEMPLATE_RESULT (decl);
5674
5675           /* Attempt to merge the declarations.  This can fail, in
5676              the case of some invalid specialization declarations.  */
5677           pop_p = push_scope (ctype);
5678           ok = duplicate_decls (decl, old_decl);
5679           if (pop_p)
5680             pop_scope (ctype);
5681           if (!ok)
5682             {
5683               error ("no `%#D' member function declared in class `%T'",
5684                      decl, ctype);
5685               return NULL_TREE;
5686             }
5687           return old_decl;
5688         }
5689     }
5690
5691   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
5692     return NULL_TREE;
5693
5694   if (ctype == NULL_TREE || check)
5695     return decl;
5696
5697   if (virtualp)
5698     DECL_VIRTUAL_P (decl) = 1;
5699
5700   return decl;
5701 }
5702
5703 /* Create a VAR_DECL named NAME with the indicated TYPE.
5704
5705    If SCOPE is non-NULL, it is the class type or namespace containing
5706    the variable.  If SCOPE is NULL, the variable should is created in
5707    the innermost enclosings scope.  */
5708
5709 static tree
5710 grokvardecl (tree type,
5711              tree name,
5712              const cp_decl_specifier_seq *declspecs,
5713              int initialized,
5714              int constp,
5715              tree scope)
5716 {
5717   tree decl;
5718
5719   my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
5720                       20020808);
5721
5722   /* Compute the scope in which to place the variable.  */
5723   if (!scope)
5724     {
5725       /* An explicit "extern" specifier indicates a namespace-scope
5726          variable.  */
5727       if (declspecs->storage_class == sc_extern)
5728         scope = current_namespace;
5729       else if (!at_function_scope_p ())
5730         {
5731           scope = current_scope ();
5732           if (!scope)
5733             scope = current_namespace;
5734         }
5735     }
5736
5737   if (scope
5738       && (/* If the variable is a namespace-scope variable declared in a
5739              template, we need DECL_LANG_SPECIFIC.  */
5740           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
5741           /* Similarly for namespace-scope variables with language linkage
5742              other than C++.  */
5743           || (TREE_CODE (scope) == NAMESPACE_DECL
5744               && current_lang_name != lang_name_cplusplus)
5745           /* Similarly for static data members.  */
5746           || TYPE_P (scope)))
5747     decl = build_lang_decl (VAR_DECL, name, type);
5748   else
5749     decl = build_decl (VAR_DECL, name, type);
5750
5751   if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
5752     set_decl_namespace (decl, scope, 0);
5753   else
5754     DECL_CONTEXT (decl) = scope;
5755
5756   if (declspecs->storage_class == sc_extern)
5757     {
5758       DECL_THIS_EXTERN (decl) = 1;
5759       DECL_EXTERNAL (decl) = !initialized;
5760     }
5761
5762   /* In class context, static means one per class,
5763      public access, and static storage.  */
5764   if (DECL_CLASS_SCOPE_P (decl))
5765     {
5766       TREE_PUBLIC (decl) = 1;
5767       TREE_STATIC (decl) = 1;
5768       DECL_EXTERNAL (decl) = 0;
5769     }
5770   /* At top level, either `static' or no s.c. makes a definition
5771      (perhaps tentative), and absence of `static' makes it public.  */
5772   else if (toplevel_bindings_p ())
5773     {
5774       TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
5775                             && (DECL_THIS_EXTERN (decl) || ! constp));
5776       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5777     }
5778   /* Not at top level, only `static' makes a static definition.  */
5779   else
5780     {
5781       TREE_STATIC (decl) = declspecs->storage_class == sc_static;
5782       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5783     }
5784
5785   if (declspecs->specs[(int)ds_thread])
5786     {
5787       if (targetm.have_tls)
5788         DECL_THREAD_LOCAL (decl) = 1;
5789       else
5790         /* A mere warning is sure to result in improper semantics
5791            at runtime.  Don't bother to allow this to compile.  */
5792         error ("thread-local storage not supported for this target");
5793     }
5794
5795   if (TREE_PUBLIC (decl))
5796     {
5797       /* [basic.link]: A name with no linkage (notably, the name of a class
5798          or enumeration declared in a local scope) shall not be used to
5799          declare an entity with linkage.
5800
5801          Only check this for public decls for now.  */
5802       tree t = no_linkage_check (TREE_TYPE (decl));
5803       if (t)
5804         {
5805           if (TYPE_ANONYMOUS_P (t))
5806             {
5807               if (DECL_EXTERN_C_P (decl))
5808                 /* Allow this; it's pretty common in C.  */;
5809               else
5810                 {
5811                   pedwarn ("non-local variable `%#D' uses anonymous type",
5812                            decl);
5813                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5814                     cp_pedwarn_at ("\
5815 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5816                                    TYPE_NAME (t));
5817                 }
5818             }
5819           else
5820             pedwarn ("non-local variable `%#D' uses local type `%T'",
5821                         decl, t);
5822         }
5823     }
5824
5825   return decl;
5826 }
5827
5828 /* Create and return a canonical pointer to member function type, for
5829    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
5830
5831 tree
5832 build_ptrmemfunc_type (tree type)
5833 {
5834   tree field, fields;
5835   tree t;
5836   tree unqualified_variant = NULL_TREE;
5837
5838   if (type == error_mark_node)
5839     return type;
5840
5841   /* If a canonical type already exists for this type, use it.  We use
5842      this method instead of type_hash_canon, because it only does a
5843      simple equality check on the list of field members.  */
5844
5845   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
5846     return t;
5847
5848   /* Make sure that we always have the unqualified pointer-to-member
5849      type first.  */
5850   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5851     unqualified_variant
5852       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
5853
5854   t = make_aggr_type (RECORD_TYPE);
5855   xref_basetypes (t, NULL_TREE);
5856
5857   /* Let the front-end know this is a pointer to member function...  */
5858   TYPE_PTRMEMFUNC_FLAG (t) = 1;
5859   /* ... and not really an aggregate.  */
5860   SET_IS_AGGR_TYPE (t, 0);
5861
5862   field = build_decl (FIELD_DECL, pfn_identifier, type);
5863   fields = field;
5864
5865   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
5866   TREE_CHAIN (field) = fields;
5867   fields = field;
5868
5869   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
5870
5871   /* Zap out the name so that the back-end will give us the debugging
5872      information for this anonymous RECORD_TYPE.  */
5873   TYPE_NAME (t) = NULL_TREE;
5874
5875   /* If this is not the unqualified form of this pointer-to-member
5876      type, set the TYPE_MAIN_VARIANT for this type to be the
5877      unqualified type.  Since they are actually RECORD_TYPEs that are
5878      not variants of each other, we must do this manually.  */
5879   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5880     {
5881       t = build_qualified_type (t, cp_type_quals (type));
5882       TYPE_MAIN_VARIANT (t) = unqualified_variant;
5883       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
5884       TYPE_NEXT_VARIANT (unqualified_variant) = t;
5885     }
5886
5887   /* Cache this pointer-to-member type so that we can find it again
5888      later.  */
5889   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
5890
5891   return t;
5892 }
5893
5894 /* Create and return a pointer to data member type.  */
5895
5896 tree
5897 build_ptrmem_type (tree class_type, tree member_type)
5898 {
5899   if (TREE_CODE (member_type) == METHOD_TYPE)
5900     {
5901       tree arg_types;
5902
5903       arg_types = TYPE_ARG_TYPES (member_type);
5904       class_type = (cp_build_qualified_type
5905                     (class_type,
5906                      cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
5907       member_type
5908         = build_method_type_directly (class_type,
5909                                       TREE_TYPE (member_type),
5910                                       TREE_CHAIN (arg_types));
5911       return build_ptrmemfunc_type (build_pointer_type (member_type));
5912     }
5913   else
5914     {
5915       my_friendly_assert (TREE_CODE (member_type) != FUNCTION_TYPE,
5916                           20030716);
5917       return build_offset_type (class_type, member_type);
5918     }
5919 }
5920
5921 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5922    Check to see that the definition is valid.  Issue appropriate error
5923    messages.  Return 1 if the definition is particularly bad, or 0
5924    otherwise.  */
5925
5926 int
5927 check_static_variable_definition (tree decl, tree type)
5928 {
5929   /* Motion 10 at San Diego: If a static const integral data member is
5930      initialized with an integral constant expression, the initializer
5931      may appear either in the declaration (within the class), or in
5932      the definition, but not both.  If it appears in the class, the
5933      member is a member constant.  The file-scope definition is always
5934      required.  */
5935   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
5936     {
5937       error ("invalid in-class initialization of static data member of non-integral type `%T'",
5938              type);
5939       /* If we just return the declaration, crashes will sometimes
5940          occur.  We therefore return void_type_node, as if this were a
5941          friend declaration, to cause callers to completely ignore
5942          this declaration.  */
5943       return 1;
5944     }
5945   else if (!CP_TYPE_CONST_P (type))
5946     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
5947               decl);
5948   else if (pedantic && !INTEGRAL_TYPE_P (type))
5949     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
5950
5951   return 0;
5952 }
5953
5954 /* Given the SIZE (i.e., number of elements) in an array, compute an
5955    appropriate index type for the array.  If non-NULL, NAME is the
5956    name of the thing being declared.  */
5957
5958 tree
5959 compute_array_index_type (tree name, tree size)
5960 {
5961   tree type = TREE_TYPE (size);
5962   tree itype;
5963
5964   /* The array bound must be an integer type.  */
5965   if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
5966     {
5967       if (name)
5968         error ("size of array `%D' has non-integral type `%T'", name, type);
5969       else
5970         error ("size of array has non-integral type `%T'", type);
5971       size = integer_one_node;
5972       type = TREE_TYPE (size);
5973     }
5974
5975   if (abi_version_at_least (2)
5976       /* We should only handle value dependent expressions specially.  */
5977       ? value_dependent_expression_p (size)
5978       /* But for abi-1, we handled all instances in templates. This
5979          effects the manglings produced.  */
5980       : processing_template_decl)
5981     return build_index_type (build_min (MINUS_EXPR, sizetype,
5982                                         size, integer_one_node));
5983
5984   /* The size might be the result of a cast.  */
5985   STRIP_TYPE_NOPS (size);
5986
5987   /* It might be a const variable or enumeration constant.  */
5988   size = decl_constant_value (size);
5989
5990   /* Normally, the array-bound will be a constant.  */
5991   if (TREE_CODE (size) == INTEGER_CST)
5992     {
5993       /* Check to see if the array bound overflowed.  Make that an
5994          error, no matter how generous we're being.  */
5995       int old_flag_pedantic_errors = flag_pedantic_errors;
5996       int old_pedantic = pedantic;
5997       pedantic = flag_pedantic_errors = 1;
5998       constant_expression_warning (size);
5999       pedantic = old_pedantic;
6000       flag_pedantic_errors = old_flag_pedantic_errors;
6001
6002       /* An array must have a positive number of elements.  */
6003       if (INT_CST_LT (size, integer_zero_node))
6004         {
6005           if (name)
6006             error ("size of array `%D' is negative", name);
6007           else
6008             error ("size of array is negative");
6009           size = integer_one_node;
6010         }
6011       /* As an extension we allow zero-sized arrays.  We always allow
6012          them in system headers because glibc uses them.  */
6013       else if (integer_zerop (size) && pedantic && !in_system_header)
6014         {
6015           if (name)
6016             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
6017           else
6018             pedwarn ("ISO C++ forbids zero-size array");
6019         }
6020     }
6021   else if (TREE_CONSTANT (size))
6022     {
6023       /* `(int) &fn' is not a valid array bound.  */
6024       if (name)
6025         error ("size of array `%D' is not an integral constant-expression",
6026                   name);
6027       else
6028         error ("size of array is not an integral constant-expression");
6029     }
6030   else if (pedantic)
6031     {
6032       if (name)
6033         pedwarn ("ISO C++ forbids variable-size array `%D'", name);
6034       else
6035         pedwarn ("ISO C++ forbids variable-size array");
6036     }
6037
6038   if (processing_template_decl && !TREE_CONSTANT (size))
6039     /* A variable sized array.  */
6040     itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6041   else
6042     {
6043       /* Compute the index of the largest element in the array.  It is
6044          one less than the number of elements in the array.  */
6045       itype
6046         = fold (cp_build_binary_op (MINUS_EXPR,
6047                                     cp_convert (ssizetype, size),
6048                                     cp_convert (ssizetype, integer_one_node)));
6049       if (!TREE_CONSTANT (itype))
6050         /* A variable sized array.  */
6051         itype = variable_size (itype);
6052       /* Make sure that there was no overflow when creating to a signed
6053          index type.  (For example, on a 32-bit machine, an array with
6054          size 2^32 - 1 is too big.)  */
6055       else if (TREE_OVERFLOW (itype))
6056         {
6057           error ("overflow in array dimension");
6058           TREE_OVERFLOW (itype) = 0;
6059         }
6060     }
6061
6062   /* Create and return the appropriate index type.  */
6063   return build_index_type (itype);
6064 }
6065
6066 /* Returns the scope (if any) in which the entity declared by
6067    DECLARATOR will be located.  If the entity was declared with an
6068    unqualified name, NULL_TREE is returned.  */
6069
6070 tree
6071 get_scope_of_declarator (const cp_declarator *declarator)
6072 {
6073   while (declarator && declarator->kind != cdk_id)
6074     declarator = declarator->declarator;
6075
6076   /* If the declarator-id is a SCOPE_REF, the scope in which the
6077      declaration occurs is the first operand.  */
6078   if (declarator
6079       && declarator->u.id.name
6080       && TREE_CODE (declarator->u.id.name) == SCOPE_REF)
6081     return TREE_OPERAND (declarator->u.id.name, 0);
6082
6083   /* Otherwise, the declarator is not a quablified name; the entity will
6084      be declared in the current scope.  */
6085   return NULL_TREE;
6086 }
6087
6088 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6089    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
6090    with this type.  */
6091
6092 static tree
6093 create_array_type_for_decl (tree name, tree type, tree size)
6094 {
6095   tree itype = NULL_TREE;
6096   const char* error_msg;
6097
6098   /* If things have already gone awry, bail now.  */
6099   if (type == error_mark_node || size == error_mark_node)
6100     return error_mark_node;
6101
6102   /* Assume that everything will go OK.  */
6103   error_msg = NULL;
6104
6105   /* There are some types which cannot be array elements.  */
6106   switch (TREE_CODE (type))
6107     {
6108     case VOID_TYPE:
6109       error_msg = "array of void";
6110       break;
6111
6112     case FUNCTION_TYPE:
6113       error_msg = "array of functions";
6114       break;
6115
6116     case REFERENCE_TYPE:
6117       error_msg = "array of references";
6118       break;
6119
6120     case METHOD_TYPE:
6121       error_msg = "array of function members";
6122       break;
6123
6124     default:
6125       break;
6126     }
6127
6128   /* If something went wrong, issue an error-message and return.  */
6129   if (error_msg)
6130     {
6131       if (name)
6132         error ("declaration of `%D' as %s", name, error_msg);
6133       else
6134         error ("creating %s", error_msg);
6135
6136       return error_mark_node;
6137     }
6138
6139   /* [dcl.array]
6140
6141      The constant expressions that specify the bounds of the arrays
6142      can be omitted only for the first member of the sequence.  */
6143   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6144     {
6145       if (name)
6146         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
6147                   name);
6148       else
6149         error ("multidimensional array must have bounds for all dimensions except the first");
6150
6151       return error_mark_node;
6152     }
6153
6154   /* Figure out the index type for the array.  */
6155   if (size)
6156     itype = compute_array_index_type (name, size);
6157
6158   /* [dcl.array]
6159      T is called the array element type; this type shall not be [...] an
6160      abstract class type.  */
6161   abstract_virtuals_error (name, type);
6162
6163   return build_cplus_array_type (type, itype);
6164 }
6165
6166 /* Check that it's OK to declare a function with the indicated TYPE.
6167    SFK indicates the kind of special function (if any) that this
6168    function is.  OPTYPE is the type given in a conversion operator
6169    declaration.  Returns the actual return type of the function; that
6170    may be different than TYPE if an error occurs, or for certain
6171    special functions.  */
6172
6173 static tree
6174 check_special_function_return_type (special_function_kind sfk,
6175                                     tree type,
6176                                     tree optype)
6177 {
6178   switch (sfk)
6179     {
6180     case sfk_constructor:
6181       if (type)
6182         error ("return type specification for constructor invalid");
6183
6184       type = void_type_node;
6185       break;
6186
6187     case sfk_destructor:
6188       if (type)
6189         error ("return type specification for destructor invalid");
6190       type = void_type_node;
6191       break;
6192
6193     case sfk_conversion:
6194       if (type && !same_type_p (type, optype))
6195         error ("operator `%T' declared to return `%T'", optype, type);
6196       else if (type)
6197         pedwarn ("return type specified for `operator %T'",  optype);
6198       type = optype;
6199       break;
6200
6201     default:
6202       abort ();
6203       break;
6204     }
6205
6206   return type;
6207 }
6208
6209 /* Given declspecs and a declarator (abstract or otherwise), determine
6210    the name and type of the object declared and construct a DECL node
6211    for it.
6212
6213    DECLSPECS is a chain of tree_list nodes whose value fields
6214     are the storage classes and type specifiers.
6215
6216    DECL_CONTEXT says which syntactic context this declaration is in:
6217      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6218      FUNCDEF for a function definition.  Like NORMAL but a few different
6219       error messages in each case.  Return value may be zero meaning
6220       this definition is too screwy to try to parse.
6221      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
6222       handle member functions (which have FIELD context).
6223       Return value may be zero meaning this definition is too screwy to
6224       try to parse.
6225      PARM for a parameter declaration (either within a function prototype
6226       or before a function body).  Make a PARM_DECL, or return void_type_node.
6227      CATCHPARM for a parameter declaration before a catch clause.
6228      TYPENAME if for a typename (in a cast or sizeof).
6229       Don't make a DECL node; just return the ..._TYPE node.
6230      FIELD for a struct or union field; make a FIELD_DECL.
6231      BITFIELD for a field with specified width.
6232    INITIALIZED is 1 if the decl has an initializer.
6233
6234    ATTRLIST is a pointer to the list of attributes, which may be NULL
6235    if there are none; *ATTRLIST may be modified if attributes from inside
6236    the declarator should be applied to the declaration.
6237
6238    When this function is called, scoping variables (such as
6239    CURRENT_CLASS_TYPE) should reflect the scope in which the
6240    declaration occurs, not the scope in which the new declaration will
6241    be placed.  For example, on:
6242
6243      void S::f() { ... }
6244
6245    when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6246    should not be `S'.  */
6247
6248 tree
6249 grokdeclarator (const cp_declarator *declarator,
6250                 const cp_decl_specifier_seq *declspecs,
6251                 enum decl_context decl_context,
6252                 int initialized,
6253                 tree* attrlist)
6254 {
6255   tree type = NULL_TREE;
6256   int longlong = 0;
6257   int type_quals;
6258   int virtualp, explicitp, friendp, inlinep, staticp;
6259   int explicit_int = 0;
6260   int explicit_char = 0;
6261   int defaulted_int = 0;
6262   tree dependant_name = NULL_TREE;
6263
6264   tree typedef_decl = NULL_TREE;
6265   const char *name = NULL;
6266   tree typedef_type = NULL_TREE;
6267   int funcdef_flag = 0;
6268   cp_declarator_kind innermost_code = cdk_error;
6269   int bitfield = 0;
6270 #if 0
6271   /* See the code below that used this.  */
6272   tree decl_attr = NULL_TREE;
6273 #endif
6274
6275   /* Keep track of what sort of function is being processed
6276      so that we can warn about default return values, or explicit
6277      return values which do not match prescribed defaults.  */
6278   special_function_kind sfk = sfk_none;
6279
6280   tree dname = NULL_TREE;
6281   tree ctor_return_type = NULL_TREE;
6282   enum overload_flags flags = NO_SPECIAL;
6283   cp_cv_quals quals = TYPE_UNQUALIFIED;
6284   tree raises = NULL_TREE;
6285   int template_count = 0;
6286   tree returned_attrs = NULL_TREE;
6287   tree parms = NULL_TREE;
6288   const cp_declarator *id_declarator;
6289   /* The unqualified name of the declarator; either an
6290      IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR.  */
6291   tree unqualified_id;
6292   /* The class type, if any, in which this entity is located,
6293      or NULL_TREE if none.  Note that this value may be different from
6294      the current class type; for example if an attempt is made to declare
6295      "A::f" inside "B", this value will be "A".  */
6296   tree ctype = current_class_type;
6297   /* The NAMESPACE_DECL for the namespace in which this entity is
6298      located.  If an unqualified name is used to declare the entity,
6299      this value will be NULL_TREE, even if the entity is located at
6300      namespace scope.  */
6301   tree in_namespace = NULL_TREE;
6302   cp_decl_spec ds;
6303   cp_storage_class storage_class;
6304   bool unsigned_p, signed_p, short_p, long_p, thread_p;
6305
6306   signed_p = declspecs->specs[(int)ds_signed];
6307   unsigned_p = declspecs->specs[(int)ds_unsigned];
6308   short_p = declspecs->specs[(int)ds_short];
6309   long_p = declspecs->specs[(int)ds_long];
6310   thread_p = declspecs->specs[(int)ds_thread];
6311
6312   if (decl_context == FUNCDEF)
6313     funcdef_flag = 1, decl_context = NORMAL;
6314   else if (decl_context == MEMFUNCDEF)
6315     funcdef_flag = -1, decl_context = FIELD;
6316   else if (decl_context == BITFIELD)
6317     bitfield = 1, decl_context = FIELD;
6318
6319   /* Look inside a declarator for the name being declared
6320      and get it as a string, for an error message.  */
6321   for (id_declarator = declarator;
6322        id_declarator;
6323        id_declarator = id_declarator->declarator)
6324     {
6325       if (id_declarator->kind != cdk_id)
6326         innermost_code = id_declarator->kind;
6327
6328       switch (id_declarator->kind)
6329         {
6330         case cdk_function:
6331           if (id_declarator->declarator
6332               && id_declarator->declarator->kind == cdk_id)
6333             {
6334               sfk = id_declarator->declarator->u.id.sfk;
6335               if (sfk == sfk_destructor)
6336                 flags = DTOR_FLAG;
6337             }
6338           break;
6339
6340         case cdk_id:
6341           {
6342             tree decl = id_declarator->u.id.name;
6343             if (!decl)
6344               break;
6345             if (TREE_CODE (decl) == SCOPE_REF)
6346               {
6347                 tree qualifying_scope = TREE_OPERAND (decl, 0);
6348 ;
6349                 /* It is valid to write:
6350
6351                    class C { void f(); };
6352                    typedef C D;
6353                    void D::f();
6354
6355                  The standard is not clear about whether `typedef const C D' is
6356                  legal; as of 2002-09-15 the committee is considering
6357                  that question.  EDG 3.0 allows that syntax.
6358                  Therefore, we do as well.  */
6359                 if (qualifying_scope && TYPE_P (qualifying_scope))
6360                   {
6361                     ctype = TYPE_MAIN_VARIANT (qualifying_scope);
6362                     if (innermost_code != cdk_function
6363                         && current_class_type
6364                         && !UNIQUELY_DERIVED_FROM_P (ctype,
6365                                                      current_class_type))
6366                       {
6367                         error ("type `%T' is not derived from type `%T'",
6368                                ctype, current_class_type);
6369                         ctype = NULL_TREE;
6370                       }
6371                     TREE_OPERAND (decl, 0) = ctype;
6372                   }
6373                 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6374                   in_namespace = qualifying_scope;
6375                 decl = TREE_OPERAND (decl, 1);
6376               }
6377             if (TREE_CODE (decl) == BASELINK)
6378               decl = BASELINK_FUNCTIONS (decl);
6379             if (decl == error_mark_node)
6380               return error_mark_node;
6381             switch (TREE_CODE (decl))
6382               {
6383               case BIT_NOT_EXPR:
6384                 {
6385                   tree type = TREE_OPERAND (decl, 0);
6386                   type = constructor_name (type);
6387                   name = IDENTIFIER_POINTER (type);
6388                 }
6389                 break;
6390
6391               case TEMPLATE_ID_EXPR:
6392                 {
6393                   tree fns = TREE_OPERAND (decl, 0);
6394
6395                   dname = fns;
6396                   if (TREE_CODE (dname) == COMPONENT_REF)
6397                     dname = TREE_OPERAND (dname, 1);
6398                   if (TREE_CODE (dname) != IDENTIFIER_NODE)
6399                     {
6400                       my_friendly_assert (is_overloaded_fn (dname),
6401                                           19990331);
6402                       dname = DECL_NAME (get_first_fn (dname));
6403                     }
6404                 }
6405                 /* Fall through.  */
6406
6407               case IDENTIFIER_NODE:
6408                 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6409                   dname = decl;
6410
6411                 if (C_IS_RESERVED_WORD (dname))
6412                   {
6413                     error ("declarator-id missing; using reserved word `%D'",
6414                            dname);
6415                     name = IDENTIFIER_POINTER (dname);
6416                   }
6417                 else if (!IDENTIFIER_TYPENAME_P (dname))
6418                   name = IDENTIFIER_POINTER (dname);
6419                 else
6420                   {
6421                     my_friendly_assert (flags == NO_SPECIAL, 154);
6422                     flags = TYPENAME_FLAG;
6423                     ctor_return_type = TREE_TYPE (dname);
6424                     sfk = sfk_conversion;
6425                     if (is_typename_at_global_scope (dname))
6426                       name = IDENTIFIER_POINTER (dname);
6427                     else
6428                       name = "<invalid operator>";
6429                   }
6430                 break;
6431
6432               case TYPE_DECL:
6433                 dname = constructor_name (TREE_TYPE (decl));
6434                 name = IDENTIFIER_POINTER (dname);
6435                 break;
6436
6437               default:
6438                 abort ();
6439               }
6440             break;
6441
6442           case cdk_array:
6443           case cdk_pointer:
6444           case cdk_reference:
6445           case cdk_ptrmem:
6446             break;
6447
6448           case cdk_error:
6449             break;
6450
6451           default:
6452             abort ();
6453           }
6454         }
6455       if (id_declarator->kind == cdk_id)
6456         break;
6457     }
6458
6459   /* A function definition's declarator must have the form of
6460      a function declarator.  */
6461
6462   if (funcdef_flag && innermost_code != cdk_function)
6463     return 0;
6464
6465   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6466       && innermost_code != cdk_function
6467       && ! (ctype && !declspecs->any_specifiers_p))
6468     {
6469       error ("declaration of `%D' as non-function", dname);
6470       return void_type_node;
6471     }
6472
6473   /* Anything declared one level down from the top level
6474      must be one of the parameters of a function
6475      (because the body is at least two levels down).  */
6476
6477   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6478      by not allowing C++ class definitions to specify their parameters
6479      with xdecls (must be spec.d in the parmlist).
6480
6481      Since we now wait to push a class scope until we are sure that
6482      we are in a legitimate method context, we must set oldcname
6483      explicitly (since current_class_name is not yet alive).
6484
6485      We also want to avoid calling this a PARM if it is in a namespace.  */
6486
6487   if (decl_context == NORMAL && !toplevel_bindings_p ())
6488     {
6489       struct cp_binding_level *b = current_binding_level;
6490       current_binding_level = b->level_chain;
6491       if (current_binding_level != 0 && toplevel_bindings_p ())
6492         decl_context = PARM;
6493       current_binding_level = b;
6494     }
6495
6496   if (name == NULL)
6497     name = decl_context == PARM ? "parameter" : "type name";
6498
6499   /* If there were multiple types specified in the decl-specifier-seq,
6500      issue an error message.  */
6501   if (declspecs->multiple_types_p)
6502     error ("two or more data types in declaration of `%s'", name);
6503   /* Extract the basic type from the decl-specifier-seq.  */
6504   type = declspecs->type;
6505   if (type == error_mark_node)
6506     type = NULL_TREE;
6507   /* If the entire declaration is itself tagged as deprecated then
6508      suppress reports of deprecated items.  */
6509   if (type && TREE_DEPRECATED (type)
6510       && deprecated_state != DEPRECATED_SUPPRESS)
6511     warn_deprecated_use (type);
6512   if (type && TREE_CODE (type) == TYPE_DECL)
6513     {
6514       typedef_decl = type;
6515       type = TREE_TYPE (typedef_decl);
6516     }
6517   /* No type at all: default to `int', and set DEFAULTED_INT
6518      because it was not a user-defined typedef.  */
6519   if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
6520     {
6521       /* These imply 'int'.  */
6522       type = integer_type_node;
6523       defaulted_int = 1;
6524     }
6525   /* Gather flags.  */
6526   explicit_int = declspecs->explicit_int_p;
6527   explicit_char = declspecs->explicit_char_p;
6528
6529   /* Check for repeated decl-specifiers.  */
6530   for (ds = ds_first; ds != ds_last; ++ds)
6531     {
6532       unsigned count = declspecs->specs[(int)ds];
6533       if (count < 2)
6534         continue;
6535       /* The "long" specifier is a special case because of
6536          "long long".  */
6537       if (ds == ds_long)
6538         {
6539           if (count > 2)
6540             error ("`long long long' is too long for GCC");
6541           else if (pedantic && !in_system_header && warn_long_long)
6542             pedwarn ("ISO C++ does not support `long long'");
6543           else
6544             longlong = 1;
6545         }
6546       else if (declspecs->specs[(int)ds] > 1)
6547         {
6548           static const char *const decl_spec_names[] = {
6549             "signed",
6550             "unsigned",
6551             "short",
6552             "long",
6553             "const",
6554             "volatile",
6555             "restrict",
6556             "inline",
6557             "virtual",
6558             "explicit",
6559             "friend",
6560             "typedef",
6561             "__complex",
6562             "__thread"
6563           };
6564           error ("duplicate `%s'", decl_spec_names[(int)ds]);
6565         }
6566     }
6567
6568 #if 0
6569   /* See the code below that used this.  */
6570   if (typedef_decl)
6571     decl_attr = DECL_ATTRIBUTES (typedef_decl);
6572 #endif
6573   typedef_type = type;
6574
6575
6576   if (sfk != sfk_none)
6577     type = check_special_function_return_type (sfk, type,
6578                                                ctor_return_type);
6579   else if (type == NULL_TREE)
6580     {
6581       int is_main;
6582
6583       explicit_int = -1;
6584
6585       /* We handle `main' specially here, because 'main () { }' is so
6586          common.  With no options, it is allowed.  With -Wreturn-type,
6587          it is a warning.  It is only an error with -pedantic-errors.  */
6588       is_main = (funcdef_flag
6589                  && dname && MAIN_NAME_P (dname)
6590                  && ctype == NULL_TREE
6591                  && in_namespace == NULL_TREE
6592                  && current_namespace == global_namespace);
6593
6594       if (in_system_header || flag_ms_extensions)
6595         /* Allow it, sigh.  */;
6596       else if (pedantic || ! is_main)
6597         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
6598                     name);
6599       else if (warn_return_type)
6600         warning ("ISO C++ forbids declaration of `%s' with no type",
6601                     name);
6602
6603       type = integer_type_node;
6604     }
6605
6606   ctype = NULL_TREE;
6607
6608   /* Now process the modifiers that were specified
6609      and check for invalid combinations.  */
6610
6611   /* Long double is a special combination.  */
6612   if (long_p && TYPE_MAIN_VARIANT (type) == double_type_node)
6613     {
6614       long_p = false;
6615       type = build_qualified_type (long_double_type_node,
6616                                    cp_type_quals (type));
6617     }
6618
6619   /* Check all other uses of type modifiers.  */
6620
6621   if (unsigned_p || signed_p || long_p || short_p)
6622     {
6623       int ok = 0;
6624
6625       if (TREE_CODE (type) == REAL_TYPE)
6626         error ("short, signed or unsigned invalid for `%s'", name);
6627       else if (TREE_CODE (type) != INTEGER_TYPE)
6628         error ("long, short, signed or unsigned invalid for `%s'", name);
6629       else if (long_p && short_p)
6630         error ("long and short specified together for `%s'", name);
6631       else if ((long_p || short_p) && explicit_char)
6632         error ("long or short specified with char for `%s'", name);
6633       else if ((long_p|| short_p) && TREE_CODE (type) == REAL_TYPE)
6634         error ("long or short specified with floating type for `%s'", name);
6635       else if (signed_p && unsigned_p)
6636         error ("signed and unsigned given together for `%s'", name);
6637       else
6638         {
6639           ok = 1;
6640           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6641             {
6642               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
6643                        name);
6644               if (flag_pedantic_errors)
6645                 ok = 0;
6646             }
6647         }
6648
6649       /* Discard the type modifiers if they are invalid.  */
6650       if (! ok)
6651         {
6652           unsigned_p = false;
6653           signed_p = false;
6654           long_p = false;
6655           short_p = false;
6656           longlong = 0;
6657         }
6658     }
6659
6660   /* Decide whether an integer type is signed or not.
6661      Optionally treat bitfields as signed by default.  */
6662   if (unsigned_p
6663       /* [class.bit]
6664
6665          It is implementation-defined whether a plain (neither
6666          explicitly signed or unsigned) char, short, int, or long
6667          bit-field is signed or unsigned.
6668
6669          Naturally, we extend this to long long as well.  Note that
6670          this does not include wchar_t.  */
6671       || (bitfield && !flag_signed_bitfields
6672           && !signed_p
6673           /* A typedef for plain `int' without `signed' can be
6674              controlled just like plain `int', but a typedef for
6675              `signed int' cannot be so controlled.  */
6676           && !(typedef_decl
6677                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
6678           && (TREE_CODE (type) == INTEGER_TYPE
6679               || TREE_CODE (type) == CHAR_TYPE)
6680           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
6681     {
6682       if (longlong)
6683         type = long_long_unsigned_type_node;
6684       else if (long_p)
6685         type = long_unsigned_type_node;
6686       else if (short_p)
6687         type = short_unsigned_type_node;
6688       else if (type == char_type_node)
6689         type = unsigned_char_type_node;
6690       else if (typedef_decl)
6691         type = c_common_unsigned_type (type);
6692       else
6693         type = unsigned_type_node;
6694     }
6695   else if (signed_p && type == char_type_node)
6696     type = signed_char_type_node;
6697   else if (longlong)
6698     type = long_long_integer_type_node;
6699   else if (long_p)
6700     type = long_integer_type_node;
6701   else if (short_p)
6702     type = short_integer_type_node;
6703
6704   if (declspecs->specs[(int)ds_complex])
6705     {
6706       if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
6707         error ("complex invalid for `%s'", name);
6708       /* If we just have "complex", it is equivalent to
6709          "complex double", but if any modifiers at all are specified it is
6710          the complex form of TYPE.  E.g, "complex short" is
6711          "complex short int".  */
6712
6713       else if (defaulted_int && ! longlong
6714                && ! (long_p || short_p || signed_p || unsigned_p))
6715         type = complex_double_type_node;
6716       else if (type == integer_type_node)
6717         type = complex_integer_type_node;
6718       else if (type == float_type_node)
6719         type = complex_float_type_node;
6720       else if (type == double_type_node)
6721         type = complex_double_type_node;
6722       else if (type == long_double_type_node)
6723         type = complex_long_double_type_node;
6724       else
6725         type = build_complex_type (type);
6726     }
6727
6728   type_quals = TYPE_UNQUALIFIED;
6729   if (declspecs->specs[(int)ds_const])
6730     type_quals |= TYPE_QUAL_CONST;
6731   if (declspecs->specs[(int)ds_volatile])
6732     type_quals |= TYPE_QUAL_VOLATILE;
6733   if (declspecs->specs[(int)ds_restrict])
6734     type_quals |= TYPE_QUAL_RESTRICT;
6735   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
6736     error ("qualifiers are not allowed on declaration of `operator %T'",
6737               ctor_return_type);
6738
6739   type_quals |= cp_type_quals (type);
6740   type = cp_build_qualified_type_real
6741     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
6742                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
6743   /* We might have ignored or rejected some of the qualifiers.  */
6744   type_quals = cp_type_quals (type);
6745
6746   staticp = 0;
6747   inlinep = !! declspecs->specs[(int)ds_inline];
6748   virtualp = !! declspecs->specs[(int)ds_virtual];
6749   explicitp = !! declspecs->specs[(int)ds_explicit];
6750
6751   storage_class = declspecs->storage_class;
6752   if (storage_class == sc_static)
6753     staticp = 1 + (decl_context == FIELD);
6754
6755   if (virtualp && staticp == 2)
6756     {
6757       error ("member `%D' cannot be declared both virtual and static",
6758                 dname);
6759       staticp = 0;
6760     }
6761   friendp = !! declspecs->specs[(int)ds_friend];
6762
6763   if (dependant_name && !friendp)
6764     {
6765       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
6766       return void_type_node;
6767     }
6768
6769   /* Issue errors about use of storage classes for parameters.  */
6770   if (decl_context == PARM)
6771     {
6772       if (declspecs->specs[(int)ds_typedef])
6773         error ("typedef declaration invalid in parameter declaration");
6774       else if (storage_class == sc_static
6775                || storage_class == sc_extern
6776                || thread_p)
6777         error ("storage class specifiers invalid in parameter declarations");
6778     }
6779
6780   /* Give error if `virtual' is used outside of class declaration.  */
6781   if (virtualp
6782       && (current_class_name == NULL_TREE || decl_context != FIELD))
6783     {
6784       error ("virtual outside class declaration");
6785       virtualp = 0;
6786     }
6787
6788   /* Static anonymous unions are dealt with here.  */
6789   if (staticp && decl_context == TYPENAME
6790       && declspecs->type
6791       && ANON_AGGR_TYPE_P (declspecs->type))
6792     decl_context = FIELD;
6793
6794   /* Warn about storage classes that are invalid for certain
6795      kinds of declarations (parameters, typenames, etc.).  */
6796   if (declspecs->multiple_storage_classes_p)
6797     error ("multiple storage classes in declaration of `%s'", name);
6798   else if (thread_p
6799            && ((storage_class
6800                 && storage_class != sc_extern
6801                 && storage_class != sc_static)
6802                || declspecs->specs[(int)ds_typedef]))
6803     {
6804       error ("multiple storage classes in declaration of `%s'", name);
6805       thread_p = false;
6806     }
6807   else if (decl_context != NORMAL
6808            && ((storage_class != sc_none
6809                 && storage_class != sc_mutable)
6810                || thread_p))
6811     {
6812       if ((decl_context == PARM || decl_context == CATCHPARM)
6813           && (storage_class == sc_register
6814               || storage_class == sc_auto))
6815         ;
6816       else if (declspecs->specs[(int)ds_typedef])
6817         ;
6818       else if (decl_context == FIELD
6819                /* C++ allows static class elements.  */
6820                && storage_class == sc_static)
6821         /* C++ also allows inlines and signed and unsigned elements,
6822            but in those cases we don't come in here.  */
6823         ;
6824       else
6825         {
6826           if (decl_context == FIELD)
6827             {
6828               tree tmp = NULL_TREE;
6829               int op = 0;
6830
6831               if (declarator)
6832                 {
6833                   /* Avoid trying to get an operand off an identifier node.  */
6834                   if (declarator->kind != cdk_id)
6835                     tmp = declarator->declarator->u.id.name;
6836                   else
6837                     tmp = declarator->u.id.name;
6838                   op = IDENTIFIER_OPNAME_P (tmp);
6839                   if (IDENTIFIER_TYPENAME_P (tmp))
6840                     {
6841                       if (is_typename_at_global_scope (tmp))
6842                         name = IDENTIFIER_POINTER (tmp);
6843                       else
6844                         name = "<invalid operator>";
6845                     }
6846                 }
6847               error ("storage class specified for %s `%s'",
6848                      op ? "member operator" : "field",
6849                      name);
6850             }
6851           else
6852             {
6853               if (decl_context == PARM || decl_context == CATCHPARM)
6854                 error ("storage class specified for parameter `%s'", name);
6855               else
6856                 error ("storage class specified for typename");
6857             }
6858           if (storage_class == sc_register
6859               || storage_class == sc_auto
6860               || storage_class == sc_extern
6861               || thread_p)
6862             storage_class = sc_none;
6863         }
6864     }
6865   else if (storage_class == sc_extern && initialized
6866            && !funcdef_flag)
6867     {
6868       if (toplevel_bindings_p ())
6869         {
6870           /* It's common practice (and completely valid) to have a const
6871              be initialized and declared extern.  */
6872           if (!(type_quals & TYPE_QUAL_CONST))
6873             warning ("`%s' initialized and declared `extern'", name);
6874         }
6875       else
6876         error ("`%s' has both `extern' and initializer", name);
6877     }
6878   else if (storage_class == sc_extern && funcdef_flag
6879            && ! toplevel_bindings_p ())
6880     error ("nested function `%s' declared `extern'", name);
6881   else if (toplevel_bindings_p ())
6882     {
6883       if (storage_class == sc_auto)
6884         error ("top-level declaration of `%s' specifies `auto'", name);
6885     }
6886   else if (thread_p
6887            && storage_class != sc_extern
6888            && storage_class != sc_static)
6889     {
6890       error ("function-scope `%s' implicitly auto and declared `__thread'",
6891              name);
6892       thread_p = false;
6893     }
6894
6895   if (storage_class && friendp)
6896     error ("storage class specifiers invalid in friend function declarations");
6897
6898   if (!id_declarator)
6899     unqualified_id = NULL_TREE;
6900   else
6901     {
6902       unqualified_id = id_declarator->u.id.name;
6903       if (TREE_CODE (unqualified_id) == SCOPE_REF)
6904         unqualified_id = TREE_OPERAND (unqualified_id, 1);
6905       if (TREE_CODE (unqualified_id) == BASELINK)
6906         unqualified_id = BASELINK_FUNCTIONS (unqualified_id);
6907       switch (TREE_CODE (unqualified_id))
6908         {
6909         case BIT_NOT_EXPR:
6910           unqualified_id
6911             = constructor_name (TREE_OPERAND (unqualified_id, 0));
6912           break;
6913
6914         case TYPE_DECL:
6915           unqualified_id
6916             = constructor_name (TREE_TYPE (unqualified_id));
6917           break;
6918
6919         case IDENTIFIER_NODE:
6920         case TEMPLATE_ID_EXPR:
6921           break;
6922
6923         default:
6924           abort ();
6925         }
6926     }
6927
6928   /* Determine the type of the entity declared by recurring on the
6929      declarator.  */
6930   for (;
6931        declarator && declarator->kind != cdk_id;
6932        declarator = declarator->declarator)
6933     {
6934       const cp_declarator *inner_declarator;
6935       tree attrs;
6936
6937       if (type == error_mark_node)
6938         return error_mark_node;
6939
6940       inner_declarator = declarator->declarator;
6941
6942       attrs = declarator->attributes;
6943       if (attrs)
6944         {
6945           int attr_flags;
6946
6947           attr_flags = 0;
6948           if (declarator == NULL || declarator->kind == cdk_id)
6949             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
6950           if (declarator->kind == cdk_function)
6951             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
6952           if (declarator->kind == cdk_array)
6953             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
6954           returned_attrs = decl_attributes (&type,
6955                                             chainon (returned_attrs, attrs),
6956                                             attr_flags);
6957         }
6958
6959       switch (declarator->kind)
6960         {
6961         case cdk_array:
6962           type = create_array_type_for_decl (dname, type,
6963                                              declarator->u.array.bounds);
6964           if (inner_declarator
6965               && (inner_declarator->kind == cdk_pointer
6966                   || inner_declarator->kind == cdk_reference
6967                   || inner_declarator->kind == cdk_ptrmem))
6968             /* We can never complete an array type which is the
6969                target of a pointer, so go ahead and lay it out.  */
6970             layout_type (type);
6971           break;
6972
6973         case cdk_function:
6974           {
6975             tree arg_types;
6976             int funcdecl_p;
6977
6978             /* Declaring a function type.
6979                Make sure we have a valid type for the function to return.  */
6980
6981             /* We now know that the TYPE_QUALS don't apply to the
6982                decl, but to its return type.  */
6983             type_quals = TYPE_UNQUALIFIED;
6984
6985             /* Warn about some types functions can't return.  */
6986
6987             if (TREE_CODE (type) == FUNCTION_TYPE)
6988               {
6989                 error ("`%s' declared as function returning a function", name);
6990                 type = integer_type_node;
6991               }
6992             if (TREE_CODE (type) == ARRAY_TYPE)
6993               {
6994                 error ("`%s' declared as function returning an array", name);
6995                 type = integer_type_node;
6996               }
6997
6998             /* Pick up type qualifiers which should be applied to `this'.  */
6999             quals = declarator->u.function.qualifiers;
7000
7001             /* Pick up the exception specifications.  */
7002             raises = declarator->u.function.exception_specification;
7003
7004             /* Say it's a definition only for the CALL_EXPR
7005                closest to the identifier.  */
7006             funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7007
7008             if (ctype == NULL_TREE
7009                 && decl_context == FIELD
7010                 && funcdecl_p
7011                 && (friendp == 0 || dname == current_class_name))
7012               ctype = current_class_type;
7013
7014             if (ctype && sfk == sfk_conversion)
7015               TYPE_HAS_CONVERSION (ctype) = 1;
7016             if (ctype && (sfk == sfk_constructor
7017                           || sfk == sfk_destructor))
7018               {
7019                 /* We are within a class's scope. If our declarator name
7020                    is the same as the class name, and we are defining
7021                    a function, then it is a constructor/destructor, and
7022                    therefore returns a void type.  */
7023
7024                 if (flags == DTOR_FLAG)
7025                   {
7026                     /* ISO C++ 12.4/2.  A destructor may not be
7027                        declared const or volatile.  A destructor may
7028                        not be static.  */
7029                     if (staticp == 2)
7030                       error ("destructor cannot be static member function");
7031                     if (quals)
7032                       {
7033                         error ("destructors may not be cv-qualified");
7034                         quals = TYPE_UNQUALIFIED;
7035                       }
7036                     if (decl_context == FIELD)
7037                       {
7038                         if (! member_function_or_else (ctype,
7039                                                        current_class_type,
7040                                                        flags))
7041                           return void_type_node;
7042                       }
7043                   }
7044                 else            /* It's a constructor.  */
7045                   {
7046                     if (explicitp == 1)
7047                       explicitp = 2;
7048                     /* ISO C++ 12.1.  A constructor may not be
7049                        declared const or volatile.  A constructor may
7050                        not be virtual.  A constructor may not be
7051                        static.  */
7052                     if (staticp == 2)
7053                       error ("constructor cannot be static member function");
7054                     if (virtualp)
7055                       {
7056                         pedwarn ("constructors cannot be declared virtual");
7057                         virtualp = 0;
7058                       }
7059                     if (quals)
7060                       {
7061                         error ("constructors may not be cv-qualified");
7062                         quals = TYPE_UNQUALIFIED;
7063                       }
7064                     if (decl_context == FIELD)
7065                       {
7066                         if (! member_function_or_else (ctype,
7067                                                        current_class_type,
7068                                                        flags))
7069                           return void_type_node;
7070                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7071                         if (sfk != sfk_constructor)
7072                           return NULL_TREE;
7073                       }
7074                   }
7075                 if (decl_context == FIELD)
7076                   staticp = 0;
7077               }
7078             else if (friendp)
7079               {
7080                 if (initialized)
7081                   error ("can't initialize friend function `%s'", name);
7082                 if (virtualp)
7083                   {
7084                     /* Cannot be both friend and virtual.  */
7085                     error ("virtual functions cannot be friends");
7086                     friendp = 0;
7087                   }
7088                 if (decl_context == NORMAL)
7089                   error ("friend declaration not in class definition");
7090                 if (current_function_decl && funcdef_flag)
7091                   error ("can't define friend function `%s' in a local class definition",
7092                             name);
7093               }
7094
7095             arg_types = grokparms (declarator->u.function.parameters,
7096                                    &parms);
7097
7098             if (inner_declarator
7099                 && inner_declarator->kind == cdk_id
7100                 && inner_declarator->u.id.sfk == sfk_destructor
7101                 && arg_types != void_list_node)
7102               {
7103                 error ("destructors may not have parameters");
7104                 arg_types = void_list_node;
7105                 parms = NULL_TREE;
7106               }
7107
7108             type = build_function_type (type, arg_types);
7109           }
7110           break;
7111
7112         case cdk_pointer:
7113         case cdk_reference:
7114         case cdk_ptrmem:
7115           /* Filter out pointers-to-references and references-to-references.
7116              We can get these if a TYPE_DECL is used.  */
7117
7118           if (TREE_CODE (type) == REFERENCE_TYPE)
7119             {
7120               error (declarator->kind == cdk_reference
7121                      ? "cannot declare reference to `%#T'"
7122                      : "cannot declare pointer to `%#T'", type);
7123               type = TREE_TYPE (type);
7124             }
7125           else if (VOID_TYPE_P (type))
7126             {
7127               if (declarator->kind == cdk_reference)
7128                 error ("cannot declare reference to `%#T'", type);
7129               else if (declarator->kind == cdk_ptrmem)
7130                 error ("cannot declare pointer to `%#T' member", type);
7131             }
7132
7133           /* We now know that the TYPE_QUALS don't apply to the decl,
7134              but to the target of the pointer.  */
7135           type_quals = TYPE_UNQUALIFIED;
7136
7137           if (declarator->kind == cdk_ptrmem
7138               && (TREE_CODE (type) == FUNCTION_TYPE
7139                   || (quals && TREE_CODE (type) == METHOD_TYPE)))
7140             {
7141               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7142               grok_method_quals (declarator->u.pointer.class_type,
7143                                  dummy, quals);
7144               type = TREE_TYPE (dummy);
7145               quals = TYPE_UNQUALIFIED;
7146             }
7147
7148           if (declarator->kind == cdk_reference)
7149             {
7150               if (!VOID_TYPE_P (type))
7151                 type = build_reference_type (type);
7152             }
7153           else if (TREE_CODE (type) == METHOD_TYPE)
7154             type = build_ptrmemfunc_type (build_pointer_type (type));
7155           else if (declarator->kind == cdk_ptrmem)
7156             type = build_ptrmem_type (declarator->u.pointer.class_type,
7157                                       type);
7158           else
7159             type = build_pointer_type (type);
7160
7161           /* Process a list of type modifier keywords (such as
7162              const or volatile) that were given inside the `*' or `&'.  */
7163
7164           if (declarator->u.pointer.qualifiers)
7165             {
7166               type
7167                 = cp_build_qualified_type (type,
7168                                            declarator->u.pointer.qualifiers);
7169               type_quals = cp_type_quals (type);
7170             }
7171           ctype = NULL_TREE;
7172           break;
7173
7174         case cdk_error:
7175           break;
7176
7177         default:
7178           abort ();
7179         }
7180     }
7181
7182   if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7183       && TREE_CODE (type) != FUNCTION_TYPE
7184       && TREE_CODE (type) != METHOD_TYPE)
7185     {
7186       error ("template-id `%D' used as a declarator",
7187              unqualified_id);
7188       unqualified_id = dname;
7189     }
7190
7191   /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7192      otherwise, we would not have exited the loop above.  */
7193   if (declarator
7194       && TREE_CODE (declarator->u.id.name) == SCOPE_REF
7195       /* If the qualifying scope was invalid, it will have been set to
7196          NULL_TREE above.  */
7197       && TREE_OPERAND (declarator->u.id.name, 0)
7198       && TYPE_P (TREE_OPERAND (declarator->u.id.name, 0)))
7199     {
7200       tree t;
7201
7202       ctype = TREE_OPERAND (declarator->u.id.name, 0);
7203       if (TYPE_P (ctype))
7204         ctype = TYPE_MAIN_VARIANT (ctype);
7205       t = ctype;
7206       while (t != NULL_TREE && CLASS_TYPE_P (t))
7207         {
7208           /* You're supposed to have one `template <...>' for every
7209              template class, but you don't need one for a full
7210              specialization.  For example:
7211
7212                template <class T> struct S{};
7213                template <> struct S<int> { void f(); };
7214                void S<int>::f () {}
7215
7216              is correct; there shouldn't be a `template <>' for the
7217              definition of `S<int>::f'.  */
7218           if (CLASSTYPE_TEMPLATE_INFO (t)
7219               && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
7220                   || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
7221               && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7222             template_count += 1;
7223
7224           t = TYPE_MAIN_DECL (t);
7225           t = DECL_CONTEXT (t);
7226         }
7227
7228       if (ctype == current_class_type)
7229         {
7230           /* class A {
7231                void A::f ();
7232              };
7233
7234              Is this ill-formed?  */
7235
7236           if (pedantic)
7237             pedwarn ("extra qualification `%T::' on member `%s' ignored",
7238                         ctype, name);
7239         }
7240       else if (TREE_CODE (type) == FUNCTION_TYPE)
7241         {
7242           tree sname = TREE_OPERAND (declarator->u.id.name, 1);
7243
7244           if (TREE_CODE (sname) == IDENTIFIER_NODE
7245               && NEW_DELETE_OPNAME_P (sname))
7246             /* Overloaded operator new and operator delete
7247                are always static functions.  */
7248             ;
7249           else if (current_class_type == NULL_TREE || friendp)
7250             type
7251               = build_method_type_directly (ctype,
7252                                             TREE_TYPE (type),
7253                                             TYPE_ARG_TYPES (type));
7254           else
7255             {
7256               error ("cannot declare member function `%T::%s' within `%T'",
7257                      ctype, name, current_class_type);
7258               return error_mark_node;
7259             }
7260         }
7261       else if (declspecs->specs[(int)ds_typedef]
7262                || COMPLETE_TYPE_P (complete_type (ctype)))
7263         {
7264           /* Have to move this code elsewhere in this function.
7265              this code is used for i.e., typedef int A::M; M *pm;
7266
7267              It is?  How? jason 10/2/94 */
7268
7269           if (current_class_type)
7270             {
7271               error ("cannot declare member `%T::%s' within `%T'",
7272                      ctype, name, current_class_type);
7273               return void_type_node;
7274             }
7275         }
7276       else
7277         {
7278           cxx_incomplete_type_error (NULL_TREE, ctype);
7279           return error_mark_node;
7280         }
7281     }
7282
7283   if (returned_attrs)
7284     {
7285       if (attrlist)
7286         *attrlist = chainon (returned_attrs, *attrlist);
7287       else
7288         attrlist = &returned_attrs;
7289     }
7290
7291   /* Now TYPE has the actual type.  */
7292
7293   /* Did array size calculations overflow?  */
7294
7295   if (TREE_CODE (type) == ARRAY_TYPE
7296       && COMPLETE_TYPE_P (type)
7297       && TREE_OVERFLOW (TYPE_SIZE (type)))
7298     {
7299       error ("size of array `%s' is too large", name);
7300       /* If we proceed with the array type as it is, we'll eventually
7301          crash in tree_low_cst().  */
7302       type = error_mark_node;
7303     }
7304
7305   if ((decl_context == FIELD || decl_context == PARM)
7306       && !processing_template_decl
7307       && variably_modified_type_p (type, NULL_TREE))
7308     {
7309       if (decl_context == FIELD)
7310         error ("data member may not have variably modified type `%T'", type);
7311       else
7312         error ("parameter may not have variably modified type `%T'", type);
7313       type = error_mark_node;
7314     }
7315
7316   if (explicitp == 1 || (explicitp && friendp))
7317     {
7318       /* [dcl.fct.spec] The explicit specifier shall only be used in
7319          declarations of constructors within a class definition.  */
7320       error ("only declarations of constructors can be `explicit'");
7321       explicitp = 0;
7322     }
7323
7324   if (storage_class == sc_mutable)
7325     {
7326       if (decl_context != FIELD || friendp)
7327         {
7328           error ("non-member `%s' cannot be declared `mutable'", name);
7329           storage_class = sc_none;
7330         }
7331       else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7332         {
7333           error ("non-object member `%s' cannot be declared `mutable'", name);
7334           storage_class = sc_none;
7335         }
7336       else if (TREE_CODE (type) == FUNCTION_TYPE
7337                || TREE_CODE (type) == METHOD_TYPE)
7338         {
7339           error ("function `%s' cannot be declared `mutable'", name);
7340           storage_class = sc_none;
7341         }
7342       else if (staticp)
7343         {
7344           error ("static `%s' cannot be declared `mutable'", name);
7345           storage_class = sc_none;
7346         }
7347       else if (type_quals & TYPE_QUAL_CONST)
7348         {
7349           error ("const `%s' cannot be declared `mutable'", name);
7350           storage_class = sc_none;
7351         }
7352     }
7353
7354   /* If this is declaring a typedef name, return a TYPE_DECL.  */
7355   if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7356     {
7357       tree decl;
7358
7359       /* Note that the grammar rejects storage classes
7360          in typenames, fields or parameters.  */
7361       if (current_lang_name == lang_name_java)
7362         TYPE_FOR_JAVA (type) = 1;
7363
7364       if (decl_context == FIELD)
7365         {
7366           if (constructor_name_p (unqualified_id, current_class_type))
7367             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7368                      unqualified_id);
7369           decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7370         }
7371       else
7372         {
7373           decl = build_decl (TYPE_DECL, unqualified_id, type);
7374           if (in_namespace || ctype)
7375             error ("%Jtypedef name may not be a nested-name-specifier", decl);
7376           if (!current_function_decl)
7377             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7378         }
7379
7380       /* If the user declares "typedef struct {...} foo" then the
7381          struct will have an anonymous name.  Fill that name in now.
7382          Nothing can refer to it, so nothing needs know about the name
7383          change.  */
7384       if (type != error_mark_node
7385           && unqualified_id
7386           && TYPE_NAME (type)
7387           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7388           && TYPE_ANONYMOUS_P (type)
7389           /* Don't do this if there are attributes.  */
7390           && (!attrlist || !*attrlist)
7391           && cp_type_quals (type) == TYPE_UNQUALIFIED)
7392         {
7393           tree oldname = TYPE_NAME (type);
7394           tree t;
7395
7396           /* Replace the anonymous name with the real name everywhere.  */
7397           lookup_tag_reverse (type, unqualified_id);
7398           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7399             if (TYPE_NAME (t) == oldname)
7400               TYPE_NAME (t) = decl;
7401
7402           if (TYPE_LANG_SPECIFIC (type))
7403             TYPE_WAS_ANONYMOUS (type) = 1;
7404
7405           /* If this is a typedef within a template class, the nested
7406              type is a (non-primary) template.  The name for the
7407              template needs updating as well.  */
7408           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7409             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7410               = TYPE_IDENTIFIER (type);
7411
7412           /* FIXME remangle member functions; member functions of a
7413              type with external linkage have external linkage.  */
7414         }
7415
7416       if (quals)
7417         {
7418           if (ctype == NULL_TREE)
7419             {
7420               if (TREE_CODE (type) != METHOD_TYPE)
7421                 error ("%Jinvalid type qualifier for non-member function type",
7422                        decl);
7423               else
7424                 ctype = TYPE_METHOD_BASETYPE (type);
7425             }
7426           if (ctype != NULL_TREE)
7427             grok_method_quals (ctype, decl, quals);
7428         }
7429
7430       if (signed_p
7431           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7432         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7433
7434       bad_specifiers (decl, "type", virtualp, quals != TYPE_UNQUALIFIED,
7435                       inlinep, friendp, raises != NULL_TREE);
7436
7437       return decl;
7438     }
7439
7440   /* Detect the case of an array type of unspecified size
7441      which came, as such, direct from a typedef name.
7442      We must copy the type, so that the array's domain can be
7443      individually set by the object's initializer.  */
7444
7445   if (type && typedef_type
7446       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7447       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7448     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7449
7450   /* Detect where we're using a typedef of function type to declare a
7451      function. PARMS will not be set, so we must create it now.  */
7452
7453   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7454     {
7455       tree decls = NULL_TREE;
7456       tree args;
7457
7458       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7459         {
7460           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7461
7462           TREE_CHAIN (decl) = decls;
7463           decls = decl;
7464         }
7465
7466       parms = nreverse (decls);
7467     }
7468
7469   /* If this is a type name (such as, in a cast or sizeof),
7470      compute the type and return it now.  */
7471
7472   if (decl_context == TYPENAME)
7473     {
7474       /* Note that the grammar rejects storage classes
7475          in typenames, fields or parameters.  */
7476       if (type_quals != TYPE_UNQUALIFIED)
7477         type_quals = TYPE_UNQUALIFIED;
7478
7479       /* Special case: "friend class foo" looks like a TYPENAME context.  */
7480       if (friendp)
7481         {
7482           if (type_quals != TYPE_UNQUALIFIED)
7483             {
7484               error ("type qualifiers specified for friend class declaration");
7485               type_quals = TYPE_UNQUALIFIED;
7486             }
7487           if (inlinep)
7488             {
7489               error ("`inline' specified for friend class declaration");
7490               inlinep = 0;
7491             }
7492
7493           if (!current_aggr)
7494             {
7495               /* Don't allow friend declaration without a class-key.  */
7496               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7497                 pedwarn ("template parameters cannot be friends");
7498               else if (TREE_CODE (type) == TYPENAME_TYPE)
7499                 pedwarn ("friend declaration requires class-key, "
7500                          "i.e. `friend class %T::%D'",
7501                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7502               else
7503                 pedwarn ("friend declaration requires class-key, "
7504                          "i.e. `friend %#T'",
7505                          type);
7506             }
7507
7508           /* Only try to do this stuff if we didn't already give up.  */
7509           if (type != integer_type_node)
7510             {
7511               /* A friendly class?  */
7512               if (current_class_type)
7513                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7514                                    /*complain=*/true);
7515               else
7516                 error ("trying to make class `%T' a friend of global scope",
7517                           type);
7518
7519               type = void_type_node;
7520             }
7521         }
7522       else if (quals)
7523         {
7524           if (ctype == NULL_TREE)
7525             {
7526               if (TREE_CODE (type) != METHOD_TYPE)
7527                 error ("invalid qualifiers on non-member function type");
7528               else
7529                 ctype = TYPE_METHOD_BASETYPE (type);
7530             }
7531           if (ctype)
7532             {
7533               tree dummy = build_decl (TYPE_DECL, unqualified_id, type);
7534               grok_method_quals (ctype, dummy, quals);
7535               type = TREE_TYPE (dummy);
7536             }
7537         }
7538
7539       return type;
7540     }
7541   else if (unqualified_id == NULL_TREE && decl_context != PARM
7542            && decl_context != CATCHPARM
7543            && TREE_CODE (type) != UNION_TYPE
7544            && ! bitfield)
7545     {
7546       error ("abstract declarator `%T' used as declaration", type);
7547       unqualified_id = make_anon_name ();
7548     }
7549
7550   /* `void' at top level (not within pointer)
7551      is allowed only in typedefs or type names.
7552      We don't complain about parms either, but that is because
7553      a better error message can be made later.  */
7554
7555   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
7556     {
7557       if (! unqualified_id)
7558         error ("unnamed variable or field declared void");
7559       else if (TREE_CODE (unqualified_id) == IDENTIFIER_NODE)
7560         {
7561           if (IDENTIFIER_OPNAME_P (unqualified_id))
7562             abort ();
7563           else
7564             error ("variable or field `%s' declared void", name);
7565         }
7566       else
7567         error ("variable or field declared void");
7568       type = integer_type_node;
7569     }
7570
7571   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7572      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
7573
7574   if (decl_context == PARM || decl_context == CATCHPARM)
7575     {
7576       if (ctype || in_namespace)
7577         error ("cannot use `::' in parameter declaration");
7578
7579       /* A parameter declared as an array of T is really a pointer to T.
7580          One declared as a function is really a pointer to a function.
7581          One declared as a member is really a pointer to member.  */
7582
7583       if (TREE_CODE (type) == ARRAY_TYPE)
7584         {
7585           /* Transfer const-ness of array into that of type pointed to.  */
7586           type = build_pointer_type (TREE_TYPE (type));
7587           type_quals = TYPE_UNQUALIFIED;
7588         }
7589       else if (TREE_CODE (type) == FUNCTION_TYPE)
7590         type = build_pointer_type (type);
7591     }
7592
7593   {
7594     tree decl;
7595
7596     if (decl_context == PARM)
7597       {
7598         decl = cp_build_parm_decl (unqualified_id, type);
7599
7600         bad_specifiers (decl, "parameter", virtualp, quals != TYPE_UNQUALIFIED,
7601                         inlinep, friendp, raises != NULL_TREE);
7602       }
7603     else if (decl_context == FIELD)
7604       {
7605         /* The C99 flexible array extension.  */
7606         if (!staticp && TREE_CODE (type) == ARRAY_TYPE
7607             && TYPE_DOMAIN (type) == NULL_TREE)
7608           {
7609             tree itype = compute_array_index_type (dname, integer_zero_node);
7610             type = build_cplus_array_type (TREE_TYPE (type), itype);
7611           }
7612
7613         if (type == error_mark_node)
7614           {
7615             /* Happens when declaring arrays of sizes which
7616                are error_mark_node, for example.  */
7617             decl = NULL_TREE;
7618           }
7619         else if (in_namespace && !friendp)
7620           {
7621             /* Something like struct S { int N::j; };  */
7622             error ("invalid use of `::'");
7623             decl = NULL_TREE;
7624           }
7625         else if (TREE_CODE (type) == FUNCTION_TYPE)
7626           {
7627             int publicp = 0;
7628             tree function_context;
7629
7630             /* We catch the others as conflicts with the builtin
7631                typedefs.  */
7632             if (friendp && unqualified_id == ridpointers[(int) RID_SIGNED])
7633               {
7634                 error ("function `%D' cannot be declared friend",
7635                        unqualified_id);
7636                 friendp = 0;
7637               }
7638
7639             if (friendp == 0)
7640               {
7641                 if (ctype == NULL_TREE)
7642                   ctype = current_class_type;
7643
7644                 if (ctype == NULL_TREE)
7645                   {
7646                     error ("can't make `%D' into a method -- not in a class",
7647                            unqualified_id);
7648                     return void_type_node;
7649                   }
7650
7651                 /* ``A union may [ ... ] not [ have ] virtual functions.''
7652                    ARM 9.5 */
7653                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
7654                   {
7655                     error ("function `%D' declared virtual inside a union",
7656                            unqualified_id);
7657                     return void_type_node;
7658                   }
7659
7660                 if (NEW_DELETE_OPNAME_P (unqualified_id))
7661                   {
7662                     if (virtualp)
7663                       {
7664                         error ("`%D' cannot be declared virtual, since it is always static",
7665                                unqualified_id);
7666                         virtualp = 0;
7667                       }
7668                   }
7669                 else if (staticp < 2)
7670                   type = build_method_type_directly (ctype,
7671                                                      TREE_TYPE (type),
7672                                                      TYPE_ARG_TYPES (type));
7673               }
7674
7675             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
7676             function_context = (ctype != NULL_TREE) ?
7677               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
7678             publicp = (! friendp || ! staticp)
7679               && function_context == NULL_TREE;
7680             decl = grokfndecl (ctype, type,
7681                                TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7682                                ? unqualified_id : dname,
7683                                parms,
7684                                unqualified_id,
7685                                virtualp, flags, quals, raises,
7686                                friendp ? -1 : 0, friendp, publicp, inlinep,
7687                                funcdef_flag, template_count, in_namespace);
7688             if (decl == NULL_TREE)
7689               return decl;
7690 #if 0
7691             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
7692             /* The decl and setting of decl_attr is also turned off.  */
7693             decl = build_decl_attribute_variant (decl, decl_attr);
7694 #endif
7695
7696             /* [class.conv.ctor]
7697
7698                A constructor declared without the function-specifier
7699                explicit that can be called with a single parameter
7700                specifies a conversion from the type of its first
7701                parameter to the type of its class.  Such a constructor
7702                is called a converting constructor.  */
7703             if (explicitp == 2)
7704               DECL_NONCONVERTING_P (decl) = 1;
7705             else if (DECL_CONSTRUCTOR_P (decl))
7706               {
7707                 /* The constructor can be called with exactly one
7708                    parameter if there is at least one parameter, and
7709                    any subsequent parameters have default arguments.
7710                    Ignore any compiler-added parms.  */
7711                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
7712
7713                 if (arg_types == void_list_node
7714                     || (arg_types
7715                         && TREE_CHAIN (arg_types)
7716                         && TREE_CHAIN (arg_types) != void_list_node
7717                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
7718                   DECL_NONCONVERTING_P (decl) = 1;
7719               }
7720           }
7721         else if (TREE_CODE (type) == METHOD_TYPE)
7722           {
7723             /* We only get here for friend declarations of
7724                members of other classes.  */
7725             /* All method decls are public, so tell grokfndecl to set
7726                TREE_PUBLIC, also.  */
7727             decl = grokfndecl (ctype, type,
7728                                TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7729                                ? unqualified_id : dname,
7730                                parms,
7731                                unqualified_id,
7732                                virtualp, flags, quals, raises,
7733                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
7734                                template_count, in_namespace);
7735             if (decl == NULL_TREE)
7736               return NULL_TREE;
7737           }
7738         else if (!staticp && !dependent_type_p (type)
7739                  && !COMPLETE_TYPE_P (complete_type (type))
7740                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
7741           {
7742             if (unqualified_id)
7743               error ("field `%D' has incomplete type", unqualified_id);
7744             else
7745               error ("name `%T' has incomplete type", type);
7746
7747             /* If we're instantiating a template, tell them which
7748                instantiation made the field's type be incomplete.  */
7749             if (current_class_type
7750                 && TYPE_NAME (current_class_type)
7751                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
7752                 && declspecs->type
7753                 && declspecs->type == type)
7754               error ("  in instantiation of template `%T'",
7755                         current_class_type);
7756
7757             type = error_mark_node;
7758             decl = NULL_TREE;
7759           }
7760         else
7761           {
7762             if (friendp)
7763               {
7764                 error ("`%E' is neither function nor member function; "
7765                        "cannot be declared friend", unqualified_id);
7766                 friendp = 0;
7767               }
7768             decl = NULL_TREE;
7769           }
7770
7771         if (friendp)
7772           {
7773             /* Friends are treated specially.  */
7774             if (ctype == current_class_type)
7775               warning ("member functions are implicitly friends of their class");
7776             else if (decl && DECL_NAME (decl))
7777               {
7778                 if (template_class_depth (current_class_type) == 0)
7779                   {
7780                     decl = check_explicit_specialization
7781                       (unqualified_id, decl, template_count,
7782                        2 * (funcdef_flag != 0) + 4);
7783                     if (decl == error_mark_node)
7784                       return error_mark_node;
7785                   }
7786
7787                 decl = do_friend (ctype, unqualified_id, decl,
7788                                   *attrlist, flags, quals, funcdef_flag);
7789                 return decl;
7790               }
7791             else
7792               return void_type_node;
7793           }
7794
7795         /* Structure field.  It may not be a function, except for C++.  */
7796
7797         if (decl == NULL_TREE)
7798           {
7799             if (initialized)
7800               {
7801                 if (!staticp)
7802                   {
7803                     /* An attempt is being made to initialize a non-static
7804                        member.  But, from [class.mem]:
7805
7806                        4 A member-declarator can contain a
7807                        constant-initializer only if it declares a static
7808                        member (_class.static_) of integral or enumeration
7809                        type, see _class.static.data_.
7810
7811                        This used to be relatively common practice, but
7812                        the rest of the compiler does not correctly
7813                        handle the initialization unless the member is
7814                        static so we make it static below.  */
7815                     pedwarn ("ISO C++ forbids initialization of member `%D'",
7816                              unqualified_id);
7817                     pedwarn ("making `%D' static", unqualified_id);
7818                     staticp = 1;
7819                   }
7820
7821                 if (uses_template_parms (type))
7822                   /* We'll check at instantiation time.  */
7823                   ;
7824                 else if (check_static_variable_definition (unqualified_id,
7825                                                            type))
7826                   /* If we just return the declaration, crashes
7827                      will sometimes occur.  We therefore return
7828                      void_type_node, as if this was a friend
7829                      declaration, to cause callers to completely
7830                      ignore this declaration.  */
7831                   return void_type_node;
7832               }
7833
7834             if (staticp)
7835               {
7836                 /* C++ allows static class members.  All other work
7837                    for this is done by grokfield.  */
7838                 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
7839                 TREE_STATIC (decl) = 1;
7840                 /* In class context, 'static' means public access.  */
7841                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
7842               }
7843             else
7844               {
7845                 decl = build_decl (FIELD_DECL, unqualified_id, type);
7846                 DECL_NONADDRESSABLE_P (decl) = bitfield;
7847                 if (storage_class == sc_mutable)
7848                   {
7849                     DECL_MUTABLE_P (decl) = 1;
7850                     storage_class = sc_none;
7851                   }
7852               }
7853
7854             bad_specifiers (decl, "field", virtualp, quals != TYPE_UNQUALIFIED,
7855                             inlinep, friendp, raises != NULL_TREE);
7856           }
7857       }
7858     else if (TREE_CODE (type) == FUNCTION_TYPE
7859              || TREE_CODE (type) == METHOD_TYPE)
7860       {
7861         tree original_name;
7862         int publicp = 0;
7863
7864         if (!unqualified_id)
7865           return NULL_TREE;
7866
7867         if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
7868           original_name = dname;
7869         else
7870           original_name = unqualified_id;
7871
7872         if (storage_class == sc_auto)
7873           error ("storage class `auto' invalid for function `%s'", name);
7874         else if (storage_class == sc_register)
7875           error ("storage class `register' invalid for function `%s'", name);
7876         else if (thread_p)
7877           error ("storage class `__thread' invalid for function `%s'", name);
7878
7879         /* Function declaration not at top level.
7880            Storage classes other than `extern' are not allowed
7881            and `extern' makes no difference.  */
7882         if (! toplevel_bindings_p ()
7883             && (storage_class == sc_static
7884                 || declspecs->specs[(int)ds_inline])
7885             && pedantic)
7886           {
7887             if (storage_class == sc_static)
7888               pedwarn ("`static' specified invalid for function `%s' declared out of global scope", name);
7889             else
7890               pedwarn ("`inline' specifier invalid for function `%s' declared out of global scope", name);
7891           }
7892
7893         if (ctype == NULL_TREE)
7894           {
7895             if (virtualp)
7896               {
7897                 error ("virtual non-class function `%s'", name);
7898                 virtualp = 0;
7899               }
7900           }
7901         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
7902                  && !NEW_DELETE_OPNAME_P (original_name))
7903           type = build_method_type_directly (ctype,
7904                                              TREE_TYPE (type),
7905                                              TYPE_ARG_TYPES (type));
7906
7907         /* Record presence of `static'.  */
7908         publicp = (ctype != NULL_TREE
7909                    || storage_class == sc_extern
7910                    || storage_class != sc_static);
7911
7912         decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
7913                            virtualp, flags, quals, raises,
7914                            1, friendp,
7915                            publicp, inlinep, funcdef_flag,
7916                            template_count, in_namespace);
7917         if (decl == NULL_TREE)
7918           return NULL_TREE;
7919
7920         if (staticp == 1)
7921           {
7922             int invalid_static = 0;
7923
7924             /* Don't allow a static member function in a class, and forbid
7925                declaring main to be static.  */
7926             if (TREE_CODE (type) == METHOD_TYPE)
7927               {
7928                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
7929                 invalid_static = 1;
7930               }
7931             else if (current_function_decl)
7932               {
7933                 /* FIXME need arm citation */
7934                 error ("cannot declare static function inside another function");
7935                 invalid_static = 1;
7936               }
7937
7938             if (invalid_static)
7939               {
7940                 staticp = 0;
7941                 storage_class = sc_none;
7942               }
7943           }
7944       }
7945     else
7946       {
7947         /* It's a variable.  */
7948
7949         /* An uninitialized decl with `extern' is a reference.  */
7950         decl = grokvardecl (type, unqualified_id,
7951                             declspecs,
7952                             initialized,
7953                             (type_quals & TYPE_QUAL_CONST) != 0,
7954                             ctype ? ctype : in_namespace);
7955         bad_specifiers (decl, "variable", virtualp, quals != TYPE_UNQUALIFIED,
7956                         inlinep, friendp, raises != NULL_TREE);
7957
7958         if (ctype)
7959           {
7960             DECL_CONTEXT (decl) = ctype;
7961             if (staticp == 1)
7962               {
7963                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
7964                 staticp = 0;
7965                 storage_class = sc_none;
7966               }
7967             if (storage_class == sc_register && TREE_STATIC (decl))
7968               {
7969                 error ("static member `%D' declared `register'", decl);
7970                 storage_class = sc_none;
7971               }
7972             if (storage_class == sc_extern && pedantic)
7973               {
7974                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
7975                             decl);
7976                 storage_class = sc_none;
7977               }
7978           }
7979       }
7980
7981     /* Record `register' declaration for warnings on &
7982        and in case doing stupid register allocation.  */
7983
7984     if (storage_class == sc_register)
7985       DECL_REGISTER (decl) = 1;
7986     else if (storage_class == sc_extern)
7987       DECL_THIS_EXTERN (decl) = 1;
7988     else if (storage_class == sc_static)
7989       DECL_THIS_STATIC (decl) = 1;
7990
7991     /* Record constancy and volatility.  There's no need to do this
7992        when processing a template; we'll do this for the instantiated
7993        declaration based on the type of DECL.  */
7994     if (!processing_template_decl)
7995       c_apply_type_quals_to_decl (type_quals, decl);
7996
7997     return decl;
7998   }
7999 }
8000 \f
8001 /* Subroutine of start_function.  Ensure that each of the parameter
8002    types (as listed in PARMS) is complete, as is required for a
8003    function definition.  */
8004
8005 static void
8006 require_complete_types_for_parms (tree parms)
8007 {
8008   for (; parms; parms = TREE_CHAIN (parms))
8009     {
8010       if (VOID_TYPE_P (TREE_TYPE (parms)))
8011         /* grokparms will have already issued an error.  */
8012         TREE_TYPE (parms) = error_mark_node;
8013       else if (complete_type_or_else (TREE_TYPE (parms), parms))
8014         {
8015           layout_decl (parms, 0);
8016           DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8017         }
8018     }
8019 }
8020
8021 /* Returns nonzero if T is a local variable.  */
8022
8023 int
8024 local_variable_p (tree t)
8025 {
8026   if ((TREE_CODE (t) == VAR_DECL
8027        /* A VAR_DECL with a context that is a _TYPE is a static data
8028           member.  */
8029        && !TYPE_P (CP_DECL_CONTEXT (t))
8030        /* Any other non-local variable must be at namespace scope.  */
8031        && !DECL_NAMESPACE_SCOPE_P (t))
8032       || (TREE_CODE (t) == PARM_DECL))
8033     return 1;
8034
8035   return 0;
8036 }
8037
8038 /* Returns nonzero if T is an automatic local variable or a label.
8039    (These are the declarations that need to be remapped when the code
8040    containing them is duplicated.)  */
8041
8042 int
8043 nonstatic_local_decl_p (tree t)
8044 {
8045   return ((local_variable_p (t) && !TREE_STATIC (t))
8046           || TREE_CODE (t) == LABEL_DECL
8047           || TREE_CODE (t) == RESULT_DECL);
8048 }
8049
8050 /* Like local_variable_p, but suitable for use as a tree-walking
8051    function.  */
8052
8053 static tree
8054 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8055                          void *data ATTRIBUTE_UNUSED)
8056 {
8057   if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8058     return *tp;
8059   else if (TYPE_P (*tp))
8060     *walk_subtrees = 0;
8061
8062   return NULL_TREE;
8063 }
8064
8065
8066 /* Check that ARG, which is a default-argument expression for a
8067    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
8068    something goes wrong.  DECL may also be a _TYPE node, rather than a
8069    DECL, if there is no DECL available.  */
8070
8071 tree
8072 check_default_argument (tree decl, tree arg)
8073 {
8074   tree var;
8075   tree decl_type;
8076
8077   if (TREE_CODE (arg) == DEFAULT_ARG)
8078     /* We get a DEFAULT_ARG when looking at an in-class declaration
8079        with a default argument.  Ignore the argument for now; we'll
8080        deal with it after the class is complete.  */
8081     return arg;
8082
8083   if (processing_template_decl || uses_template_parms (arg))
8084     /* We don't do anything checking until instantiation-time.  Note
8085        that there may be uninstantiated arguments even for an
8086        instantiated function, since default arguments are not
8087        instantiated until they are needed.  */
8088     return arg;
8089
8090   if (TYPE_P (decl))
8091     {
8092       decl_type = decl;
8093       decl = NULL_TREE;
8094     }
8095   else
8096     decl_type = TREE_TYPE (decl);
8097
8098   if (arg == error_mark_node
8099       || decl == error_mark_node
8100       || TREE_TYPE (arg) == error_mark_node
8101       || decl_type == error_mark_node)
8102     /* Something already went wrong.  There's no need to check
8103        further.  */
8104     return error_mark_node;
8105
8106   /* [dcl.fct.default]
8107
8108      A default argument expression is implicitly converted to the
8109      parameter type.  */
8110   if (!TREE_TYPE (arg)
8111       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
8112     {
8113       if (decl)
8114         error ("default argument for `%#D' has type `%T'",
8115                   decl, TREE_TYPE (arg));
8116       else
8117         error ("default argument for parameter of type `%T' has type `%T'",
8118                   decl_type, TREE_TYPE (arg));
8119
8120       return error_mark_node;
8121     }
8122
8123   /* [dcl.fct.default]
8124
8125      Local variables shall not be used in default argument
8126      expressions.
8127
8128      The keyword `this' shall not be used in a default argument of a
8129      member function.  */
8130   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8131                                       NULL);
8132   if (var)
8133     {
8134       error ("default argument `%E' uses local variable `%D'",
8135                 arg, var);
8136       return error_mark_node;
8137     }
8138
8139   /* All is well.  */
8140   return arg;
8141 }
8142
8143 /* Decode the list of parameter types for a function type.
8144    Given the list of things declared inside the parens,
8145    return a list of types.
8146
8147    If this parameter does not end with an ellipsis, we append
8148    void_list_node.
8149
8150    *PARMS is set to the chain of PARM_DECLs created.  */
8151
8152 static tree
8153 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8154 {
8155   tree result = NULL_TREE;
8156   tree decls = NULL_TREE;
8157   int ellipsis = !first_parm || first_parm->ellipsis_p;
8158   cp_parameter_declarator *parm;
8159   int any_error = 0;
8160
8161   for (parm = first_parm; parm != NULL; parm = parm->next)
8162     {
8163       tree type = NULL_TREE;
8164       tree init = parm->default_argument;
8165       tree attrs;
8166       tree decl;
8167
8168       if (parm == no_parameters)
8169         break;
8170
8171       attrs = parm->decl_specifiers.attributes;
8172       parm->decl_specifiers.attributes = NULL_TREE;
8173       decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8174                              PARM, init != NULL_TREE, &attrs);
8175       if (! decl || TREE_TYPE (decl) == error_mark_node)
8176         continue;
8177
8178       if (attrs)
8179         cplus_decl_attributes (&decl, attrs, 0);
8180
8181       type = TREE_TYPE (decl);
8182       if (VOID_TYPE_P (type))
8183         {
8184           if (same_type_p (type, void_type_node)
8185               && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8186             /* this is a parmlist of `(void)', which is ok.  */
8187             break;
8188           cxx_incomplete_type_error (decl, type);
8189           /* It's not a good idea to actually create parameters of
8190              type `void'; other parts of the compiler assume that a
8191              void type terminates the parameter list.  */
8192           type = error_mark_node;
8193           TREE_TYPE (decl) = error_mark_node;
8194         }
8195
8196       if (type != error_mark_node)
8197         {
8198           /* Top-level qualifiers on the parameters are
8199              ignored for function types.  */
8200           type = cp_build_qualified_type (type, 0);
8201           if (TREE_CODE (type) == METHOD_TYPE)
8202             {
8203               error ("parameter `%D' invalidly declared method type", decl);
8204               type = build_pointer_type (type);
8205               TREE_TYPE (decl) = type;
8206             }
8207           else if (abstract_virtuals_error (decl, type))
8208             any_error = 1;  /* Seems like a good idea.  */
8209           else if (POINTER_TYPE_P (type))
8210             {
8211               /* [dcl.fct]/6, parameter types cannot contain pointers
8212                  (references) to arrays of unknown bound.  */
8213               tree t = TREE_TYPE (type);
8214               int ptr = TYPE_PTR_P (type);
8215
8216               while (1)
8217                 {
8218                   if (TYPE_PTR_P (t))
8219                     ptr = 1;
8220                   else if (TREE_CODE (t) != ARRAY_TYPE)
8221                     break;
8222                   else if (!TYPE_DOMAIN (t))
8223                     break;
8224                   t = TREE_TYPE (t);
8225                 }
8226               if (TREE_CODE (t) == ARRAY_TYPE)
8227                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
8228                           decl, ptr ? "pointer" : "reference", t);
8229             }
8230
8231           if (!any_error && init)
8232             init = check_default_argument (decl, init);
8233           else
8234             init = NULL_TREE;
8235         }
8236
8237       TREE_CHAIN (decl) = decls;
8238       decls = decl;
8239       result = tree_cons (init, type, result);
8240     }
8241   decls = nreverse (decls);
8242   result = nreverse (result);
8243   if (!ellipsis)
8244     result = chainon (result, void_list_node);
8245   *parms = decls;
8246
8247   return result;
8248 }
8249
8250 \f
8251 /* D is a constructor or overloaded `operator='.
8252
8253    Let T be the class in which D is declared. Then, this function
8254    returns:
8255
8256    -1 if D's is an ill-formed constructor or copy assignment operator
8257       whose first parameter is of type `T'.
8258    0  if D is not a copy constructor or copy assignment
8259       operator.
8260    1  if D is a copy constructor or copy assignment operator whose
8261       first parameter is a reference to const qualified T.
8262    2  if D is a copy constructor or copy assignment operator whose
8263       first parameter is a reference to non-const qualified T.
8264
8265    This function can be used as a predicate. Positive values indicate
8266    a copy constructor and nonzero values indicate a copy assignment
8267    operator.  */
8268
8269 int
8270 copy_fn_p (tree d)
8271 {
8272   tree args;
8273   tree arg_type;
8274   int result = 1;
8275
8276   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
8277
8278   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
8279     /* Instantiations of template member functions are never copy
8280        functions.  Note that member functions of templated classes are
8281        represented as template functions internally, and we must
8282        accept those as copy functions.  */
8283     return 0;
8284
8285   args = FUNCTION_FIRST_USER_PARMTYPE (d);
8286   if (!args)
8287     return 0;
8288
8289   arg_type = TREE_VALUE (args);
8290
8291   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8292     {
8293       /* Pass by value copy assignment operator.  */
8294       result = -1;
8295     }
8296   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8297            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8298     {
8299       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8300         result = 2;
8301     }
8302   else
8303     return 0;
8304
8305   args = TREE_CHAIN (args);
8306
8307   if (args && args != void_list_node && !TREE_PURPOSE (args))
8308     /* There are more non-optional args.  */
8309     return 0;
8310
8311   return result;
8312 }
8313
8314 /* Remember any special properties of member function DECL.  */
8315
8316 void grok_special_member_properties (tree decl)
8317 {
8318   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8319     ; /* Not special.  */
8320   else if (DECL_CONSTRUCTOR_P (decl))
8321     {
8322       int ctor = copy_fn_p (decl);
8323
8324       if (ctor > 0)
8325         {
8326           /* [class.copy]
8327
8328              A non-template constructor for class X is a copy
8329              constructor if its first parameter is of type X&, const
8330              X&, volatile X& or const volatile X&, and either there
8331              are no other parameters or else all other parameters have
8332              default arguments.  */
8333           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8334           if (ctor > 1)
8335             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8336         }
8337       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8338         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8339     }
8340   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8341     {
8342       /* [class.copy]
8343
8344          A non-template assignment operator for class X is a copy
8345          assignment operator if its parameter is of type X, X&, const
8346          X&, volatile X& or const volatile X&.  */
8347
8348       int assop = copy_fn_p (decl);
8349
8350       if (assop)
8351         {
8352           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8353           if (assop != 1)
8354             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8355           if (DECL_PURE_VIRTUAL_P (decl))
8356             TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8357         }
8358     }
8359 }
8360
8361 /* Check a constructor DECL has the correct form.  Complains
8362    if the class has a constructor of the form X(X).  */
8363
8364 int
8365 grok_ctor_properties (tree ctype, tree decl)
8366 {
8367   int ctor_parm = copy_fn_p (decl);
8368
8369   if (ctor_parm < 0)
8370     {
8371       /* [class.copy]
8372
8373          A declaration of a constructor for a class X is ill-formed if
8374          its first parameter is of type (optionally cv-qualified) X
8375          and either there are no other parameters or else all other
8376          parameters have default arguments.
8377
8378          We *don't* complain about member template instantiations that
8379          have this form, though; they can occur as we try to decide
8380          what constructor to use during overload resolution.  Since
8381          overload resolution will never prefer such a constructor to
8382          the non-template copy constructor (which is either explicitly
8383          or implicitly defined), there's no need to worry about their
8384          existence.  Theoretically, they should never even be
8385          instantiated, but that's hard to forestall.  */
8386       error ("invalid constructor; you probably meant `%T (const %T&)'",
8387                 ctype, ctype);
8388       return 0;
8389     }
8390
8391   return 1;
8392 }
8393
8394 /* An operator with this code is unary, but can also be binary.  */
8395
8396 static int
8397 ambi_op_p (enum tree_code code)
8398 {
8399   return (code == INDIRECT_REF
8400           || code == ADDR_EXPR
8401           || code == CONVERT_EXPR
8402           || code == NEGATE_EXPR
8403           || code == PREINCREMENT_EXPR
8404           || code == PREDECREMENT_EXPR);
8405 }
8406
8407 /* An operator with this name can only be unary.  */
8408
8409 static int
8410 unary_op_p (enum tree_code code)
8411 {
8412   return (code == TRUTH_NOT_EXPR
8413           || code == BIT_NOT_EXPR
8414           || code == COMPONENT_REF
8415           || code == TYPE_EXPR);
8416 }
8417
8418 /* DECL is a declaration for an overloaded operator.  Returns true if
8419    the declaration is valid; false otherwise.  If COMPLAIN is true,
8420    errors are issued for invalid declarations.  */
8421
8422 bool
8423 grok_op_properties (tree decl, int friendp, bool complain)
8424 {
8425   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8426   tree argtype;
8427   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8428   tree name = DECL_NAME (decl);
8429   enum tree_code operator_code;
8430   int arity;
8431   bool ok;
8432
8433   /* Assume that the declaration is valid.  */
8434   ok = true;
8435
8436   /* Count the number of arguments.  */
8437   for (argtype = argtypes, arity = 0;
8438        argtype && argtype != void_list_node;
8439        argtype = TREE_CHAIN (argtype))
8440     ++arity;
8441
8442   if (current_class_type == NULL_TREE)
8443     friendp = 1;
8444
8445   if (DECL_CONV_FN_P (decl))
8446     operator_code = TYPE_EXPR;
8447   else
8448     do
8449       {
8450 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
8451         if (ansi_opname (CODE) == name)                         \
8452           {                                                     \
8453             operator_code = (CODE);                             \
8454             break;                                              \
8455           }                                                     \
8456         else if (ansi_assopname (CODE) == name)                 \
8457           {                                                     \
8458             operator_code = (CODE);                             \
8459             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
8460             break;                                              \
8461           }
8462
8463 #include "operators.def"
8464 #undef DEF_OPERATOR
8465
8466         abort ();
8467       }
8468     while (0);
8469   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
8470   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8471
8472   if (! friendp)
8473     {
8474       switch (operator_code)
8475         {
8476         case NEW_EXPR:
8477           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8478           break;
8479
8480         case DELETE_EXPR:
8481           TYPE_GETS_DELETE (current_class_type) |= 1;
8482           break;
8483
8484         case VEC_NEW_EXPR:
8485           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8486           break;
8487
8488         case VEC_DELETE_EXPR:
8489           TYPE_GETS_DELETE (current_class_type) |= 2;
8490           break;
8491
8492         default:
8493           break;
8494         }
8495     }
8496
8497     /* [basic.std.dynamic.allocation]/1:
8498
8499        A program is ill-formed if an allocation function is declared
8500        in a namespace scope other than global scope or declared static
8501        in global scope.
8502
8503        The same also holds true for deallocation functions.  */
8504   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
8505       || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8506     {
8507       if (DECL_NAMESPACE_SCOPE_P (decl))
8508         {
8509           if (CP_DECL_CONTEXT (decl) != global_namespace)
8510             error ("`%D' may not be declared within a namespace", decl);
8511           else if (!TREE_PUBLIC (decl))
8512             error ("`%D' may not be declared as static", decl);
8513         }
8514     }
8515
8516   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8517     TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8518   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8519     TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8520   else
8521     {
8522       /* An operator function must either be a non-static member function
8523          or have at least one parameter of a class, a reference to a class,
8524          an enumeration, or a reference to an enumeration.  13.4.0.6 */
8525       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8526         {
8527           if (operator_code == TYPE_EXPR
8528               || operator_code == CALL_EXPR
8529               || operator_code == COMPONENT_REF
8530               || operator_code == ARRAY_REF
8531               || operator_code == NOP_EXPR)
8532             error ("`%D' must be a nonstatic member function", decl);
8533           else
8534             {
8535               tree p;
8536
8537               if (DECL_STATIC_FUNCTION_P (decl))
8538                 error ("`%D' must be either a non-static member function or a non-member function", decl);
8539
8540               for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8541                 {
8542                   tree arg = non_reference (TREE_VALUE (p));
8543                   /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8544                      because these checks are performed even on
8545                      template functions.  */
8546                   if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8547                     break;
8548                 }
8549
8550               if (!p || p == void_list_node)
8551                 {
8552                   if (!complain)
8553                     return false;
8554
8555                   error ("`%D' must have an argument of class or "
8556                          "enumerated type",
8557                          decl);
8558                   ok = false;
8559                 }
8560             }
8561         }
8562
8563       /* There are no restrictions on the arguments to an overloaded
8564          "operator ()".  */
8565       if (operator_code == CALL_EXPR)
8566         return ok;
8567
8568       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
8569         {
8570           tree t = TREE_TYPE (name);
8571           if (! friendp)
8572             {
8573               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8574               const char *what = 0;
8575
8576               if (ref)
8577                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8578
8579               if (TREE_CODE (t) == VOID_TYPE)
8580                 what = "void";
8581               else if (t == current_class_type)
8582                 what = "the same type";
8583               /* Don't force t to be complete here.  */
8584               else if (IS_AGGR_TYPE (t)
8585                        && COMPLETE_TYPE_P (t)
8586                        && DERIVED_FROM_P (t, current_class_type))
8587                 what = "a base class";
8588
8589               if (what && warn_conversion)
8590                 warning ("conversion to %s%s will never use a type conversion operator",
8591                          ref ? "a reference to " : "", what);
8592             }
8593         }
8594       if (operator_code == COND_EXPR)
8595         {
8596           /* 13.4.0.3 */
8597           error ("ISO C++ prohibits overloading operator ?:");
8598         }
8599       else if (ambi_op_p (operator_code))
8600         {
8601           if (arity == 1)
8602             /* We pick the one-argument operator codes by default, so
8603                we don't have to change anything.  */
8604             ;
8605           else if (arity == 2)
8606             {
8607               /* If we thought this was a unary operator, we now know
8608                  it to be a binary operator.  */
8609               switch (operator_code)
8610                 {
8611                 case INDIRECT_REF:
8612                   operator_code = MULT_EXPR;
8613                   break;
8614
8615                 case ADDR_EXPR:
8616                   operator_code = BIT_AND_EXPR;
8617                   break;
8618
8619                 case CONVERT_EXPR:
8620                   operator_code = PLUS_EXPR;
8621                   break;
8622
8623                 case NEGATE_EXPR:
8624                   operator_code = MINUS_EXPR;
8625                   break;
8626
8627                 case PREINCREMENT_EXPR:
8628                   operator_code = POSTINCREMENT_EXPR;
8629                   break;
8630
8631                 case PREDECREMENT_EXPR:
8632                   operator_code = POSTDECREMENT_EXPR;
8633                   break;
8634
8635                 default:
8636                   abort ();
8637                 }
8638
8639               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8640
8641               if ((operator_code == POSTINCREMENT_EXPR
8642                    || operator_code == POSTDECREMENT_EXPR)
8643                   && ! processing_template_decl
8644                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8645                 {
8646                   if (methodp)
8647                     error ("postfix `%D' must take `int' as its argument",
8648                               decl);
8649                   else
8650                     error
8651                       ("postfix `%D' must take `int' as its second argument",
8652                        decl);
8653                 }
8654             }
8655           else
8656             {
8657               if (methodp)
8658                 error ("`%D' must take either zero or one argument", decl);
8659               else
8660                 error ("`%D' must take either one or two arguments", decl);
8661             }
8662
8663           /* More Effective C++ rule 6.  */
8664           if (warn_ecpp
8665               && (operator_code == POSTINCREMENT_EXPR
8666                   || operator_code == POSTDECREMENT_EXPR
8667                   || operator_code == PREINCREMENT_EXPR
8668                   || operator_code == PREDECREMENT_EXPR))
8669             {
8670               tree arg = TREE_VALUE (argtypes);
8671               tree ret = TREE_TYPE (TREE_TYPE (decl));
8672               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
8673                 arg = TREE_TYPE (arg);
8674               arg = TYPE_MAIN_VARIANT (arg);
8675               if (operator_code == PREINCREMENT_EXPR
8676                   || operator_code == PREDECREMENT_EXPR)
8677                 {
8678                   if (TREE_CODE (ret) != REFERENCE_TYPE
8679                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
8680                                        arg))
8681                     warning ("prefix `%D' should return `%T'", decl,
8682                                 build_reference_type (arg));
8683                 }
8684               else
8685                 {
8686                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
8687                     warning ("postfix `%D' should return `%T'", decl, arg);
8688                 }
8689             }
8690         }
8691       else if (unary_op_p (operator_code))
8692         {
8693           if (arity != 1)
8694             {
8695               if (methodp)
8696                 error ("`%D' must take `void'", decl);
8697               else
8698                 error ("`%D' must take exactly one argument", decl);
8699             }
8700         }
8701       else /* if (binary_op_p (operator_code)) */
8702         {
8703           if (arity != 2)
8704             {
8705               if (methodp)
8706                 error ("`%D' must take exactly one argument", decl);
8707               else
8708                 error ("`%D' must take exactly two arguments", decl);
8709             }
8710
8711           /* More Effective C++ rule 7.  */
8712           if (warn_ecpp
8713               && (operator_code == TRUTH_ANDIF_EXPR
8714                   || operator_code == TRUTH_ORIF_EXPR
8715                   || operator_code == COMPOUND_EXPR))
8716             warning ("user-defined `%D' always evaluates both arguments",
8717                         decl);
8718         }
8719
8720       /* Effective C++ rule 23.  */
8721       if (warn_ecpp
8722           && arity == 2
8723           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
8724           && (operator_code == PLUS_EXPR
8725               || operator_code == MINUS_EXPR
8726               || operator_code == TRUNC_DIV_EXPR
8727               || operator_code == MULT_EXPR
8728               || operator_code == TRUNC_MOD_EXPR)
8729           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
8730         warning ("`%D' should return by value", decl);
8731
8732       /* [over.oper]/8 */
8733       for (; argtypes && argtypes != void_list_node;
8734           argtypes = TREE_CHAIN (argtypes))
8735         if (TREE_PURPOSE (argtypes))
8736           {
8737             TREE_PURPOSE (argtypes) = NULL_TREE;
8738             if (operator_code == POSTINCREMENT_EXPR
8739                 || operator_code == POSTDECREMENT_EXPR)
8740               {
8741                 if (pedantic)
8742                   pedwarn ("`%D' cannot have default arguments", decl);
8743               }
8744             else
8745               error ("`%D' cannot have default arguments", decl);
8746           }
8747
8748     }
8749
8750   return ok;
8751 }
8752 \f
8753 static const char *
8754 tag_name (enum tag_types code)
8755 {
8756   switch (code)
8757     {
8758     case record_type:
8759       return "struct";
8760     case class_type:
8761       return "class";
8762     case union_type:
8763       return "union ";
8764     case enum_type:
8765       return "enum";
8766     default:
8767       abort ();
8768     }
8769 }
8770
8771 /* Name lookup in an elaborated-type-specifier (after the keyword
8772    indicated by TAG_CODE) has found the TYPE_DECL DECL.  If the
8773    elaborated-type-specifier is invalid, issue a diagnostic and return
8774    error_mark_node; otherwise, return the *_TYPE to which it referred.
8775    If ALLOW_TEMPLATE_P is true, TYPE may be a class template.  */
8776
8777 tree
8778 check_elaborated_type_specifier (enum tag_types tag_code,
8779                                  tree decl,
8780                                  bool allow_template_p)
8781 {
8782   tree type;
8783
8784   /* In the case of:
8785
8786        struct S { struct S *p; };
8787
8788      name lookup will find the TYPE_DECL for the implicit "S::S"
8789      typedef.  Adjust for that here.  */
8790   if (DECL_SELF_REFERENCE_P (decl))
8791     decl = TYPE_NAME (TREE_TYPE (decl));
8792
8793   type = TREE_TYPE (decl);
8794
8795   /*   [dcl.type.elab]
8796
8797        If the identifier resolves to a typedef-name or a template
8798        type-parameter, the elaborated-type-specifier is ill-formed.
8799
8800      In other words, the only legitimate declaration to use in the
8801      elaborated type specifier is the implicit typedef created when
8802      the type is declared.  */
8803   if (!DECL_IMPLICIT_TYPEDEF_P (decl))
8804     {
8805       error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code));
8806       return IS_AGGR_TYPE (type) ? type : error_mark_node;
8807     }
8808
8809   if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8810     {
8811       error ("using template type parameter `%T' after `%s'",
8812              type, tag_name (tag_code));
8813       return error_mark_node;
8814     }
8815   else if (TREE_CODE (type) != RECORD_TYPE
8816            && TREE_CODE (type) != UNION_TYPE
8817            && tag_code != enum_type)
8818     {
8819       error ("`%T' referred to as `%s'", type, tag_name (tag_code));
8820       return error_mark_node;
8821     }
8822   else if (TREE_CODE (type) != ENUMERAL_TYPE
8823            && tag_code == enum_type)
8824     {
8825       error ("`%T' referred to as enum", type);
8826       return error_mark_node;
8827     }
8828   else if (!allow_template_p
8829            && TREE_CODE (type) == RECORD_TYPE
8830            && CLASSTYPE_IS_TEMPLATE (type))
8831     {
8832       /* If a class template appears as elaborated type specifier
8833          without a template header such as:
8834
8835            template <class T> class C {};
8836            void f(class C);             // No template header here
8837
8838          then the required template argument is missing.  */
8839
8840       error ("template argument required for `%s %T'",
8841              tag_name (tag_code),
8842              DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
8843       return error_mark_node;
8844     }
8845
8846   return type;
8847 }
8848
8849 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8850    Define the tag as a forward-reference if it is not defined.
8851
8852    If a declaration is given, process it here, and report an error if
8853    multiple declarations are not identical.
8854
8855    GLOBALIZE is false when this is also a definition.  Only look in
8856    the current frame for the name (since C++ allows new names in any
8857    scope.)
8858
8859    TEMPLATE_HEADER_P is true when this declaration is preceded by
8860    a set of template parameters.  */
8861
8862 tree
8863 xref_tag (enum tag_types tag_code, tree name,
8864           bool globalize, bool template_header_p)
8865 {
8866   enum tree_code code;
8867   tree t;
8868   struct cp_binding_level *b = current_binding_level;
8869   tree context = NULL_TREE;
8870
8871   timevar_push (TV_NAME_LOOKUP);
8872
8873   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
8874
8875   switch (tag_code)
8876     {
8877     case record_type:
8878     case class_type:
8879       code = RECORD_TYPE;
8880       break;
8881     case union_type:
8882       code = UNION_TYPE;
8883       break;
8884     case enum_type:
8885       code = ENUMERAL_TYPE;
8886       break;
8887     default:
8888       abort ();
8889     }
8890
8891   if (! globalize)
8892     {
8893       /* If we know we are defining this tag, only look it up in
8894          this scope and don't try to find it as a type.  */
8895       t = lookup_tag (code, name, b, 1);
8896     }
8897   else
8898     {
8899       tree decl = lookup_name (name, 2);
8900
8901       if (decl && DECL_CLASS_TEMPLATE_P (decl))
8902         decl = DECL_TEMPLATE_RESULT (decl);
8903
8904       if (decl && TREE_CODE (decl) == TYPE_DECL)
8905         {
8906           /* Two cases we need to consider when deciding if a class
8907              template is allowed as an elaborated type specifier:
8908              1. It is a self reference to its own class.
8909              2. It comes with a template header.
8910
8911              For example:
8912
8913                template <class T> class C {
8914                  class C *c1;           // DECL_SELF_REFERENCE_P is true
8915                  class D;
8916                };
8917                template <class U> class C; // template_header_p is true
8918                template <class T> class C<T>::D {
8919                  class C *c2;           // DECL_SELF_REFERENCE_P is true
8920                };  */
8921
8922           t = check_elaborated_type_specifier (tag_code,
8923                                                decl,
8924                                                template_header_p
8925                                                | DECL_SELF_REFERENCE_P (decl));
8926           if (t == error_mark_node)
8927             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8928         }
8929       else
8930         t = NULL_TREE;
8931
8932       if (t && current_class_type
8933           && template_class_depth (current_class_type)
8934           && template_header_p)
8935         {
8936           /* Since GLOBALIZE is nonzero, we are not looking at a
8937              definition of this tag.  Since, in addition, we are currently
8938              processing a (member) template declaration of a template
8939              class, we must be very careful; consider:
8940
8941                template <class X>
8942                struct S1
8943
8944                template <class U>
8945                struct S2
8946                { template <class V>
8947                friend struct S1; };
8948
8949              Here, the S2::S1 declaration should not be confused with the
8950              outer declaration.  In particular, the inner version should
8951              have a template parameter of level 2, not level 1.  This
8952              would be particularly important if the member declaration
8953              were instead:
8954
8955                template <class V = U> friend struct S1;
8956
8957              say, when we should tsubst into `U' when instantiating
8958              S2.  On the other hand, when presented with:
8959
8960                  template <class T>
8961                  struct S1 {
8962                    template <class U>
8963                    struct S2 {};
8964                    template <class U>
8965                    friend struct S2;
8966                  };
8967
8968               we must find the inner binding eventually.  We
8969               accomplish this by making sure that the new type we
8970               create to represent this declaration has the right
8971               TYPE_CONTEXT.  */
8972           context = TYPE_CONTEXT (t);
8973           t = NULL_TREE;
8974         }
8975     }
8976
8977   if (! t)
8978     {
8979       /* If no such tag is yet defined, create a forward-reference node
8980          and record it as the "definition".
8981          When a real declaration of this type is found,
8982          the forward-reference will be altered into a real type.  */
8983       if (code == ENUMERAL_TYPE)
8984         {
8985           error ("use of enum `%#D' without previous declaration", name);
8986           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8987         }
8988       else
8989         {
8990           t = make_aggr_type (code);
8991           TYPE_CONTEXT (t) = context;
8992           pushtag (name, t, globalize);
8993         }
8994     }
8995   else
8996     {
8997       if (!globalize && processing_template_decl && IS_AGGR_TYPE (t))
8998         redeclare_class_template (t, current_template_parms);
8999       else if (!processing_template_decl
9000                && CLASS_TYPE_P (t)
9001                && CLASSTYPE_IS_TEMPLATE (t))
9002         {
9003           error ("redeclaration of `%T' as a non-template", t);
9004           t = error_mark_node;
9005         }
9006     }
9007
9008   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9009 }
9010
9011 tree
9012 xref_tag_from_type (tree old, tree id, int globalize)
9013 {
9014   enum tag_types tag_kind;
9015
9016   if (TREE_CODE (old) == RECORD_TYPE)
9017     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9018   else
9019     tag_kind  = union_type;
9020
9021   if (id == NULL_TREE)
9022     id = TYPE_IDENTIFIER (old);
9023
9024   return xref_tag (tag_kind, id, globalize, false);
9025 }
9026
9027 /* REF is a type (named NAME), for which we have just seen some
9028    baseclasses.  BASE_LIST is a list of those baseclasses; the
9029    TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
9030    the base-class.  Non-NULL TREE_TYPE indicates virtual inheritance.
9031    CODE_TYPE_NODE indicates whether REF is a class, struct, or
9032    union.  */
9033
9034 void
9035 xref_basetypes (tree ref, tree base_list)
9036 {
9037   /* In the declaration `A : X, Y, ... Z' we mark all the types
9038      (A, X, Y, ..., Z) so we can check for duplicates.  */
9039   tree *basep;
9040   unsigned max_vbases = 0;
9041   int i;
9042   enum tag_types tag_code;
9043
9044   if (ref == error_mark_node)
9045     return;
9046
9047   tag_code = TREE_CODE (ref) == UNION_TYPE ? union_type
9048     : (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
9049
9050   /* First, make sure that any templates in base-classes are
9051      instantiated.  This ensures that if we call ourselves recursively
9052      we do not get confused about which classes are marked and which
9053      are not.  */
9054   basep = &base_list;
9055   while (*basep)
9056     {
9057       tree basetype = TREE_VALUE (*basep);
9058
9059       if (!(processing_template_decl && uses_template_parms (basetype))
9060           && !complete_type_or_else (basetype, NULL))
9061         /* An incomplete type.  Remove it from the list.  */
9062         *basep = TREE_CHAIN (*basep);
9063       else
9064         basep = &TREE_CHAIN (*basep);
9065     }
9066
9067   SET_CLASSTYPE_MARKED (ref);
9068   i = list_length (base_list);
9069   /* The binfo slot should be empty, unless this is an (ill-formed)
9070      redefinition.  */
9071   my_friendly_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref), 20040706);
9072   my_friendly_assert (TYPE_MAIN_VARIANT (ref) == ref, 20040712);
9073   TYPE_BINFO (ref) = make_tree_binfo (BINFO_LANG_SLOTS);
9074   BINFO_OFFSET (TYPE_BINFO (ref)) = size_zero_node;
9075   BINFO_TYPE (TYPE_BINFO (ref)) = ref;
9076
9077   if (i)
9078     {
9079       tree binfo = TYPE_BINFO (ref);
9080       tree binfos = make_tree_vec (i);
9081       tree accesses = make_tree_vec (i);
9082
9083       BINFO_BASE_BINFOS (binfo) = binfos;
9084       BINFO_BASE_ACCESSES (binfo) = accesses;
9085
9086       for (i = 0; base_list; base_list = TREE_CHAIN (base_list))
9087         {
9088           tree access = TREE_PURPOSE (base_list);
9089           int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9090           tree basetype = TREE_VALUE (base_list);
9091           tree base_binfo;
9092
9093           if (via_virtual)
9094             max_vbases++;
9095           if (access == access_default_node)
9096             /* The base of a derived struct is public by default.  */
9097             access = (tag_code == class_type
9098                       ? access_private_node : access_public_node);
9099
9100           if (basetype && TREE_CODE (basetype) == TYPE_DECL)
9101             basetype = TREE_TYPE (basetype);
9102           if (!basetype
9103               || (TREE_CODE (basetype) != RECORD_TYPE
9104                   && TREE_CODE (basetype) != TYPENAME_TYPE
9105                   && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9106                   && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
9107             {
9108               error ("base type `%T' fails to be a struct or class type",
9109                      basetype);
9110               continue;
9111             }
9112
9113           if (CLASSTYPE_MARKED (basetype))
9114             {
9115               if (basetype == ref)
9116                 error ("recursive type `%T' undefined", basetype);
9117               else
9118                 error ("duplicate base type `%T' invalid", basetype);
9119               continue;
9120             }
9121
9122           if (TYPE_FOR_JAVA (basetype)
9123               && (current_lang_depth () == 0))
9124             TYPE_FOR_JAVA (ref) = 1;
9125
9126           if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9127             {
9128               base_binfo = TYPE_BINFO (basetype);
9129
9130               my_friendly_assert (base_binfo, 20040706);
9131             }
9132           else
9133             {
9134               base_binfo = make_tree_binfo (BINFO_LANG_SLOTS);
9135
9136               BINFO_TYPE (base_binfo) = basetype;
9137               BINFO_DEPENDENT_BASE_P (base_binfo) = 1;
9138             }
9139
9140           TREE_VEC_ELT (binfos, i) = base_binfo;
9141           TREE_VEC_ELT (accesses, i) = access;
9142           /* This flag will be in the binfo of the base type, we must
9143              clear it after copying the base binfos.  */
9144           BINFO_VIRTUAL_P (base_binfo) = via_virtual;
9145
9146           SET_CLASSTYPE_MARKED (basetype);
9147
9148           /* We are free to modify these bits because they are meaningless
9149              at top level, and BASETYPE is a top-level type.  */
9150           if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
9151             {
9152               TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
9153               /* Converting to a virtual base class requires looking
9154                  up the offset of the virtual base.  */
9155               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9156             }
9157
9158           if (CLASS_TYPE_P (basetype))
9159             {
9160               TYPE_HAS_NEW_OPERATOR (ref)
9161                 |= TYPE_HAS_NEW_OPERATOR (basetype);
9162               TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9163                 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9164               TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9165               /* If the base-class uses multiple inheritance, so do we.  */
9166               TYPE_USES_MULTIPLE_INHERITANCE (ref)
9167                 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
9168               /* Likewise, if converting to a base of the base may require
9169                  code, then we may need to generate code to convert to a
9170                  base as well.  */
9171               TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
9172                 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
9173               max_vbases += VEC_length
9174                 (tree, CLASSTYPE_VBASECLASSES (basetype));
9175             }
9176           i++;
9177         }
9178       if (i)
9179         TREE_VEC_LENGTH (accesses) = TREE_VEC_LENGTH (binfos) = i;
9180       else
9181         BINFO_BASE_ACCESSES (binfo) = BINFO_BASE_BINFOS (binfo) = NULL_TREE;
9182       if (max_vbases)
9183         CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, max_vbases);
9184
9185       if (i > 1)
9186         {
9187           TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
9188           /* If there is more than one non-empty they cannot be at the same
9189              address.  */
9190           TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9191         }
9192     }
9193
9194   /* Copy the base binfos, collect the virtual bases and set the
9195      inheritance order chain.  */
9196   copy_base_binfos (TYPE_BINFO (ref), ref, NULL_TREE);
9197
9198   if (TREE_CODE (ref) == UNION_TYPE)
9199     {
9200       if (i)
9201         error ("derived union `%T' invalid", ref);
9202     }
9203
9204   if (TYPE_FOR_JAVA (ref))
9205     {
9206       if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
9207         error ("Java class '%T' cannot have multiple bases", ref);
9208       if (CLASSTYPE_VBASECLASSES (ref))
9209         error ("Java class '%T' cannot have virtual bases", ref);
9210     }
9211
9212   /* Unmark all the types.  */
9213   while (i--)
9214     {
9215       tree binfo = BINFO_BASE_BINFO (TYPE_BINFO (ref), i);
9216       tree basetype = BINFO_TYPE (binfo);
9217
9218       CLEAR_CLASSTYPE_MARKED (basetype);
9219       if (!BINFO_DEPENDENT_BASE_P (binfo))
9220         BINFO_VIRTUAL_P (TYPE_BINFO (basetype)) = 0;
9221     }
9222   CLEAR_CLASSTYPE_MARKED (ref);
9223 }
9224
9225 \f
9226 /* Begin compiling the definition of an enumeration type.
9227    NAME is its name (or null if anonymous).
9228    Returns the type object, as yet incomplete.
9229    Also records info about it so that build_enumerator
9230    may be used to declare the individual values as they are read.  */
9231
9232 tree
9233 start_enum (tree name)
9234 {
9235   tree enumtype = NULL_TREE;
9236   struct cp_binding_level *b = current_binding_level;
9237
9238   /* If this is the real definition for a previous forward reference,
9239      fill in the contents in the same object that used to be the
9240      forward reference.  */
9241
9242   if (name != NULL_TREE)
9243     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
9244
9245   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9246     {
9247       error ("multiple definition of `%#T'", enumtype);
9248       error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9249       /* Clear out TYPE_VALUES, and start again.  */
9250       TYPE_VALUES (enumtype) = NULL_TREE;
9251     }
9252   else
9253     {
9254       enumtype = make_node (ENUMERAL_TYPE);
9255       pushtag (name, enumtype, 0);
9256     }
9257
9258   return enumtype;
9259 }
9260
9261 /* After processing and defining all the values of an enumeration type,
9262    install their decls in the enumeration type and finish it off.
9263    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
9264
9265 void
9266 finish_enum (tree enumtype)
9267 {
9268   tree values;
9269   tree decl;
9270   tree value;
9271   tree minnode;
9272   tree maxnode;
9273   tree t;
9274   bool unsignedp;
9275   int lowprec;
9276   int highprec;
9277   int precision;
9278   integer_type_kind itk;
9279   tree underlying_type = NULL_TREE;
9280
9281   /* We built up the VALUES in reverse order.  */
9282   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9283
9284   /* For an enum defined in a template, just set the type of the values;
9285      all further processing is postponed until the template is
9286      instantiated.  We need to set the type so that tsubst of a CONST_DECL
9287      works.  */
9288   if (processing_template_decl)
9289     {
9290       for (values = TYPE_VALUES (enumtype);
9291            values;
9292            values = TREE_CHAIN (values))
9293         TREE_TYPE (TREE_VALUE (values)) = enumtype;
9294       if (at_function_scope_p ())
9295         add_stmt (build_min (TAG_DEFN, enumtype));
9296       return;
9297     }
9298
9299   /* Determine the minimum and maximum values of the enumerators.  */
9300   if (TYPE_VALUES (enumtype))
9301     {
9302       minnode = maxnode = NULL_TREE;
9303
9304       for (values = TYPE_VALUES (enumtype);
9305            values;
9306            values = TREE_CHAIN (values))
9307         {
9308           decl = TREE_VALUE (values);
9309
9310           /* [dcl.enum]: Following the closing brace of an enum-specifier,
9311              each enumerator has the type of its enumeration.  Prior to the
9312              closing brace, the type of each enumerator is the type of its
9313              initializing value.  */
9314           TREE_TYPE (decl) = enumtype;
9315
9316           /* Update the minimum and maximum values, if appropriate.  */
9317           value = DECL_INITIAL (decl);
9318           /* Figure out what the minimum and maximum values of the
9319              enumerators are.  */
9320           if (!minnode)
9321             minnode = maxnode = value;
9322           else if (tree_int_cst_lt (maxnode, value))
9323             maxnode = value;
9324           else if (tree_int_cst_lt (value, minnode))
9325             minnode = value;
9326
9327           /* Set the TREE_TYPE for the values as well.  That's so that when
9328              we call decl_constant_value we get an entity of the right type
9329              (but with the constant value).  But first make a copy so we
9330              don't clobber shared INTEGER_CSTs.  */
9331           if (TREE_TYPE (value) != enumtype)
9332             {
9333               value = DECL_INITIAL (decl) = copy_node (value);
9334               TREE_TYPE (value) = enumtype;
9335             }
9336         }
9337     }
9338   else
9339     /* [dcl.enum]
9340
9341        If the enumerator-list is empty, the underlying type is as if
9342        the enumeration had a single enumerator with value 0.  */
9343     minnode = maxnode = integer_zero_node;
9344
9345   /* Compute the number of bits require to represent all values of the
9346      enumeration.  We must do this before the type of MINNODE and
9347      MAXNODE are transformed, since min_precision relies on the
9348      TREE_TYPE of the value it is passed.  */
9349   unsignedp = tree_int_cst_sgn (minnode) >= 0;
9350   lowprec = min_precision (minnode, unsignedp);
9351   highprec = min_precision (maxnode, unsignedp);
9352   precision = MAX (lowprec, highprec);
9353
9354   /* Determine the underlying type of the enumeration.
9355
9356        [dcl.enum]
9357
9358        The underlying type of an enumeration is an integral type that
9359        can represent all the enumerator values defined in the
9360        enumeration.  It is implementation-defined which integral type is
9361        used as the underlying type for an enumeration except that the
9362        underlying type shall not be larger than int unless the value of
9363        an enumerator cannot fit in an int or unsigned int.
9364
9365      We use "int" or an "unsigned int" as the underlying type, even if
9366      a smaller integral type would work, unless the user has
9367      explicitly requested that we use the smallest possible type.  */
9368   for (itk = (flag_short_enums ? itk_char : itk_int);
9369        itk != itk_none;
9370        itk++)
9371     {
9372       underlying_type = integer_types[itk];
9373       if (TYPE_PRECISION (underlying_type) >= precision
9374           && TYPE_UNSIGNED (underlying_type) == unsignedp)
9375         break;
9376     }
9377   if (itk == itk_none)
9378     {
9379       /* DR 377
9380
9381          IF no integral type can represent all the enumerator values, the
9382          enumeration is ill-formed.  */
9383       error ("no integral type can represent all of the enumerator values "
9384              "for `%T'", enumtype);
9385       precision = TYPE_PRECISION (long_long_integer_type_node);
9386       underlying_type = integer_types[itk_unsigned_long_long];
9387     }
9388
9389   /* Compute the minium and maximum values for the type.
9390
9391      [dcl.enum]
9392
9393      For an enumeration where emin is the smallest enumerator and emax
9394      is the largest, the values of the enumeration are the values of the
9395      underlying type in the range bmin to bmax, where bmin and bmax are,
9396      respectively, the smallest and largest values of the smallest bit-
9397      field that can store emin and emax.  */
9398   TYPE_PRECISION (enumtype) = precision;
9399   set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9400
9401   /* [dcl.enum]
9402
9403      The value of sizeof() applied to an enumeration type, an object
9404      of an enumeration type, or an enumerator, is the value of sizeof()
9405      applied to the underlying type.  */
9406   TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9407   TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9408   TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9409   TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9410   TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9411   TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9412
9413   /* Convert each of the enumerators to the type of the underlying
9414      type of the enumeration.  */
9415   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9416     {
9417       decl = TREE_VALUE (values);
9418       value = perform_implicit_conversion (underlying_type,
9419                                            DECL_INITIAL (decl));
9420       TREE_TYPE (value) = enumtype;
9421       DECL_INITIAL (decl) = value;
9422       TREE_VALUE (values) = value;
9423     }
9424
9425   /* Fix up all variant types of this enum type.  */
9426   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9427     {
9428       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9429       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9430       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9431       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9432       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9433       TYPE_MODE (t) = TYPE_MODE (enumtype);
9434       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9435       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9436       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9437       TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9438     }
9439
9440   /* Finish debugging output for this type.  */
9441   rest_of_type_compilation (enumtype, namespace_bindings_p ());
9442 }
9443
9444 /* Build and install a CONST_DECL for an enumeration constant of the
9445    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9446    Assignment of sequential values by default is handled here.  */
9447
9448 void
9449 build_enumerator (tree name, tree value, tree enumtype)
9450 {
9451   tree decl;
9452   tree context;
9453   tree type;
9454
9455   /* Remove no-op casts from the value.  */
9456   if (value)
9457     STRIP_TYPE_NOPS (value);
9458
9459   if (! processing_template_decl)
9460     {
9461       /* Validate and default VALUE.  */
9462       if (value != NULL_TREE)
9463         {
9464           value = decl_constant_value (value);
9465
9466           if (TREE_CODE (value) == INTEGER_CST)
9467             {
9468               value = perform_integral_promotions (value);
9469               constant_expression_warning (value);
9470             }
9471           else
9472             {
9473               error ("enumerator value for `%D' not integer constant", name);
9474               value = NULL_TREE;
9475             }
9476         }
9477
9478       /* Default based on previous value.  */
9479       if (value == NULL_TREE)
9480         {
9481           tree prev_value;
9482
9483           if (TYPE_VALUES (enumtype))
9484             {
9485               /* The next value is the previous value ...  */
9486               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9487               /* ... plus one.  */
9488               value = cp_build_binary_op (PLUS_EXPR,
9489                                           prev_value,
9490                                           integer_one_node);
9491
9492               if (tree_int_cst_lt (value, prev_value))
9493                 error ("overflow in enumeration values at `%D'", name);
9494             }
9495           else
9496             value = integer_zero_node;
9497         }
9498
9499       /* Remove no-op casts from the value.  */
9500       STRIP_TYPE_NOPS (value);
9501     }
9502
9503   /* C++ associates enums with global, function, or class declarations.  */
9504   context = current_scope ();
9505   if (!context)
9506     context = current_namespace;
9507
9508   /* Build the actual enumeration constant.  Note that the enumeration
9509     constants have the type of their initializers until the
9510     enumeration is complete:
9511
9512       [ dcl.enum ]
9513
9514       Following the closing brace of an enum-specifier, each enumer-
9515       ator has the type of its enumeration.  Prior to the closing
9516       brace, the type of each enumerator is the type of its
9517       initializing value.
9518
9519     In finish_enum we will reset the type.  Of course, if we're
9520     processing a template, there may be no value.  */
9521   type = value ? TREE_TYPE (value) : NULL_TREE;
9522
9523   if (context && context == current_class_type)
9524     /* This enum declaration is local to the class.  We need the full
9525        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
9526     decl = build_lang_decl (CONST_DECL, name, type);
9527   else
9528     /* It's a global enum, or it's local to a function.  (Note local to
9529       a function could mean local to a class method.  */
9530     decl = build_decl (CONST_DECL, name, type);
9531
9532   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9533   TREE_CONSTANT (decl) = 1;
9534   TREE_INVARIANT (decl) = 1;
9535   TREE_READONLY (decl) = 1;
9536   DECL_INITIAL (decl) = value;
9537
9538   if (context && context == current_class_type)
9539     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9540        on the TYPE_FIELDS list for `S'.  (That's so that you can say
9541        things like `S::i' later.)  */
9542     finish_member_declaration (decl);
9543   else
9544     pushdecl (decl);
9545
9546   /* Add this enumeration constant to the list for this type.  */
9547   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
9548 }
9549
9550 \f
9551 /* We're defining DECL.  Make sure that it's type is OK.  */
9552
9553 static void
9554 check_function_type (tree decl, tree current_function_parms)
9555 {
9556   tree fntype = TREE_TYPE (decl);
9557   tree return_type = complete_type (TREE_TYPE (fntype));
9558
9559   /* In a function definition, arg types must be complete.  */
9560   require_complete_types_for_parms (current_function_parms);
9561
9562   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
9563     {
9564       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
9565
9566       /* Make it return void instead, but don't change the
9567          type of the DECL_RESULT, in case we have a named return value.  */
9568       if (TREE_CODE (fntype) == METHOD_TYPE)
9569         {
9570           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
9571           TREE_TYPE (decl)
9572             = build_method_type_directly (ctype,
9573                                           void_type_node,
9574                                           FUNCTION_ARG_CHAIN (decl));
9575         }
9576       else
9577         TREE_TYPE (decl)
9578           = build_function_type (void_type_node,
9579                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
9580       TREE_TYPE (decl)
9581         = build_exception_variant (fntype,
9582                                    TYPE_RAISES_EXCEPTIONS (fntype));
9583     }
9584   else
9585     abstract_virtuals_error (decl, TREE_TYPE (fntype));
9586 }
9587
9588 /* Create the FUNCTION_DECL for a function definition.
9589    DECLSPECS and DECLARATOR are the parts of the declaration;
9590    they describe the function's name and the type it returns,
9591    but twisted together in a fashion that parallels the syntax of C.
9592
9593    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9594    DECLARATOR is really the DECL for the function we are about to
9595    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9596    indicating that the function is an inline defined in-class.
9597
9598    This function creates a binding context for the function body
9599    as well as setting up the FUNCTION_DECL in current_function_decl.
9600
9601    For C++, we must first check whether that datum makes any sense.
9602    For example, "class A local_a(1,2);" means that variable local_a
9603    is an aggregate of type A, which should have a constructor
9604    applied to it with the argument list [1, 2].  */
9605
9606 void
9607 start_preparsed_function (tree decl1, tree attrs, int flags)
9608 {
9609   tree ctype = NULL_TREE;
9610   tree fntype;
9611   tree restype;
9612   int doing_friend = 0;
9613   struct cp_binding_level *bl;
9614   tree current_function_parms;
9615
9616   /* Sanity check.  */
9617   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
9618   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
9619
9620   fntype = TREE_TYPE (decl1);
9621   if (TREE_CODE (fntype) == METHOD_TYPE)
9622     ctype = TYPE_METHOD_BASETYPE (fntype);
9623
9624   /* ISO C++ 11.4/5.  A friend function defined in a class is in
9625      the (lexical) scope of the class in which it is defined.  */
9626   if (!ctype && DECL_FRIEND_P (decl1))
9627     {
9628       ctype = DECL_FRIEND_CONTEXT (decl1);
9629
9630       /* CTYPE could be null here if we're dealing with a template;
9631          for example, `inline friend float foo()' inside a template
9632          will have no CTYPE set.  */
9633       if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
9634         ctype = NULL_TREE;
9635       else
9636         doing_friend = 1;
9637     }
9638
9639   if (DECL_DECLARED_INLINE_P (decl1)
9640       && lookup_attribute ("noinline", attrs))
9641     warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
9642
9643   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
9644     /* This is a constructor, we must ensure that any default args
9645        introduced by this definition are propagated to the clones
9646        now. The clones are used directly in overload resolution.  */
9647     adjust_clone_args (decl1);
9648
9649   /* Sometimes we don't notice that a function is a static member, and
9650      build a METHOD_TYPE for it.  Fix that up now.  */
9651   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
9652       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
9653     {
9654       revert_static_member_fn (decl1);
9655       ctype = NULL_TREE;
9656     }
9657
9658   /* Set up current_class_type, and enter the scope of the class, if
9659      appropriate.  */
9660   if (ctype)
9661     push_nested_class (ctype);
9662   else if (DECL_STATIC_FUNCTION_P (decl1))
9663     push_nested_class (DECL_CONTEXT (decl1));
9664
9665   /* Now that we have entered the scope of the class, we must restore
9666      the bindings for any template parameters surrounding DECL1, if it
9667      is an inline member template.  (Order is important; consider the
9668      case where a template parameter has the same name as a field of
9669      the class.)  It is not until after this point that
9670      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
9671   if (flags & SF_INCLASS_INLINE)
9672     maybe_begin_member_template_processing (decl1);
9673
9674   /* Effective C++ rule 15.  */
9675   if (warn_ecpp
9676       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9677       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
9678     warning ("`operator=' should return a reference to `*this'");
9679
9680   /* Make the init_value nonzero so pushdecl knows this is not tentative.
9681      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
9682   if (!DECL_INITIAL (decl1))
9683     DECL_INITIAL (decl1) = error_mark_node;
9684
9685   /* This function exists in static storage.
9686      (This does not mean `static' in the C sense!)  */
9687   TREE_STATIC (decl1) = 1;
9688
9689   /* We must call push_template_decl after current_class_type is set
9690      up.  (If we are processing inline definitions after exiting a
9691      class scope, current_class_type will be NULL_TREE until set above
9692      by push_nested_class.)  */
9693   if (processing_template_decl)
9694     decl1 = push_template_decl (decl1);
9695
9696   /* We are now in the scope of the function being defined.  */
9697   current_function_decl = decl1;
9698
9699   /* Save the parm names or decls from this function's declarator
9700      where store_parm_decls will find them.  */
9701   current_function_parms = DECL_ARGUMENTS (decl1);
9702
9703   /* Make sure the parameter and return types are reasonable.  When
9704      you declare a function, these types can be incomplete, but they
9705      must be complete when you define the function.  */
9706   if (! processing_template_decl)
9707     check_function_type (decl1, current_function_parms);
9708
9709   /* Build the return declaration for the function.  */
9710   restype = TREE_TYPE (fntype);
9711   /* Promote the value to int before returning it.  */
9712   if (c_promoting_integer_type_p (restype))
9713     restype = type_promotes_to (restype);
9714   if (DECL_RESULT (decl1) == NULL_TREE)
9715     {
9716       DECL_RESULT (decl1)
9717         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
9718       c_apply_type_quals_to_decl (cp_type_quals (restype),
9719                                   DECL_RESULT (decl1));
9720     }
9721
9722   /* Initialize RTL machinery.  We cannot do this until
9723      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
9724      even when processing a template; this is how we get
9725      CFUN set up, and our per-function variables initialized.
9726      FIXME factor out the non-RTL stuff.  */
9727   bl = current_binding_level;
9728   allocate_struct_function (decl1);
9729   current_binding_level = bl;
9730
9731   /* Even though we're inside a function body, we still don't want to
9732      call expand_expr to calculate the size of a variable-sized array.
9733      We haven't necessarily assigned RTL to all variables yet, so it's
9734      not safe to try to expand expressions involving them.  */
9735   cfun->x_dont_save_pending_sizes_p = 1;
9736
9737   /* Start the statement-tree, start the tree now.  */
9738   DECL_SAVED_TREE (decl1) = push_stmt_list ();
9739
9740   /* Let the user know we're compiling this function.  */
9741   announce_function (decl1);
9742
9743   /* Record the decl so that the function name is defined.
9744      If we already have a decl for this name, and it is a FUNCTION_DECL,
9745      use the old decl.  */
9746   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
9747     {
9748       /* A specialization is not used to guide overload resolution.  */
9749       if (!DECL_FUNCTION_MEMBER_P (decl1)
9750           && !(DECL_USE_TEMPLATE (decl1) &&
9751                PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
9752         {
9753           tree olddecl = pushdecl (decl1);
9754
9755           if (olddecl == error_mark_node)
9756             /* If something went wrong when registering the declaration,
9757                use DECL1; we have to have a FUNCTION_DECL to use when
9758                parsing the body of the function.  */
9759             ;
9760           else
9761             /* Otherwise, OLDDECL is either a previous declaration of
9762                the same function or DECL1 itself.  */
9763             decl1 = olddecl;
9764         }
9765       else
9766         {
9767           /* We need to set the DECL_CONTEXT.  */
9768           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
9769             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
9770           /* And make sure we have enough default args.  */
9771           check_default_args (decl1);
9772         }
9773       fntype = TREE_TYPE (decl1);
9774     }
9775
9776   /* Reset these in case the call to pushdecl changed them.  */
9777   current_function_decl = decl1;
9778   cfun->decl = decl1;
9779
9780   /* If we are (erroneously) defining a function that we have already
9781      defined before, wipe out what we knew before.  */
9782   if (!DECL_PENDING_INLINE_P (decl1))
9783     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
9784
9785   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
9786     {
9787       /* We know that this was set up by `grokclassfn'.  We do not
9788          wait until `store_parm_decls', since evil parse errors may
9789          never get us to that point.  Here we keep the consistency
9790          between `current_class_type' and `current_class_ptr'.  */
9791       tree t = DECL_ARGUMENTS (decl1);
9792
9793       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
9794                           162);
9795       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
9796                           19990811);
9797
9798       cp_function_chain->x_current_class_ref
9799         = build_indirect_ref (t, NULL);
9800       cp_function_chain->x_current_class_ptr = t;
9801
9802       /* Constructors and destructors need to know whether they're "in
9803          charge" of initializing virtual base classes.  */
9804       t = TREE_CHAIN (t);
9805       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
9806         {
9807           current_in_charge_parm = t;
9808           t = TREE_CHAIN (t);
9809         }
9810       if (DECL_HAS_VTT_PARM_P (decl1))
9811         {
9812           if (DECL_NAME (t) != vtt_parm_identifier)
9813             abort ();
9814           current_vtt_parm = t;
9815         }
9816     }
9817
9818   if (DECL_INTERFACE_KNOWN (decl1))
9819     {
9820       tree ctx = decl_function_context (decl1);
9821
9822       if (DECL_NOT_REALLY_EXTERN (decl1))
9823         DECL_EXTERNAL (decl1) = 0;
9824
9825       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
9826           && TREE_PUBLIC (ctx))
9827         /* This is a function in a local class in an extern inline
9828            function.  */
9829         comdat_linkage (decl1);
9830     }
9831   /* If this function belongs to an interface, it is public.
9832      If it belongs to someone else's interface, it is also external.
9833      This only affects inlines and template instantiations.  */
9834   else if (interface_unknown == 0
9835            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9836     {
9837       if (DECL_DECLARED_INLINE_P (decl1)
9838           || DECL_TEMPLATE_INSTANTIATION (decl1)
9839           || processing_template_decl)
9840         {
9841           DECL_EXTERNAL (decl1)
9842             = (interface_only
9843                || (DECL_DECLARED_INLINE_P (decl1)
9844                    && ! flag_implement_inlines
9845                    && !DECL_VINDEX (decl1)));
9846
9847           /* For WIN32 we also want to put these in linkonce sections.  */
9848           maybe_make_one_only (decl1);
9849         }
9850       else
9851         DECL_EXTERNAL (decl1) = 0;
9852       DECL_NOT_REALLY_EXTERN (decl1) = 0;
9853       DECL_INTERFACE_KNOWN (decl1) = 1;
9854     }
9855   else if (interface_unknown && interface_only
9856            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9857     {
9858       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
9859          interface, we will have interface_only set but not
9860          interface_known.  In that case, we don't want to use the normal
9861          heuristics because someone will supply a #pragma implementation
9862          elsewhere, and deducing it here would produce a conflict.  */
9863       comdat_linkage (decl1);
9864       DECL_EXTERNAL (decl1) = 0;
9865       DECL_INTERFACE_KNOWN (decl1) = 1;
9866       DECL_DEFER_OUTPUT (decl1) = 1;
9867     }
9868   else
9869     {
9870       /* This is a definition, not a reference.
9871          So clear DECL_EXTERNAL.  */
9872       DECL_EXTERNAL (decl1) = 0;
9873
9874       if ((DECL_DECLARED_INLINE_P (decl1)
9875            || DECL_TEMPLATE_INSTANTIATION (decl1))
9876           && ! DECL_INTERFACE_KNOWN (decl1)
9877           /* Don't try to defer nested functions for now.  */
9878           && ! decl_function_context (decl1))
9879         DECL_DEFER_OUTPUT (decl1) = 1;
9880       else
9881         DECL_INTERFACE_KNOWN (decl1) = 1;
9882     }
9883
9884   begin_scope (sk_function_parms, decl1);
9885
9886   ++function_depth;
9887
9888   if (DECL_DESTRUCTOR_P (decl1))
9889     {
9890       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
9891       DECL_CONTEXT (dtor_label) = current_function_decl;
9892     }
9893
9894   start_fname_decls ();
9895
9896   store_parm_decls (current_function_parms);
9897 }
9898
9899
9900 /* Like start_preparsed_function, except that instead of a
9901    FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
9902
9903    Returns 1 on success.  If the DECLARATOR is not suitable for a function
9904    (it defines a datum instead), we return 0, which tells
9905    yyparse to report a parse error.  */
9906
9907 int
9908 start_function (cp_decl_specifier_seq *declspecs,
9909                 const cp_declarator *declarator,
9910                 tree attrs)
9911 {
9912   tree decl1;
9913
9914   if (have_extern_spec)
9915     {
9916       declspecs->storage_class = sc_extern;
9917       /* This should only be done once on the outermost decl.  */
9918       have_extern_spec = false;
9919     }
9920
9921   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
9922   /* If the declarator is not suitable for a function definition,
9923      cause a syntax error.  */
9924   if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
9925     return 0;
9926
9927   cplus_decl_attributes (&decl1, attrs, 0);
9928
9929   /* If #pragma weak was used, mark the decl weak now.  */
9930   if (global_scope_p (current_binding_level))
9931     maybe_apply_pragma_weak (decl1);
9932
9933   if (DECL_MAIN_P (decl1))
9934     {
9935       /* If this doesn't return integer_type, or a typedef to
9936          integer_type, complain.  */
9937       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node))
9938         {
9939           if (pedantic || warn_return_type)
9940             pedwarn ("return type for `main' changed to `int'");
9941           TREE_TYPE (decl1) = default_function_type;
9942         }
9943     }
9944
9945   start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
9946
9947   return 1;
9948 }
9949 \f
9950 /* Store the parameter declarations into the current function declaration.
9951    This is called after parsing the parameter declarations, before
9952    digesting the body of the function.
9953
9954    Also install to binding contour return value identifier, if any.  */
9955
9956 static void
9957 store_parm_decls (tree current_function_parms)
9958 {
9959   tree fndecl = current_function_decl;
9960   tree parm;
9961
9962   /* This is a chain of any other decls that came in among the parm
9963      declarations.  If a parm is declared with  enum {foo, bar} x;
9964      then CONST_DECLs for foo and bar are put here.  */
9965   tree nonparms = NULL_TREE;
9966
9967   if (current_function_parms)
9968     {
9969       /* This case is when the function was defined with an ANSI prototype.
9970          The parms already have decls, so we need not do anything here
9971          except record them as in effect
9972          and complain if any redundant old-style parm decls were written.  */
9973
9974       tree specparms = current_function_parms;
9975       tree next;
9976
9977       /* Must clear this because it might contain TYPE_DECLs declared
9978              at class level.  */
9979       current_binding_level->names = NULL;
9980
9981       /* If we're doing semantic analysis, then we'll call pushdecl
9982              for each of these.  We must do them in reverse order so that
9983              they end in the correct forward order.  */
9984       specparms = nreverse (specparms);
9985
9986       for (parm = specparms; parm; parm = next)
9987         {
9988           next = TREE_CHAIN (parm);
9989           if (TREE_CODE (parm) == PARM_DECL)
9990             {
9991               if (DECL_NAME (parm) == NULL_TREE
9992                   || TREE_CODE (parm) != VOID_TYPE)
9993                 pushdecl (parm);
9994               else
9995                 error ("parameter `%D' declared void", parm);
9996             }
9997           else
9998             {
9999               /* If we find an enum constant or a type tag,
10000                  put it aside for the moment.  */
10001               TREE_CHAIN (parm) = NULL_TREE;
10002               nonparms = chainon (nonparms, parm);
10003             }
10004         }
10005
10006       /* Get the decls in their original chain order and record in the
10007          function.  This is all and only the PARM_DECLs that were
10008          pushed into scope by the loop above.  */
10009       DECL_ARGUMENTS (fndecl) = getdecls ();
10010     }
10011   else
10012     DECL_ARGUMENTS (fndecl) = NULL_TREE;
10013
10014   /* Now store the final chain of decls for the arguments
10015      as the decl-chain of the current lexical scope.
10016      Put the enumerators in as well, at the front so that
10017      DECL_ARGUMENTS is not modified.  */
10018   current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10019
10020   /* Do the starting of the exception specifications, if we have any.  */
10021   if (flag_exceptions && !processing_template_decl
10022       && flag_enforce_eh_specs
10023       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10024     current_eh_spec_block = begin_eh_spec_block ();
10025 }
10026
10027 \f
10028 /* We have finished doing semantic analysis on DECL, but have not yet
10029    generated RTL for its body.  Save away our current state, so that
10030    when we want to generate RTL later we know what to do.  */
10031
10032 static void
10033 save_function_data (tree decl)
10034 {
10035   struct language_function *f;
10036
10037   /* Save the language-specific per-function data so that we can
10038      get it back when we really expand this function.  */
10039   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
10040                       19990908);
10041
10042   /* Make a copy.  */
10043   f = ggc_alloc (sizeof (struct language_function));
10044   memcpy (f, cp_function_chain, sizeof (struct language_function));
10045   DECL_SAVED_FUNCTION_DATA (decl) = f;
10046
10047   /* Clear out the bits we don't need.  */
10048   f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10049   f->x_named_label_uses = NULL;
10050   f->bindings = NULL;
10051   f->x_local_names = NULL;
10052 }
10053
10054 /* Add a note to mark the beginning of the main body of the constructor.
10055    This is used to set up the data structures for the cleanup regions for
10056    fully-constructed bases and members.  */
10057
10058 static void
10059 begin_constructor_body (void)
10060 {
10061 }
10062
10063 /* Add a note to mark the end of the main body of the constructor.  This is
10064    used to end the cleanup regions for fully-constructed bases and
10065    members.  */
10066
10067 static void
10068 finish_constructor_body (void)
10069 {
10070 }
10071
10072 /* Do all the processing for the beginning of a destructor; set up the
10073    vtable pointers and cleanups for bases and members.  */
10074
10075 static void
10076 begin_destructor_body (void)
10077 {
10078   tree if_stmt;
10079   tree compound_stmt;
10080
10081   /* If the dtor is empty, and we know there is not any possible
10082      way we could use any vtable entries, before they are possibly
10083      set by a base class dtor, we don't have to setup the vtables,
10084      as we know that any base class dtor will set up any vtables
10085      it needs.  We avoid MI, because one base class dtor can do a
10086      virtual dispatch to an overridden function that would need to
10087      have a non-related vtable set up, we cannot avoid setting up
10088      vtables in that case.  We could change this to see if there
10089      is just one vtable.
10090
10091      ??? In the destructor for a class, the vtables are set
10092      appropriately for that class.  There will be no non-related
10093      vtables.  jason 2001-12-11.  */
10094   if_stmt = begin_if_stmt ();
10095
10096   /* If it is not safe to avoid setting up the vtables, then
10097      someone will change the condition to be boolean_true_node.
10098      (Actually, for now, we do not have code to set the condition
10099      appropriately, so we just assume that we always need to
10100      initialize the vtables.)  */
10101   finish_if_stmt_cond (boolean_true_node, if_stmt);
10102
10103   compound_stmt = begin_compound_stmt (0);
10104
10105   /* Make all virtual function table pointers in non-virtual base
10106      classes point to CURRENT_CLASS_TYPE's virtual function
10107      tables.  */
10108   initialize_vtbl_ptrs (current_class_ptr);
10109
10110   finish_compound_stmt (compound_stmt);
10111   finish_then_clause (if_stmt);
10112   finish_if_stmt (if_stmt);
10113
10114   /* And insert cleanups for our bases and members so that they
10115      will be properly destroyed if we throw.  */
10116   push_base_cleanups ();
10117 }
10118
10119 /* At the end of every destructor we generate code to delete the object if
10120    necessary.  Do that now.  */
10121
10122 static void
10123 finish_destructor_body (void)
10124 {
10125   tree exprstmt;
10126
10127   /* Any return from a destructor will end up here; that way all base
10128      and member cleanups will be run when the function returns.  */
10129   add_stmt (build_stmt (LABEL_EXPR, dtor_label));
10130
10131   /* In a virtual destructor, we must call delete.  */
10132   if (DECL_VIRTUAL_P (current_function_decl))
10133     {
10134       tree if_stmt;
10135       tree virtual_size = cxx_sizeof (current_class_type);
10136
10137       /* [class.dtor]
10138
10139       At the point of definition of a virtual destructor (including
10140       an implicit definition), non-placement operator delete shall
10141       be looked up in the scope of the destructor's class and if
10142       found shall be accessible and unambiguous.  */
10143       exprstmt = build_op_delete_call
10144         (DELETE_EXPR, current_class_ptr, virtual_size,
10145          /*global_p=*/false, NULL_TREE);
10146
10147       if_stmt = begin_if_stmt ();
10148       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
10149                                   current_in_charge_parm,
10150                                   integer_one_node),
10151                            if_stmt);
10152       finish_expr_stmt (exprstmt);
10153       finish_then_clause (if_stmt);
10154       finish_if_stmt (if_stmt);
10155     }
10156 }
10157
10158 /* Do the necessary processing for the beginning of a function body, which
10159    in this case includes member-initializers, but not the catch clauses of
10160    a function-try-block.  Currently, this means opening a binding level
10161    for the member-initializers (in a ctor) and member cleanups (in a dtor).
10162    In other functions, this isn't necessary, but it doesn't hurt.  */
10163
10164 tree
10165 begin_function_body (void)
10166 {
10167   tree stmt;
10168
10169   if (processing_template_decl)
10170     /* Do nothing now.  */;
10171   else
10172     /* Always keep the BLOCK node associated with the outermost pair of
10173        curly braces of a function.  These are needed for correct
10174        operation of dwarfout.c.  */
10175     keep_next_level (true);
10176
10177   stmt = begin_compound_stmt (BCS_FN_BODY);
10178
10179   if (processing_template_decl)
10180     /* Do nothing now.  */;
10181   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10182     begin_constructor_body ();
10183   else if (DECL_DESTRUCTOR_P (current_function_decl))
10184     begin_destructor_body ();
10185
10186   return stmt;
10187 }
10188
10189 /* Do the processing for the end of a function body.  Currently, this means
10190    closing out the cleanups for fully-constructed bases and members, and in
10191    the case of the destructor, deleting the object if desired.  Again, this
10192    is only meaningful for [cd]tors, since they are the only functions where
10193    there is a significant distinction between the main body and any
10194    function catch clauses.  Handling, say, main() return semantics here
10195    would be wrong, as flowing off the end of a function catch clause for
10196    main() would also need to return 0.  */
10197
10198 void
10199 finish_function_body (tree compstmt)
10200 {
10201   /* Close the block.  */
10202   finish_compound_stmt (compstmt);
10203
10204   if (processing_template_decl)
10205     /* Do nothing now.  */;
10206   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10207     finish_constructor_body ();
10208   else if (DECL_DESTRUCTOR_P (current_function_decl))
10209     finish_destructor_body ();
10210 }
10211
10212 /* Finish up a function declaration and compile that function
10213    all the way to assembler language output.  The free the storage
10214    for the function definition.
10215
10216    FLAGS is a bitwise or of the following values:
10217      2 - INCLASS_INLINE
10218        We just finished processing the body of an in-class inline
10219        function definition.  (This processing will have taken place
10220        after the class definition is complete.)  */
10221
10222 tree
10223 finish_function (int flags)
10224 {
10225   tree fndecl = current_function_decl;
10226   tree fntype, ctype = NULL_TREE;
10227   int inclass_inline = (flags & 2) != 0;
10228   int nested;
10229
10230   /* When we get some parse errors, we can end up without a
10231      current_function_decl, so cope.  */
10232   if (fndecl == NULL_TREE)
10233     return error_mark_node;
10234
10235   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10236       && DECL_VIRTUAL_P (fndecl)
10237       && !processing_template_decl)
10238     {
10239       tree fnclass = DECL_CONTEXT (fndecl);
10240       if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10241         keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10242     }
10243
10244   nested = function_depth > 1;
10245   fntype = TREE_TYPE (fndecl);
10246
10247   /*  TREE_READONLY (fndecl) = 1;
10248       This caused &foo to be of type ptr-to-const-function
10249       which then got a warning when stored in a ptr-to-function variable.  */
10250
10251   my_friendly_assert (building_stmt_tree (), 20000911);
10252
10253   /* For a cloned function, we've already got all the code we need;
10254      there's no need to add any extra bits.  */
10255   if (!DECL_CLONED_FUNCTION_P (fndecl))
10256     {
10257       if (DECL_MAIN_P (current_function_decl))
10258         {
10259           /* Make it so that `main' always returns 0 by default.  */
10260 #if VMS_TARGET
10261           finish_return_stmt (integer_one_node);
10262 #else
10263           finish_return_stmt (integer_zero_node);
10264 #endif
10265         }
10266
10267       /* Finish dealing with exception specifiers.  */
10268       if (flag_exceptions && !processing_template_decl
10269           && flag_enforce_eh_specs
10270           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10271         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10272                               (TREE_TYPE (current_function_decl)),
10273                               current_eh_spec_block);
10274     }
10275
10276   /* If we're saving up tree structure, tie off the function now.  */
10277   DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10278
10279   finish_fname_decls ();
10280
10281   /* If this function can't throw any exceptions, remember that.  */
10282   if (!processing_template_decl
10283       && !cp_function_chain->can_throw
10284       && !flag_non_call_exceptions)
10285     TREE_NOTHROW (fndecl) = 1;
10286
10287   /* This must come after expand_function_end because cleanups might
10288      have declarations (from inline functions) that need to go into
10289      this function's blocks.  */
10290
10291   /* If the current binding level isn't the outermost binding level
10292      for this function, either there is a bug, or we have experienced
10293      syntax errors and the statement tree is malformed.  */
10294   if (current_binding_level->kind != sk_function_parms)
10295     {
10296       /* Make sure we have already experienced errors.  */
10297       if (errorcount == 0)
10298         abort ();
10299
10300       /* Throw away the broken statement tree and extra binding
10301          levels.  */
10302       DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10303
10304       while (current_binding_level->kind != sk_function_parms)
10305         {
10306           if (current_binding_level->kind == sk_class)
10307             pop_nested_class ();
10308           else
10309             poplevel (0, 0, 0);
10310         }
10311     }
10312   poplevel (1, 0, 1);
10313
10314   /* Statements should always be full-expressions at the outermost set
10315      of curly braces for a function.  */
10316   my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
10317
10318   /* Set up the named return value optimization, if we can.  Candidate
10319      variables are selected in check_return_value.  */
10320   if (current_function_return_value)
10321     {
10322       tree r = current_function_return_value;
10323       tree outer;
10324
10325       if (r != error_mark_node
10326           /* This is only worth doing for fns that return in memory--and
10327              simpler, since we don't have to worry about promoted modes.  */
10328           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10329           /* Only allow this for variables declared in the outer scope of
10330              the function so we know that their lifetime always ends with a
10331              return; see g++.dg/opt/nrv6.C.  We could be more flexible if
10332              we were to do this optimization in tree-ssa.  */
10333           && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)))
10334           /* Skip the artificial function body block.  */
10335           && (outer = BLOCK_SUBBLOCKS (outer))
10336           && chain_member (r, BLOCK_VARS (outer)))
10337         finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10338
10339       current_function_return_value = NULL_TREE;
10340     }
10341
10342   /* Remember that we were in class scope.  */
10343   if (current_class_name)
10344     ctype = current_class_type;
10345
10346   /* Must mark the RESULT_DECL as being in this function.  */
10347   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10348
10349   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10350      to the FUNCTION_DECL node itself.  */
10351   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10352
10353   /* Save away current state, if appropriate.  */
10354   if (!processing_template_decl)
10355     save_function_data (fndecl);
10356
10357   /* Complain if there's just no return statement.  */
10358   if (warn_return_type
10359       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10360       && !dependent_type_p (TREE_TYPE (fntype))
10361       && !current_function_returns_value && !current_function_returns_null
10362       /* Don't complain if we abort or throw.  */
10363       && !current_function_returns_abnormally
10364       && !DECL_NAME (DECL_RESULT (fndecl))
10365       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
10366          inline function, as we might never be compiled separately.  */
10367       && (DECL_INLINE (fndecl) || processing_template_decl))
10368     warning ("no return statement in function returning non-void");
10369
10370   /* Store the end of the function, so that we get good line number
10371      info for the epilogue.  */
10372   cfun->function_end_locus = input_location;
10373
10374   /* Genericize before inlining.  */
10375   if (!processing_template_decl)
10376     {
10377       cp_genericize (fndecl);
10378
10379       /* Handle attribute((warn_unused_result)).  Relies on gimple input.  */
10380       c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10381     }
10382
10383   /* We're leaving the context of this function, so zap cfun.  It's still in
10384      DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation.  */
10385   cfun = NULL;
10386   current_function_decl = NULL;
10387
10388   /* If this is an in-class inline definition, we may have to pop the
10389      bindings for the template parameters that we added in
10390      maybe_begin_member_template_processing when start_function was
10391      called.  */
10392   if (inclass_inline)
10393     maybe_end_member_template_processing ();
10394
10395   /* Leave the scope of the class.  */
10396   if (ctype)
10397     pop_nested_class ();
10398
10399   --function_depth;
10400
10401   /* Clean up.  */
10402   if (! nested)
10403     /* Let the error reporting routines know that we're outside a
10404        function.  For a nested function, this value is used in
10405        cxx_pop_function_context and then reset via pop_function_context.  */
10406     current_function_decl = NULL_TREE;
10407
10408   return fndecl;
10409 }
10410 \f
10411 /* Create the FUNCTION_DECL for a function definition.
10412    DECLSPECS and DECLARATOR are the parts of the declaration;
10413    they describe the return type and the name of the function,
10414    but twisted together in a fashion that parallels the syntax of C.
10415
10416    This function creates a binding context for the function body
10417    as well as setting up the FUNCTION_DECL in current_function_decl.
10418
10419    Returns a FUNCTION_DECL on success.
10420
10421    If the DECLARATOR is not suitable for a function (it defines a datum
10422    instead), we return 0, which tells yyparse to report a parse error.
10423
10424    May return void_type_node indicating that this method is actually
10425    a friend.  See grokfield for more details.
10426
10427    Came here with a `.pushlevel' .
10428
10429    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10430    CHANGES TO CODE IN `grokfield'.  */
10431
10432 tree
10433 start_method (cp_decl_specifier_seq *declspecs,
10434               const cp_declarator *declarator, tree attrlist)
10435 {
10436   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10437                                 &attrlist);
10438
10439   if (fndecl == error_mark_node)
10440     return error_mark_node;
10441
10442   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10443     {
10444       error ("invalid member function declaration");
10445       return error_mark_node;
10446     }
10447
10448   if (attrlist)
10449     cplus_decl_attributes (&fndecl, attrlist, 0);
10450
10451   /* Pass friends other than inline friend functions back.  */
10452   if (fndecl == void_type_node)
10453     return fndecl;
10454
10455   if (DECL_IN_AGGR_P (fndecl))
10456     {
10457       if (DECL_CONTEXT (fndecl)
10458           && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10459         error ("`%D' is already defined in class `%T'", fndecl,
10460                DECL_CONTEXT (fndecl));
10461       return void_type_node;
10462     }
10463
10464   check_template_shadow (fndecl);
10465
10466   DECL_DECLARED_INLINE_P (fndecl) = 1;
10467   if (flag_default_inline)
10468     DECL_INLINE (fndecl) = 1;
10469
10470   /* We process method specializations in finish_struct_1.  */
10471   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10472     {
10473       fndecl = push_template_decl (fndecl);
10474       if (fndecl == error_mark_node)
10475         return fndecl;
10476     }
10477
10478   if (! DECL_FRIEND_P (fndecl))
10479     {
10480       if (TREE_CHAIN (fndecl))
10481         {
10482           fndecl = copy_node (fndecl);
10483           TREE_CHAIN (fndecl) = NULL_TREE;
10484         }
10485       grok_special_member_properties (fndecl);
10486     }
10487
10488   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10489
10490   /* Make a place for the parms.  */
10491   begin_scope (sk_function_parms, fndecl);
10492
10493   DECL_IN_AGGR_P (fndecl) = 1;
10494   return fndecl;
10495 }
10496
10497 /* Go through the motions of finishing a function definition.
10498    We don't compile this method until after the whole class has
10499    been processed.
10500
10501    FINISH_METHOD must return something that looks as though it
10502    came from GROKFIELD (since we are defining a method, after all).
10503
10504    This is called after parsing the body of the function definition.
10505    STMTS is the chain of statements that makes up the function body.
10506
10507    DECL is the ..._DECL that `start_method' provided.  */
10508
10509 tree
10510 finish_method (tree decl)
10511 {
10512   tree fndecl = decl;
10513   tree old_initial;
10514
10515   tree link;
10516
10517   if (decl == void_type_node)
10518     return decl;
10519
10520   old_initial = DECL_INITIAL (fndecl);
10521
10522   /* Undo the level for the parms (from start_method).
10523      This is like poplevel, but it causes nothing to be
10524      saved.  Saving information here confuses symbol-table
10525      output routines.  Besides, this information will
10526      be correctly output when this method is actually
10527      compiled.  */
10528
10529   /* Clear out the meanings of the local variables of this level;
10530      also record in each decl which block it belongs to.  */
10531
10532   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
10533     {
10534       if (DECL_NAME (link) != NULL_TREE)
10535         pop_binding (DECL_NAME (link), link);
10536       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
10537       DECL_CONTEXT (link) = NULL_TREE;
10538     }
10539
10540   poplevel (0, 0, 0);
10541
10542   DECL_INITIAL (fndecl) = old_initial;
10543
10544   /* We used to check if the context of FNDECL was different from
10545      current_class_type as another way to get inside here.  This didn't work
10546      for String.cc in libg++.  */
10547   if (DECL_FRIEND_P (fndecl))
10548     {
10549       CLASSTYPE_INLINE_FRIENDS (current_class_type)
10550         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
10551       decl = void_type_node;
10552     }
10553
10554   return decl;
10555 }
10556 \f
10557
10558 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
10559    we can lay it out later, when and if its type becomes complete.  */
10560
10561 void
10562 maybe_register_incomplete_var (tree var)
10563 {
10564   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
10565
10566   /* Keep track of variables with incomplete types.  */
10567   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
10568       && DECL_EXTERNAL (var))
10569     {
10570       tree inner_type = TREE_TYPE (var);
10571
10572       while (TREE_CODE (inner_type) == ARRAY_TYPE)
10573         inner_type = TREE_TYPE (inner_type);
10574       inner_type = TYPE_MAIN_VARIANT (inner_type);
10575
10576       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
10577           /* RTTI TD entries are created while defining the type_info.  */
10578           || (TYPE_LANG_SPECIFIC (inner_type)
10579               && TYPE_BEING_DEFINED (inner_type)))
10580         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
10581     }
10582 }
10583
10584 /* Called when a class type (given by TYPE) is defined.  If there are
10585    any existing VAR_DECLs whose type hsa been completed by this
10586    declaration, update them now.  */
10587
10588 void
10589 complete_vars (tree type)
10590 {
10591   tree *list = &incomplete_vars;
10592
10593   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
10594   while (*list)
10595     {
10596       if (same_type_p (type, TREE_PURPOSE (*list)))
10597         {
10598           tree var = TREE_VALUE (*list);
10599           /* Complete the type of the variable.  The VAR_DECL itself
10600              will be laid out in expand_expr.  */
10601           complete_type (TREE_TYPE (var));
10602           /* Remove this entry from the list.  */
10603           *list = TREE_CHAIN (*list);
10604         }
10605       else
10606         list = &TREE_CHAIN (*list);
10607     }
10608
10609   /* Check for pending declarations which may have abstract type.  */
10610   complete_type_check_abstract (type);
10611 }
10612
10613 /* If DECL is of a type which needs a cleanup, build that cleanup
10614    here.  */
10615
10616 tree
10617 cxx_maybe_build_cleanup (tree decl)
10618 {
10619   tree type = TREE_TYPE (decl);
10620
10621   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
10622     {
10623       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
10624       tree rval;
10625
10626       if (TREE_CODE (type) == ARRAY_TYPE)
10627         rval = decl;
10628       else
10629         {
10630           cxx_mark_addressable (decl);
10631           rval = build_unary_op (ADDR_EXPR, decl, 0);
10632         }
10633
10634       /* Optimize for space over speed here.  */
10635       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
10636           || flag_expensive_optimizations)
10637         flags |= LOOKUP_NONVIRTUAL;
10638
10639       rval = build_delete (TREE_TYPE (rval), rval,
10640                            sfk_complete_destructor, flags, 0);
10641
10642       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
10643           && ! TYPE_HAS_DESTRUCTOR (type))
10644         rval = build_compound_expr (rval, build_vbase_delete (type, decl));
10645
10646       return rval;
10647     }
10648   return NULL_TREE;
10649 }
10650 \f
10651 /* When a stmt has been parsed, this function is called.  */
10652
10653 void
10654 finish_stmt (void)
10655 {
10656 }
10657
10658 /* DECL was originally constructed as a non-static member function,
10659    but turned out to be static.  Update it accordingly.  */
10660
10661 void
10662 revert_static_member_fn (tree decl)
10663 {
10664   tree tmp;
10665   tree function = TREE_TYPE (decl);
10666   tree args = TYPE_ARG_TYPES (function);
10667
10668   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
10669       != TYPE_UNQUALIFIED)
10670     error ("static member function `%#D' declared with type qualifiers",
10671               decl);
10672
10673   args = TREE_CHAIN (args);
10674   tmp = build_function_type (TREE_TYPE (function), args);
10675   tmp = build_qualified_type (tmp, cp_type_quals (function));
10676   tmp = build_exception_variant (tmp,
10677                                  TYPE_RAISES_EXCEPTIONS (function));
10678   TREE_TYPE (decl) = tmp;
10679   if (DECL_ARGUMENTS (decl))
10680     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
10681   DECL_STATIC_FUNCTION_P (decl) = 1;
10682 }
10683
10684 /* Initialize the variables used during compilation of a C++
10685    function.  */
10686
10687 void
10688 cxx_push_function_context (struct function * f)
10689 {
10690   struct language_function *p
10691     = ggc_alloc_cleared (sizeof (struct language_function));
10692   f->language = p;
10693
10694   /* Whenever we start a new function, we destroy temporaries in the
10695      usual way.  */
10696   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
10697
10698   if (f->decl)
10699     {
10700       tree fn = f->decl;
10701
10702       if (DECL_SAVED_FUNCTION_DATA (fn))
10703         {
10704           /* If we already parsed this function, and we're just expanding it
10705              now, restore saved state.  */
10706           *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
10707
10708           /* We don't need the saved data anymore.  Unless this is an inline
10709              function; we need the named return value info for
10710              cp_copy_res_decl_for_inlining.  */
10711           if (! DECL_INLINE (fn))
10712             DECL_SAVED_FUNCTION_DATA (fn) = NULL;
10713         }
10714     }
10715 }
10716
10717 /* Free the language-specific parts of F, now that we've finished
10718    compiling the function.  */
10719
10720 void
10721 cxx_pop_function_context (struct function * f)
10722 {
10723   f->language = 0;
10724 }
10725
10726 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
10727    one of the language-independent trees.  */
10728
10729 enum cp_tree_node_structure_enum
10730 cp_tree_node_structure (union lang_tree_node * t)
10731 {
10732   switch (TREE_CODE (&t->generic))
10733     {
10734     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
10735     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
10736     case OVERLOAD:              return TS_CP_OVERLOAD;
10737     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
10738     case PTRMEM_CST:            return TS_CP_PTRMEM;
10739     case BASELINK:              return TS_CP_BASELINK;
10740     default:                    return TS_CP_GENERIC;
10741     }
10742 }
10743
10744 /* Build the void_list_node (void_type_node having been created).  */
10745 tree
10746 build_void_list_node (void)
10747 {
10748   tree t = build_tree_list (NULL_TREE, void_type_node);
10749   return t;
10750 }
10751
10752 bool
10753 cp_missing_noreturn_ok_p (tree decl)
10754 {
10755   /* A missing noreturn is ok for the `main' function.  */
10756   return DECL_MAIN_P (decl);
10757 }
10758
10759 #include "gt-cp-decl.h"
10760 #include "gtype-cp.h"