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           tree name = DECL_NAME (link);
 544           cxx_binding *ob;
 545           tree ns_binding;
 546
 547           ob = outer_binding (name,
 548                               IDENTIFIER_BINDING (name),
 549                               /*class_p=*/true);
 550           if (!ob)
 551             ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
 552           else
 553             ns_binding = NULL_TREE;
 554
 555           if (ob && ob->scope == current_binding_level->level_chain)
 556             /* We have something like:
 557
 558                  int i;
 559                  for (int i; ;);
 560
 561                and we are leaving the `for' scope.  There's no reason to
 562                keep the binding of the inner `i' in this case.  */
 563             pop_binding (name, link);
 564           else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
 565                    || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
 566             /* Here, we have something like:
 567
 568                  typedef int I;
 569
 570                  void f () {
 571                    for (int I; ;);
 572                  }
 573
 574                We must pop the for-scope binding so we know what's a
 575                type and what isn't.  */
 576             pop_binding (name, link);
 577           else
 578             {
 579               /* Mark this VAR_DECL as dead so that we can tell we left it
 580                  there only for backward compatibility.  */
 581               DECL_DEAD_FOR_LOCAL (link) = 1;
 582
 583               /* Keep track of what should have happened when we
 584                  popped the binding.  */
 585               if (ob && ob->value)
 586                 DECL_SHADOWED_FOR_VAR (link) = ob->value;
 587
 588               /* Add it to the list of dead variables in the next
 589                  outermost binding to that we can remove these when we
 590                  leave that binding.  */
 591               current_binding_level->level_chain->dead_vars_from_for
 592                 = tree_cons (NULL_TREE, link,
 593                              current_binding_level->level_chain->
 594                              dead_vars_from_for);
 595
 596               /* Although we don't pop the cxx_binding, we do clear
 597                  its SCOPE since the scope is going away now.  */
 598               IDENTIFIER_BINDING (name)->scope
 599                 = current_binding_level->level_chain;
 600             }
 601         }
 602       else
 603         {
 604           /* Remove the binding.  */
 605           decl = link;
 606           if (TREE_CODE (decl) == TREE_LIST)
 607             decl = TREE_VALUE (decl);
 608           if (DECL_P (decl))
 609             pop_binding (DECL_NAME (decl), decl);
 610           else if (TREE_CODE (decl) == OVERLOAD)
 611             pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
 612           else
 613             abort ();
 614         }
 615     }
 616
 617   /* Remove declarations for any `for' variables from inner scopes
 618      that we kept around.  */
 619   for (link = current_binding_level->dead_vars_from_for;
 620        link; link = TREE_CHAIN (link))
 621     pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
 622
 623   /* Restore the IDENTIFIER_TYPE_VALUEs.  */
 624   for (link = current_binding_level->type_shadowed;
 625        link; link = TREE_CHAIN (link))
 626     SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
 627
 628   /* Restore the IDENTIFIER_LABEL_VALUEs for local labels.  */
 629   for (link = current_binding_level->shadowed_labels;
 630        link;
 631        link = TREE_CHAIN (link))
 632     pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
 633
 634   /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
 635      list if a `using' declaration put them there.  The debugging
 636      back-ends won't understand OVERLOAD, so we remove them here.
 637      Because the BLOCK_VARS are (temporarily) shared with
 638      CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
 639      popped all the bindings.  */
 640   if (block)
 641     {
 642       tree* d;
 643
 644       for (d = &BLOCK_VARS (block); *d; )
 645         {
 646           if (TREE_CODE (*d) == TREE_LIST)
 647             *d = TREE_CHAIN (*d);
 648           else
 649             d = &TREE_CHAIN (*d);
 650         }
 651     }
 652
 653   /* If the level being exited is the top level of a function,
 654      check over all the labels.  */
 655   if (functionbody)
 656     {
 657       /* Since this is the top level block of a function, the vars are
 658          the function's parameters.  Don't leave them in the BLOCK
 659          because they are found in the FUNCTION_DECL instead.  */
 660       BLOCK_VARS (block) = 0;
 661       pop_labels (block);
 662     }
 663
 664   kind = current_binding_level->kind;
 665   if (kind == sk_cleanup)
 666     {
 667       tree stmt;
 668
 669       /* If this is a temporary binding created for a cleanup, then we'll
 670          have pushed a statement list level.  Pop that, create a new
 671          BIND_EXPR for the block, and insert it into the stream.  */
 672       stmt = pop_stmt_list (current_binding_level->statement_list);
 673       stmt = c_build_bind_expr (block, stmt);
 674       add_stmt (stmt);
 675     }
 676
 677   leave_scope ();
 678   if (functionbody)
 679     DECL_INITIAL (current_function_decl) = block;
 680   else if (block)
 681     current_binding_level->blocks
 682       = chainon (current_binding_level->blocks, block);
 683
 684   /* If we did not make a block for the level just exited,
 685      any blocks made for inner levels
 686      (since they cannot be recorded as subblocks in that level)
 687      must be carried forward so they will later become subblocks
 688      of something else.  */
 689   else if (subblocks)
 690     current_binding_level->blocks
 691       = chainon (current_binding_level->blocks, subblocks);
 692
 693   /* Each and every BLOCK node created here in `poplevel' is important
 694      (e.g. for proper debugging information) so if we created one
 695      earlier, mark it as "used".  */
 696   if (block)
 697     TREE_USED (block) = 1;
 698
 699   /* All temporary bindings created for cleanups are popped silently.  */
 700   if (kind == sk_cleanup)
 701     goto restart;
 702
 703   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
 704 }
 705
 706 /* Delete the node BLOCK from the current binding level.
 707    This is used for the block inside a stmt expr ({...})
 708    so that the block can be reinserted where appropriate.  */
 709
 710 void
 711 delete_block (tree block)
 712 {
 713   tree t;
 714   if (current_binding_level->blocks == block)
 715     current_binding_level->blocks = TREE_CHAIN (block);
 716   for (t = current_binding_level->blocks; t;)
 717     {
 718       if (TREE_CHAIN (t) == block)
 719         TREE_CHAIN (t) = TREE_CHAIN (block);
 720       else
 721         t = TREE_CHAIN (t);
 722     }
 723   TREE_CHAIN (block) = NULL_TREE;
 724   /* Clear TREE_USED which is always set by poplevel.
 725      The flag is set again if insert_block is called.  */
 726   TREE_USED (block) = 0;
 727 }
 728
 729 /* Insert BLOCK at the end of the list of subblocks of the
 730    current binding level.  This is used when a BIND_EXPR is expanded,
 731    to handle the BLOCK node inside the BIND_EXPR.  */
 732
 733 void
 734 insert_block (tree block)
 735 {
 736   TREE_USED (block) = 1;
 737   current_binding_level->blocks
 738     = chainon (current_binding_level->blocks, block);
 739 }
 740
 741 /* Returns nonzero if T is a virtual function table.  */
 742
 743 int
 744 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
 745 {
 746   return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
 747 }
 748
 749 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
 750    functions.  */
 751
 752 int
 753 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
 754 {
 755   return (TREE_CODE (t) == TYPE_DECL
 756           && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
 757           && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
 758 }
 759
 760 struct walk_globals_data {
 761   walk_globals_pred p;
 762   walk_globals_fn f;
 763   void *data;
 764 };
 765
 766 /* Walk the vtable declarations in NAMESPACE.  Whenever one is found
 767    for which P returns nonzero, call F with its address.  If any call
 768    to F returns a nonzero value, return a nonzero value.  */
 769
 770 static int
 771 walk_vtables_r (tree namespace, void* data)
 772 {
 773   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
 774   walk_globals_fn f = wgd->f;
 775   void *d = wgd->data;
 776   tree decl = NAMESPACE_LEVEL (namespace)->vtables;
 777   int result = 0;
 778
 779   for (; decl ; decl = TREE_CHAIN (decl))
 780     result |= (*f) (&decl, d);
 781
 782   return result;
 783 }
 784
 785 /* Walk the vtable declarations.  Whenever one is found for which P
 786    returns nonzero, call F with its address.  If any call to F
 787    returns a nonzero value, return a nonzero value.  */
 788 bool
 789 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
 790 {
 791   struct walk_globals_data wgd;
 792   wgd.p = p;
 793   wgd.f = f;
 794   wgd.data = data;
 795
 796   return walk_namespaces (walk_vtables_r, &wgd);
 797 }
 798
 799 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
 800    itself, calling F for each.  The DATA is passed to F as well.  */
 801
 802 static int
 803 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
 804 {
 805   int result = 0;
 806   tree current = NAMESPACE_LEVEL (namespace)->namespaces;
 807
 808   result |= (*f) (namespace, data);
 809
 810   for (; current; current = TREE_CHAIN (current))
 811     result |= walk_namespaces_r (current, f, data);
 812
 813   return result;
 814 }
 815
 816 /* Walk all the namespaces, calling F for each.  The DATA is passed to
 817    F as well.  */
 818
 819 int
 820 walk_namespaces (walk_namespaces_fn f, void* data)
 821 {
 822   return walk_namespaces_r (global_namespace, f, data);
 823 }
 824
 825 /* Walk the global declarations in NAMESPACE.  Whenever one is found
 826    for which P returns nonzero, call F with its address.  If any call
 827    to F returns a nonzero value, return a nonzero value.  */
 828
 829 static int
 830 walk_globals_r (tree namespace, void* data)
 831 {
 832   struct walk_globals_data* wgd = (struct walk_globals_data *) data;
 833   walk_globals_pred p = wgd->p;
 834   walk_globals_fn f = wgd->f;
 835   void *d = wgd->data;
 836   tree *t;
 837   int result = 0;
 838
 839   t = &NAMESPACE_LEVEL (namespace)->names;
 840
 841   while (*t)
 842     {
 843       tree glbl = *t;
 844
 845       if ((*p) (glbl, d))
 846         result |= (*f) (t, d);
 847
 848       /* If F changed *T, then *T still points at the next item to
 849          examine.  */
 850       if (*t == glbl)
 851         t = &TREE_CHAIN (*t);
 852     }
 853
 854   return result;
 855 }
 856
 857 /* Walk the global declarations.  Whenever one is found for which P
 858    returns true, call F with its address.  If any call to F
 859    returns true, return true.  */
 860
 861 bool
 862 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
 863 {
 864   struct walk_globals_data wgd;
 865   wgd.p = p;
 866   wgd.f = f;
 867   wgd.data = data;
 868
 869   return walk_namespaces (walk_globals_r, &wgd);
 870 }
 871
 872 /* Call wrapup_globals_declarations for the globals in NAMESPACE.  If
 873    DATA is non-NULL, this is the last time we will call
 874    wrapup_global_declarations for this NAMESPACE.  */
 875
 876 int
 877 wrapup_globals_for_namespace (tree namespace, void* data)
 878 {
 879   struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
 880   varray_type statics = level->static_decls;
 881   tree *vec = &VARRAY_TREE (statics, 0);
 882   int len = VARRAY_ACTIVE_SIZE (statics);
 883   int last_time = (data != 0);
 884
 885   if (last_time)
 886     {
 887       check_global_declarations (vec, len);
 888       return 0;
 889     }
 890
 891   /* Write out any globals that need to be output.  */
 892   return wrapup_global_declarations (vec, len);
 893 }
 894
 895 \f
 896 /* In C++, you don't have to write `struct S' to refer to `S'; you
 897    can just use `S'.  We accomplish this by creating a TYPE_DECL as
 898    if the user had written `typedef struct S S'.  Create and return
 899    the TYPE_DECL for TYPE.  */
 900
 901 tree
 902 create_implicit_typedef (tree name, tree type)
 903 {
 904   tree decl;
 905
 906   decl = build_decl (TYPE_DECL, name, type);
 907   DECL_ARTIFICIAL (decl) = 1;
 908   /* There are other implicit type declarations, like the one *within*
 909      a class that allows you to write `S::S'.  We must distinguish
 910      amongst these.  */
 911   SET_DECL_IMPLICIT_TYPEDEF_P (decl);
 912   TYPE_NAME (type) = decl;
 913
 914   return decl;
 915 }
 916
 917 /* Remember a local name for name-mangling purposes.  */
 918
 919 static void
 920 push_local_name (tree decl)
 921 {
 922   size_t i, nelts;
 923   tree t, name;
 924
 925   timevar_push (TV_NAME_LOOKUP);
 926   if (!local_names)
 927     VARRAY_TREE_INIT (local_names, 8, "local_names");
 928
 929   name = DECL_NAME (decl);
 930
 931   nelts = VARRAY_ACTIVE_SIZE (local_names);
 932   for (i = 0; i < nelts; i++)
 933     {
 934       t = VARRAY_TREE (local_names, i);
 935       if (DECL_NAME (t) == name)
 936         {
 937           if (!DECL_LANG_SPECIFIC (decl))
 938             retrofit_lang_decl (decl);
 939           DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
 940           if (DECL_LANG_SPECIFIC (t))
 941             DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
 942           else
 943             DECL_DISCRIMINATOR (decl) = 1;
 944
 945           VARRAY_TREE (local_names, i) = decl;
 946           timevar_pop (TV_NAME_LOOKUP);
 947           return;
 948         }
 949     }
 950
 951   VARRAY_PUSH_TREE (local_names, decl);
 952   timevar_pop (TV_NAME_LOOKUP);
 953 }
 954 \f
 955 /* Subroutine of duplicate_decls: return truthvalue of whether
 956    or not types of these decls match.
 957
 958    For C++, we must compare the parameter list so that `int' can match
 959    `int&' in a parameter position, but `int&' is not confused with
 960    `const int&'.  */
 961
 962 int
 963 decls_match (tree newdecl, tree olddecl)
 964 {
 965   int types_match;
 966
 967   if (newdecl == olddecl)
 968     return 1;
 969
 970   if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
 971     /* If the two DECLs are not even the same kind of thing, we're not
 972        interested in their types.  */
 973     return 0;
 974
 975   if (TREE_CODE (newdecl) == FUNCTION_DECL)
 976     {
 977       tree f1 = TREE_TYPE (newdecl);
 978       tree f2 = TREE_TYPE (olddecl);
 979       tree p1 = TYPE_ARG_TYPES (f1);
 980       tree p2 = TYPE_ARG_TYPES (f2);
 981
 982       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
 983           && ! (DECL_EXTERN_C_P (newdecl)
 984                 && DECL_EXTERN_C_P (olddecl)))
 985         return 0;
 986
 987       if (TREE_CODE (f1) != TREE_CODE (f2))
 988         return 0;
 989
 990       if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
 991         {
 992           if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
 993               && (DECL_BUILT_IN (olddecl)
 994 #ifndef NO_IMPLICIT_EXTERN_C
 995                   || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
 996                   || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
 997 #endif
 998               ))
 999             {
1000               types_match = self_promoting_args_p (p1);
1001               if (p1 == void_list_node)
1002                 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1003             }
1004 #ifndef NO_IMPLICIT_EXTERN_C
1005           else if (p1 == NULL_TREE
1006                    && (DECL_EXTERN_C_P (olddecl)
1007                        && DECL_IN_SYSTEM_HEADER (olddecl)
1008                        && !DECL_CLASS_SCOPE_P (olddecl))
1009                    && (DECL_EXTERN_C_P (newdecl)
1010                        && DECL_IN_SYSTEM_HEADER (newdecl)
1011                        && !DECL_CLASS_SCOPE_P (newdecl)))
1012             {
1013               types_match = self_promoting_args_p (p2);
1014               TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1015             }
1016 #endif
1017           else
1018             types_match = compparms (p1, p2);
1019         }
1020       else
1021         types_match = 0;
1022     }
1023   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1024     {
1025       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1026           != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1027         return 0;
1028
1029       if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1030                                 DECL_TEMPLATE_PARMS (olddecl)))
1031         return 0;
1032
1033       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1034         types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1035                                    TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1036       else
1037         types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1038                                    DECL_TEMPLATE_RESULT (newdecl));
1039     }
1040   else
1041     {
1042       if (TREE_TYPE (newdecl) == error_mark_node)
1043         types_match = TREE_TYPE (olddecl) == error_mark_node;
1044       else if (TREE_TYPE (olddecl) == NULL_TREE)
1045         types_match = TREE_TYPE (newdecl) == NULL_TREE;
1046       else if (TREE_TYPE (newdecl) == NULL_TREE)
1047         types_match = 0;
1048       else
1049         types_match = comptypes (TREE_TYPE (newdecl),
1050                                  TREE_TYPE (olddecl),
1051                                  COMPARE_REDECLARATION);
1052     }
1053
1054   return types_match;
1055 }
1056
1057 /* If NEWDECL is `static' and an `extern' was seen previously,
1058    warn about it.  OLDDECL is the previous declaration.
1059
1060    Note that this does not apply to the C++ case of declaring
1061    a variable `extern const' and then later `const'.
1062
1063    Don't complain about built-in functions, since they are beyond
1064    the user's control.  */
1065
1066 void
1067 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1068 {
1069   tree name;
1070
1071   if (TREE_CODE (newdecl) == TYPE_DECL
1072       || TREE_CODE (newdecl) == TEMPLATE_DECL
1073       || TREE_CODE (newdecl) == CONST_DECL
1074       || TREE_CODE (newdecl) == NAMESPACE_DECL)
1075     return;
1076
1077   /* Don't get confused by static member functions; that's a different
1078      use of `static'.  */
1079   if (TREE_CODE (newdecl) == FUNCTION_DECL
1080       && DECL_STATIC_FUNCTION_P (newdecl))
1081     return;
1082
1083   /* If the old declaration was `static', or the new one isn't, then
1084      then everything is OK.  */
1085   if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1086     return;
1087
1088   /* It's OK to declare a builtin function as `static'.  */
1089   if (TREE_CODE (olddecl) == FUNCTION_DECL
1090       && DECL_ARTIFICIAL (olddecl))
1091     return;
1092
1093   name = DECL_ASSEMBLER_NAME (newdecl);
1094   pedwarn ("`%D' was declared `extern' and later `static'", newdecl);
1095   cp_pedwarn_at ("previous declaration of `%D'", olddecl);
1096 }
1097
1098 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1099    If the redeclaration is invalid, a diagnostic is issued, and the
1100    error_mark_node is returned.  Otherwise, OLDDECL is returned.
1101
1102    If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1103    returned.  */
1104
1105 tree
1106 duplicate_decls (tree newdecl, tree olddecl)
1107 {
1108   unsigned olddecl_uid = DECL_UID (olddecl);
1109   int olddecl_friend = 0, types_match = 0;
1110   int new_defines_function = 0;
1111
1112   if (newdecl == olddecl)
1113     return olddecl;
1114
1115   types_match = decls_match (newdecl, olddecl);
1116
1117   /* If either the type of the new decl or the type of the old decl is an
1118      error_mark_node, then that implies that we have already issued an
1119      error (earlier) for some bogus type specification, and in that case,
1120      it is rather pointless to harass the user with yet more error message
1121      about the same declaration, so just pretend the types match here.  */
1122   if (TREE_TYPE (newdecl) == error_mark_node
1123       || TREE_TYPE (olddecl) == error_mark_node)
1124     types_match = 1;
1125
1126   if (DECL_P (olddecl)
1127       && TREE_CODE (newdecl) == FUNCTION_DECL
1128       && TREE_CODE (olddecl) == FUNCTION_DECL
1129       && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1130     {
1131       if (DECL_DECLARED_INLINE_P (newdecl)
1132           && DECL_UNINLINABLE (newdecl)
1133           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1134         /* Already warned elsewhere.  */;
1135       else if (DECL_DECLARED_INLINE_P (olddecl)
1136                && DECL_UNINLINABLE (olddecl)
1137                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1138         /* Already warned.  */;
1139       else if (DECL_DECLARED_INLINE_P (newdecl)
1140                && DECL_UNINLINABLE (olddecl)
1141                && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1142         {
1143           warning ("%Jfunction '%D' redeclared as inline", newdecl, newdecl);
1144           warning ("%Jprevious declaration of '%D' with attribute noinline",
1145                    olddecl, olddecl);
1146         }
1147       else if (DECL_DECLARED_INLINE_P (olddecl)
1148                && DECL_UNINLINABLE (newdecl)
1149                && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1150         {
1151           warning ("%Jfunction '%D' redeclared with attribute noinline",
1152                    newdecl, newdecl);
1153           warning ("%Jprevious declaration of '%D' was inline",
1154                    olddecl, olddecl);
1155         }
1156     }
1157
1158   /* Check for redeclaration and other discrepancies.  */
1159   if (TREE_CODE (olddecl) == FUNCTION_DECL
1160       && DECL_ARTIFICIAL (olddecl))
1161     {
1162       if (TREE_CODE (newdecl) != FUNCTION_DECL)
1163         {
1164           /* Avoid warnings redeclaring anticipated built-ins.  */
1165           if (DECL_ANTICIPATED (olddecl))
1166             return NULL_TREE;
1167
1168           /* If you declare a built-in or predefined function name as static,
1169              the old definition is overridden, but optionally warn this was a
1170              bad choice of name.  */
1171           if (! TREE_PUBLIC (newdecl))
1172             {
1173               if (warn_shadow)
1174                 warning ("shadowing %s function `%#D'",
1175                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1176                             olddecl);
1177               /* Discard the old built-in function.  */
1178               return NULL_TREE;
1179             }
1180           /* If the built-in is not ansi, then programs can override
1181              it even globally without an error.  */
1182           else if (! DECL_BUILT_IN (olddecl))
1183             warning ("library function `%#D' redeclared as non-function `%#D'",
1184                         olddecl, newdecl);
1185           else
1186             {
1187               error ("declaration of `%#D'", newdecl);
1188               error ("conflicts with built-in declaration `%#D'",
1189                         olddecl);
1190             }
1191           return NULL_TREE;
1192         }
1193       else if (!types_match)
1194         {
1195           /* Avoid warnings redeclaring anticipated built-ins.  */
1196           if (DECL_ANTICIPATED (olddecl))
1197             {
1198               /* Deal with fileptr_type_node.  FILE type is not known
1199                  at the time we create the builtins.  */
1200               tree t1, t2;
1201
1202               for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1203                    t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1204                    t1 || t2;
1205                    t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1206                 if (!t1 || !t2)
1207                   break;
1208                 else if (TREE_VALUE (t2) == fileptr_type_node)
1209                   {
1210                     tree t = TREE_VALUE (t1);
1211
1212                     if (TREE_CODE (t) == POINTER_TYPE
1213                         && TYPE_NAME (TREE_TYPE (t))
1214                         && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1215                            == get_identifier ("FILE")
1216                         && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1217                       {
1218                         tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1219
1220                         TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1221                           = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1222                         types_match = decls_match (newdecl, olddecl);
1223                         if (types_match)
1224                           return duplicate_decls (newdecl, olddecl);
1225                         TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1226                       }
1227                   }
1228                 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1229                   break;
1230             }
1231           else if ((DECL_EXTERN_C_P (newdecl)
1232                     && DECL_EXTERN_C_P (olddecl))
1233                    || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1234                                  TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1235             {
1236               /* A near match; override the builtin.  */
1237
1238               if (TREE_PUBLIC (newdecl))
1239                 {
1240                   warning ("new declaration `%#D'", newdecl);
1241                   warning ("ambiguates built-in declaration `%#D'",
1242                               olddecl);
1243                 }
1244               else if (warn_shadow)
1245                 warning ("shadowing %s function `%#D'",
1246                             DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1247                             olddecl);
1248             }
1249           else
1250             /* Discard the old built-in function.  */
1251             return NULL_TREE;
1252
1253           /* Replace the old RTL to avoid problems with inlining.  */
1254           COPY_DECL_RTL (newdecl, olddecl);
1255         }
1256       /* Even if the types match, prefer the new declarations type
1257          for anticipated built-ins, for exception lists, etc...  */
1258       else if (DECL_ANTICIPATED (olddecl))
1259         {
1260           tree type = TREE_TYPE (newdecl);
1261           tree attribs = (*targetm.merge_type_attributes)
1262             (TREE_TYPE (olddecl), type);
1263
1264           type = cp_build_type_attribute_variant (type, attribs);
1265           TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1266         }
1267
1268       /* Whether or not the builtin can throw exceptions has no
1269          bearing on this declarator.  */
1270       TREE_NOTHROW (olddecl) = 0;
1271
1272       if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1273         {
1274           /* If a builtin function is redeclared as `static', merge
1275              the declarations, but make the original one static.  */
1276           DECL_THIS_STATIC (olddecl) = 1;
1277           TREE_PUBLIC (olddecl) = 0;
1278
1279           /* Make the old declaration consistent with the new one so
1280              that all remnants of the builtin-ness of this function
1281              will be banished.  */
1282           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1283           COPY_DECL_RTL (newdecl, olddecl);
1284         }
1285     }
1286   else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1287     {
1288       if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1289            && TREE_CODE (newdecl) != TYPE_DECL
1290            && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1291                  && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1292           || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1293               && TREE_CODE (olddecl) != TYPE_DECL
1294               && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1295                     && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1296                         == TYPE_DECL))))
1297         {
1298           /* We do nothing special here, because C++ does such nasty
1299              things with TYPE_DECLs.  Instead, just let the TYPE_DECL
1300              get shadowed, and know that if we need to find a TYPE_DECL
1301              for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1302              slot of the identifier.  */
1303           return NULL_TREE;
1304         }
1305
1306       if ((TREE_CODE (newdecl) == FUNCTION_DECL
1307            && DECL_FUNCTION_TEMPLATE_P (olddecl))
1308           || (TREE_CODE (olddecl) == FUNCTION_DECL
1309               && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1310         return NULL_TREE;
1311
1312       error ("`%#D' redeclared as different kind of symbol", newdecl);
1313       if (TREE_CODE (olddecl) == TREE_LIST)
1314         olddecl = TREE_VALUE (olddecl);
1315       cp_error_at ("previous declaration of `%#D'", olddecl);
1316
1317       return error_mark_node;
1318     }
1319   else if (!types_match)
1320     {
1321       if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1322         /* These are certainly not duplicate declarations; they're
1323            from different scopes.  */
1324         return NULL_TREE;
1325
1326       if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1327         {
1328           /* The name of a class template may not be declared to refer to
1329              any other template, class, function, object, namespace, value,
1330              or type in the same scope.  */
1331           if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1332               || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1333             {
1334               error ("declaration of template `%#D'", newdecl);
1335               cp_error_at ("conflicts with previous declaration `%#D'",
1336                            olddecl);
1337             }
1338           else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1339                    && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1340                    && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1341                                  TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1342                    && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1343                                            DECL_TEMPLATE_PARMS (olddecl))
1344                    /* Template functions can be disambiguated by
1345                       return type.  */
1346                    && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1347                                    TREE_TYPE (TREE_TYPE (olddecl))))
1348             {
1349               error ("new declaration `%#D'", newdecl);
1350               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1351             }
1352           return NULL_TREE;
1353         }
1354       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1355         {
1356           if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1357             {
1358               error ("declaration of C function `%#D' conflicts with",
1359                         newdecl);
1360               cp_error_at ("previous declaration `%#D' here", olddecl);
1361             }
1362           else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1363                               TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1364             {
1365               error ("new declaration `%#D'", newdecl);
1366               cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1367             }
1368           else
1369             return NULL_TREE;
1370         }
1371       else
1372         {
1373           error ("conflicting declaration '%#D'", newdecl);
1374           cp_error_at ("'%D' has a previous declaration as `%#D'",
1375                        olddecl, olddecl);
1376           return NULL_TREE;
1377         }
1378     }
1379   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1380             && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1381                  && (!DECL_TEMPLATE_INFO (newdecl)
1382                      || (DECL_TI_TEMPLATE (newdecl)
1383                          != DECL_TI_TEMPLATE (olddecl))))
1384                 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1385                     && (!DECL_TEMPLATE_INFO (olddecl)
1386                         || (DECL_TI_TEMPLATE (olddecl)
1387                             != DECL_TI_TEMPLATE (newdecl))))))
1388     /* It's OK to have a template specialization and a non-template
1389        with the same type, or to have specializations of two
1390        different templates with the same type.  Note that if one is a
1391        specialization, and the other is an instantiation of the same
1392        template, that we do not exit at this point.  That situation
1393        can occur if we instantiate a template class, and then
1394        specialize one of its methods.  This situation is valid, but
1395        the declarations must be merged in the usual way.  */
1396     return NULL_TREE;
1397   else if (TREE_CODE (newdecl) == FUNCTION_DECL
1398            && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1399                 && !DECL_USE_TEMPLATE (newdecl))
1400                || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1401                    && !DECL_USE_TEMPLATE (olddecl))))
1402     /* One of the declarations is a template instantiation, and the
1403        other is not a template at all.  That's OK.  */
1404     return NULL_TREE;
1405   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
1406            && DECL_NAMESPACE_ALIAS (newdecl)
1407            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
1408     /* In [namespace.alias] we have:
1409
1410          In a declarative region, a namespace-alias-definition can be
1411          used to redefine a namespace-alias declared in that declarative
1412          region to refer only to the namespace to which it already
1413          refers.
1414
1415       Therefore, if we encounter a second alias directive for the same
1416       alias, we can just ignore the second directive.  */
1417     return olddecl;
1418   else
1419     {
1420       const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1421       if (errmsg)
1422         {
1423           error (errmsg, newdecl);
1424           if (DECL_NAME (olddecl) != NULL_TREE)
1425             cp_error_at ((DECL_INITIAL (olddecl)
1426                           && namespace_bindings_p ())
1427                          ? "`%#D' previously defined here"
1428                          : "`%#D' previously declared here", olddecl);
1429           return error_mark_node;
1430         }
1431       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1432                && DECL_INITIAL (olddecl) != NULL_TREE
1433                && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1434                && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1435         {
1436           /* Prototype decl follows defn w/o prototype.  */
1437           cp_warning_at ("prototype for `%#D'", newdecl);
1438           warning ("%Jfollows non-prototype definition here", olddecl);
1439         }
1440       else if (TREE_CODE (olddecl) == FUNCTION_DECL
1441                && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1442         {
1443           /* extern "C" int foo ();
1444              int foo () { bar (); }
1445              is OK.  */
1446           if (current_lang_depth () == 0)
1447             SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1448           else
1449             {
1450               cp_error_at ("previous declaration of `%#D' with %L linkage",
1451                            olddecl, DECL_LANGUAGE (olddecl));
1452               error ("conflicts with new declaration with %L linkage",
1453                         DECL_LANGUAGE (newdecl));
1454             }
1455         }
1456
1457       if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1458         ;
1459       else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1460         {
1461           tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1462           tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1463           int i = 1;
1464
1465           if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1466             t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1467
1468           for (; t1 && t1 != void_list_node;
1469                t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1470             if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1471               {
1472                 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1473                                            TREE_PURPOSE (t2)))
1474                   {
1475                     pedwarn ("default argument given for parameter %d of `%#D'",
1476                              i, newdecl);
1477                     cp_pedwarn_at ("after previous specification in `%#D'",
1478                                    olddecl);
1479                   }
1480                 else
1481                   {
1482                     error ("default argument given for parameter %d of `%#D'",
1483                               i, newdecl);
1484                     cp_error_at ("after previous specification in `%#D'",
1485                                  olddecl);
1486                   }
1487               }
1488
1489           if (DECL_DECLARED_INLINE_P (newdecl)
1490               && ! DECL_DECLARED_INLINE_P (olddecl)
1491               && TREE_ADDRESSABLE (olddecl) && warn_inline)
1492             {
1493               warning ("`%#D' was used before it was declared inline", newdecl);
1494               warning ("%Jprevious non-inline declaration here", olddecl);
1495             }
1496         }
1497     }
1498
1499   /* Do not merge an implicit typedef with an explicit one.  In:
1500
1501        class A;
1502        ...
1503        typedef class A A __attribute__ ((foo));
1504
1505      the attribute should apply only to the typedef.  */
1506   if (TREE_CODE (olddecl) == TYPE_DECL
1507       && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1508           || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1509     return NULL_TREE;
1510
1511   /* If new decl is `static' and an `extern' was seen previously,
1512      warn about it.  */
1513   warn_extern_redeclared_static (newdecl, olddecl);
1514
1515   /* We have committed to returning 1 at this point.  */
1516   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1517     {
1518       /* Now that functions must hold information normally held
1519          by field decls, there is extra work to do so that
1520          declaration information does not get destroyed during
1521          definition.  */
1522       if (DECL_VINDEX (olddecl))
1523         DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1524       if (DECL_CONTEXT (olddecl))
1525         DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1526       DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1527       DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1528       DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1529       DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1530       DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
1531       DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1532       if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1533         SET_OVERLOADED_OPERATOR_CODE
1534           (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1535       new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1536
1537       /* Optionally warn about more than one declaration for the same
1538          name, but don't warn about a function declaration followed by a
1539          definition.  */
1540       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1541           && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1542           /* Don't warn about extern decl followed by definition.  */
1543           && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1544           /* Don't warn about friends, let add_friend take care of it.  */
1545           && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
1546         {
1547           warning ("redundant redeclaration of `%D' in same scope", newdecl);
1548           cp_warning_at ("previous declaration of `%D'", olddecl);
1549         }
1550     }
1551
1552   /* Deal with C++: must preserve virtual function table size.  */
1553   if (TREE_CODE (olddecl) == TYPE_DECL)
1554     {
1555       tree newtype = TREE_TYPE (newdecl);
1556       tree oldtype = TREE_TYPE (olddecl);
1557
1558       if (newtype != error_mark_node && oldtype != error_mark_node
1559           && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1560         CLASSTYPE_FRIEND_CLASSES (newtype)
1561           = CLASSTYPE_FRIEND_CLASSES (oldtype);
1562
1563       DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1564     }
1565
1566   /* Copy all the DECL_... slots specified in the new decl
1567      except for any that we copy here from the old type.  */
1568   DECL_ATTRIBUTES (newdecl)
1569     = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1570
1571   if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1572     {
1573       TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
1574       DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1575         = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1576                    DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1577
1578       /* If the new declaration is a definition, update the file and
1579          line information on the declaration.  */
1580       if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
1581           && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
1582         {
1583           DECL_SOURCE_LOCATION (olddecl)
1584             = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
1585             = DECL_SOURCE_LOCATION (newdecl);
1586           if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1587             DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl))
1588               = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl));
1589         }
1590
1591       if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1592         {
1593           DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl))
1594             |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl));
1595           DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl))
1596             |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl));
1597         }
1598
1599       return olddecl;
1600     }
1601
1602   if (types_match)
1603     {
1604       /* Automatically handles default parameters.  */
1605       tree oldtype = TREE_TYPE (olddecl);
1606       tree newtype;
1607
1608       /* Merge the data types specified in the two decls.  */
1609       newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1610
1611       /* If merge_types produces a non-typedef type, just use the old type.  */
1612       if (TREE_CODE (newdecl) == TYPE_DECL
1613           && newtype == DECL_ORIGINAL_TYPE (newdecl))
1614         newtype = oldtype;
1615
1616       if (TREE_CODE (newdecl) == VAR_DECL)
1617         {
1618           DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1619           DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1620           DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1621             |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1622         }
1623
1624       /* Do this after calling `merge_types' so that default
1625          parameters don't confuse us.  */
1626       else if (TREE_CODE (newdecl) == FUNCTION_DECL
1627           && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
1628               != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
1629         {
1630           TREE_TYPE (newdecl) = build_exception_variant (newtype,
1631                                                          TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
1632           TREE_TYPE (olddecl) = build_exception_variant (newtype,
1633                                                          TYPE_RAISES_EXCEPTIONS (oldtype));
1634
1635           if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
1636               && ! DECL_IS_BUILTIN (olddecl)
1637               && flag_exceptions
1638               && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
1639                                      TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
1640             {
1641               error ("declaration of `%F' throws different exceptions",
1642                         newdecl);
1643               cp_error_at ("than previous declaration `%F'", olddecl);
1644             }
1645         }
1646       TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1647
1648       /* Lay the type out, unless already done.  */
1649       if (! same_type_p (newtype, oldtype)
1650           && TREE_TYPE (newdecl) != error_mark_node
1651           && !(processing_template_decl && uses_template_parms (newdecl)))
1652         layout_type (TREE_TYPE (newdecl));
1653
1654       if ((TREE_CODE (newdecl) == VAR_DECL
1655            || TREE_CODE (newdecl) == PARM_DECL
1656            || TREE_CODE (newdecl) == RESULT_DECL
1657            || TREE_CODE (newdecl) == FIELD_DECL
1658            || TREE_CODE (newdecl) == TYPE_DECL)
1659           && !(processing_template_decl && uses_template_parms (newdecl)))
1660         layout_decl (newdecl, 0);
1661
1662       /* Merge the type qualifiers.  */
1663       if (TREE_READONLY (newdecl))
1664         TREE_READONLY (olddecl) = 1;
1665       if (TREE_THIS_VOLATILE (newdecl))
1666         TREE_THIS_VOLATILE (olddecl) = 1;
1667
1668       /* Merge the initialization information.  */
1669       if (DECL_INITIAL (newdecl) == NULL_TREE
1670           && DECL_INITIAL (olddecl) != NULL_TREE)
1671         {
1672           DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1673           DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1674           if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1675               && DECL_LANG_SPECIFIC (newdecl)
1676               && DECL_LANG_SPECIFIC (olddecl))
1677             {
1678               DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1679               DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1680             }
1681         }
1682
1683       /* Merge the section attribute.
1684          We want to issue an error if the sections conflict but that must be
1685          done later in decl_attributes since we are called before attributes
1686          are assigned.  */
1687       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1688         DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1689
1690       if (TREE_CODE (newdecl) == FUNCTION_DECL)
1691         {
1692           DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1693             |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1694           DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1695           TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1696           TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1697           TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1698           DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1699           DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1700           /* Keep the old RTL.  */
1701           COPY_DECL_RTL (olddecl, newdecl);
1702         }
1703       else if (TREE_CODE (newdecl) == VAR_DECL
1704                && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1705         {
1706           /* Keep the old RTL.  We cannot keep the old RTL if the old
1707              declaration was for an incomplete object and the new
1708              declaration is not since many attributes of the RTL will
1709              change.  */
1710           COPY_DECL_RTL (olddecl, newdecl);
1711         }
1712     }
1713   /* If cannot merge, then use the new type and qualifiers,
1714      and don't preserve the old rtl.  */
1715   else
1716     {
1717       /* Clean out any memory we had of the old declaration.  */
1718       tree oldstatic = value_member (olddecl, static_aggregates);
1719       if (oldstatic)
1720         TREE_VALUE (oldstatic) = error_mark_node;
1721
1722       TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1723       TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1724       TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1725       TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1726     }
1727
1728   /* Merge the storage class information.  */
1729   merge_weak (newdecl, olddecl);
1730
1731   DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1732   DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1733   TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1734   TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1735   if (! DECL_EXTERNAL (olddecl))
1736     DECL_EXTERNAL (newdecl) = 0;
1737
1738   if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1739     {
1740       DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1741       DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1742       DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1743       DECL_TEMPLATE_INSTANTIATED (newdecl)
1744         |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1745       /* Don't really know how much of the language-specific
1746          values we should copy from old to new.  */
1747       DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1748       DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1749         DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1750       DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1751       DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1752       DECL_INITIALIZED_IN_CLASS_P (newdecl)
1753         |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1754       olddecl_friend = DECL_FRIEND_P (olddecl);
1755
1756       /* Only functions have DECL_BEFRIENDING_CLASSES.  */
1757       if (TREE_CODE (newdecl) == FUNCTION_DECL
1758           || DECL_FUNCTION_TEMPLATE_P (newdecl))
1759         {
1760           DECL_BEFRIENDING_CLASSES (newdecl)
1761             = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1762                        DECL_BEFRIENDING_CLASSES (olddecl));
1763           /* DECL_THUNKS is only valid for virtual functions,
1764              otherwise it is a DECL_FRIEND_CONTEXT.  */
1765           if (DECL_VIRTUAL_P (newdecl))
1766             DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1767         }
1768     }
1769
1770   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1771     {
1772       if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1773           && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1774         {
1775           /* If newdecl is not a specialization, then it is not a
1776              template-related function at all.  And that means that we
1777              should have exited above, returning 0.  */
1778           my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
1779                               0);
1780
1781           if (TREE_USED (olddecl))
1782             /* From [temp.expl.spec]:
1783
1784                If a template, a member template or the member of a class
1785                template is explicitly specialized then that
1786                specialization shall be declared before the first use of
1787                that specialization that would cause an implicit
1788                instantiation to take place, in every translation unit in
1789                which such a use occurs.  */
1790             error ("explicit specialization of %D after first use",
1791                       olddecl);
1792
1793           SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1794
1795           /* [temp.expl.spec/14] We don't inline explicit specialization
1796              just because the primary template says so.  */
1797         }
1798       else
1799         {
1800           if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1801             DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1802
1803           DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1804
1805           /* If either decl says `inline', this fn is inline, unless
1806              its definition was passed already.  */
1807           if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1808             DECL_INLINE (olddecl) = 1;
1809           DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1810
1811           DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1812             = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1813         }
1814
1815       /* Preserve abstractness on cloned [cd]tors.  */
1816       DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1817
1818       if (! types_match)
1819         {
1820           SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1821           COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1822           COPY_DECL_RTL (newdecl, olddecl);
1823         }
1824       if (! types_match || new_defines_function)
1825         {
1826           /* These need to be copied so that the names are available.
1827              Note that if the types do match, we'll preserve inline
1828              info and other bits, but if not, we won't.  */
1829           DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1830           DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1831         }
1832       if (new_defines_function)
1833         /* If defining a function declared with other language
1834            linkage, use the previously declared language linkage.  */
1835         SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1836       else if (types_match)
1837         {
1838           /* If redeclaring a builtin function, and not a definition,
1839              it stays built in.  */
1840           if (DECL_BUILT_IN (olddecl))
1841             {
1842               DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1843               DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1844               /* If we're keeping the built-in definition, keep the rtl,
1845                  regardless of declaration matches.  */
1846               COPY_DECL_RTL (olddecl, newdecl);
1847             }
1848
1849           DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1850           /* Don't clear out the arguments if we're redefining a function.  */
1851           if (DECL_ARGUMENTS (olddecl))
1852             DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1853         }
1854     }
1855   else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1856     NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1857
1858   /* Now preserve various other info from the definition.  */
1859   TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1860   TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1861   DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1862   COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1863
1864   /* If either declaration has a nondefault visibility, use it.  */
1865   if (DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT)
1866     {
1867       if (DECL_VISIBILITY (newdecl) != VISIBILITY_DEFAULT
1868           && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1869         {
1870           warning ("%J'%D': visibility attribute ignored because it",
1871                    newdecl, newdecl);
1872           warning ("%Jconflicts with previous declaration here", olddecl);
1873         }
1874       DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1875     }
1876
1877   if (TREE_CODE (newdecl) == FUNCTION_DECL)
1878     {
1879       int function_size;
1880
1881       function_size = sizeof (struct tree_decl);
1882
1883       memcpy ((char *) olddecl + sizeof (struct tree_common),
1884               (char *) newdecl + sizeof (struct tree_common),
1885               function_size - sizeof (struct tree_common));
1886
1887       if (DECL_TEMPLATE_INSTANTIATION (newdecl))
1888         /* If newdecl is a template instantiation, it is possible that
1889            the following sequence of events has occurred:
1890
1891            o A friend function was declared in a class template.  The
1892            class template was instantiated.
1893
1894            o The instantiation of the friend declaration was
1895            recorded on the instantiation list, and is newdecl.
1896
1897            o Later, however, instantiate_class_template called pushdecl
1898            on the newdecl to perform name injection.  But, pushdecl in
1899            turn called duplicate_decls when it discovered that another
1900            declaration of a global function with the same name already
1901            existed.
1902
1903            o Here, in duplicate_decls, we decided to clobber newdecl.
1904
1905            If we're going to do that, we'd better make sure that
1906            olddecl, and not newdecl, is on the list of
1907            instantiations so that if we try to do the instantiation
1908            again we won't get the clobbered declaration.  */
1909         reregister_specialization (newdecl,
1910                                    DECL_TI_TEMPLATE (newdecl),
1911                                    olddecl);
1912     }
1913   else
1914     {
1915       memcpy ((char *) olddecl + sizeof (struct tree_common),
1916               (char *) newdecl + sizeof (struct tree_common),
1917               sizeof (struct tree_decl) - sizeof (struct tree_common)
1918               + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1919     }
1920
1921   DECL_UID (olddecl) = olddecl_uid;
1922   if (olddecl_friend)
1923     DECL_FRIEND_P (olddecl) = 1;
1924
1925   /* NEWDECL contains the merged attribute lists.
1926      Update OLDDECL to be the same.  */
1927   DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1928
1929   /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1930     so that encode_section_info has a chance to look at the new decl
1931     flags and attributes.  */
1932   if (DECL_RTL_SET_P (olddecl)
1933       && (TREE_CODE (olddecl) == FUNCTION_DECL
1934           || (TREE_CODE (olddecl) == VAR_DECL
1935               && TREE_STATIC (olddecl))))
1936     make_decl_rtl (olddecl, NULL);
1937
1938   return olddecl;
1939 }
1940 \f
1941 /* Return zero if the declaration NEWDECL is valid
1942    when the declaration OLDDECL (assumed to be for the same name)
1943    has already been seen.
1944    Otherwise return an error message format string with a %s
1945    where the identifier should go.  */
1946
1947 static const char *
1948 redeclaration_error_message (tree newdecl, tree olddecl)
1949 {
1950   if (TREE_CODE (newdecl) == TYPE_DECL)
1951     {
1952       /* Because C++ can put things into name space for free,
1953          constructs like "typedef struct foo { ... } foo"
1954          would look like an erroneous redeclaration.  */
1955       if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
1956         return 0;
1957       else
1958         return "redefinition of `%#D'";
1959     }
1960   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1961     {
1962       /* If this is a pure function, its olddecl will actually be
1963          the original initialization to `0' (which we force to call
1964          abort()).  Don't complain about redefinition in this case.  */
1965       if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
1966         return 0;
1967
1968       /* If both functions come from different namespaces, this is not
1969          a redeclaration - this is a conflict with a used function.  */
1970       if (DECL_NAMESPACE_SCOPE_P (olddecl)
1971           && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
1972         return "`%D' conflicts with used function";
1973
1974       /* We'll complain about linkage mismatches in
1975          warn_extern_redeclared_static.  */
1976
1977       /* Defining the same name twice is no good.  */
1978       if (DECL_INITIAL (olddecl) != NULL_TREE
1979           && DECL_INITIAL (newdecl) != NULL_TREE)
1980         {
1981           if (DECL_NAME (olddecl) == NULL_TREE)
1982             return "`%#D' not declared in class";
1983           else
1984             return "redefinition of `%#D'";
1985         }
1986       return 0;
1987     }
1988   else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1989     {
1990       tree nt, ot;
1991
1992       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1993         {
1994           if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
1995               && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
1996             return "redefinition of `%#D'";
1997           return NULL;
1998         }
1999
2000       if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2001           || (DECL_TEMPLATE_RESULT (newdecl)
2002               == DECL_TEMPLATE_RESULT (olddecl)))
2003         return NULL;
2004
2005       nt = DECL_TEMPLATE_RESULT (newdecl);
2006       if (DECL_TEMPLATE_INFO (nt))
2007         nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2008       ot = DECL_TEMPLATE_RESULT (olddecl);
2009       if (DECL_TEMPLATE_INFO (ot))
2010         ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2011       if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2012         return "redefinition of `%#D'";
2013
2014       return NULL;
2015     }
2016   else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2017     {
2018       /* Objects declared at top level:  */
2019       /* If at least one is a reference, it's ok.  */
2020       if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2021         return 0;
2022       /* Reject two definitions.  */
2023       return "redefinition of `%#D'";
2024     }
2025   else
2026     {
2027       /* Objects declared with block scope:  */
2028       /* Reject two definitions, and reject a definition
2029          together with an external reference.  */
2030       if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2031         return "redeclaration of `%#D'";
2032       return 0;
2033     }
2034 }
2035 \f
2036 /* Create a new label, named ID.  */
2037
2038 static tree
2039 make_label_decl (tree id, int local_p)
2040 {
2041   tree decl;
2042
2043   decl = build_decl (LABEL_DECL, id, void_type_node);
2044
2045   DECL_CONTEXT (decl) = current_function_decl;
2046   DECL_MODE (decl) = VOIDmode;
2047   C_DECLARED_LABEL_FLAG (decl) = local_p;
2048
2049   /* Say where one reference is to the label, for the sake of the
2050      error if it is not defined.  */
2051   DECL_SOURCE_LOCATION (decl) = input_location;
2052
2053   /* Record the fact that this identifier is bound to this label.  */
2054   SET_IDENTIFIER_LABEL_VALUE (id, decl);
2055
2056   return decl;
2057 }
2058
2059 /* Record this label on the list of used labels so that we can check
2060    at the end of the function to see whether or not the label was
2061    actually defined, and so we can check when the label is defined whether
2062    this use is valid.  */
2063
2064 static void
2065 use_label (tree decl)
2066 {
2067   if (named_label_uses == NULL
2068       || named_label_uses->names_in_scope != current_binding_level->names
2069       || named_label_uses->label_decl != decl)
2070     {
2071       struct named_label_use_list *new_ent;
2072       new_ent = ggc_alloc (sizeof (struct named_label_use_list));
2073       new_ent->label_decl = decl;
2074       new_ent->names_in_scope = current_binding_level->names;
2075       new_ent->binding_level = current_binding_level;
2076       new_ent->o_goto_locus = input_location;
2077       new_ent->next = named_label_uses;
2078       named_label_uses = new_ent;
2079     }
2080 }
2081
2082 /* Look for a label named ID in the current function.  If one cannot
2083    be found, create one.  (We keep track of used, but undefined,
2084    labels, and complain about them at the end of a function.)  */
2085
2086 tree
2087 lookup_label (tree id)
2088 {
2089   tree decl;
2090   struct named_label_list *ent;
2091
2092   timevar_push (TV_NAME_LOOKUP);
2093   /* You can't use labels at global scope.  */
2094   if (current_function_decl == NULL_TREE)
2095     {
2096       error ("label `%E' referenced outside of any function", id);
2097       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2098     }
2099
2100   /* See if we've already got this label.  */
2101   decl = IDENTIFIER_LABEL_VALUE (id);
2102   if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2103     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2104
2105   /* Record this label on the list of labels used in this function.
2106      We do this before calling make_label_decl so that we get the
2107      IDENTIFIER_LABEL_VALUE before the new label is declared.  */
2108   ent = ggc_alloc_cleared (sizeof (struct named_label_list));
2109   ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2110   ent->next = named_labels;
2111   named_labels = ent;
2112
2113   /* We need a new label.  */
2114   decl = make_label_decl (id, /*local_p=*/0);
2115
2116   /* Now fill in the information we didn't have before.  */
2117   ent->label_decl = decl;
2118
2119   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2120 }
2121
2122 /* Declare a local label named ID.  */
2123
2124 tree
2125 declare_local_label (tree id)
2126 {
2127   tree decl;
2128
2129   /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2130      this scope we can restore the old value of
2131      IDENTIFIER_TYPE_VALUE.  */
2132   current_binding_level->shadowed_labels
2133     = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2134                  current_binding_level->shadowed_labels);
2135   /* Look for the label.  */
2136   decl = make_label_decl (id, /*local_p=*/1);
2137   /* Now fill in the information we didn't have before.  */
2138   TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2139
2140   return decl;
2141 }
2142
2143 /* Returns nonzero if it is ill-formed to jump past the declaration of
2144    DECL.  Returns 2 if it's also a real problem.  */
2145
2146 static int
2147 decl_jump_unsafe (tree decl)
2148 {
2149   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
2150     return 0;
2151
2152   if (DECL_INITIAL (decl) == NULL_TREE
2153       && pod_type_p (TREE_TYPE (decl)))
2154     return 0;
2155
2156   /* This is really only important if we're crossing an initialization.
2157      The POD stuff is just pedantry; why should it matter if the class
2158      contains a field of pointer to member type?  */
2159   if (DECL_INITIAL (decl)
2160       || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
2161     return 2;
2162   return 1;
2163 }
2164
2165 /* Check that a single previously seen jump to a newly defined label
2166    is OK.  DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2167    the jump context; NAMES are the names in scope in LEVEL at the jump
2168    context; FILE and LINE are the source position of the jump or 0.  */
2169
2170 static void
2171 check_previous_goto_1 (tree decl,
2172                        struct cp_binding_level* level,
2173                        tree names, const location_t *locus)
2174 {
2175   int identified = 0;
2176   int saw_eh = 0;
2177   struct cp_binding_level *b = current_binding_level;
2178   for (; b; b = b->level_chain)
2179     {
2180       tree new_decls = b->names;
2181       tree old_decls = (b == level ? names : NULL_TREE);
2182       for (; new_decls != old_decls;
2183            new_decls = TREE_CHAIN (new_decls))
2184         {
2185           int problem = decl_jump_unsafe (new_decls);
2186           if (! problem)
2187             continue;
2188
2189           if (! identified)
2190             {
2191               if (decl)
2192                 pedwarn ("jump to label `%D'", decl);
2193               else
2194                 pedwarn ("jump to case label");
2195
2196               if (locus)
2197                 pedwarn ("%H  from here", locus);
2198               identified = 1;
2199             }
2200
2201           if (problem > 1)
2202             cp_error_at ("  crosses initialization of `%#D'",
2203                          new_decls);
2204           else
2205             cp_pedwarn_at ("  enters scope of non-POD `%#D'",
2206                            new_decls);
2207         }
2208
2209       if (b == level)
2210         break;
2211       if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2212         {
2213           if (! identified)
2214             {
2215               if (decl)
2216                 pedwarn ("jump to label `%D'", decl);
2217               else
2218                 pedwarn ("jump to case label");
2219
2220               if (locus)
2221                 pedwarn ("%H  from here", locus);
2222               identified = 1;
2223             }
2224           if (b->kind == sk_try)
2225             error ("  enters try block");
2226           else
2227             error ("  enters catch block");
2228           saw_eh = 1;
2229         }
2230     }
2231 }
2232
2233 static void
2234 check_previous_goto (struct named_label_use_list* use)
2235 {
2236   check_previous_goto_1 (use->label_decl, use->binding_level,
2237                          use->names_in_scope, &use->o_goto_locus);
2238 }
2239
2240 static void
2241 check_switch_goto (struct cp_binding_level* level)
2242 {
2243   check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2244 }
2245
2246 /* Check that any previously seen jumps to a newly defined label DECL
2247    are OK.  Called by define_label.  */
2248
2249 static void
2250 check_previous_gotos (tree decl)
2251 {
2252   struct named_label_use_list **usep;
2253
2254   if (! TREE_USED (decl))
2255     return;
2256
2257   for (usep = &named_label_uses; *usep; )
2258     {
2259       struct named_label_use_list *use = *usep;
2260       if (use->label_decl == decl)
2261         {
2262           check_previous_goto (use);
2263           *usep = use->next;
2264         }
2265       else
2266         usep = &(use->next);
2267     }
2268 }
2269
2270 /* Check that a new jump to a label DECL is OK.  Called by
2271    finish_goto_stmt.  */
2272
2273 void
2274 check_goto (tree decl)
2275 {
2276   int identified = 0;
2277   tree bad;
2278   struct named_label_list *lab;
2279
2280   /* We can't know where a computed goto is jumping.  So we assume
2281      that it's OK.  */
2282   if (! DECL_P (decl))
2283     return;
2284
2285   /* If the label hasn't been defined yet, defer checking.  */
2286   if (! DECL_INITIAL (decl))
2287     {
2288       use_label (decl);
2289       return;
2290     }
2291
2292   for (lab = named_labels; lab; lab = lab->next)
2293     if (decl == lab->label_decl)
2294       break;
2295
2296   /* If the label is not on named_labels it's a gcc local label, so
2297      it must be in an outer scope, so jumping to it is always OK.  */
2298   if (lab == 0)
2299     return;
2300
2301   if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2302       && !identified)
2303     {
2304       cp_pedwarn_at ("jump to label `%D'", decl);
2305       pedwarn ("  from here");
2306       identified = 1;
2307     }
2308
2309   for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2310     {
2311       tree b = TREE_VALUE (bad);
2312       int u = decl_jump_unsafe (b);
2313
2314       if (u > 1 && DECL_ARTIFICIAL (b))
2315         /* Can't skip init of __exception_info.  */
2316         error ("%J  enters catch block", b);
2317       else if (u > 1)
2318         cp_error_at ("  skips initialization of `%#D'", b);
2319       else
2320         cp_pedwarn_at ("  enters scope of non-POD `%#D'", b);
2321     }
2322
2323   if (lab->in_try_scope)
2324     error ("  enters try block");
2325   else if (lab->in_catch_scope)
2326     error ("  enters catch block");
2327 }
2328
2329 /* Define a label, specifying the location in the source file.
2330    Return the LABEL_DECL node for the label.  */
2331
2332 tree
2333 define_label (location_t location, tree name)
2334 {
2335   tree decl = lookup_label (name);
2336   struct named_label_list *ent;
2337   struct cp_binding_level *p;
2338
2339   timevar_push (TV_NAME_LOOKUP);
2340   for (ent = named_labels; ent; ent = ent->next)
2341     if (ent->label_decl == decl)
2342       break;
2343
2344   /* After labels, make any new cleanups in the function go into their
2345      own new (temporary) binding contour.  */
2346   for (p = current_binding_level;
2347        p->kind != sk_function_parms;
2348        p = p->level_chain)
2349     p->more_cleanups_ok = 0;
2350
2351   if (name == get_identifier ("wchar_t"))
2352     pedwarn ("label named wchar_t");
2353
2354   if (DECL_INITIAL (decl) != NULL_TREE)
2355     error ("duplicate label `%D'", decl);
2356   else
2357     {
2358       /* Mark label as having been defined.  */
2359       DECL_INITIAL (decl) = error_mark_node;
2360       /* Say where in the source.  */
2361       DECL_SOURCE_LOCATION (decl) = location;
2362       if (ent)
2363         {
2364           ent->names_in_scope = current_binding_level->names;
2365           ent->binding_level = current_binding_level;
2366         }
2367       check_previous_gotos (decl);
2368     }
2369
2370   timevar_pop (TV_NAME_LOOKUP);
2371   return decl;
2372 }
2373
2374 struct cp_switch
2375 {
2376   struct cp_binding_level *level;
2377   struct cp_switch *next;
2378   /* The SWITCH_STMT being built.  */
2379   tree switch_stmt;
2380   /* A splay-tree mapping the low element of a case range to the high
2381      element, or NULL_TREE if there is no high element.  Used to
2382      determine whether or not a new case label duplicates an old case
2383      label.  We need a tree, rather than simply a hash table, because
2384      of the GNU case range extension.  */
2385   splay_tree cases;
2386 };
2387
2388 /* A stack of the currently active switch statements.  The innermost
2389    switch statement is on the top of the stack.  There is no need to
2390    mark the stack for garbage collection because it is only active
2391    during the processing of the body of a function, and we never
2392    collect at that point.  */
2393
2394 static struct cp_switch *switch_stack;
2395
2396 /* Called right after a switch-statement condition is parsed.
2397    SWITCH_STMT is the switch statement being parsed.  */
2398
2399 void
2400 push_switch (tree switch_stmt)
2401 {
2402   struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2403   p->level = current_binding_level;
2404   p->next = switch_stack;
2405   p->switch_stmt = switch_stmt;
2406   p->cases = splay_tree_new (case_compare, NULL, NULL);
2407   switch_stack = p;
2408 }
2409
2410 void
2411 pop_switch (void)
2412 {
2413   struct cp_switch *cs = switch_stack;
2414
2415   /* Emit warnings as needed.  */
2416   c_do_switch_warnings (cs->cases, cs->switch_stmt);
2417
2418   splay_tree_delete (cs->cases);
2419   switch_stack = switch_stack->next;
2420   free (cs);
2421 }
2422
2423 /* Note that we've seen a definition of a case label, and complain if this
2424    is a bad place for one.  */
2425
2426 tree
2427 finish_case_label (tree low_value, tree high_value)
2428 {
2429   tree cond, r;
2430   struct cp_binding_level *p;
2431
2432   if (processing_template_decl)
2433     {
2434       tree label;
2435
2436       /* For templates, just add the case label; we'll do semantic
2437          analysis at instantiation-time.  */
2438       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2439       return add_stmt (build_case_label (low_value, high_value, label));
2440     }
2441
2442   /* Find the condition on which this switch statement depends.  */
2443   cond = SWITCH_COND (switch_stack->switch_stmt);
2444   if (cond && TREE_CODE (cond) == TREE_LIST)
2445     cond = TREE_VALUE (cond);
2446
2447   r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
2448
2449   check_switch_goto (switch_stack->level);
2450
2451   /* After labels, make any new cleanups in the function go into their
2452      own new (temporary) binding contour.  */
2453   for (p = current_binding_level;
2454        p->kind != sk_function_parms;
2455        p = p->level_chain)
2456     p->more_cleanups_ok = 0;
2457
2458   return r;
2459 }
2460 \f
2461 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
2462
2463 static hashval_t
2464 typename_hash (const void* k)
2465 {
2466   hashval_t hash;
2467   tree t = (tree) k;
2468
2469   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2470           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2471
2472   return hash;
2473 }
2474
2475 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
2476
2477 static int
2478 typename_compare (const void * k1, const void * k2)
2479 {
2480   tree t1;
2481   tree t2;
2482   tree d1;
2483   tree d2;
2484
2485   t1 = (tree) k1;
2486   t2 = (tree) k2;
2487   d1 = TYPE_NAME (t1);
2488   d2 = TYPE_NAME (t2);
2489
2490   return (DECL_NAME (d1) == DECL_NAME (d2)
2491           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
2492           && ((TREE_TYPE (t1) != NULL_TREE)
2493               == (TREE_TYPE (t2) != NULL_TREE))
2494           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2495           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
2496 }
2497
2498 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
2499    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
2500    is non-NULL, this type is being created by the implicit typename
2501    extension, and BASE_TYPE is a type named `t' in some base class of
2502    `T' which depends on template parameters.
2503
2504    Returns the new TYPENAME_TYPE.  */
2505
2506 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2507
2508 static tree
2509 build_typename_type (tree context, tree name, tree fullname)
2510 {
2511   tree t;
2512   tree d;
2513   void **e;
2514
2515   if (typename_htab == NULL)
2516     {
2517       typename_htab = htab_create_ggc (61, &typename_hash,
2518                                        &typename_compare, NULL);
2519     }
2520
2521   /* Build the TYPENAME_TYPE.  */
2522   t = make_aggr_type (TYPENAME_TYPE);
2523   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2524   TYPENAME_TYPE_FULLNAME (t) = fullname;
2525
2526   /* Build the corresponding TYPE_DECL.  */
2527   d = build_decl (TYPE_DECL, name, t);
2528   TYPE_NAME (TREE_TYPE (d)) = d;
2529   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2530   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2531   DECL_ARTIFICIAL (d) = 1;
2532
2533   /* See if we already have this type.  */
2534   e = htab_find_slot (typename_htab, t, INSERT);
2535   if (*e)
2536     t = (tree) *e;
2537   else
2538     *e = t;
2539
2540   return t;
2541 }
2542
2543 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
2544    unless an error occurs, in which case error_mark_node is returned.
2545    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2546    set, we return that, rather than the _TYPE it corresponds to, in
2547    other cases we look through the type decl.  If TF_ERROR is set,
2548    complain about errors, otherwise be quiet.  */
2549
2550 tree
2551 make_typename_type (tree context, tree name, tsubst_flags_t complain)
2552 {
2553   tree fullname;
2554
2555   if (name == error_mark_node
2556       || context == NULL_TREE
2557       || context == error_mark_node)
2558     return error_mark_node;
2559
2560   if (TYPE_P (name))
2561     {
2562       if (!(TYPE_LANG_SPECIFIC (name)
2563             && (CLASSTYPE_IS_TEMPLATE (name)
2564                 || CLASSTYPE_USE_TEMPLATE (name))))
2565         name = TYPE_IDENTIFIER (name);
2566       else
2567         /* Create a TEMPLATE_ID_EXPR for the type.  */
2568         name = build_nt (TEMPLATE_ID_EXPR,
2569                          CLASSTYPE_TI_TEMPLATE (name),
2570                          CLASSTYPE_TI_ARGS (name));
2571     }
2572   else if (TREE_CODE (name) == TYPE_DECL)
2573     name = DECL_NAME (name);
2574
2575   fullname = name;
2576
2577   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2578     {
2579       name = TREE_OPERAND (name, 0);
2580       if (TREE_CODE (name) == TEMPLATE_DECL)
2581         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2582     }
2583   if (TREE_CODE (name) == TEMPLATE_DECL)
2584     {
2585       error ("`%D' used without template parameters", name);
2586       return error_mark_node;
2587     }
2588   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802);
2589
2590   if (TREE_CODE (context) == NAMESPACE_DECL)
2591     {
2592       /* We can get here from typename_sub0 in the explicit_template_type
2593          expansion.  Just fail.  */
2594       if (complain & tf_error)
2595         error ("no class template named `%#T' in `%#T'",
2596                   name, context);
2597       return error_mark_node;
2598     }
2599
2600   if (!dependent_type_p (context)
2601       || currently_open_class (context))
2602     {
2603       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2604         {
2605           tree tmpl = NULL_TREE;
2606           if (IS_AGGR_TYPE (context))
2607             tmpl = lookup_field (context, name, 0, false);
2608           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2609             {
2610               if (complain & tf_error)
2611                 error ("no class template named `%#T' in `%#T'",
2612                           name, context);
2613               return error_mark_node;
2614             }
2615
2616           if (complain & tf_error)
2617             perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2618
2619           return lookup_template_class (tmpl,
2620                                         TREE_OPERAND (fullname, 1),
2621                                         NULL_TREE, context,
2622                                         /*entering_scope=*/0,
2623                                         tf_error | tf_warning | tf_user);
2624         }
2625       else
2626         {
2627           tree t;
2628
2629           if (!IS_AGGR_TYPE (context))
2630             {
2631               if (complain & tf_error)
2632                 error ("no type named `%#T' in `%#T'", name, context);
2633               return error_mark_node;
2634             }
2635
2636           t = lookup_field (context, name, 0, true);
2637           if (t)
2638             {
2639               if (TREE_CODE (t) != TYPE_DECL)
2640                 {
2641                   if (complain & tf_error)
2642                     error ("no type named `%#T' in `%#T'", name, context);
2643                   return error_mark_node;
2644                 }
2645
2646               if (complain & tf_error)
2647                 perform_or_defer_access_check (TYPE_BINFO (context), t);
2648
2649               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2650                 t = TREE_TYPE (t);
2651
2652               return t;
2653             }
2654         }
2655     }
2656
2657   /* If the CONTEXT is not a template type, then either the field is
2658      there now or its never going to be.  */
2659   if (!dependent_type_p (context))
2660     {
2661       if (complain & tf_error)
2662         error ("no type named `%#T' in `%#T'", name, context);
2663       return error_mark_node;
2664     }
2665
2666   return build_typename_type (context, name, fullname);
2667 }
2668
2669 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
2670    unless an error occurs, in which case error_mark_node is returned.
2671    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2672    corresponds to.  If COMPLAIN zero, don't complain about any errors
2673    that occur.  */
2674
2675 tree
2676 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
2677 {
2678   tree t;
2679   tree d;
2680
2681   if (TYPE_P (name))
2682     name = TYPE_IDENTIFIER (name);
2683   else if (DECL_P (name))
2684     name = DECL_NAME (name);
2685   if (TREE_CODE (name) != IDENTIFIER_NODE)
2686     abort ();
2687
2688   if (!dependent_type_p (context)
2689       || currently_open_class (context))
2690     {
2691       tree tmpl = NULL_TREE;
2692
2693       if (IS_AGGR_TYPE (context))
2694         tmpl = lookup_field (context, name, 0, false);
2695
2696       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2697         {
2698           if (complain & tf_error)
2699             error ("no class template named `%#T' in `%#T'", name, context);
2700           return error_mark_node;
2701         }
2702
2703       if (complain & tf_error)
2704         perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2705
2706       return tmpl;
2707     }
2708
2709   /* Build the UNBOUND_CLASS_TEMPLATE.  */
2710   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2711   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2712   TREE_TYPE (t) = NULL_TREE;
2713
2714   /* Build the corresponding TEMPLATE_DECL.  */
2715   d = build_decl (TEMPLATE_DECL, name, t);
2716   TYPE_NAME (TREE_TYPE (d)) = d;
2717   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2718   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2719   DECL_ARTIFICIAL (d) = 1;
2720
2721   return t;
2722 }
2723
2724 \f
2725
2726 /* Push the declarations of builtin types into the namespace.
2727    RID_INDEX is the index of the builtin type in the array
2728    RID_POINTERS.  NAME is the name used when looking up the builtin
2729    type.  TYPE is the _TYPE node for the builtin type.  */
2730
2731 void
2732 record_builtin_type (enum rid rid_index,
2733                      const char* name,
2734                      tree type)
2735 {
2736   tree rname = NULL_TREE, tname = NULL_TREE;
2737   tree tdecl = NULL_TREE;
2738
2739   if ((int) rid_index < (int) RID_MAX)
2740     rname = ridpointers[(int) rid_index];
2741   if (name)
2742     tname = get_identifier (name);
2743
2744   /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2745      eliminated.  Built-in types should not be looked up name; their
2746      names are keywords that the parser can recognize.  However, there
2747      is code in c-common.c that uses identifier_global_value to look
2748      up built-in types by name.  */
2749   if (tname)
2750     {
2751       tdecl = build_decl (TYPE_DECL, tname, type);
2752       DECL_ARTIFICIAL (tdecl) = 1;
2753       SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2754     }
2755   if (rname)
2756     {
2757       if (!tdecl)
2758         {
2759           tdecl = build_decl (TYPE_DECL, rname, type);
2760           DECL_ARTIFICIAL (tdecl) = 1;
2761         }
2762       SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2763     }
2764
2765   if (!TYPE_NAME (type))
2766     TYPE_NAME (type) = tdecl;
2767
2768   if (tdecl)
2769     debug_hooks->type_decl (tdecl, 0);
2770 }
2771
2772 /* Record one of the standard Java types.
2773  * Declare it as having the given NAME.
2774  * If SIZE > 0, it is the size of one of the integral types;
2775  * otherwise it is the negative of the size of one of the other types.  */
2776
2777 static tree
2778 record_builtin_java_type (const char* name, int size)
2779 {
2780   tree type, decl;
2781   if (size > 0)
2782     type = make_signed_type (size);
2783   else if (size > -32)
2784     { /* "__java_char" or ""__java_boolean".  */
2785       type = make_unsigned_type (-size);
2786       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2787     }
2788   else
2789     { /* "__java_float" or ""__java_double".  */
2790       type = make_node (REAL_TYPE);
2791       TYPE_PRECISION (type) = - size;
2792       layout_type (type);
2793     }
2794   record_builtin_type (RID_MAX, name, type);
2795   decl = TYPE_NAME (type);
2796
2797   /* Suppress generate debug symbol entries for these types,
2798      since for normal C++ they are just clutter.
2799      However, push_lang_context undoes this if extern "Java" is seen.  */
2800   DECL_IGNORED_P (decl) = 1;
2801
2802   TYPE_FOR_JAVA (type) = 1;
2803   return type;
2804 }
2805
2806 /* Push a type into the namespace so that the back-ends ignore it.  */
2807
2808 static void
2809 record_unknown_type (tree type, const char* name)
2810 {
2811   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2812   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
2813   DECL_IGNORED_P (decl) = 1;
2814   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2815   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2816   TYPE_ALIGN (type) = 1;
2817   TYPE_USER_ALIGN (type) = 0;
2818   TYPE_MODE (type) = TYPE_MODE (void_type_node);
2819 }
2820
2821 /* An string for which we should create an IDENTIFIER_NODE at
2822    startup.  */
2823
2824 typedef struct predefined_identifier
2825 {
2826   /* The name of the identifier.  */
2827   const char *const name;
2828   /* The place where the IDENTIFIER_NODE should be stored.  */
2829   tree *const node;
2830   /* Nonzero if this is the name of a constructor or destructor.  */
2831   const int ctor_or_dtor_p;
2832 } predefined_identifier;
2833
2834 /* Create all the predefined identifiers.  */
2835
2836 static void
2837 initialize_predefined_identifiers (void)
2838 {
2839   const predefined_identifier *pid;
2840
2841   /* A table of identifiers to create at startup.  */
2842   static const predefined_identifier predefined_identifiers[] = {
2843     { "C++", &lang_name_cplusplus, 0 },
2844     { "C", &lang_name_c, 0 },
2845     { "Java", &lang_name_java, 0 },
2846     { CTOR_NAME, &ctor_identifier, 1 },
2847     { "__base_ctor", &base_ctor_identifier, 1 },
2848     { "__comp_ctor", &complete_ctor_identifier, 1 },
2849     { DTOR_NAME, &dtor_identifier, 1 },
2850     { "__comp_dtor", &complete_dtor_identifier, 1 },
2851     { "__base_dtor", &base_dtor_identifier, 1 },
2852     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
2853     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2854     { "nelts", &nelts_identifier, 0 },
2855     { THIS_NAME, &this_identifier, 0 },
2856     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2857     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2858     { "_vptr", &vptr_identifier, 0 },
2859     { "__vtt_parm", &vtt_parm_identifier, 0 },
2860     { "::", &global_scope_name, 0 },
2861     { "std", &std_identifier, 0 },
2862     { NULL, NULL, 0 }
2863   };
2864
2865   for (pid = predefined_identifiers; pid->name; ++pid)
2866     {
2867       *pid->node = get_identifier (pid->name);
2868       if (pid->ctor_or_dtor_p)
2869         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2870     }
2871 }
2872
2873 /* Create the predefined scalar types of C,
2874    and some nodes representing standard constants (0, 1, (void *)0).
2875    Initialize the global binding level.
2876    Make definitions for built-in primitive functions.  */
2877
2878 void
2879 cxx_init_decl_processing (void)
2880 {
2881   tree void_ftype;
2882   tree void_ftype_ptr;
2883
2884   build_common_tree_nodes (flag_signed_char);
2885
2886   /* Create all the identifiers we need.  */
2887   initialize_predefined_identifiers ();
2888
2889   /* Create the global variables.  */
2890   push_to_top_level ();
2891
2892   current_function_decl = NULL_TREE;
2893   current_binding_level = NULL;
2894   /* Enter the global namespace.  */
2895   my_friendly_assert (global_namespace == NULL_TREE, 375);
2896   global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2897                                       void_type_node);
2898   begin_scope (sk_namespace, global_namespace);
2899
2900   current_lang_name = NULL_TREE;
2901
2902   /* Adjust various flags based on command-line settings.  */
2903   if (!flag_permissive)
2904     flag_pedantic_errors = 1;
2905   if (!flag_no_inline)
2906     {
2907       flag_inline_trees = 1;
2908       flag_no_inline = 1;
2909     }
2910   if (flag_inline_functions)
2911     {
2912       flag_inline_trees = 2;
2913       flag_inline_functions = 0;
2914     }
2915
2916   /* Force minimum function alignment if using the least significant
2917      bit of function pointers to store the virtual bit.  */
2918   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2919       && force_align_functions_log < 1)
2920     force_align_functions_log = 1;
2921
2922   /* Initially, C.  */
2923   current_lang_name = lang_name_c;
2924
2925   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2926   TREE_TYPE (error_mark_list) = error_mark_node;
2927
2928   /* Create the `std' namespace.  */
2929   push_namespace (std_identifier);
2930   std_node = current_namespace;
2931   pop_namespace ();
2932
2933   c_common_nodes_and_builtins ();
2934
2935   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2936   java_short_type_node = record_builtin_java_type ("__java_short", 16);
2937   java_int_type_node = record_builtin_java_type ("__java_int", 32);
2938   java_long_type_node = record_builtin_java_type ("__java_long", 64);
2939   java_float_type_node = record_builtin_java_type ("__java_float", -32);
2940   java_double_type_node = record_builtin_java_type ("__java_double", -64);
2941   java_char_type_node = record_builtin_java_type ("__java_char", -16);
2942   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2943
2944   integer_two_node = build_int_2 (2, 0);
2945   TREE_TYPE (integer_two_node) = integer_type_node;
2946   integer_three_node = build_int_2 (3, 0);
2947   TREE_TYPE (integer_three_node) = integer_type_node;
2948
2949   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2950   truthvalue_type_node = boolean_type_node;
2951   truthvalue_false_node = boolean_false_node;
2952   truthvalue_true_node = boolean_true_node;
2953
2954   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
2955
2956 #if 0
2957   record_builtin_type (RID_MAX, NULL, string_type_node);
2958 #endif
2959
2960   delta_type_node = ptrdiff_type_node;
2961   vtable_index_type = ptrdiff_type_node;
2962
2963   vtt_parm_type = build_pointer_type (const_ptr_type_node);
2964   void_ftype = build_function_type (void_type_node, void_list_node);
2965   void_ftype_ptr = build_function_type (void_type_node,
2966                                         tree_cons (NULL_TREE,
2967                                                    ptr_type_node,
2968                                                    void_list_node));
2969   void_ftype_ptr
2970     = build_exception_variant (void_ftype_ptr, empty_except_spec);
2971
2972   /* C++ extensions */
2973
2974   unknown_type_node = make_node (UNKNOWN_TYPE);
2975   record_unknown_type (unknown_type_node, "unknown type");
2976
2977   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
2978   TREE_TYPE (unknown_type_node) = unknown_type_node;
2979
2980   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
2981      result.  */
2982   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
2983   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
2984
2985   {
2986     /* Make sure we get a unique function type, so we can give
2987        its pointer type a name.  (This wins for gdb.) */
2988     tree vfunc_type = make_node (FUNCTION_TYPE);
2989     TREE_TYPE (vfunc_type) = integer_type_node;
2990     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
2991     layout_type (vfunc_type);
2992
2993     vtable_entry_type = build_pointer_type (vfunc_type);
2994   }
2995   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
2996
2997   vtbl_type_node
2998     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
2999   layout_type (vtbl_type_node);
3000   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3001   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3002   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3003   layout_type (vtbl_ptr_type_node);
3004   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3005
3006   push_namespace (get_identifier ("__cxxabiv1"));
3007   abi_node = current_namespace;
3008   pop_namespace ();
3009
3010   global_type_node = make_node (LANG_TYPE);
3011   record_unknown_type (global_type_node, "global type");
3012
3013   /* Now, C++.  */
3014   current_lang_name = lang_name_cplusplus;
3015
3016   {
3017     tree bad_alloc_id;
3018     tree bad_alloc_type_node;
3019     tree bad_alloc_decl;
3020     tree newtype, deltype;
3021     tree ptr_ftype_sizetype;
3022
3023     push_namespace (std_identifier);
3024     bad_alloc_id = get_identifier ("bad_alloc");
3025     bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3026     TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3027     bad_alloc_decl
3028       = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3029     DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3030     TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3031     pop_namespace ();
3032
3033     ptr_ftype_sizetype
3034       = build_function_type (ptr_type_node,
3035                              tree_cons (NULL_TREE,
3036                                         size_type_node,
3037                                         void_list_node));
3038     newtype = build_exception_variant
3039       (ptr_ftype_sizetype, add_exception_specifier
3040        (NULL_TREE, bad_alloc_type_node, -1));
3041     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3042     push_cp_library_fn (NEW_EXPR, newtype);
3043     push_cp_library_fn (VEC_NEW_EXPR, newtype);
3044     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3045     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3046   }
3047
3048   abort_fndecl
3049     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3050
3051   /* Perform other language dependent initializations.  */
3052   init_class_processing ();
3053   init_rtti_processing ();
3054
3055   if (flag_exceptions)
3056     init_exception_processing ();
3057
3058   if (! supports_one_only ())
3059     flag_weak = 0;
3060
3061   make_fname_decl = cp_make_fname_decl;
3062   start_fname_decls ();
3063
3064   /* Show we use EH for cleanups.  */
3065   if (flag_exceptions)
3066     using_eh_for_cleanups ();
3067 }
3068
3069 /* Generate an initializer for a function naming variable from
3070    NAME. NAME may be NULL, to indicate a dependent name.  TYPE_P is
3071    filled in with the type of the init.  */
3072
3073 tree
3074 cp_fname_init (const char* name, tree *type_p)
3075 {
3076   tree domain = NULL_TREE;
3077   tree type;
3078   tree init = NULL_TREE;
3079   size_t length = 0;
3080
3081   if (name)
3082     {
3083       length = strlen (name);
3084       domain = build_index_type (size_int (length));
3085       init = build_string (length + 1, name);
3086     }
3087
3088   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3089   type = build_cplus_array_type (type, domain);
3090
3091   *type_p = type;
3092
3093   if (init)
3094     TREE_TYPE (init) = type;
3095   else
3096     init = error_mark_node;
3097
3098   return init;
3099 }
3100
3101 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3102    decl, NAME is the initialization string and TYPE_DEP indicates whether
3103    NAME depended on the type of the function. We make use of that to detect
3104    __PRETTY_FUNCTION__ inside a template fn. This is being done
3105    lazily at the point of first use, so we mustn't push the decl now.  */
3106
3107 static tree
3108 cp_make_fname_decl (tree id, int type_dep)
3109 {
3110   const char *const name = (type_dep && processing_template_decl
3111                             ? NULL : fname_as_string (type_dep));
3112   tree type;
3113   tree init = cp_fname_init (name, &type);
3114   tree decl = build_decl (VAR_DECL, id, type);
3115
3116   if (name)
3117     free ((char *) name);
3118
3119   /* As we're using pushdecl_with_scope, we must set the context.  */
3120   DECL_CONTEXT (decl) = current_function_decl;
3121   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3122
3123   TREE_STATIC (decl) = 1;
3124   TREE_READONLY (decl) = 1;
3125   DECL_ARTIFICIAL (decl) = 1;
3126   DECL_INITIAL (decl) = init;
3127
3128   TREE_USED (decl) = 1;
3129
3130   if (current_function_decl)
3131     {
3132       struct cp_binding_level *b = current_binding_level;
3133       while (b->level_chain->kind != sk_function_parms)
3134         b = b->level_chain;
3135       pushdecl_with_scope (decl, b);
3136       cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3137     }
3138   else
3139     pushdecl_top_level_and_finish (decl, init);
3140
3141   return decl;
3142 }
3143
3144 /* Make a definition for a builtin function named NAME in the current
3145    namespace, whose data type is TYPE and whose context is CONTEXT.
3146    TYPE should be a function type with argument types.
3147
3148    CLASS and CODE tell later passes how to compile calls to this function.
3149    See tree.h for possible values.
3150
3151    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3152    the name to be called if we can't opencode the function.
3153    If ATTRS is nonzero, use that for the function's attribute
3154    list.  */
3155
3156 static tree
3157 builtin_function_1 (const char* name,
3158                     tree type,
3159                     tree context,
3160                     int code,
3161                     enum built_in_class class,
3162                     const char* libname,
3163                     tree attrs)
3164 {
3165   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3166   DECL_BUILT_IN_CLASS (decl) = class;
3167   DECL_FUNCTION_CODE (decl) = code;
3168   DECL_CONTEXT (decl) = context;
3169
3170   pushdecl (decl);
3171
3172   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3173      we cannot change DECL_ASSEMBLER_NAME until we have installed this
3174      function in the namespace.  */
3175   if (libname)
3176     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3177
3178   /* Warn if a function in the namespace for users
3179      is used without an occasion to consider it declared.  */
3180   if (name[0] != '_' || name[1] != '_')
3181     DECL_ANTICIPATED (decl) = 1;
3182
3183   /* Possibly apply some default attributes to this built-in function.  */
3184   if (attrs)
3185     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3186   else
3187     decl_attributes (&decl, NULL_TREE, 0);
3188
3189   return decl;
3190 }
3191
3192 /* Entry point for the benefit of c_common_nodes_and_builtins.
3193
3194    Make a definition for a builtin function named NAME and whose data type
3195    is TYPE.  TYPE should be a function type with argument types.  This
3196    function places the anticipated declaration in the global namespace
3197    and additionally in the std namespace if appropriate.
3198
3199    CLASS and CODE tell later passes how to compile calls to this function.
3200    See tree.h for possible values.
3201
3202    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3203    the name to be called if we can't opencode the function.
3204
3205    If ATTRS is nonzero, use that for the function's attribute
3206    list.  */
3207
3208 tree
3209 builtin_function (const char* name,
3210                   tree type,
3211                   int code,
3212                   enum built_in_class class,
3213                   const char* libname,
3214                   tree attrs)
3215 {
3216   /* All builtins that don't begin with an '_' should additionally
3217      go in the 'std' namespace.  */
3218   if (name[0] != '_')
3219     {
3220       push_namespace (std_identifier);
3221       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
3222       pop_namespace ();
3223     }
3224
3225   return builtin_function_1 (name, type, NULL_TREE, code,
3226                              class, libname, attrs);
3227 }
3228
3229 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3230    function.  Not called directly.  */
3231
3232 static tree
3233 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3234 {
3235   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3236   DECL_EXTERNAL (fn) = 1;
3237   TREE_PUBLIC (fn) = 1;
3238   DECL_ARTIFICIAL (fn) = 1;
3239   TREE_NOTHROW (fn) = 1;
3240   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3241   SET_DECL_LANGUAGE (fn, lang_c);
3242   return fn;
3243 }
3244
3245 /* Returns the _DECL for a library function with C linkage.
3246    We assume that such functions never throw; if this is incorrect,
3247    callers should unset TREE_NOTHROW.  */
3248
3249 tree
3250 build_library_fn (tree name, tree type)
3251 {
3252   return build_library_fn_1 (name, ERROR_MARK, type);
3253 }
3254
3255 /* Returns the _DECL for a library function with C++ linkage.  */
3256
3257 static tree
3258 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3259 {
3260   tree fn = build_library_fn_1 (name, operator_code, type);
3261   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3262   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3263   SET_DECL_LANGUAGE (fn, lang_cplusplus);
3264   return fn;
3265 }
3266
3267 /* Like build_library_fn, but takes a C string instead of an
3268    IDENTIFIER_NODE.  */
3269
3270 tree
3271 build_library_fn_ptr (const char* name, tree type)
3272 {
3273   return build_library_fn (get_identifier (name), type);
3274 }
3275
3276 /* Like build_cp_library_fn, but takes a C string instead of an
3277    IDENTIFIER_NODE.  */
3278
3279 tree
3280 build_cp_library_fn_ptr (const char* name, tree type)
3281 {
3282   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3283 }
3284
3285 /* Like build_library_fn, but also pushes the function so that we will
3286    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
3287
3288 tree
3289 push_library_fn (tree name, tree type)
3290 {
3291   tree fn = build_library_fn (name, type);
3292   pushdecl_top_level (fn);
3293   return fn;
3294 }
3295
3296 /* Like build_cp_library_fn, but also pushes the function so that it
3297    will be found by normal lookup.  */
3298
3299 static tree
3300 push_cp_library_fn (enum tree_code operator_code, tree type)
3301 {
3302   tree fn = build_cp_library_fn (ansi_opname (operator_code),
3303                                  operator_code,
3304                                  type);
3305   pushdecl (fn);
3306   return fn;
3307 }
3308
3309 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3310    a FUNCTION_TYPE.  */
3311
3312 tree
3313 push_void_library_fn (tree name, tree parmtypes)
3314 {
3315   tree type = build_function_type (void_type_node, parmtypes);
3316   return push_library_fn (name, type);
3317 }
3318
3319 /* Like push_library_fn, but also note that this function throws
3320    and does not return.  Used for __throw_foo and the like.  */
3321
3322 tree
3323 push_throw_library_fn (tree name, tree type)
3324 {
3325   tree fn = push_library_fn (name, type);
3326   TREE_THIS_VOLATILE (fn) = 1;
3327   TREE_NOTHROW (fn) = 0;
3328   return fn;
3329 }
3330 \f
3331 /* When we call finish_struct for an anonymous union, we create
3332    default copy constructors and such.  But, an anonymous union
3333    shouldn't have such things; this function undoes the damage to the
3334    anonymous union type T.
3335
3336    (The reason that we create the synthesized methods is that we don't
3337    distinguish `union { int i; }' from `typedef union { int i; } U'.
3338    The first is an anonymous union; the second is just an ordinary
3339    union type.)  */
3340
3341 void
3342 fixup_anonymous_aggr (tree t)
3343 {
3344   tree *q;
3345
3346   /* Wipe out memory of synthesized methods.  */
3347   TYPE_HAS_CONSTRUCTOR (t) = 0;
3348   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3349   TYPE_HAS_INIT_REF (t) = 0;
3350   TYPE_HAS_CONST_INIT_REF (t) = 0;
3351   TYPE_HAS_ASSIGN_REF (t) = 0;
3352   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3353
3354   /* Splice the implicitly generated functions out of the TYPE_METHODS
3355      list.  */
3356   q = &TYPE_METHODS (t);
3357   while (*q)
3358     {
3359       if (DECL_ARTIFICIAL (*q))
3360         *q = TREE_CHAIN (*q);
3361       else
3362         q = &TREE_CHAIN (*q);
3363     }
3364
3365   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
3366   if (TYPE_METHODS (t))
3367     error ("%Jan anonymous union cannot have function members",
3368            TYPE_MAIN_DECL (t));
3369
3370   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3371      assignment operators (because they cannot have these methods themselves).
3372      For anonymous unions this is already checked because they are not allowed
3373      in any union, otherwise we have to check it.  */
3374   if (TREE_CODE (t) != UNION_TYPE)
3375     {
3376       tree field, type;
3377
3378       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3379         if (TREE_CODE (field) == FIELD_DECL)
3380           {
3381             type = TREE_TYPE (field);
3382             if (CLASS_TYPE_P (type))
3383               {
3384                 if (TYPE_NEEDS_CONSTRUCTING (type))
3385                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3386                                field);
3387                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3388                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3389                                field);
3390                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3391                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3392                                field);
3393               }
3394           }
3395     }
3396 }
3397
3398 /* Make sure that a declaration with no declarator is well-formed, i.e.
3399    just declares a tagged type or anonymous union.
3400
3401    Returns the type declared; or NULL_TREE if none.  */
3402
3403 tree
3404 check_tag_decl (cp_decl_specifier_seq *declspecs)
3405 {
3406   int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3407   int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3408   /* If a class, struct, or enum type is declared by the DECLSPECS
3409      (i.e, if a class-specifier, enum-specifier, or non-typename
3410      elaborated-type-specifier appears in the DECLSPECS),
3411      DECLARED_TYPE is set to the corresponding type.  */
3412   tree declared_type = NULL_TREE;
3413   bool error_p = false;
3414
3415   if (declspecs->multiple_types_p)
3416     error ("multiple types in one declaration");
3417   else if (declspecs->redefined_builtin_type)
3418     {
3419       if (!in_system_header)
3420         pedwarn ("redeclaration of C++ built-in type %qT",
3421                  declspecs->redefined_builtin_type);
3422       return NULL_TREE;
3423     }
3424
3425   if (TYPE_P (declspecs->type)
3426       && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3427            && IS_AGGR_TYPE (declspecs->type))
3428           || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3429     declared_type = declspecs->type;
3430   else if (declspecs->type == error_mark_node)
3431     error_p = true;
3432   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3433     pedwarn ("declaration does not declare anything");
3434   /* Check for an anonymous union.  */
3435   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3436            && TYPE_ANONYMOUS_P (declared_type))
3437     {
3438       /* 7/3 In a simple-declaration, the optional init-declarator-list
3439          can be omitted only when declaring a class (clause 9) or
3440          enumeration (7.2), that is, when the decl-specifier-seq contains
3441          either a class-specifier, an elaborated-type-specifier with
3442          a class-key (9.1), or an enum-specifier.  In these cases and
3443          whenever a class-specifier or enum-specifier is present in the
3444          decl-specifier-seq, the identifiers in these specifiers are among
3445          the names being declared by the declaration (as class-name,
3446          enum-names, or enumerators, depending on the syntax).  In such
3447          cases, and except for the declaration of an unnamed bit-field (9.6),
3448          the decl-specifier-seq shall introduce one or more names into the
3449          program, or shall redeclare a name introduced by a previous
3450          declaration.  [Example:
3451              enum { };            // ill-formed
3452              typedef class { };   // ill-formed
3453          --end example]  */
3454       if (saw_typedef)
3455         {
3456           error ("missing type-name in typedef-declaration");
3457           return NULL_TREE;
3458         }
3459       /* Anonymous unions are objects, so they can have specifiers.  */;
3460       SET_ANON_AGGR_TYPE_P (declared_type);
3461
3462       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3463           && !in_system_header)
3464         pedwarn ("ISO C++ prohibits anonymous structs");
3465     }
3466
3467   else
3468     {
3469       if (declspecs->specs[(int)ds_inline]
3470           || declspecs->specs[(int)ds_virtual])
3471         error ("`%s' can only be specified for functions",
3472                declspecs->specs[(int)ds_inline]
3473                ? "inline" : "virtual");
3474       else if (saw_friend
3475                && (!current_class_type
3476                    || current_scope () != current_class_type))
3477         error ("`friend' can only be specified inside a class");
3478       else if (declspecs->specs[(int)ds_explicit])
3479         error ("`explicit' can only be specified for constructors");
3480       else if (declspecs->storage_class)
3481         error ("a storage class can only be specified for objects "
3482                "and functions");
3483       else if (declspecs->specs[(int)ds_const]
3484                || declspecs->specs[(int)ds_volatile]
3485                || declspecs->specs[(int)ds_restrict]
3486                || declspecs->specs[(int)ds_thread])
3487         error ("qualifiers can only be specified for objects "
3488                "and functions");
3489     }
3490
3491   return declared_type;
3492 }
3493
3494 /* Called when a declaration is seen that contains no names to declare.
3495    If its type is a reference to a structure, union or enum inherited
3496    from a containing scope, shadow that tag name for the current scope
3497    with a forward reference.
3498    If its type defines a new named structure or union
3499    or defines an enum, it is valid but we need not do anything here.
3500    Otherwise, it is an error.
3501
3502    C++: may have to grok the declspecs to learn about static,
3503    complain for anonymous unions.
3504
3505    Returns the TYPE declared -- or NULL_TREE if none.  */
3506
3507 tree
3508 shadow_tag (cp_decl_specifier_seq *declspecs)
3509 {
3510   tree t = check_tag_decl (declspecs);
3511
3512   if (!t)
3513     return NULL_TREE;
3514
3515   maybe_process_partial_specialization (t);
3516
3517   /* This is where the variables in an anonymous union are
3518      declared.  An anonymous union declaration looks like:
3519      union { ... } ;
3520      because there is no declarator after the union, the parser
3521      sends that declaration here.  */
3522   if (ANON_AGGR_TYPE_P (t))
3523     {
3524       fixup_anonymous_aggr (t);
3525
3526       if (TYPE_FIELDS (t))
3527         {
3528           tree decl = grokdeclarator (/*declarator=*/NULL,
3529                                       declspecs, NORMAL, 0, NULL);
3530           finish_anon_union (decl);
3531         }
3532     }
3533
3534   return t;
3535 }
3536 \f
3537 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3538
3539 tree
3540 groktypename (cp_decl_specifier_seq *type_specifiers,
3541               const cp_declarator *declarator)
3542 {
3543   tree attrs;
3544   tree type;
3545   attrs = type_specifiers->attributes;
3546   type_specifiers->attributes = NULL_TREE;
3547   type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3548   if (attrs)
3549     cplus_decl_attributes (&type, attrs, 0);
3550   return type;
3551 }
3552
3553 /* Decode a declarator in an ordinary declaration or data definition.
3554    This is called as soon as the type information and variable name
3555    have been parsed, before parsing the initializer if any.
3556    Here we create the ..._DECL node, fill in its type,
3557    and put it on the list of decls for the current context.
3558    The ..._DECL node is returned as the value.
3559
3560    Exception: for arrays where the length is not specified,
3561    the type is left null, to be filled in by `cp_finish_decl'.
3562
3563    Function definitions do not come here; they go to start_function
3564    instead.  However, external and forward declarations of functions
3565    do go through here.  Structure field declarations are done by
3566    grokfield and not through here.  */
3567
3568 tree
3569 start_decl (const cp_declarator *declarator,
3570             cp_decl_specifier_seq *declspecs,
3571             int initialized,
3572             tree attributes,
3573             tree prefix_attributes)
3574 {
3575   tree decl;
3576   tree type, tem;
3577   tree context;
3578
3579   /* This should only be done once on the top most decl.  */
3580   if (have_extern_spec)
3581     {
3582       declspecs->storage_class = sc_extern;
3583       have_extern_spec = false;
3584     }
3585
3586   /* An object declared as __attribute__((deprecated)) suppresses
3587      warnings of uses of other deprecated items.  */
3588   if (lookup_attribute ("deprecated", attributes))
3589     deprecated_state = DEPRECATED_SUPPRESS;
3590
3591   attributes = chainon (attributes, prefix_attributes);
3592
3593   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3594                          &attributes);
3595
3596   deprecated_state = DEPRECATED_NORMAL;
3597
3598   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3599     return NULL_TREE;
3600
3601   type = TREE_TYPE (decl);
3602
3603   if (type == error_mark_node)
3604     return NULL_TREE;
3605
3606   context = DECL_CONTEXT (decl);
3607
3608   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
3609       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
3610     {
3611       /* When parsing the initializer, lookup should use the object's
3612          namespace.  */
3613       push_decl_namespace (context);
3614     }
3615
3616   /* We are only interested in class contexts, later.  */
3617   if (context && TREE_CODE (context) == NAMESPACE_DECL)
3618     context = NULL_TREE;
3619
3620   if (initialized)
3621     /* Is it valid for this decl to have an initializer at all?
3622        If not, set INITIALIZED to zero, which will indirectly
3623        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3624     switch (TREE_CODE (decl))
3625       {
3626       case TYPE_DECL:
3627         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
3628         initialized = 0;
3629         break;
3630
3631       case FUNCTION_DECL:
3632         error ("function `%#D' is initialized like a variable", decl);
3633         initialized = 0;
3634         break;
3635
3636       default:
3637         break;
3638       }
3639
3640   if (initialized)
3641     {
3642       if (! toplevel_bindings_p ()
3643           && DECL_EXTERNAL (decl))
3644         warning ("declaration of `%#D' has `extern' and is initialized",
3645                     decl);
3646       DECL_EXTERNAL (decl) = 0;
3647       if (toplevel_bindings_p ())
3648         TREE_STATIC (decl) = 1;
3649
3650       /* Tell `pushdecl' this is an initialized decl
3651          even though we don't yet have the initializer expression.
3652          Also tell `cp_finish_decl' it may store the real initializer.  */
3653       DECL_INITIAL (decl) = error_mark_node;
3654     }
3655
3656   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3657   cplus_decl_attributes (&decl, attributes, 0);
3658
3659   /* If #pragma weak was used, mark the decl weak now.  */
3660   if (global_scope_p (current_binding_level))
3661     maybe_apply_pragma_weak (decl);
3662
3663   if (TREE_CODE (decl) == FUNCTION_DECL
3664       && DECL_DECLARED_INLINE_P (decl)
3665       && DECL_UNINLINABLE (decl)
3666       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3667     warning ("%Jinline function '%D' given attribute noinline", decl, decl);
3668
3669   if (context && COMPLETE_TYPE_P (complete_type (context)))
3670     {
3671       push_nested_class (context);
3672
3673       if (TREE_CODE (decl) == VAR_DECL)
3674         {
3675           tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3676           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3677             error ("`%#D' is not a static member of `%#T'", decl, context);
3678           else
3679             {
3680               if (DECL_CONTEXT (field) != context)
3681                 {
3682                   if (!same_type_p (DECL_CONTEXT (field), context))
3683                     pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3684                              DECL_CONTEXT (field), DECL_NAME (decl),
3685                              context, DECL_NAME (decl));
3686                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3687                 }
3688               /* Static data member are tricky; an in-class initialization
3689                  still doesn't provide a definition, so the in-class
3690                  declaration will have DECL_EXTERNAL set, but will have an
3691                  initialization.  Thus, duplicate_decls won't warn
3692                  about this situation, and so we check here.  */
3693               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3694                 error ("duplicate initialization of %D", decl);
3695               if (duplicate_decls (decl, field))
3696                 decl = field;
3697             }
3698         }
3699       else
3700         {
3701           tree field = check_classfn (context, decl,
3702                                       (processing_template_decl
3703                                        > template_class_depth (context))
3704                                       ? current_template_parms
3705                                       : NULL_TREE);
3706           if (field && duplicate_decls (decl, field))
3707             decl = field;
3708         }
3709
3710       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
3711       DECL_IN_AGGR_P (decl) = 0;
3712       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3713           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3714         {
3715           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3716           /* [temp.expl.spec] An explicit specialization of a static data
3717              member of a template is a definition if the declaration
3718              includes an initializer; otherwise, it is a declaration.
3719
3720              We check for processing_specialization so this only applies
3721              to the new specialization syntax.  */
3722           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3723             DECL_EXTERNAL (decl) = 1;
3724         }
3725
3726       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3727         pedwarn ("declaration of `%#D' outside of class is not definition",
3728                     decl);
3729     }
3730
3731   /* Enter this declaration into the symbol table.  */
3732   tem = maybe_push_decl (decl);
3733
3734   if (processing_template_decl)
3735     tem = push_template_decl (tem);
3736   if (tem == error_mark_node)
3737     return error_mark_node;
3738
3739 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3740   /* Tell the back-end to use or not use .common as appropriate.  If we say
3741      -fconserve-space, we want this to save .data space, at the expense of
3742      wrong semantics.  If we say -fno-conserve-space, we want this to
3743      produce errors about redefs; to do this we force variables into the
3744      data segment.  */
3745   DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3746                         || !DECL_THREAD_LOCAL (tem))
3747                        && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3748 #endif
3749
3750   if (! processing_template_decl)
3751     start_decl_1 (tem);
3752
3753   return tem;
3754 }
3755
3756 void
3757 start_decl_1 (tree decl)
3758 {
3759   tree type = TREE_TYPE (decl);
3760   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3761
3762   if (type == error_mark_node)
3763     return;
3764
3765   if (initialized)
3766     /* Is it valid for this decl to have an initializer at all?
3767        If not, set INITIALIZED to zero, which will indirectly
3768        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3769     {
3770       /* Don't allow initializations for incomplete types except for
3771          arrays which might be completed by the initialization.  */
3772       if (COMPLETE_TYPE_P (complete_type (type)))
3773         ;                       /* A complete type is ok.  */
3774       else if (TREE_CODE (type) != ARRAY_TYPE)
3775         {
3776           error ("variable `%#D' has initializer but incomplete type",
3777                     decl);
3778           initialized = 0;
3779           type = TREE_TYPE (decl) = error_mark_node;
3780         }
3781       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3782         {
3783           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3784             error ("elements of array `%#D' have incomplete type", decl);
3785           /* else we already gave an error in start_decl.  */
3786           initialized = 0;
3787         }
3788     }
3789
3790   if (!initialized
3791       && TREE_CODE (decl) != TYPE_DECL
3792       && TREE_CODE (decl) != TEMPLATE_DECL
3793       && type != error_mark_node
3794       && IS_AGGR_TYPE (type)
3795       && ! DECL_EXTERNAL (decl))
3796     {
3797       if ((! processing_template_decl || ! uses_template_parms (type))
3798           && !COMPLETE_TYPE_P (complete_type (type)))
3799         {
3800           error ("aggregate `%#D' has incomplete type and cannot be defined",
3801                  decl);
3802           /* Change the type so that assemble_variable will give
3803              DECL an rtl we can live with: (mem (const_int 0)).  */
3804           type = TREE_TYPE (decl) = error_mark_node;
3805         }
3806       else
3807         {
3808           /* If any base type in the hierarchy of TYPE needs a constructor,
3809              then we set initialized to 1.  This way any nodes which are
3810              created for the purposes of initializing this aggregate
3811              will live as long as it does.  This is necessary for global
3812              aggregates which do not have their initializers processed until
3813              the end of the file.  */
3814           initialized = TYPE_NEEDS_CONSTRUCTING (type);
3815         }
3816     }
3817
3818   if (! initialized)
3819     DECL_INITIAL (decl) = NULL_TREE;
3820
3821   /* Create a new scope to hold this declaration if necessary.
3822      Whether or not a new scope is necessary cannot be determined
3823      until after the type has been completed; if the type is a
3824      specialization of a class template it is not until after
3825      instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3826      will be set correctly.  */
3827   maybe_push_cleanup_level (type);
3828 }
3829
3830 /* Handle initialization of references.  DECL, TYPE, and INIT have the
3831    same meaning as in cp_finish_decl.  *CLEANUP must be NULL on entry,
3832    but will be set to a new CLEANUP_STMT if a temporary is created
3833    that must be destroyed subsequently.
3834
3835    Returns an initializer expression to use to initialize DECL, or
3836    NULL if the initialization can be performed statically.
3837
3838    Quotes on semantics can be found in ARM 8.4.3.  */
3839
3840 static tree
3841 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3842 {
3843   tree tmp;
3844
3845   if (init == NULL_TREE)
3846     {
3847       if ((DECL_LANG_SPECIFIC (decl) == 0
3848            || DECL_IN_AGGR_P (decl) == 0)
3849           && ! DECL_THIS_EXTERN (decl))
3850         error ("`%D' declared as reference but not initialized", decl);
3851       return NULL_TREE;
3852     }
3853
3854   if (TREE_CODE (init) == CONSTRUCTOR)
3855     {
3856       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
3857       return NULL_TREE;
3858     }
3859
3860   if (TREE_CODE (init) == TREE_LIST)
3861     init = build_x_compound_expr_from_list (init, "initializer");
3862
3863   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
3864     init = convert_from_reference (init);
3865
3866   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3867       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3868     /* Note: default conversion is only called in very special cases.  */
3869     init = decay_conversion (init);
3870
3871   /* Convert INIT to the reference type TYPE.  This may involve the
3872      creation of a temporary, whose lifetime must be the same as that
3873      of the reference.  If so, a DECL_EXPR for the temporary will be
3874      added just after the DECL_EXPR for DECL.  That's why we don't set
3875      DECL_INITIAL for local references (instead assigning to them
3876      explicitly); we need to allow the temporary to be initialized
3877      first.  */
3878   tmp = initialize_reference (type, init, decl, cleanup);
3879
3880   if (tmp == error_mark_node)
3881     return NULL_TREE;
3882   else if (tmp == NULL_TREE)
3883     {
3884       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
3885       return NULL_TREE;
3886     }
3887
3888   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3889     return tmp;
3890
3891   DECL_INITIAL (decl) = tmp;
3892
3893   return NULL_TREE;
3894 }
3895
3896 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3897    array until we finish parsing the initializer.  If that's the
3898    situation we're in, update DECL accordingly.  */
3899
3900 static void
3901 maybe_deduce_size_from_array_init (tree decl, tree init)
3902 {
3903   tree type = TREE_TYPE (decl);
3904
3905   if (TREE_CODE (type) == ARRAY_TYPE
3906       && TYPE_DOMAIN (type) == NULL_TREE
3907       && TREE_CODE (decl) != TYPE_DECL)
3908     {
3909       /* do_default is really a C-ism to deal with tentative definitions.
3910          But let's leave it here to ease the eventual merge.  */
3911       int do_default = !DECL_EXTERNAL (decl);
3912       tree initializer = init ? init : DECL_INITIAL (decl);
3913       int failure = complete_array_type (type, initializer, do_default);
3914
3915       if (failure == 1)
3916         error ("initializer fails to determine size of `%D'", decl);
3917
3918       if (failure == 2)
3919         {
3920           if (do_default)
3921             error ("array size missing in `%D'", decl);
3922           /* If a `static' var's size isn't known, make it extern as
3923              well as static, so it does not get allocated.  If it's not
3924              `static', then don't mark it extern; finish_incomplete_decl
3925              will give it a default size and it will get allocated.  */
3926           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3927             DECL_EXTERNAL (decl) = 1;
3928         }
3929
3930       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
3931           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3932                               integer_zero_node))
3933         error ("zero-size array `%D'", decl);
3934
3935       layout_decl (decl, 0);
3936     }
3937 }
3938
3939 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3940    any appropriate error messages regarding the layout.  */
3941
3942 static void
3943 layout_var_decl (tree decl)
3944 {
3945   tree type = TREE_TYPE (decl);
3946 #if 0
3947   tree ttype = target_type (type);
3948 #endif
3949
3950   /* If we haven't already layed out this declaration, do so now.
3951      Note that we must not call complete type for an external object
3952      because it's type might involve templates that we are not
3953      supposed to instantiate yet.  (And it's perfectly valid to say
3954      `extern X x' for some incomplete type `X'.)  */
3955   if (!DECL_EXTERNAL (decl))
3956     complete_type (type);
3957   if (!DECL_SIZE (decl)
3958       && TREE_TYPE (decl) != error_mark_node
3959       && (COMPLETE_TYPE_P (type)
3960           || (TREE_CODE (type) == ARRAY_TYPE
3961               && !TYPE_DOMAIN (type)
3962               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
3963     layout_decl (decl, 0);
3964
3965   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
3966     {
3967       /* An automatic variable with an incomplete type: that is an error.
3968          Don't talk about array types here, since we took care of that
3969          message in grokdeclarator.  */
3970       error ("storage size of `%D' isn't known", decl);
3971       TREE_TYPE (decl) = error_mark_node;
3972     }
3973 #if 0
3974   /* Keep this code around in case we later want to control debug info
3975      based on whether a type is "used".  (jason 1999-11-11) */
3976
3977   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
3978     /* Let debugger know it should output info for this type.  */
3979     note_debug_info_needed (ttype);
3980
3981   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
3982     note_debug_info_needed (DECL_CONTEXT (decl));
3983 #endif
3984
3985   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3986       && DECL_SIZE (decl) != NULL_TREE
3987       && ! TREE_CONSTANT (DECL_SIZE (decl)))
3988     {
3989       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3990         constant_expression_warning (DECL_SIZE (decl));
3991       else
3992         error ("storage size of `%D' isn't constant", decl);
3993     }
3994
3995   if (TREE_STATIC (decl)
3996       && !DECL_ARTIFICIAL (decl)
3997       && current_function_decl
3998       && DECL_CONTEXT (decl) == current_function_decl)
3999     push_local_name (decl);
4000 }
4001
4002 /* If a local static variable is declared in an inline function, or if
4003    we have a weak definition, we must endeavor to create only one
4004    instance of the variable at link-time.  */
4005
4006 static void
4007 maybe_commonize_var (tree decl)
4008 {
4009   /* Static data in a function with comdat linkage also has comdat
4010      linkage.  */
4011   if (TREE_STATIC (decl)
4012       /* Don't mess with __FUNCTION__.  */
4013       && ! DECL_ARTIFICIAL (decl)
4014       && DECL_FUNCTION_SCOPE_P (decl)
4015       /* Unfortunately, import_export_decl has not always been called
4016          before the function is processed, so we cannot simply check
4017          DECL_COMDAT.  */
4018       && (DECL_COMDAT (DECL_CONTEXT (decl))
4019           || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4020                || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4021               && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4022     {
4023       if (flag_weak)
4024         {
4025           /* With weak symbols, we simply make the variable COMDAT;
4026              that will cause copies in multiple translations units to
4027              be merged.  */
4028           comdat_linkage (decl);
4029         }
4030       else
4031         {
4032           if (DECL_INITIAL (decl) == NULL_TREE
4033               || DECL_INITIAL (decl) == error_mark_node)
4034             {
4035               /* Without weak symbols, we can use COMMON to merge
4036                  uninitialized variables.  */
4037               TREE_PUBLIC (decl) = 1;
4038               DECL_COMMON (decl) = 1;
4039             }
4040           else
4041             {
4042               /* While for initialized variables, we must use internal
4043                  linkage -- which means that multiple copies will not
4044                  be merged.  */
4045               TREE_PUBLIC (decl) = 0;
4046               DECL_COMMON (decl) = 0;
4047               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
4048               warning ("%J  you can work around this by removing the initializer",
4049                        decl);
4050             }
4051         }
4052     }
4053   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4054     /* Set it up again; we might have set DECL_INITIAL since the last
4055        time.  */
4056     comdat_linkage (decl);
4057 }
4058
4059 /* Issue an error message if DECL is an uninitialized const variable.  */
4060
4061 static void
4062 check_for_uninitialized_const_var (tree decl)
4063 {
4064   tree type = TREE_TYPE (decl);
4065
4066   /* ``Unless explicitly declared extern, a const object does not have
4067      external linkage and must be initialized. ($8.4; $12.1)'' ARM
4068      7.1.6 */
4069   if (TREE_CODE (decl) == VAR_DECL
4070       && TREE_CODE (type) != REFERENCE_TYPE
4071       && CP_TYPE_CONST_P (type)
4072       && !TYPE_NEEDS_CONSTRUCTING (type)
4073       && !DECL_INITIAL (decl))
4074     error ("uninitialized const `%D'", decl);
4075 }
4076
4077 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
4078    returned is the next FIELD_DECL (possibly FIELD itself) that can be
4079    initialized.  If there are no more such fields, the return value
4080    will be NULL.  */
4081
4082 static tree
4083 next_initializable_field (tree field)
4084 {
4085   while (field
4086          && (TREE_CODE (field) != FIELD_DECL
4087              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4088              || DECL_ARTIFICIAL (field)))
4089     field = TREE_CHAIN (field);
4090
4091   return field;
4092 }
4093
4094 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4095    brace-enclosed aggregate initializer.
4096
4097    *INITP is one of a list of initializers describing a brace-enclosed
4098    initializer for an entity of the indicated aggregate TYPE.  It may
4099    not presently match the shape of the TYPE; for example:
4100
4101      struct S { int a; int b; };
4102      struct S a[] = { 1, 2, 3, 4 };
4103
4104    Here *INITP will point to TREE_LIST of four elements, rather than a
4105    list of two elements, each itself a list of two elements.  This
4106    routine transforms INIT from the former form into the latter.  The
4107    revised initializer is returned.  */
4108
4109 static tree
4110 reshape_init (tree type, tree *initp)
4111 {
4112   tree inits;
4113   tree old_init;
4114   tree old_init_value;
4115   tree new_init;
4116   bool brace_enclosed_p;
4117
4118   old_init = *initp;
4119   old_init_value = (TREE_CODE (*initp) == TREE_LIST
4120                     ? TREE_VALUE (*initp) : old_init);
4121
4122   my_friendly_assert (old_init_value, 20030723);
4123
4124   /* If the initializer is brace-enclosed, pull initializers from the
4125      enclosed elements.  Advance past the brace-enclosed initializer
4126      now.  */
4127   if (TREE_CODE (old_init_value) == CONSTRUCTOR
4128       && BRACE_ENCLOSED_INITIALIZER_P (old_init_value))
4129     {
4130       *initp = TREE_CHAIN (old_init);
4131       TREE_CHAIN (old_init) = NULL_TREE;
4132       inits = CONSTRUCTOR_ELTS (old_init_value);
4133       initp = &inits;
4134       brace_enclosed_p = true;
4135     }
4136   else
4137     {
4138       inits = NULL_TREE;
4139       brace_enclosed_p = false;
4140     }
4141
4142   /* A non-aggregate type is always initialized with a single
4143      initializer.  */
4144   if (!CP_AGGREGATE_TYPE_P (type))
4145       {
4146         *initp = TREE_CHAIN (old_init);
4147         TREE_CHAIN (old_init) = NULL_TREE;
4148         /* It is invalid to initialize a non-aggregate type with a
4149            brace-enclosed initializer.  */
4150         if (brace_enclosed_p)
4151           {
4152             error ("brace-enclosed initializer used to initialize `%T'",
4153                    type);
4154             if (TREE_CODE (old_init) == TREE_LIST)
4155               TREE_VALUE (old_init) = error_mark_node;
4156             else
4157               old_init = error_mark_node;
4158           }
4159
4160         return old_init;
4161       }
4162
4163   /* [dcl.init.aggr]
4164
4165      All implicit type conversions (clause _conv_) are considered when
4166      initializing the aggregate member with an initializer from an
4167      initializer-list.  If the initializer can initialize a member,
4168      the member is initialized.  Otherwise, if the member is itself a
4169      non-empty subaggregate, brace elision is assumed and the
4170      initializer is considered for the initialization of the first
4171      member of the subaggregate.  */
4172   if (!brace_enclosed_p
4173       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4174     {
4175       *initp = TREE_CHAIN (old_init);
4176       TREE_CHAIN (old_init) = NULL_TREE;
4177       return old_init;
4178     }
4179
4180   if (TREE_CODE (old_init_value) == STRING_CST
4181       && TREE_CODE (type) == ARRAY_TYPE
4182       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4183     {
4184       /* [dcl.init.string]
4185
4186          A char array (whether plain char, signed char, or unsigned char)
4187          can be initialized by a string-literal (optionally enclosed in
4188          braces); a wchar_t array can be initialized by a wide
4189          string-literal (optionally enclosed in braces).  */
4190       new_init = old_init;
4191       /* Move past the initializer.  */
4192       *initp = TREE_CHAIN (old_init);
4193       TREE_CHAIN (old_init) = NULL_TREE;
4194     }
4195   else
4196     {
4197       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
4198       new_init = build_constructor (NULL_TREE, NULL_TREE);
4199
4200       if (CLASS_TYPE_P (type))
4201         {
4202           tree field;
4203
4204           field = next_initializable_field (TYPE_FIELDS (type));
4205
4206           if (!field)
4207             {
4208               /* [dcl.init.aggr]
4209
4210                  An initializer for an aggregate member that is an
4211                  empty class shall have the form of an empty
4212                  initializer-list {}.  */
4213               if (!brace_enclosed_p)
4214                 {
4215                   error ("initializer for `%T' must be brace-enclosed",
4216                          type);
4217                   return error_mark_node;
4218                 }
4219             }
4220           else
4221             {
4222               /* Loop through the initializable fields, gathering
4223                  initializers.  */
4224               while (*initp)
4225                 {
4226                   tree field_init;
4227
4228                   /* Handle designated initializers, as an extension.  */
4229                   if (TREE_PURPOSE (*initp))
4230                     {
4231                       if (pedantic)
4232                         pedwarn ("ISO C++ does not allow designated initializers");
4233                       field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4234                                               /*want_type=*/false);
4235                       if (!field || TREE_CODE (field) != FIELD_DECL)
4236                         error ("`%T' has no non-static data member named `%D'",
4237                                type, TREE_PURPOSE (*initp));
4238                     }
4239                   if (!field)
4240                     break;
4241
4242                   field_init = reshape_init (TREE_TYPE (field), initp);
4243                   if (field_init == error_mark_node)
4244                     return error_mark_node;
4245                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4246                   CONSTRUCTOR_ELTS (new_init) = field_init;
4247                   /* [dcl.init.aggr]
4248
4249                      When a union  is  initialized with a brace-enclosed
4250                      initializer, the braces shall only contain an
4251                      initializer for the first member of the union.  */
4252                   if (TREE_CODE (type) == UNION_TYPE)
4253                     break;
4254                   field = next_initializable_field (TREE_CHAIN (field));
4255                 }
4256             }
4257         }
4258       else if (TREE_CODE (type) == ARRAY_TYPE
4259                || TREE_CODE (type) == VECTOR_TYPE)
4260         {
4261           tree index;
4262           tree max_index;
4263
4264           /* If the bound of the array is known, take no more initializers
4265              than are allowed.  */
4266           max_index = NULL_TREE;
4267           if (TREE_CODE (type) == ARRAY_TYPE)
4268             {
4269               if (TYPE_DOMAIN (type))
4270                 max_index = array_type_nelts (type);
4271             }
4272           else
4273             {
4274               /* For a vector, the representation type is a struct
4275                  containing a single member which is an array of the
4276                  appropriate size.  */
4277               tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4278               if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4279                 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4280             }
4281
4282           /* Loop through the array elements, gathering initializers.  */
4283           for (index = size_zero_node;
4284                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
4285                index = size_binop (PLUS_EXPR, index, size_one_node))
4286             {
4287               tree element_init;
4288
4289               element_init = reshape_init (TREE_TYPE (type), initp);
4290               if (element_init == error_mark_node)
4291                 return error_mark_node;
4292               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4293               CONSTRUCTOR_ELTS (new_init) = element_init;
4294               if (TREE_PURPOSE (element_init))
4295                 {
4296                   tree next_index = TREE_PURPOSE (element_init);
4297                   if (TREE_CODE (next_index) == IDENTIFIER_NODE)
4298                     {
4299                       error ("name `%D' used in a GNU-style designated "
4300                              "initializer for an array", next_index);
4301                       TREE_PURPOSE (element_init) = NULL_TREE;
4302                     }
4303                   else
4304                     index = next_index;
4305                 }
4306             }
4307         }
4308       else
4309         abort ();
4310
4311       /* The initializers were placed in reverse order in the
4312          CONSTRUCTOR.  */
4313       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4314
4315       if (TREE_CODE (old_init) == TREE_LIST)
4316         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4317     }
4318
4319   /* If this was a brace-enclosed initializer and all of the
4320      initializers were not used up, there is a problem.  */
4321   if (brace_enclosed_p && *initp)
4322     error ("too many initializers for `%T'", type);
4323
4324   return new_init;
4325 }
4326
4327 /* Verify INIT (the initializer for DECL), and record the
4328    initialization in DECL_INITIAL, if appropriate.  CLEANUP is as for
4329    grok_reference_init.
4330
4331    If the return value is non-NULL, it is an expression that must be
4332    evaluated dynamically to initialize DECL.  */
4333
4334 static tree
4335 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4336 {
4337   tree type = TREE_TYPE (decl);
4338   tree init_code = NULL;
4339
4340   /* If `start_decl' didn't like having an initialization, ignore it now.  */
4341   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4342     init = NULL_TREE;
4343
4344   /* If an initializer is present, DECL_INITIAL has been
4345      error_mark_node, to indicate that an as-of-yet unevaluated
4346      initialization will occur.  From now on, DECL_INITIAL reflects
4347      the static initialization -- if any -- of DECL.  */
4348   DECL_INITIAL (decl) = NULL_TREE;
4349
4350   /* Things that are going to be initialized need to have complete
4351      type.  */
4352   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4353
4354   if (type == error_mark_node)
4355     /* We will have already complained.  */
4356     init = NULL_TREE;
4357   else if (init && COMPLETE_TYPE_P (type)
4358            && !TREE_CONSTANT (TYPE_SIZE (type)))
4359     {
4360       error ("variable-sized object `%D' may not be initialized", decl);
4361       init = NULL_TREE;
4362     }
4363   else if (TREE_CODE (type) == ARRAY_TYPE
4364            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4365     {
4366       error ("elements of array `%#D' have incomplete type", decl);
4367       init = NULL_TREE;
4368     }
4369   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4370     {
4371       error ("`%D' has incomplete type", decl);
4372       TREE_TYPE (decl) = error_mark_node;
4373       init = NULL_TREE;
4374     }
4375
4376   if (TREE_CODE (decl) == CONST_DECL)
4377     {
4378       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
4379
4380       DECL_INITIAL (decl) = init;
4381
4382       my_friendly_assert (init != NULL_TREE, 149);
4383       init = NULL_TREE;
4384     }
4385   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4386     init = grok_reference_init (decl, type, init, cleanup);
4387   else if (init)
4388     {
4389       if (TREE_CODE (init) == CONSTRUCTOR
4390           && BRACE_ENCLOSED_INITIALIZER_P (init))
4391         {
4392           /* [dcl.init] paragraph 13,
4393              If T is a scalar type, then a declaration of the form
4394              T x = { a };
4395              is equivalent to
4396              T x = a;
4397
4398              reshape_init will complain about the extra braces,
4399              and doesn't do anything useful in the case where TYPE is
4400              scalar, so just don't call it.  */
4401           if (CP_AGGREGATE_TYPE_P (type))
4402             init = reshape_init (type, &init);
4403
4404           if ((*targetm.vector_opaque_p) (type))
4405             {
4406               error ("opaque vector types cannot be initialized");
4407               init = error_mark_node;
4408             }
4409         }
4410
4411       /* If DECL has an array type without a specific bound, deduce the
4412          array size from the initializer.  */
4413       maybe_deduce_size_from_array_init (decl, init);
4414       type = TREE_TYPE (decl);
4415
4416       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4417         {
4418           if (TREE_CODE (type) == ARRAY_TYPE)
4419             goto initialize_aggr;
4420           else if (TREE_CODE (init) == CONSTRUCTOR
4421                    && BRACE_ENCLOSED_INITIALIZER_P (init))
4422             {
4423               if (TYPE_NON_AGGREGATE_CLASS (type))
4424                 {
4425                   error ("`%D' must be initialized by constructor, not by `{...}'",
4426                          decl);
4427                   init = error_mark_node;
4428                 }
4429               else
4430                 goto dont_use_constructor;
4431             }
4432           else
4433             {
4434               int saved_stmts_are_full_exprs_p;
4435
4436             initialize_aggr:
4437               saved_stmts_are_full_exprs_p = 0;
4438               if (building_stmt_tree ())
4439                 {
4440                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4441                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4442                 }
4443               init = build_aggr_init (decl, init, flags);
4444               if (building_stmt_tree ())
4445                 current_stmt_tree ()->stmts_are_full_exprs_p =
4446                   saved_stmts_are_full_exprs_p;
4447               return init;
4448             }
4449         }
4450       else
4451         {
4452         dont_use_constructor:
4453           if (TREE_CODE (init) != TREE_VEC)
4454             {
4455               init_code = store_init_value (decl, init);
4456               init = NULL;
4457             }
4458         }
4459     }
4460   else if (DECL_EXTERNAL (decl))
4461     ;
4462   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4463     goto initialize_aggr;
4464   else if (IS_AGGR_TYPE (type))
4465     {
4466       tree core_type = strip_array_types (type);
4467
4468       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4469         error ("structure `%D' with uninitialized const members", decl);
4470       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4471         error ("structure `%D' with uninitialized reference members",
4472                decl);
4473
4474       check_for_uninitialized_const_var (decl);
4475     }
4476   else
4477     check_for_uninitialized_const_var (decl);
4478
4479   if (init && init != error_mark_node)
4480     init_code = build (INIT_EXPR, type, decl, init);
4481
4482   return init_code;
4483 }
4484
4485 /* If DECL is not a local variable, give it RTL.  */
4486
4487 static void
4488 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4489 {
4490   int toplev = toplevel_bindings_p ();
4491   int defer_p;
4492
4493   /* Handle non-variables up front.  */
4494   if (TREE_CODE (decl) != VAR_DECL)
4495     {
4496       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4497       return;
4498     }
4499
4500   /* If we see a class member here, it should be a static data
4501      member.  */
4502   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4503     {
4504       my_friendly_assert (TREE_STATIC (decl), 19990828);
4505       /* An in-class declaration of a static data member should be
4506          external; it is only a declaration, and not a definition.  */
4507       if (init == NULL_TREE)
4508         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
4509     }
4510
4511   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
4512   if (asmspec)
4513     {
4514       change_decl_assembler_name (decl, get_identifier (asmspec));
4515       /* The `register' keyword, when used together with an
4516          asm-specification, indicates that the variable should be
4517          placed in a particular register.  */
4518       if (DECL_REGISTER (decl))
4519         DECL_HARD_REGISTER (decl) = 1;
4520     }
4521
4522   /* We don't create any RTL for local variables.  */
4523   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4524     return;
4525
4526   /* We defer emission of local statics until the corresponding
4527      DECL_EXPR is expanded.  */
4528   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4529
4530   /* We try to defer namespace-scope static constants so that they are
4531      not emitted into the object file unnecessarily.  */
4532   if (!DECL_VIRTUAL_P (decl)
4533       && TREE_READONLY (decl)
4534       && DECL_INITIAL (decl) != NULL_TREE
4535       && DECL_INITIAL (decl) != error_mark_node
4536       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4537       && toplev
4538       && !TREE_PUBLIC (decl))
4539     {
4540       /* Fool with the linkage of static consts according to #pragma
4541          interface.  */
4542       if (!interface_unknown && !TREE_PUBLIC (decl))
4543         {
4544           TREE_PUBLIC (decl) = 1;
4545           DECL_EXTERNAL (decl) = interface_only;
4546         }
4547
4548       defer_p = 1;
4549     }
4550   /* Likewise for template instantiations.  */
4551   else if (DECL_COMDAT (decl))
4552     defer_p = 1;
4553
4554   /* If we're deferring the variable, we only need to make RTL if
4555      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
4556      we need it.  (There's no way to lazily create RTL for things that
4557      have assembly specs because the information about the specifier
4558      isn't stored in the tree, yet)  */
4559   if (defer_p && asmspec)
4560     make_decl_rtl (decl, asmspec);
4561   /* If we're not deferring, go ahead and assemble the variable.  */
4562   else if (!defer_p)
4563     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4564 }
4565
4566 /* Generate code to initialize DECL (a local variable).  */
4567
4568 static void
4569 initialize_local_var (tree decl, tree init)
4570 {
4571   tree type = TREE_TYPE (decl);
4572   tree cleanup;
4573
4574   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
4575                       || TREE_CODE (decl) == RESULT_DECL,
4576                       20021010);
4577   my_friendly_assert (!TREE_STATIC (decl), 20021010);
4578
4579   if (DECL_SIZE (decl) == NULL_TREE)
4580     {
4581       /* If we used it already as memory, it must stay in memory.  */
4582       DECL_INITIAL (decl) = NULL_TREE;
4583       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4584     }
4585
4586   if (DECL_SIZE (decl) && type != error_mark_node)
4587     {
4588       int already_used;
4589
4590       /* Compute and store the initial value.  */
4591       already_used = TREE_USED (decl) || TREE_USED (type);
4592
4593       /* Perform the initialization.  */
4594       if (init)
4595         {
4596           int saved_stmts_are_full_exprs_p;
4597
4598           my_friendly_assert (building_stmt_tree (), 20000906);
4599           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4600           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4601           finish_expr_stmt (init);
4602           current_stmt_tree ()->stmts_are_full_exprs_p =
4603             saved_stmts_are_full_exprs_p;
4604         }
4605
4606       /* Set this to 0 so we can tell whether an aggregate which was
4607          initialized was ever used.  Don't do this if it has a
4608          destructor, so we don't complain about the 'resource
4609          allocation is initialization' idiom.  Now set
4610          attribute((unused)) on types so decls of that type will be
4611          marked used. (see TREE_USED, above.)  */
4612       if (TYPE_NEEDS_CONSTRUCTING (type)
4613           && ! already_used
4614           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4615           && DECL_NAME (decl))
4616         TREE_USED (decl) = 0;
4617       else if (already_used)
4618         TREE_USED (decl) = 1;
4619     }
4620
4621   /* Generate a cleanup, if necessary.  */
4622   cleanup = cxx_maybe_build_cleanup (decl);
4623   if (DECL_SIZE (decl) && cleanup)
4624     finish_decl_cleanup (decl, cleanup);
4625 }
4626
4627 /* Finish processing of a declaration;
4628    install its line number and initial value.
4629    If the length of an array type is not known before,
4630    it must be determined now, from the initial value, or it is an error.
4631
4632    INIT holds the value of an initializer that should be allowed to escape
4633    the normal rules.
4634
4635    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4636    if the (init) syntax was used.  */
4637
4638 void
4639 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4640 {
4641   tree type;
4642   tree ttype = NULL_TREE;
4643   tree cleanup;
4644   const char *asmspec = NULL;
4645   int was_readonly = 0;
4646
4647   if (decl == error_mark_node)
4648     return;
4649   else if (! decl)
4650     {
4651       if (init)
4652         error ("assignment (not initialization) in declaration");
4653       return;
4654     }
4655
4656   my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);
4657
4658   /* Assume no cleanup is required.  */
4659   cleanup = NULL_TREE;
4660
4661   /* If a name was specified, get the string.  */
4662   if (global_scope_p (current_binding_level))
4663     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4664   if (asmspec_tree)
4665     asmspec = TREE_STRING_POINTER (asmspec_tree);
4666
4667   if (init && TREE_CODE (init) == NAMESPACE_DECL)
4668     {
4669       error ("cannot initialize `%D' to namespace `%D'",
4670                 decl, init);
4671       init = NULL_TREE;
4672     }
4673
4674   if (current_class_type
4675       && CP_DECL_CONTEXT (decl) == current_class_type
4676       && TYPE_BEING_DEFINED (current_class_type)
4677       && (DECL_INITIAL (decl) || init))
4678     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4679
4680   if (TREE_CODE (decl) == VAR_DECL
4681       && DECL_CONTEXT (decl)
4682       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
4683       && DECL_CONTEXT (decl) != current_namespace
4684       && init)
4685     {
4686       /* Leave the namespace of the object.  */
4687       pop_decl_namespace ();
4688     }
4689
4690   type = TREE_TYPE (decl);
4691
4692   if (type == error_mark_node)
4693     goto finish_end0;
4694
4695   if (TYPE_HAS_MUTABLE_P (type))
4696     TREE_READONLY (decl) = 0;
4697
4698   if (processing_template_decl)
4699     {
4700       /* Add this declaration to the statement-tree.  */
4701       if (at_function_scope_p ())
4702         add_decl_expr (decl);
4703
4704       if (init && DECL_INITIAL (decl))
4705         DECL_INITIAL (decl) = init;
4706       if (TREE_CODE (decl) == VAR_DECL
4707           && !DECL_PRETTY_FUNCTION_P (decl)
4708           && !dependent_type_p (TREE_TYPE (decl)))
4709         maybe_deduce_size_from_array_init (decl, init);
4710       goto finish_end0;
4711     }
4712
4713   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
4714   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
4715
4716   /* Take care of TYPE_DECLs up front.  */
4717   if (TREE_CODE (decl) == TYPE_DECL)
4718     {
4719       if (type != error_mark_node
4720           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4721         {
4722           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4723             warning ("shadowing previous type declaration of `%#D'", decl);
4724           set_identifier_type_value (DECL_NAME (decl), decl);
4725         }
4726
4727       /* If we have installed this as the canonical typedef for this
4728          type, and that type has not been defined yet, delay emitting
4729          the debug information for it, as we will emit it later.  */
4730       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4731           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4732         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4733
4734       rest_of_decl_compilation (decl, NULL,
4735                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
4736       goto finish_end;
4737     }
4738
4739   if (TREE_CODE (decl) != FUNCTION_DECL)
4740     ttype = target_type (type);
4741
4742
4743   /* Currently, GNU C++ puts constants in text space, making them
4744      impossible to initialize.  In the future, one would hope for
4745      an operating system which understood the difference between
4746      initialization and the running of a program.  */
4747   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl))
4748     {
4749       was_readonly = 1;
4750       if (TYPE_NEEDS_CONSTRUCTING (type)
4751           || TREE_CODE (type) == REFERENCE_TYPE)
4752         TREE_READONLY (decl) = 0;
4753     }
4754
4755   if (TREE_CODE (decl) == VAR_DECL)
4756     {
4757       /* Only PODs can have thread-local storage.  Other types may require
4758          various kinds of non-trivial initialization.  */
4759       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4760         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4761                decl, TREE_TYPE (decl));
4762       /* Convert the initializer to the type of DECL, if we have not
4763          already initialized DECL.  */
4764       if (!DECL_INITIALIZED_P (decl)
4765           /* If !DECL_EXTERNAL then DECL is being defined.  In the
4766              case of a static data member initialized inside the
4767              class-specifier, there can be an initializer even if DECL
4768              is *not* defined.  */
4769           && (!DECL_EXTERNAL (decl) || init))
4770         {
4771           init = check_initializer (decl, init, flags, &cleanup);
4772           /* Thread-local storage cannot be dynamically initialized.  */
4773           if (DECL_THREAD_LOCAL (decl) && init)
4774             {
4775               error ("`%D' is thread-local and so cannot be dynamically "
4776                      "initialized", decl);
4777               init = NULL_TREE;
4778             }
4779           /* Handle:
4780
4781              [dcl.init]
4782
4783              The memory occupied by any object of static storage
4784              duration is zero-initialized at program startup before
4785              any other initialization takes place.
4786
4787              We cannot create an appropriate initializer until after
4788              the type of DECL is finalized.  If DECL_INITIAL is set,
4789              then the DECL is statically initialized, and any
4790              necessary zero-initialization has already been performed.  */
4791           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4792             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4793                                                    /*nelts=*/NULL_TREE,
4794                                                    /*static_storage_p=*/true);
4795           /* Remember that the initialization for this variable has
4796              taken place.  */
4797           DECL_INITIALIZED_P (decl) = 1;
4798         }
4799       /* If the variable has an array type, lay out the type, even if
4800          there is no initializer.  It is valid to index through the
4801          array, and we must get TYPE_ALIGN set correctly on the array
4802          type.  */
4803       else if (TREE_CODE (type) == ARRAY_TYPE)
4804         layout_type (type);
4805     }
4806
4807   /* Add this declaration to the statement-tree.  This needs to happen
4808      after the call to check_initializer so that the DECL_EXPR for a
4809      reference temp is added before the DECL_EXPR for the reference itself.  */
4810   if (at_function_scope_p ())
4811     add_decl_expr (decl);
4812
4813   if (TREE_CODE (decl) == VAR_DECL)
4814     layout_var_decl (decl);
4815
4816   /* Output the assembler code and/or RTL code for variables and functions,
4817      unless the type is an undefined structure or union.
4818      If not, it will get done when the type is completed.  */
4819   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4820     {
4821       if (TREE_CODE (decl) == VAR_DECL)
4822         maybe_commonize_var (decl);
4823
4824       make_rtl_for_nonlocal_decl (decl, init, asmspec);
4825
4826       /* Check for abstractness of the type. Notice that there is no
4827          need to strip array types here since the check for those types
4828          is already done within create_array_type_for_decl.  */
4829       if (TREE_CODE (type) == FUNCTION_TYPE
4830           || TREE_CODE (type) == METHOD_TYPE)
4831         abstract_virtuals_error (decl, TREE_TYPE (type));
4832       else
4833         abstract_virtuals_error (decl, type);
4834
4835       if (TREE_CODE (decl) == FUNCTION_DECL
4836           || TREE_TYPE (decl) == error_mark_node)
4837         /* No initialization required.  */
4838         ;
4839       else if (DECL_EXTERNAL (decl)
4840                && ! (DECL_LANG_SPECIFIC (decl)
4841                      && DECL_NOT_REALLY_EXTERN (decl)))
4842         {
4843           if (init)
4844             DECL_INITIAL (decl) = init;
4845         }
4846       else
4847         {
4848           /* A variable definition.  */
4849           if (DECL_FUNCTION_SCOPE_P (decl))
4850             {
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         }
8356     }
8357 }
8358
8359 /* Check a constructor DECL has the correct form.  Complains
8360    if the class has a constructor of the form X(X).  */
8361
8362 int
8363 grok_ctor_properties (tree ctype, tree decl)
8364 {
8365   int ctor_parm = copy_fn_p (decl);
8366
8367   if (ctor_parm < 0)
8368     {
8369       /* [class.copy]
8370
8371          A declaration of a constructor for a class X is ill-formed if
8372          its first parameter is of type (optionally cv-qualified) X
8373          and either there are no other parameters or else all other
8374          parameters have default arguments.
8375
8376          We *don't* complain about member template instantiations that
8377          have this form, though; they can occur as we try to decide
8378          what constructor to use during overload resolution.  Since
8379          overload resolution will never prefer such a constructor to
8380          the non-template copy constructor (which is either explicitly
8381          or implicitly defined), there's no need to worry about their
8382          existence.  Theoretically, they should never even be
8383          instantiated, but that's hard to forestall.  */
8384       error ("invalid constructor; you probably meant `%T (const %T&)'",
8385                 ctype, ctype);
8386       return 0;
8387     }
8388
8389   return 1;
8390 }
8391
8392 /* An operator with this code is unary, but can also be binary.  */
8393
8394 static int
8395 ambi_op_p (enum tree_code code)
8396 {
8397   return (code == INDIRECT_REF
8398           || code == ADDR_EXPR
8399           || code == CONVERT_EXPR
8400           || code == NEGATE_EXPR
8401           || code == PREINCREMENT_EXPR
8402           || code == PREDECREMENT_EXPR);
8403 }
8404
8405 /* An operator with this name can only be unary.  */
8406
8407 static int
8408 unary_op_p (enum tree_code code)
8409 {
8410   return (code == TRUTH_NOT_EXPR
8411           || code == BIT_NOT_EXPR
8412           || code == COMPONENT_REF
8413           || code == TYPE_EXPR);
8414 }
8415
8416 /* DECL is a declaration for an overloaded operator.  Returns true if
8417    the declaration is valid; false otherwise.  If COMPLAIN is true,
8418    errors are issued for invalid declarations.  */
8419
8420 bool
8421 grok_op_properties (tree decl, int friendp, bool complain)
8422 {
8423   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8424   tree argtype;
8425   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8426   tree name = DECL_NAME (decl);
8427   enum tree_code operator_code;
8428   int arity;
8429   bool ok;
8430
8431   /* Assume that the declaration is valid.  */
8432   ok = true;
8433
8434   /* Count the number of arguments.  */
8435   for (argtype = argtypes, arity = 0;
8436        argtype && argtype != void_list_node;
8437        argtype = TREE_CHAIN (argtype))
8438     ++arity;
8439
8440   if (current_class_type == NULL_TREE)
8441     friendp = 1;
8442
8443   if (DECL_CONV_FN_P (decl))
8444     operator_code = TYPE_EXPR;
8445   else
8446     do
8447       {
8448 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
8449         if (ansi_opname (CODE) == name)                         \
8450           {                                                     \
8451             operator_code = (CODE);                             \
8452             break;                                              \
8453           }                                                     \
8454         else if (ansi_assopname (CODE) == name)                 \
8455           {                                                     \
8456             operator_code = (CODE);                             \
8457             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
8458             break;                                              \
8459           }
8460
8461 #include "operators.def"
8462 #undef DEF_OPERATOR
8463
8464         abort ();
8465       }
8466     while (0);
8467   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
8468   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8469
8470   if (! friendp)
8471     {
8472       switch (operator_code)
8473         {
8474         case NEW_EXPR:
8475           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8476           break;
8477
8478         case DELETE_EXPR:
8479           TYPE_GETS_DELETE (current_class_type) |= 1;
8480           break;
8481
8482         case VEC_NEW_EXPR:
8483           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8484           break;
8485
8486         case VEC_DELETE_EXPR:
8487           TYPE_GETS_DELETE (current_class_type) |= 2;
8488           break;
8489
8490         default:
8491           break;
8492         }
8493     }
8494
8495     /* [basic.std.dynamic.allocation]/1:
8496
8497        A program is ill-formed if an allocation function is declared
8498        in a namespace scope other than global scope or declared static
8499        in global scope.
8500
8501        The same also holds true for deallocation functions.  */
8502   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
8503       || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8504     {
8505       if (DECL_NAMESPACE_SCOPE_P (decl))
8506         {
8507           if (CP_DECL_CONTEXT (decl) != global_namespace)
8508             error ("`%D' may not be declared within a namespace", decl);
8509           else if (!TREE_PUBLIC (decl))
8510             error ("`%D' may not be declared as static", decl);
8511         }
8512     }
8513
8514   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8515     TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8516   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8517     TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8518   else
8519     {
8520       /* An operator function must either be a non-static member function
8521          or have at least one parameter of a class, a reference to a class,
8522          an enumeration, or a reference to an enumeration.  13.4.0.6 */
8523       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8524         {
8525           if (operator_code == TYPE_EXPR
8526               || operator_code == CALL_EXPR
8527               || operator_code == COMPONENT_REF
8528               || operator_code == ARRAY_REF
8529               || operator_code == NOP_EXPR)
8530             error ("`%D' must be a nonstatic member function", decl);
8531           else
8532             {
8533               tree p;
8534
8535               if (DECL_STATIC_FUNCTION_P (decl))
8536                 error ("`%D' must be either a non-static member function or a non-member function", decl);
8537
8538               for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8539                 {
8540                   tree arg = non_reference (TREE_VALUE (p));
8541                   /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8542                      because these checks are performed even on
8543                      template functions.  */
8544                   if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8545                     break;
8546                 }
8547
8548               if (!p || p == void_list_node)
8549                 {
8550                   if (!complain)
8551                     return false;
8552
8553                   error ("`%D' must have an argument of class or "
8554                          "enumerated type",
8555                          decl);
8556                   ok = false;
8557                 }
8558             }
8559         }
8560
8561       /* There are no restrictions on the arguments to an overloaded
8562          "operator ()".  */
8563       if (operator_code == CALL_EXPR)
8564         return ok;
8565
8566       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
8567         {
8568           tree t = TREE_TYPE (name);
8569           if (! friendp)
8570             {
8571               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8572               const char *what = 0;
8573
8574               if (ref)
8575                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8576
8577               if (TREE_CODE (t) == VOID_TYPE)
8578                 what = "void";
8579               else if (t == current_class_type)
8580                 what = "the same type";
8581               /* Don't force t to be complete here.  */
8582               else if (IS_AGGR_TYPE (t)
8583                        && COMPLETE_TYPE_P (t)
8584                        && DERIVED_FROM_P (t, current_class_type))
8585                 what = "a base class";
8586
8587               if (what && warn_conversion)
8588                 warning ("conversion to %s%s will never use a type conversion operator",
8589                          ref ? "a reference to " : "", what);
8590             }
8591         }
8592       if (operator_code == COND_EXPR)
8593         {
8594           /* 13.4.0.3 */
8595           error ("ISO C++ prohibits overloading operator ?:");
8596         }
8597       else if (ambi_op_p (operator_code))
8598         {
8599           if (arity == 1)
8600             /* We pick the one-argument operator codes by default, so
8601                we don't have to change anything.  */
8602             ;
8603           else if (arity == 2)
8604             {
8605               /* If we thought this was a unary operator, we now know
8606                  it to be a binary operator.  */
8607               switch (operator_code)
8608                 {
8609                 case INDIRECT_REF:
8610                   operator_code = MULT_EXPR;
8611                   break;
8612
8613                 case ADDR_EXPR:
8614                   operator_code = BIT_AND_EXPR;
8615                   break;
8616
8617                 case CONVERT_EXPR:
8618                   operator_code = PLUS_EXPR;
8619                   break;
8620
8621                 case NEGATE_EXPR:
8622                   operator_code = MINUS_EXPR;
8623                   break;
8624
8625                 case PREINCREMENT_EXPR:
8626                   operator_code = POSTINCREMENT_EXPR;
8627                   break;
8628
8629                 case PREDECREMENT_EXPR:
8630                   operator_code = POSTDECREMENT_EXPR;
8631                   break;
8632
8633                 default:
8634                   abort ();
8635                 }
8636
8637               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8638
8639               if ((operator_code == POSTINCREMENT_EXPR
8640                    || operator_code == POSTDECREMENT_EXPR)
8641                   && ! processing_template_decl
8642                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8643                 {
8644                   if (methodp)
8645                     error ("postfix `%D' must take `int' as its argument",
8646                               decl);
8647                   else
8648                     error
8649                       ("postfix `%D' must take `int' as its second argument",
8650                        decl);
8651                 }
8652             }
8653           else
8654             {
8655               if (methodp)
8656                 error ("`%D' must take either zero or one argument", decl);
8657               else
8658                 error ("`%D' must take either one or two arguments", decl);
8659             }
8660
8661           /* More Effective C++ rule 6.  */
8662           if (warn_ecpp
8663               && (operator_code == POSTINCREMENT_EXPR
8664                   || operator_code == POSTDECREMENT_EXPR
8665                   || operator_code == PREINCREMENT_EXPR
8666                   || operator_code == PREDECREMENT_EXPR))
8667             {
8668               tree arg = TREE_VALUE (argtypes);
8669               tree ret = TREE_TYPE (TREE_TYPE (decl));
8670               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
8671                 arg = TREE_TYPE (arg);
8672               arg = TYPE_MAIN_VARIANT (arg);
8673               if (operator_code == PREINCREMENT_EXPR
8674                   || operator_code == PREDECREMENT_EXPR)
8675                 {
8676                   if (TREE_CODE (ret) != REFERENCE_TYPE
8677                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
8678                                        arg))
8679                     warning ("prefix `%D' should return `%T'", decl,
8680                                 build_reference_type (arg));
8681                 }
8682               else
8683                 {
8684                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
8685                     warning ("postfix `%D' should return `%T'", decl, arg);
8686                 }
8687             }
8688         }
8689       else if (unary_op_p (operator_code))
8690         {
8691           if (arity != 1)
8692             {
8693               if (methodp)
8694                 error ("`%D' must take `void'", decl);
8695               else
8696                 error ("`%D' must take exactly one argument", decl);
8697             }
8698         }
8699       else /* if (binary_op_p (operator_code)) */
8700         {
8701           if (arity != 2)
8702             {
8703               if (methodp)
8704                 error ("`%D' must take exactly one argument", decl);
8705               else
8706                 error ("`%D' must take exactly two arguments", decl);
8707             }
8708
8709           /* More Effective C++ rule 7.  */
8710           if (warn_ecpp
8711               && (operator_code == TRUTH_ANDIF_EXPR
8712                   || operator_code == TRUTH_ORIF_EXPR
8713                   || operator_code == COMPOUND_EXPR))
8714             warning ("user-defined `%D' always evaluates both arguments",
8715                         decl);
8716         }
8717
8718       /* Effective C++ rule 23.  */
8719       if (warn_ecpp
8720           && arity == 2
8721           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
8722           && (operator_code == PLUS_EXPR
8723               || operator_code == MINUS_EXPR
8724               || operator_code == TRUNC_DIV_EXPR
8725               || operator_code == MULT_EXPR
8726               || operator_code == TRUNC_MOD_EXPR)
8727           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
8728         warning ("`%D' should return by value", decl);
8729
8730       /* [over.oper]/8 */
8731       for (; argtypes && argtypes != void_list_node;
8732           argtypes = TREE_CHAIN (argtypes))
8733         if (TREE_PURPOSE (argtypes))
8734           {
8735             TREE_PURPOSE (argtypes) = NULL_TREE;
8736             if (operator_code == POSTINCREMENT_EXPR
8737                 || operator_code == POSTDECREMENT_EXPR)
8738               {
8739                 if (pedantic)
8740                   pedwarn ("`%D' cannot have default arguments", decl);
8741               }
8742             else
8743               error ("`%D' cannot have default arguments", decl);
8744           }
8745
8746     }
8747
8748   return ok;
8749 }
8750 \f
8751 static const char *
8752 tag_name (enum tag_types code)
8753 {
8754   switch (code)
8755     {
8756     case record_type:
8757       return "struct";
8758     case class_type:
8759       return "class";
8760     case union_type:
8761       return "union ";
8762     case enum_type:
8763       return "enum";
8764     default:
8765       abort ();
8766     }
8767 }
8768
8769 /* Name lookup in an elaborated-type-specifier (after the keyword
8770    indicated by TAG_CODE) has found the TYPE_DECL DECL.  If the
8771    elaborated-type-specifier is invalid, issue a diagnostic and return
8772    error_mark_node; otherwise, return the *_TYPE to which it referred.
8773    If ALLOW_TEMPLATE_P is true, TYPE may be a class template.  */
8774
8775 tree
8776 check_elaborated_type_specifier (enum tag_types tag_code,
8777                                  tree decl,
8778                                  bool allow_template_p)
8779 {
8780   tree type;
8781
8782   /* In the case of:
8783
8784        struct S { struct S *p; };
8785
8786      name lookup will find the TYPE_DECL for the implicit "S::S"
8787      typedef.  Adjust for that here.  */
8788   if (DECL_SELF_REFERENCE_P (decl))
8789     decl = TYPE_NAME (TREE_TYPE (decl));
8790
8791   type = TREE_TYPE (decl);
8792
8793   /*   [dcl.type.elab]
8794
8795        If the identifier resolves to a typedef-name or a template
8796        type-parameter, the elaborated-type-specifier is ill-formed.
8797
8798      In other words, the only legitimate declaration to use in the
8799      elaborated type specifier is the implicit typedef created when
8800      the type is declared.  */
8801   if (!DECL_IMPLICIT_TYPEDEF_P (decl))
8802     {
8803       error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code));
8804       return IS_AGGR_TYPE (type) ? type : error_mark_node;
8805     }
8806
8807   if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8808     {
8809       error ("using template type parameter `%T' after `%s'",
8810              type, tag_name (tag_code));
8811       return error_mark_node;
8812     }
8813   else if (TREE_CODE (type) != RECORD_TYPE
8814            && TREE_CODE (type) != UNION_TYPE
8815            && tag_code != enum_type)
8816     {
8817       error ("`%T' referred to as `%s'", type, tag_name (tag_code));
8818       return error_mark_node;
8819     }
8820   else if (TREE_CODE (type) != ENUMERAL_TYPE
8821            && tag_code == enum_type)
8822     {
8823       error ("`%T' referred to as enum", type);
8824       return error_mark_node;
8825     }
8826   else if (!allow_template_p
8827            && TREE_CODE (type) == RECORD_TYPE
8828            && CLASSTYPE_IS_TEMPLATE (type))
8829     {
8830       /* If a class template appears as elaborated type specifier
8831          without a template header such as:
8832
8833            template <class T> class C {};
8834            void f(class C);             // No template header here
8835
8836          then the required template argument is missing.  */
8837
8838       error ("template argument required for `%s %T'",
8839              tag_name (tag_code),
8840              DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
8841       return error_mark_node;
8842     }
8843
8844   return type;
8845 }
8846
8847 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8848    Define the tag as a forward-reference if it is not defined.
8849
8850    If a declaration is given, process it here, and report an error if
8851    multiple declarations are not identical.
8852
8853    GLOBALIZE is false when this is also a definition.  Only look in
8854    the current frame for the name (since C++ allows new names in any
8855    scope.)
8856
8857    TEMPLATE_HEADER_P is true when this declaration is preceded by
8858    a set of template parameters.  */
8859
8860 tree
8861 xref_tag (enum tag_types tag_code, tree name,
8862           bool globalize, bool template_header_p)
8863 {
8864   enum tree_code code;
8865   tree t;
8866   struct cp_binding_level *b = current_binding_level;
8867   tree context = NULL_TREE;
8868
8869   timevar_push (TV_NAME_LOOKUP);
8870
8871   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
8872
8873   switch (tag_code)
8874     {
8875     case record_type:
8876     case class_type:
8877       code = RECORD_TYPE;
8878       break;
8879     case union_type:
8880       code = UNION_TYPE;
8881       break;
8882     case enum_type:
8883       code = ENUMERAL_TYPE;
8884       break;
8885     default:
8886       abort ();
8887     }
8888
8889   if (! globalize)
8890     {
8891       /* If we know we are defining this tag, only look it up in
8892          this scope and don't try to find it as a type.  */
8893       t = lookup_tag (code, name, b, 1);
8894     }
8895   else
8896     {
8897       tree decl = lookup_name (name, 2);
8898
8899       if (decl && DECL_CLASS_TEMPLATE_P (decl))
8900         decl = DECL_TEMPLATE_RESULT (decl);
8901
8902       if (decl && TREE_CODE (decl) == TYPE_DECL)
8903         {
8904           /* Two cases we need to consider when deciding if a class
8905              template is allowed as an elaborated type specifier:
8906              1. It is a self reference to its own class.
8907              2. It comes with a template header.
8908
8909              For example:
8910
8911                template <class T> class C {
8912                  class C *c1;           // DECL_SELF_REFERENCE_P is true
8913                  class D;
8914                };
8915                template <class U> class C; // template_header_p is true
8916                template <class T> class C<T>::D {
8917                  class C *c2;           // DECL_SELF_REFERENCE_P is true
8918                };  */
8919
8920           t = check_elaborated_type_specifier (tag_code,
8921                                                decl,
8922                                                template_header_p
8923                                                | DECL_SELF_REFERENCE_P (decl));
8924           if (t == error_mark_node)
8925             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8926         }
8927       else
8928         t = NULL_TREE;
8929
8930       if (t && current_class_type
8931           && template_class_depth (current_class_type)
8932           && template_header_p)
8933         {
8934           /* Since GLOBALIZE is nonzero, we are not looking at a
8935              definition of this tag.  Since, in addition, we are currently
8936              processing a (member) template declaration of a template
8937              class, we must be very careful; consider:
8938
8939                template <class X>
8940                struct S1
8941
8942                template <class U>
8943                struct S2
8944                { template <class V>
8945                friend struct S1; };
8946
8947              Here, the S2::S1 declaration should not be confused with the
8948              outer declaration.  In particular, the inner version should
8949              have a template parameter of level 2, not level 1.  This
8950              would be particularly important if the member declaration
8951              were instead:
8952
8953                template <class V = U> friend struct S1;
8954
8955              say, when we should tsubst into `U' when instantiating
8956              S2.  On the other hand, when presented with:
8957
8958                  template <class T>
8959                  struct S1 {
8960                    template <class U>
8961                    struct S2 {};
8962                    template <class U>
8963                    friend struct S2;
8964                  };
8965
8966               we must find the inner binding eventually.  We
8967               accomplish this by making sure that the new type we
8968               create to represent this declaration has the right
8969               TYPE_CONTEXT.  */
8970           context = TYPE_CONTEXT (t);
8971           t = NULL_TREE;
8972         }
8973     }
8974
8975   if (! t)
8976     {
8977       /* If no such tag is yet defined, create a forward-reference node
8978          and record it as the "definition".
8979          When a real declaration of this type is found,
8980          the forward-reference will be altered into a real type.  */
8981       if (code == ENUMERAL_TYPE)
8982         {
8983           error ("use of enum `%#D' without previous declaration", name);
8984           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8985         }
8986       else
8987         {
8988           t = make_aggr_type (code);
8989           TYPE_CONTEXT (t) = context;
8990           pushtag (name, t, globalize);
8991         }
8992     }
8993   else
8994     {
8995       if (!globalize && processing_template_decl && IS_AGGR_TYPE (t))
8996         redeclare_class_template (t, current_template_parms);
8997       else if (!processing_template_decl
8998                && CLASS_TYPE_P (t)
8999                && CLASSTYPE_IS_TEMPLATE (t))
9000         {
9001           error ("redeclaration of `%T' as a non-template", t);
9002           t = error_mark_node;
9003         }
9004     }
9005
9006   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9007 }
9008
9009 tree
9010 xref_tag_from_type (tree old, tree id, int globalize)
9011 {
9012   enum tag_types tag_kind;
9013
9014   if (TREE_CODE (old) == RECORD_TYPE)
9015     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9016   else
9017     tag_kind  = union_type;
9018
9019   if (id == NULL_TREE)
9020     id = TYPE_IDENTIFIER (old);
9021
9022   return xref_tag (tag_kind, id, globalize, false);
9023 }
9024
9025 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9026    BASE_LIST.  For each element on BASE_LIST the TREE_PURPOSE is an
9027    access_* node, and the TREE_VALUE is the type of the base-class.
9028    Non-NULL TREE_TYPE indicates virtual inheritance.  */
9029
9030 void
9031 xref_basetypes (tree ref, tree base_list)
9032 {
9033   tree *basep;
9034   tree binfo;
9035   unsigned max_vbases = 0; /* Maxium direct & indirect virtual bases. */
9036   unsigned max_bases = 0;  /* Maxium direct bases.  */
9037   int i;
9038   tree default_access;
9039   tree igo_prev; /* Track Inheritance Graph Order.  */
9040
9041   if (ref == error_mark_node)
9042     return;
9043
9044   /* The base of a derived class is private by default, all others are
9045      public.  */
9046   default_access = (TREE_CODE (ref) == RECORD_TYPE
9047                     && CLASSTYPE_DECLARED_CLASS (ref)
9048                     ? access_private_node : access_public_node);
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         {
9065           max_bases++;
9066           if (TREE_TYPE (*basep))
9067             max_vbases++;
9068           if (CLASS_TYPE_P (basetype))
9069             max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9070           basep = &TREE_CHAIN (*basep);
9071         }
9072     }
9073
9074   SET_CLASSTYPE_MARKED (ref);
9075
9076   /* The binfo slot should be empty, unless this is an (ill-formed)
9077      redefinition.  */
9078   my_friendly_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref), 20040706);
9079   my_friendly_assert (TYPE_MAIN_VARIANT (ref) == ref, 20040712);
9080
9081   binfo = make_tree_binfo (BINFO_LANG_SLOTS);
9082   TYPE_BINFO (ref) = binfo;
9083   BINFO_OFFSET (binfo) = size_zero_node;
9084   BINFO_TYPE (binfo) = ref;
9085
9086   if (max_bases)
9087     {
9088       BINFO_BASE_BINFOS (binfo) = make_tree_vec (max_bases);
9089       BINFO_BASE_ACCESSES (binfo) = make_tree_vec (max_bases);
9090       /* An aggregate cannot have baseclasses.  */
9091       CLASSTYPE_NON_AGGREGATE (ref) = 1;
9092
9093       if (TREE_CODE (ref) == UNION_TYPE)
9094         error ("derived union `%T' invalid", ref);
9095     }
9096
9097   if (max_bases > 1)
9098     {
9099       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
9100       /* If there is more than one non-empty they cannot be at the
9101          same address.  */
9102       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9103
9104       if (TYPE_FOR_JAVA (ref))
9105         error ("Java class '%T' cannot have multiple bases", ref);
9106     }
9107
9108   if (max_vbases)
9109     {
9110       CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, max_vbases);
9111       TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
9112       /* Converting to a virtual base class requires looking up the
9113          offset of the virtual base.  */
9114       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9115
9116       if (TYPE_FOR_JAVA (ref))
9117         error ("Java class '%T' cannot have virtual bases", ref);
9118     }
9119
9120   i = 0;
9121   for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9122     {
9123       tree access = TREE_PURPOSE (base_list);
9124       int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9125       tree basetype = TREE_VALUE (base_list);
9126       tree base_binfo = NULL_TREE;
9127
9128       if (access == access_default_node)
9129         access = default_access;
9130
9131       if (TREE_CODE (basetype) == TYPE_DECL)
9132         basetype = TREE_TYPE (basetype);
9133       if (TREE_CODE (basetype) != RECORD_TYPE
9134           && TREE_CODE (basetype) != TYPENAME_TYPE
9135           && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9136           && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9137         {
9138           error ("base type `%T' fails to be a struct or class type",
9139                  basetype);
9140           continue;
9141         }
9142
9143       if (CLASSTYPE_MARKED (basetype))
9144         {
9145           if (basetype == ref)
9146             error ("recursive type `%T' undefined", basetype);
9147           else
9148             error ("duplicate base type `%T' invalid", basetype);
9149           continue;
9150         }
9151       SET_CLASSTYPE_MARKED (basetype);
9152
9153       if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9154         TYPE_FOR_JAVA (ref) = 1;
9155
9156       if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9157         {
9158           base_binfo = TYPE_BINFO (basetype);
9159           /* The orignal basetype could have been a typedef'd type.  */
9160           basetype = BINFO_TYPE (base_binfo);
9161
9162           /* Inherit flags from the base.  */
9163           TYPE_HAS_NEW_OPERATOR (ref)
9164             |= TYPE_HAS_NEW_OPERATOR (basetype);
9165           TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9166             |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9167           TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9168           TYPE_USES_MULTIPLE_INHERITANCE (ref)
9169             |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
9170           TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
9171             |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
9172           TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9173         }
9174
9175       base_binfo = copy_binfo (base_binfo, basetype, ref,
9176                                &igo_prev, via_virtual);
9177       if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9178         BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9179
9180       TREE_VEC_ELT (BINFO_BASE_ACCESSES (binfo), i) = access;
9181       BINFO_BASE_BINFO (binfo, i) = base_binfo;
9182       i++;
9183     }
9184
9185   if (max_bases)
9186     {
9187       /* If any bases were invalid, we will have allocated too many
9188          slots.  */
9189       TREE_VEC_LENGTH (BINFO_BASE_ACCESSES (binfo)) = i;
9190       TREE_VEC_LENGTH (BINFO_BASE_BINFOS (binfo)) = i;
9191     }
9192
9193   /* Unmark all the types.  */
9194   for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
9195     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (BINFO_BASE_BINFO (binfo, i)));
9196   CLEAR_CLASSTYPE_MARKED (ref);
9197 }
9198
9199 \f
9200 /* Begin compiling the definition of an enumeration type.
9201    NAME is its name (or null if anonymous).
9202    Returns the type object, as yet incomplete.
9203    Also records info about it so that build_enumerator
9204    may be used to declare the individual values as they are read.  */
9205
9206 tree
9207 start_enum (tree name)
9208 {
9209   tree enumtype = NULL_TREE;
9210   struct cp_binding_level *b = current_binding_level;
9211
9212   /* If this is the real definition for a previous forward reference,
9213      fill in the contents in the same object that used to be the
9214      forward reference.  */
9215
9216   if (name != NULL_TREE)
9217     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
9218
9219   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9220     {
9221       error ("multiple definition of `%#T'", enumtype);
9222       error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9223       /* Clear out TYPE_VALUES, and start again.  */
9224       TYPE_VALUES (enumtype) = NULL_TREE;
9225     }
9226   else
9227     {
9228       enumtype = make_node (ENUMERAL_TYPE);
9229       pushtag (name, enumtype, 0);
9230     }
9231
9232   return enumtype;
9233 }
9234
9235 /* After processing and defining all the values of an enumeration type,
9236    install their decls in the enumeration type and finish it off.
9237    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
9238
9239 void
9240 finish_enum (tree enumtype)
9241 {
9242   tree values;
9243   tree decl;
9244   tree value;
9245   tree minnode;
9246   tree maxnode;
9247   tree t;
9248   bool unsignedp;
9249   int lowprec;
9250   int highprec;
9251   int precision;
9252   integer_type_kind itk;
9253   tree underlying_type = NULL_TREE;
9254
9255   /* We built up the VALUES in reverse order.  */
9256   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9257
9258   /* For an enum defined in a template, just set the type of the values;
9259      all further processing is postponed until the template is
9260      instantiated.  We need to set the type so that tsubst of a CONST_DECL
9261      works.  */
9262   if (processing_template_decl)
9263     {
9264       for (values = TYPE_VALUES (enumtype);
9265            values;
9266            values = TREE_CHAIN (values))
9267         TREE_TYPE (TREE_VALUE (values)) = enumtype;
9268       if (at_function_scope_p ())
9269         add_stmt (build_min (TAG_DEFN, enumtype));
9270       return;
9271     }
9272
9273   /* Determine the minimum and maximum values of the enumerators.  */
9274   if (TYPE_VALUES (enumtype))
9275     {
9276       minnode = maxnode = NULL_TREE;
9277
9278       for (values = TYPE_VALUES (enumtype);
9279            values;
9280            values = TREE_CHAIN (values))
9281         {
9282           decl = TREE_VALUE (values);
9283
9284           /* [dcl.enum]: Following the closing brace of an enum-specifier,
9285              each enumerator has the type of its enumeration.  Prior to the
9286              closing brace, the type of each enumerator is the type of its
9287              initializing value.  */
9288           TREE_TYPE (decl) = enumtype;
9289
9290           /* Update the minimum and maximum values, if appropriate.  */
9291           value = DECL_INITIAL (decl);
9292           /* Figure out what the minimum and maximum values of the
9293              enumerators are.  */
9294           if (!minnode)
9295             minnode = maxnode = value;
9296           else if (tree_int_cst_lt (maxnode, value))
9297             maxnode = value;
9298           else if (tree_int_cst_lt (value, minnode))
9299             minnode = value;
9300
9301           /* Set the TREE_TYPE for the values as well.  That's so that when
9302              we call decl_constant_value we get an entity of the right type
9303              (but with the constant value).  But first make a copy so we
9304              don't clobber shared INTEGER_CSTs.  */
9305           if (TREE_TYPE (value) != enumtype)
9306             {
9307               value = DECL_INITIAL (decl) = copy_node (value);
9308               TREE_TYPE (value) = enumtype;
9309             }
9310         }
9311     }
9312   else
9313     /* [dcl.enum]
9314
9315        If the enumerator-list is empty, the underlying type is as if
9316        the enumeration had a single enumerator with value 0.  */
9317     minnode = maxnode = integer_zero_node;
9318
9319   /* Compute the number of bits require to represent all values of the
9320      enumeration.  We must do this before the type of MINNODE and
9321      MAXNODE are transformed, since min_precision relies on the
9322      TREE_TYPE of the value it is passed.  */
9323   unsignedp = tree_int_cst_sgn (minnode) >= 0;
9324   lowprec = min_precision (minnode, unsignedp);
9325   highprec = min_precision (maxnode, unsignedp);
9326   precision = MAX (lowprec, highprec);
9327
9328   /* Determine the underlying type of the enumeration.
9329
9330        [dcl.enum]
9331
9332        The underlying type of an enumeration is an integral type that
9333        can represent all the enumerator values defined in the
9334        enumeration.  It is implementation-defined which integral type is
9335        used as the underlying type for an enumeration except that the
9336        underlying type shall not be larger than int unless the value of
9337        an enumerator cannot fit in an int or unsigned int.
9338
9339      We use "int" or an "unsigned int" as the underlying type, even if
9340      a smaller integral type would work, unless the user has
9341      explicitly requested that we use the smallest possible type.  */
9342   for (itk = (flag_short_enums ? itk_char : itk_int);
9343        itk != itk_none;
9344        itk++)
9345     {
9346       underlying_type = integer_types[itk];
9347       if (TYPE_PRECISION (underlying_type) >= precision
9348           && TYPE_UNSIGNED (underlying_type) == unsignedp)
9349         break;
9350     }
9351   if (itk == itk_none)
9352     {
9353       /* DR 377
9354
9355          IF no integral type can represent all the enumerator values, the
9356          enumeration is ill-formed.  */
9357       error ("no integral type can represent all of the enumerator values "
9358              "for `%T'", enumtype);
9359       precision = TYPE_PRECISION (long_long_integer_type_node);
9360       underlying_type = integer_types[itk_unsigned_long_long];
9361     }
9362
9363   /* Compute the minium and maximum values for the type.
9364
9365      [dcl.enum]
9366
9367      For an enumeration where emin is the smallest enumerator and emax
9368      is the largest, the values of the enumeration are the values of the
9369      underlying type in the range bmin to bmax, where bmin and bmax are,
9370      respectively, the smallest and largest values of the smallest bit-
9371      field that can store emin and emax.  */
9372   TYPE_PRECISION (enumtype) = precision;
9373   set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9374
9375   /* [dcl.enum]
9376
9377      The value of sizeof() applied to an enumeration type, an object
9378      of an enumeration type, or an enumerator, is the value of sizeof()
9379      applied to the underlying type.  */
9380   TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9381   TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9382   TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9383   TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9384   TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9385   TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9386
9387   /* Convert each of the enumerators to the type of the underlying
9388      type of the enumeration.  */
9389   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9390     {
9391       decl = TREE_VALUE (values);
9392       value = perform_implicit_conversion (underlying_type,
9393                                            DECL_INITIAL (decl));
9394       TREE_TYPE (value) = enumtype;
9395       DECL_INITIAL (decl) = value;
9396       TREE_VALUE (values) = value;
9397     }
9398
9399   /* Fix up all variant types of this enum type.  */
9400   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9401     {
9402       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9403       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9404       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9405       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9406       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9407       TYPE_MODE (t) = TYPE_MODE (enumtype);
9408       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9409       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9410       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9411       TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9412     }
9413
9414   /* Finish debugging output for this type.  */
9415   rest_of_type_compilation (enumtype, namespace_bindings_p ());
9416 }
9417
9418 /* Build and install a CONST_DECL for an enumeration constant of the
9419    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9420    Assignment of sequential values by default is handled here.  */
9421
9422 void
9423 build_enumerator (tree name, tree value, tree enumtype)
9424 {
9425   tree decl;
9426   tree context;
9427   tree type;
9428
9429   /* Remove no-op casts from the value.  */
9430   if (value)
9431     STRIP_TYPE_NOPS (value);
9432
9433   if (! processing_template_decl)
9434     {
9435       /* Validate and default VALUE.  */
9436       if (value != NULL_TREE)
9437         {
9438           value = decl_constant_value (value);
9439
9440           if (TREE_CODE (value) == INTEGER_CST)
9441             {
9442               value = perform_integral_promotions (value);
9443               constant_expression_warning (value);
9444             }
9445           else
9446             {
9447               error ("enumerator value for `%D' not integer constant", name);
9448               value = NULL_TREE;
9449             }
9450         }
9451
9452       /* Default based on previous value.  */
9453       if (value == NULL_TREE)
9454         {
9455           tree prev_value;
9456
9457           if (TYPE_VALUES (enumtype))
9458             {
9459               /* The next value is the previous value ...  */
9460               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9461               /* ... plus one.  */
9462               value = cp_build_binary_op (PLUS_EXPR,
9463                                           prev_value,
9464                                           integer_one_node);
9465
9466               if (tree_int_cst_lt (value, prev_value))
9467                 error ("overflow in enumeration values at `%D'", name);
9468             }
9469           else
9470             value = integer_zero_node;
9471         }
9472
9473       /* Remove no-op casts from the value.  */
9474       STRIP_TYPE_NOPS (value);
9475     }
9476
9477   /* C++ associates enums with global, function, or class declarations.  */
9478   context = current_scope ();
9479   if (!context)
9480     context = current_namespace;
9481
9482   /* Build the actual enumeration constant.  Note that the enumeration
9483     constants have the type of their initializers until the
9484     enumeration is complete:
9485
9486       [ dcl.enum ]
9487
9488       Following the closing brace of an enum-specifier, each enumer-
9489       ator has the type of its enumeration.  Prior to the closing
9490       brace, the type of each enumerator is the type of its
9491       initializing value.
9492
9493     In finish_enum we will reset the type.  Of course, if we're
9494     processing a template, there may be no value.  */
9495   type = value ? TREE_TYPE (value) : NULL_TREE;
9496
9497   if (context && context == current_class_type)
9498     /* This enum declaration is local to the class.  We need the full
9499        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
9500     decl = build_lang_decl (CONST_DECL, name, type);
9501   else
9502     /* It's a global enum, or it's local to a function.  (Note local to
9503       a function could mean local to a class method.  */
9504     decl = build_decl (CONST_DECL, name, type);
9505
9506   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9507   TREE_CONSTANT (decl) = 1;
9508   TREE_INVARIANT (decl) = 1;
9509   TREE_READONLY (decl) = 1;
9510   DECL_INITIAL (decl) = value;
9511
9512   if (context && context == current_class_type)
9513     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9514        on the TYPE_FIELDS list for `S'.  (That's so that you can say
9515        things like `S::i' later.)  */
9516     finish_member_declaration (decl);
9517   else
9518     pushdecl (decl);
9519
9520   /* Add this enumeration constant to the list for this type.  */
9521   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
9522 }
9523
9524 \f
9525 /* We're defining DECL.  Make sure that it's type is OK.  */
9526
9527 static void
9528 check_function_type (tree decl, tree current_function_parms)
9529 {
9530   tree fntype = TREE_TYPE (decl);
9531   tree return_type = complete_type (TREE_TYPE (fntype));
9532
9533   /* In a function definition, arg types must be complete.  */
9534   require_complete_types_for_parms (current_function_parms);
9535
9536   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
9537     {
9538       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
9539
9540       /* Make it return void instead, but don't change the
9541          type of the DECL_RESULT, in case we have a named return value.  */
9542       if (TREE_CODE (fntype) == METHOD_TYPE)
9543         {
9544           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
9545           TREE_TYPE (decl)
9546             = build_method_type_directly (ctype,
9547                                           void_type_node,
9548                                           FUNCTION_ARG_CHAIN (decl));
9549         }
9550       else
9551         TREE_TYPE (decl)
9552           = build_function_type (void_type_node,
9553                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
9554       TREE_TYPE (decl)
9555         = build_exception_variant (fntype,
9556                                    TYPE_RAISES_EXCEPTIONS (fntype));
9557     }
9558   else
9559     abstract_virtuals_error (decl, TREE_TYPE (fntype));
9560 }
9561
9562 /* Create the FUNCTION_DECL for a function definition.
9563    DECLSPECS and DECLARATOR are the parts of the declaration;
9564    they describe the function's name and the type it returns,
9565    but twisted together in a fashion that parallels the syntax of C.
9566
9567    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9568    DECLARATOR is really the DECL for the function we are about to
9569    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9570    indicating that the function is an inline defined in-class.
9571
9572    This function creates a binding context for the function body
9573    as well as setting up the FUNCTION_DECL in current_function_decl.
9574
9575    For C++, we must first check whether that datum makes any sense.
9576    For example, "class A local_a(1,2);" means that variable local_a
9577    is an aggregate of type A, which should have a constructor
9578    applied to it with the argument list [1, 2].  */
9579
9580 void
9581 start_preparsed_function (tree decl1, tree attrs, int flags)
9582 {
9583   tree ctype = NULL_TREE;
9584   tree fntype;
9585   tree restype;
9586   int doing_friend = 0;
9587   struct cp_binding_level *bl;
9588   tree current_function_parms;
9589
9590   /* Sanity check.  */
9591   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
9592   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
9593
9594   fntype = TREE_TYPE (decl1);
9595   if (TREE_CODE (fntype) == METHOD_TYPE)
9596     ctype = TYPE_METHOD_BASETYPE (fntype);
9597
9598   /* ISO C++ 11.4/5.  A friend function defined in a class is in
9599      the (lexical) scope of the class in which it is defined.  */
9600   if (!ctype && DECL_FRIEND_P (decl1))
9601     {
9602       ctype = DECL_FRIEND_CONTEXT (decl1);
9603
9604       /* CTYPE could be null here if we're dealing with a template;
9605          for example, `inline friend float foo()' inside a template
9606          will have no CTYPE set.  */
9607       if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
9608         ctype = NULL_TREE;
9609       else
9610         doing_friend = 1;
9611     }
9612
9613   if (DECL_DECLARED_INLINE_P (decl1)
9614       && lookup_attribute ("noinline", attrs))
9615     warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
9616
9617   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
9618     /* This is a constructor, we must ensure that any default args
9619        introduced by this definition are propagated to the clones
9620        now. The clones are used directly in overload resolution.  */
9621     adjust_clone_args (decl1);
9622
9623   /* Sometimes we don't notice that a function is a static member, and
9624      build a METHOD_TYPE for it.  Fix that up now.  */
9625   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
9626       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
9627     {
9628       revert_static_member_fn (decl1);
9629       ctype = NULL_TREE;
9630     }
9631
9632   /* Set up current_class_type, and enter the scope of the class, if
9633      appropriate.  */
9634   if (ctype)
9635     push_nested_class (ctype);
9636   else if (DECL_STATIC_FUNCTION_P (decl1))
9637     push_nested_class (DECL_CONTEXT (decl1));
9638
9639   /* Now that we have entered the scope of the class, we must restore
9640      the bindings for any template parameters surrounding DECL1, if it
9641      is an inline member template.  (Order is important; consider the
9642      case where a template parameter has the same name as a field of
9643      the class.)  It is not until after this point that
9644      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
9645   if (flags & SF_INCLASS_INLINE)
9646     maybe_begin_member_template_processing (decl1);
9647
9648   /* Effective C++ rule 15.  */
9649   if (warn_ecpp
9650       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9651       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
9652     warning ("`operator=' should return a reference to `*this'");
9653
9654   /* Make the init_value nonzero so pushdecl knows this is not tentative.
9655      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
9656   if (!DECL_INITIAL (decl1))
9657     DECL_INITIAL (decl1) = error_mark_node;
9658
9659   /* This function exists in static storage.
9660      (This does not mean `static' in the C sense!)  */
9661   TREE_STATIC (decl1) = 1;
9662
9663   /* We must call push_template_decl after current_class_type is set
9664      up.  (If we are processing inline definitions after exiting a
9665      class scope, current_class_type will be NULL_TREE until set above
9666      by push_nested_class.)  */
9667   if (processing_template_decl)
9668     decl1 = push_template_decl (decl1);
9669
9670   /* We are now in the scope of the function being defined.  */
9671   current_function_decl = decl1;
9672
9673   /* Save the parm names or decls from this function's declarator
9674      where store_parm_decls will find them.  */
9675   current_function_parms = DECL_ARGUMENTS (decl1);
9676
9677   /* Make sure the parameter and return types are reasonable.  When
9678      you declare a function, these types can be incomplete, but they
9679      must be complete when you define the function.  */
9680   if (! processing_template_decl)
9681     check_function_type (decl1, current_function_parms);
9682
9683   /* Build the return declaration for the function.  */
9684   restype = TREE_TYPE (fntype);
9685   /* Promote the value to int before returning it.  */
9686   if (c_promoting_integer_type_p (restype))
9687     restype = type_promotes_to (restype);
9688   if (DECL_RESULT (decl1) == NULL_TREE)
9689     {
9690       DECL_RESULT (decl1)
9691         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
9692       c_apply_type_quals_to_decl (cp_type_quals (restype),
9693                                   DECL_RESULT (decl1));
9694     }
9695
9696   /* Initialize RTL machinery.  We cannot do this until
9697      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
9698      even when processing a template; this is how we get
9699      CFUN set up, and our per-function variables initialized.
9700      FIXME factor out the non-RTL stuff.  */
9701   bl = current_binding_level;
9702   allocate_struct_function (decl1);
9703   current_binding_level = bl;
9704
9705   /* Even though we're inside a function body, we still don't want to
9706      call expand_expr to calculate the size of a variable-sized array.
9707      We haven't necessarily assigned RTL to all variables yet, so it's
9708      not safe to try to expand expressions involving them.  */
9709   cfun->x_dont_save_pending_sizes_p = 1;
9710
9711   /* Start the statement-tree, start the tree now.  */
9712   DECL_SAVED_TREE (decl1) = push_stmt_list ();
9713
9714   /* Let the user know we're compiling this function.  */
9715   announce_function (decl1);
9716
9717   /* Record the decl so that the function name is defined.
9718      If we already have a decl for this name, and it is a FUNCTION_DECL,
9719      use the old decl.  */
9720   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
9721     {
9722       /* A specialization is not used to guide overload resolution.  */
9723       if (!DECL_FUNCTION_MEMBER_P (decl1)
9724           && !(DECL_USE_TEMPLATE (decl1) &&
9725                PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
9726         {
9727           tree olddecl = pushdecl (decl1);
9728
9729           if (olddecl == error_mark_node)
9730             /* If something went wrong when registering the declaration,
9731                use DECL1; we have to have a FUNCTION_DECL to use when
9732                parsing the body of the function.  */
9733             ;
9734           else
9735             /* Otherwise, OLDDECL is either a previous declaration of
9736                the same function or DECL1 itself.  */
9737             decl1 = olddecl;
9738         }
9739       else
9740         {
9741           /* We need to set the DECL_CONTEXT.  */
9742           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
9743             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
9744           /* And make sure we have enough default args.  */
9745           check_default_args (decl1);
9746         }
9747       fntype = TREE_TYPE (decl1);
9748     }
9749
9750   /* Reset these in case the call to pushdecl changed them.  */
9751   current_function_decl = decl1;
9752   cfun->decl = decl1;
9753
9754   /* If we are (erroneously) defining a function that we have already
9755      defined before, wipe out what we knew before.  */
9756   if (!DECL_PENDING_INLINE_P (decl1))
9757     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
9758
9759   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
9760     {
9761       /* We know that this was set up by `grokclassfn'.  We do not
9762          wait until `store_parm_decls', since evil parse errors may
9763          never get us to that point.  Here we keep the consistency
9764          between `current_class_type' and `current_class_ptr'.  */
9765       tree t = DECL_ARGUMENTS (decl1);
9766
9767       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
9768                           162);
9769       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
9770                           19990811);
9771
9772       cp_function_chain->x_current_class_ref
9773         = build_indirect_ref (t, NULL);
9774       cp_function_chain->x_current_class_ptr = t;
9775
9776       /* Constructors and destructors need to know whether they're "in
9777          charge" of initializing virtual base classes.  */
9778       t = TREE_CHAIN (t);
9779       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
9780         {
9781           current_in_charge_parm = t;
9782           t = TREE_CHAIN (t);
9783         }
9784       if (DECL_HAS_VTT_PARM_P (decl1))
9785         {
9786           if (DECL_NAME (t) != vtt_parm_identifier)
9787             abort ();
9788           current_vtt_parm = t;
9789         }
9790     }
9791
9792   if (DECL_INTERFACE_KNOWN (decl1))
9793     {
9794       tree ctx = decl_function_context (decl1);
9795
9796       if (DECL_NOT_REALLY_EXTERN (decl1))
9797         DECL_EXTERNAL (decl1) = 0;
9798
9799       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
9800           && TREE_PUBLIC (ctx))
9801         /* This is a function in a local class in an extern inline
9802            function.  */
9803         comdat_linkage (decl1);
9804     }
9805   /* If this function belongs to an interface, it is public.
9806      If it belongs to someone else's interface, it is also external.
9807      This only affects inlines and template instantiations.  */
9808   else if (interface_unknown == 0
9809            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9810     {
9811       if (DECL_DECLARED_INLINE_P (decl1)
9812           || DECL_TEMPLATE_INSTANTIATION (decl1)
9813           || processing_template_decl)
9814         {
9815           DECL_EXTERNAL (decl1)
9816             = (interface_only
9817                || (DECL_DECLARED_INLINE_P (decl1)
9818                    && ! flag_implement_inlines
9819                    && !DECL_VINDEX (decl1)));
9820
9821           /* For WIN32 we also want to put these in linkonce sections.  */
9822           maybe_make_one_only (decl1);
9823         }
9824       else
9825         DECL_EXTERNAL (decl1) = 0;
9826       DECL_NOT_REALLY_EXTERN (decl1) = 0;
9827       DECL_INTERFACE_KNOWN (decl1) = 1;
9828     }
9829   else if (interface_unknown && interface_only
9830            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9831     {
9832       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
9833          interface, we will have interface_only set but not
9834          interface_known.  In that case, we don't want to use the normal
9835          heuristics because someone will supply a #pragma implementation
9836          elsewhere, and deducing it here would produce a conflict.  */
9837       comdat_linkage (decl1);
9838       DECL_EXTERNAL (decl1) = 0;
9839       DECL_INTERFACE_KNOWN (decl1) = 1;
9840       DECL_DEFER_OUTPUT (decl1) = 1;
9841     }
9842   else
9843     {
9844       /* This is a definition, not a reference.
9845          So clear DECL_EXTERNAL.  */
9846       DECL_EXTERNAL (decl1) = 0;
9847
9848       if ((DECL_DECLARED_INLINE_P (decl1)
9849            || DECL_TEMPLATE_INSTANTIATION (decl1))
9850           && ! DECL_INTERFACE_KNOWN (decl1)
9851           /* Don't try to defer nested functions for now.  */
9852           && ! decl_function_context (decl1))
9853         DECL_DEFER_OUTPUT (decl1) = 1;
9854       else
9855         DECL_INTERFACE_KNOWN (decl1) = 1;
9856     }
9857
9858   begin_scope (sk_function_parms, decl1);
9859
9860   ++function_depth;
9861
9862   if (DECL_DESTRUCTOR_P (decl1))
9863     {
9864       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
9865       DECL_CONTEXT (dtor_label) = current_function_decl;
9866     }
9867
9868   start_fname_decls ();
9869
9870   store_parm_decls (current_function_parms);
9871 }
9872
9873
9874 /* Like start_preparsed_function, except that instead of a
9875    FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
9876
9877    Returns 1 on success.  If the DECLARATOR is not suitable for a function
9878    (it defines a datum instead), we return 0, which tells
9879    yyparse to report a parse error.  */
9880
9881 int
9882 start_function (cp_decl_specifier_seq *declspecs,
9883                 const cp_declarator *declarator,
9884                 tree attrs)
9885 {
9886   tree decl1;
9887
9888   if (have_extern_spec)
9889     {
9890       declspecs->storage_class = sc_extern;
9891       /* This should only be done once on the outermost decl.  */
9892       have_extern_spec = false;
9893     }
9894
9895   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
9896   /* If the declarator is not suitable for a function definition,
9897      cause a syntax error.  */
9898   if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
9899     return 0;
9900
9901   cplus_decl_attributes (&decl1, attrs, 0);
9902
9903   /* If #pragma weak was used, mark the decl weak now.  */
9904   if (global_scope_p (current_binding_level))
9905     maybe_apply_pragma_weak (decl1);
9906
9907   if (DECL_MAIN_P (decl1))
9908     {
9909       /* If this doesn't return integer_type, or a typedef to
9910          integer_type, complain.  */
9911       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node))
9912         {
9913           if (pedantic || warn_return_type)
9914             pedwarn ("return type for `main' changed to `int'");
9915           TREE_TYPE (decl1) = default_function_type;
9916         }
9917     }
9918
9919   start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
9920
9921   return 1;
9922 }
9923 \f
9924 /* Store the parameter declarations into the current function declaration.
9925    This is called after parsing the parameter declarations, before
9926    digesting the body of the function.
9927
9928    Also install to binding contour return value identifier, if any.  */
9929
9930 static void
9931 store_parm_decls (tree current_function_parms)
9932 {
9933   tree fndecl = current_function_decl;
9934   tree parm;
9935
9936   /* This is a chain of any other decls that came in among the parm
9937      declarations.  If a parm is declared with  enum {foo, bar} x;
9938      then CONST_DECLs for foo and bar are put here.  */
9939   tree nonparms = NULL_TREE;
9940
9941   if (current_function_parms)
9942     {
9943       /* This case is when the function was defined with an ANSI prototype.
9944          The parms already have decls, so we need not do anything here
9945          except record them as in effect
9946          and complain if any redundant old-style parm decls were written.  */
9947
9948       tree specparms = current_function_parms;
9949       tree next;
9950
9951       /* Must clear this because it might contain TYPE_DECLs declared
9952              at class level.  */
9953       current_binding_level->names = NULL;
9954
9955       /* If we're doing semantic analysis, then we'll call pushdecl
9956              for each of these.  We must do them in reverse order so that
9957              they end in the correct forward order.  */
9958       specparms = nreverse (specparms);
9959
9960       for (parm = specparms; parm; parm = next)
9961         {
9962           next = TREE_CHAIN (parm);
9963           if (TREE_CODE (parm) == PARM_DECL)
9964             {
9965               if (DECL_NAME (parm) == NULL_TREE
9966                   || TREE_CODE (parm) != VOID_TYPE)
9967                 pushdecl (parm);
9968               else
9969                 error ("parameter `%D' declared void", parm);
9970             }
9971           else
9972             {
9973               /* If we find an enum constant or a type tag,
9974                  put it aside for the moment.  */
9975               TREE_CHAIN (parm) = NULL_TREE;
9976               nonparms = chainon (nonparms, parm);
9977             }
9978         }
9979
9980       /* Get the decls in their original chain order and record in the
9981          function.  This is all and only the PARM_DECLs that were
9982          pushed into scope by the loop above.  */
9983       DECL_ARGUMENTS (fndecl) = getdecls ();
9984     }
9985   else
9986     DECL_ARGUMENTS (fndecl) = NULL_TREE;
9987
9988   /* Now store the final chain of decls for the arguments
9989      as the decl-chain of the current lexical scope.
9990      Put the enumerators in as well, at the front so that
9991      DECL_ARGUMENTS is not modified.  */
9992   current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
9993
9994   /* Do the starting of the exception specifications, if we have any.  */
9995   if (flag_exceptions && !processing_template_decl
9996       && flag_enforce_eh_specs
9997       && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
9998     current_eh_spec_block = begin_eh_spec_block ();
9999 }
10000
10001 \f
10002 /* We have finished doing semantic analysis on DECL, but have not yet
10003    generated RTL for its body.  Save away our current state, so that
10004    when we want to generate RTL later we know what to do.  */
10005
10006 static void
10007 save_function_data (tree decl)
10008 {
10009   struct language_function *f;
10010
10011   /* Save the language-specific per-function data so that we can
10012      get it back when we really expand this function.  */
10013   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
10014                       19990908);
10015
10016   /* Make a copy.  */
10017   f = ggc_alloc (sizeof (struct language_function));
10018   memcpy (f, cp_function_chain, sizeof (struct language_function));
10019   DECL_SAVED_FUNCTION_DATA (decl) = f;
10020
10021   /* Clear out the bits we don't need.  */
10022   f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10023   f->x_named_label_uses = NULL;
10024   f->bindings = NULL;
10025   f->x_local_names = NULL;
10026 }
10027
10028 /* Add a note to mark the beginning of the main body of the constructor.
10029    This is used to set up the data structures for the cleanup regions for
10030    fully-constructed bases and members.  */
10031
10032 static void
10033 begin_constructor_body (void)
10034 {
10035 }
10036
10037 /* Add a note to mark the end of the main body of the constructor.  This is
10038    used to end the cleanup regions for fully-constructed bases and
10039    members.  */
10040
10041 static void
10042 finish_constructor_body (void)
10043 {
10044 }
10045
10046 /* Do all the processing for the beginning of a destructor; set up the
10047    vtable pointers and cleanups for bases and members.  */
10048
10049 static void
10050 begin_destructor_body (void)
10051 {
10052   tree if_stmt;
10053   tree compound_stmt;
10054
10055   /* If the dtor is empty, and we know there is not any possible
10056      way we could use any vtable entries, before they are possibly
10057      set by a base class dtor, we don't have to setup the vtables,
10058      as we know that any base class dtor will set up any vtables
10059      it needs.  We avoid MI, because one base class dtor can do a
10060      virtual dispatch to an overridden function that would need to
10061      have a non-related vtable set up, we cannot avoid setting up
10062      vtables in that case.  We could change this to see if there
10063      is just one vtable.
10064
10065      ??? In the destructor for a class, the vtables are set
10066      appropriately for that class.  There will be no non-related
10067      vtables.  jason 2001-12-11.  */
10068   if_stmt = begin_if_stmt ();
10069
10070   /* If it is not safe to avoid setting up the vtables, then
10071      someone will change the condition to be boolean_true_node.
10072      (Actually, for now, we do not have code to set the condition
10073      appropriately, so we just assume that we always need to
10074      initialize the vtables.)  */
10075   finish_if_stmt_cond (boolean_true_node, if_stmt);
10076
10077   compound_stmt = begin_compound_stmt (0);
10078
10079   /* Make all virtual function table pointers in non-virtual base
10080      classes point to CURRENT_CLASS_TYPE's virtual function
10081      tables.  */
10082   initialize_vtbl_ptrs (current_class_ptr);
10083
10084   finish_compound_stmt (compound_stmt);
10085   finish_then_clause (if_stmt);
10086   finish_if_stmt (if_stmt);
10087
10088   /* And insert cleanups for our bases and members so that they
10089      will be properly destroyed if we throw.  */
10090   push_base_cleanups ();
10091 }
10092
10093 /* At the end of every destructor we generate code to delete the object if
10094    necessary.  Do that now.  */
10095
10096 static void
10097 finish_destructor_body (void)
10098 {
10099   tree exprstmt;
10100
10101   /* Any return from a destructor will end up here; that way all base
10102      and member cleanups will be run when the function returns.  */
10103   add_stmt (build_stmt (LABEL_EXPR, dtor_label));
10104
10105   /* In a virtual destructor, we must call delete.  */
10106   if (DECL_VIRTUAL_P (current_function_decl))
10107     {
10108       tree if_stmt;
10109       tree virtual_size = cxx_sizeof (current_class_type);
10110
10111       /* [class.dtor]
10112
10113       At the point of definition of a virtual destructor (including
10114       an implicit definition), non-placement operator delete shall
10115       be looked up in the scope of the destructor's class and if
10116       found shall be accessible and unambiguous.  */
10117       exprstmt = build_op_delete_call
10118         (DELETE_EXPR, current_class_ptr, virtual_size,
10119          /*global_p=*/false, NULL_TREE);
10120
10121       if_stmt = begin_if_stmt ();
10122       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
10123                                   current_in_charge_parm,
10124                                   integer_one_node),
10125                            if_stmt);
10126       finish_expr_stmt (exprstmt);
10127       finish_then_clause (if_stmt);
10128       finish_if_stmt (if_stmt);
10129     }
10130 }
10131
10132 /* Do the necessary processing for the beginning of a function body, which
10133    in this case includes member-initializers, but not the catch clauses of
10134    a function-try-block.  Currently, this means opening a binding level
10135    for the member-initializers (in a ctor) and member cleanups (in a dtor).
10136    In other functions, this isn't necessary, but it doesn't hurt.  */
10137
10138 tree
10139 begin_function_body (void)
10140 {
10141   tree stmt;
10142
10143   if (processing_template_decl)
10144     /* Do nothing now.  */;
10145   else
10146     /* Always keep the BLOCK node associated with the outermost pair of
10147        curly braces of a function.  These are needed for correct
10148        operation of dwarfout.c.  */
10149     keep_next_level (true);
10150
10151   stmt = begin_compound_stmt (BCS_FN_BODY);
10152
10153   if (processing_template_decl)
10154     /* Do nothing now.  */;
10155   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10156     begin_constructor_body ();
10157   else if (DECL_DESTRUCTOR_P (current_function_decl))
10158     begin_destructor_body ();
10159
10160   return stmt;
10161 }
10162
10163 /* Do the processing for the end of a function body.  Currently, this means
10164    closing out the cleanups for fully-constructed bases and members, and in
10165    the case of the destructor, deleting the object if desired.  Again, this
10166    is only meaningful for [cd]tors, since they are the only functions where
10167    there is a significant distinction between the main body and any
10168    function catch clauses.  Handling, say, main() return semantics here
10169    would be wrong, as flowing off the end of a function catch clause for
10170    main() would also need to return 0.  */
10171
10172 void
10173 finish_function_body (tree compstmt)
10174 {
10175   /* Close the block.  */
10176   finish_compound_stmt (compstmt);
10177
10178   if (processing_template_decl)
10179     /* Do nothing now.  */;
10180   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10181     finish_constructor_body ();
10182   else if (DECL_DESTRUCTOR_P (current_function_decl))
10183     finish_destructor_body ();
10184 }
10185
10186 /* Finish up a function declaration and compile that function
10187    all the way to assembler language output.  The free the storage
10188    for the function definition.
10189
10190    FLAGS is a bitwise or of the following values:
10191      2 - INCLASS_INLINE
10192        We just finished processing the body of an in-class inline
10193        function definition.  (This processing will have taken place
10194        after the class definition is complete.)  */
10195
10196 tree
10197 finish_function (int flags)
10198 {
10199   tree fndecl = current_function_decl;
10200   tree fntype, ctype = NULL_TREE;
10201   int inclass_inline = (flags & 2) != 0;
10202   int nested;
10203
10204   /* When we get some parse errors, we can end up without a
10205      current_function_decl, so cope.  */
10206   if (fndecl == NULL_TREE)
10207     return error_mark_node;
10208
10209   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10210       && DECL_VIRTUAL_P (fndecl)
10211       && !processing_template_decl)
10212     {
10213       tree fnclass = DECL_CONTEXT (fndecl);
10214       if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10215         keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10216     }
10217
10218   nested = function_depth > 1;
10219   fntype = TREE_TYPE (fndecl);
10220
10221   /*  TREE_READONLY (fndecl) = 1;
10222       This caused &foo to be of type ptr-to-const-function
10223       which then got a warning when stored in a ptr-to-function variable.  */
10224
10225   my_friendly_assert (building_stmt_tree (), 20000911);
10226
10227   /* For a cloned function, we've already got all the code we need;
10228      there's no need to add any extra bits.  */
10229   if (!DECL_CLONED_FUNCTION_P (fndecl))
10230     {
10231       if (DECL_MAIN_P (current_function_decl))
10232         {
10233           /* Make it so that `main' always returns 0 by default.  */
10234 #if VMS_TARGET
10235           finish_return_stmt (integer_one_node);
10236 #else
10237           finish_return_stmt (integer_zero_node);
10238 #endif
10239         }
10240
10241       /* Finish dealing with exception specifiers.  */
10242       if (flag_exceptions && !processing_template_decl
10243           && flag_enforce_eh_specs
10244           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10245         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10246                               (TREE_TYPE (current_function_decl)),
10247                               current_eh_spec_block);
10248     }
10249
10250   /* If we're saving up tree structure, tie off the function now.  */
10251   DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10252
10253   finish_fname_decls ();
10254
10255   /* If this function can't throw any exceptions, remember that.  */
10256   if (!processing_template_decl
10257       && !cp_function_chain->can_throw
10258       && !flag_non_call_exceptions)
10259     TREE_NOTHROW (fndecl) = 1;
10260
10261   /* This must come after expand_function_end because cleanups might
10262      have declarations (from inline functions) that need to go into
10263      this function's blocks.  */
10264
10265   /* If the current binding level isn't the outermost binding level
10266      for this function, either there is a bug, or we have experienced
10267      syntax errors and the statement tree is malformed.  */
10268   if (current_binding_level->kind != sk_function_parms)
10269     {
10270       /* Make sure we have already experienced errors.  */
10271       if (errorcount == 0)
10272         abort ();
10273
10274       /* Throw away the broken statement tree and extra binding
10275          levels.  */
10276       DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10277
10278       while (current_binding_level->kind != sk_function_parms)
10279         {
10280           if (current_binding_level->kind == sk_class)
10281             pop_nested_class ();
10282           else
10283             poplevel (0, 0, 0);
10284         }
10285     }
10286   poplevel (1, 0, 1);
10287
10288   /* Statements should always be full-expressions at the outermost set
10289      of curly braces for a function.  */
10290   my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
10291
10292   /* Set up the named return value optimization, if we can.  Candidate
10293      variables are selected in check_return_value.  */
10294   if (current_function_return_value)
10295     {
10296       tree r = current_function_return_value;
10297       tree outer;
10298
10299       if (r != error_mark_node
10300           /* This is only worth doing for fns that return in memory--and
10301              simpler, since we don't have to worry about promoted modes.  */
10302           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10303           /* Only allow this for variables declared in the outer scope of
10304              the function so we know that their lifetime always ends with a
10305              return; see g++.dg/opt/nrv6.C.  We could be more flexible if
10306              we were to do this optimization in tree-ssa.  */
10307           && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)))
10308           /* Skip the artificial function body block.  */
10309           && (outer = BLOCK_SUBBLOCKS (outer))
10310           && chain_member (r, BLOCK_VARS (outer)))
10311         finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10312
10313       current_function_return_value = NULL_TREE;
10314     }
10315
10316   /* Remember that we were in class scope.  */
10317   if (current_class_name)
10318     ctype = current_class_type;
10319
10320   /* Must mark the RESULT_DECL as being in this function.  */
10321   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10322
10323   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10324      to the FUNCTION_DECL node itself.  */
10325   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10326
10327   /* Save away current state, if appropriate.  */
10328   if (!processing_template_decl)
10329     save_function_data (fndecl);
10330
10331   /* Complain if there's just no return statement.  */
10332   if (warn_return_type
10333       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10334       && !dependent_type_p (TREE_TYPE (fntype))
10335       && !current_function_returns_value && !current_function_returns_null
10336       /* Don't complain if we abort or throw.  */
10337       && !current_function_returns_abnormally
10338       && !DECL_NAME (DECL_RESULT (fndecl))
10339       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
10340          inline function, as we might never be compiled separately.  */
10341       && (DECL_INLINE (fndecl) || processing_template_decl))
10342     warning ("no return statement in function returning non-void");
10343
10344   /* Store the end of the function, so that we get good line number
10345      info for the epilogue.  */
10346   cfun->function_end_locus = input_location;
10347
10348   /* Genericize before inlining.  */
10349   if (!processing_template_decl)
10350     {
10351       cp_genericize (fndecl);
10352
10353       /* Handle attribute((warn_unused_result)).  Relies on gimple input.  */
10354       c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10355     }
10356
10357   /* We're leaving the context of this function, so zap cfun.  It's still in
10358      DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation.  */
10359   cfun = NULL;
10360   current_function_decl = NULL;
10361
10362   /* If this is an in-class inline definition, we may have to pop the
10363      bindings for the template parameters that we added in
10364      maybe_begin_member_template_processing when start_function was
10365      called.  */
10366   if (inclass_inline)
10367     maybe_end_member_template_processing ();
10368
10369   /* Leave the scope of the class.  */
10370   if (ctype)
10371     pop_nested_class ();
10372
10373   --function_depth;
10374
10375   /* Clean up.  */
10376   if (! nested)
10377     /* Let the error reporting routines know that we're outside a
10378        function.  For a nested function, this value is used in
10379        cxx_pop_function_context and then reset via pop_function_context.  */
10380     current_function_decl = NULL_TREE;
10381
10382   return fndecl;
10383 }
10384 \f
10385 /* Create the FUNCTION_DECL for a function definition.
10386    DECLSPECS and DECLARATOR are the parts of the declaration;
10387    they describe the return type and the name of the function,
10388    but twisted together in a fashion that parallels the syntax of C.
10389
10390    This function creates a binding context for the function body
10391    as well as setting up the FUNCTION_DECL in current_function_decl.
10392
10393    Returns a FUNCTION_DECL on success.
10394
10395    If the DECLARATOR is not suitable for a function (it defines a datum
10396    instead), we return 0, which tells yyparse to report a parse error.
10397
10398    May return void_type_node indicating that this method is actually
10399    a friend.  See grokfield for more details.
10400
10401    Came here with a `.pushlevel' .
10402
10403    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10404    CHANGES TO CODE IN `grokfield'.  */
10405
10406 tree
10407 start_method (cp_decl_specifier_seq *declspecs,
10408               const cp_declarator *declarator, tree attrlist)
10409 {
10410   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10411                                 &attrlist);
10412
10413   if (fndecl == error_mark_node)
10414     return error_mark_node;
10415
10416   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10417     {
10418       error ("invalid member function declaration");
10419       return error_mark_node;
10420     }
10421
10422   if (attrlist)
10423     cplus_decl_attributes (&fndecl, attrlist, 0);
10424
10425   /* Pass friends other than inline friend functions back.  */
10426   if (fndecl == void_type_node)
10427     return fndecl;
10428
10429   if (DECL_IN_AGGR_P (fndecl))
10430     {
10431       if (DECL_CONTEXT (fndecl)
10432           && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10433         error ("`%D' is already defined in class `%T'", fndecl,
10434                DECL_CONTEXT (fndecl));
10435       return void_type_node;
10436     }
10437
10438   check_template_shadow (fndecl);
10439
10440   DECL_DECLARED_INLINE_P (fndecl) = 1;
10441   if (flag_default_inline)
10442     DECL_INLINE (fndecl) = 1;
10443
10444   /* We process method specializations in finish_struct_1.  */
10445   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10446     {
10447       fndecl = push_template_decl (fndecl);
10448       if (fndecl == error_mark_node)
10449         return fndecl;
10450     }
10451
10452   if (! DECL_FRIEND_P (fndecl))
10453     {
10454       if (TREE_CHAIN (fndecl))
10455         {
10456           fndecl = copy_node (fndecl);
10457           TREE_CHAIN (fndecl) = NULL_TREE;
10458         }
10459       grok_special_member_properties (fndecl);
10460     }
10461
10462   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10463
10464   /* Make a place for the parms.  */
10465   begin_scope (sk_function_parms, fndecl);
10466
10467   DECL_IN_AGGR_P (fndecl) = 1;
10468   return fndecl;
10469 }
10470
10471 /* Go through the motions of finishing a function definition.
10472    We don't compile this method until after the whole class has
10473    been processed.
10474
10475    FINISH_METHOD must return something that looks as though it
10476    came from GROKFIELD (since we are defining a method, after all).
10477
10478    This is called after parsing the body of the function definition.
10479    STMTS is the chain of statements that makes up the function body.
10480
10481    DECL is the ..._DECL that `start_method' provided.  */
10482
10483 tree
10484 finish_method (tree decl)
10485 {
10486   tree fndecl = decl;
10487   tree old_initial;
10488
10489   tree link;
10490
10491   if (decl == void_type_node)
10492     return decl;
10493
10494   old_initial = DECL_INITIAL (fndecl);
10495
10496   /* Undo the level for the parms (from start_method).
10497      This is like poplevel, but it causes nothing to be
10498      saved.  Saving information here confuses symbol-table
10499      output routines.  Besides, this information will
10500      be correctly output when this method is actually
10501      compiled.  */
10502
10503   /* Clear out the meanings of the local variables of this level;
10504      also record in each decl which block it belongs to.  */
10505
10506   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
10507     {
10508       if (DECL_NAME (link) != NULL_TREE)
10509         pop_binding (DECL_NAME (link), link);
10510       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
10511       DECL_CONTEXT (link) = NULL_TREE;
10512     }
10513
10514   poplevel (0, 0, 0);
10515
10516   DECL_INITIAL (fndecl) = old_initial;
10517
10518   /* We used to check if the context of FNDECL was different from
10519      current_class_type as another way to get inside here.  This didn't work
10520      for String.cc in libg++.  */
10521   if (DECL_FRIEND_P (fndecl))
10522     {
10523       CLASSTYPE_INLINE_FRIENDS (current_class_type)
10524         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
10525       decl = void_type_node;
10526     }
10527
10528   return decl;
10529 }
10530 \f
10531
10532 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
10533    we can lay it out later, when and if its type becomes complete.  */
10534
10535 void
10536 maybe_register_incomplete_var (tree var)
10537 {
10538   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
10539
10540   /* Keep track of variables with incomplete types.  */
10541   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
10542       && DECL_EXTERNAL (var))
10543     {
10544       tree inner_type = TREE_TYPE (var);
10545
10546       while (TREE_CODE (inner_type) == ARRAY_TYPE)
10547         inner_type = TREE_TYPE (inner_type);
10548       inner_type = TYPE_MAIN_VARIANT (inner_type);
10549
10550       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
10551           /* RTTI TD entries are created while defining the type_info.  */
10552           || (TYPE_LANG_SPECIFIC (inner_type)
10553               && TYPE_BEING_DEFINED (inner_type)))
10554         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
10555     }
10556 }
10557
10558 /* Called when a class type (given by TYPE) is defined.  If there are
10559    any existing VAR_DECLs whose type hsa been completed by this
10560    declaration, update them now.  */
10561
10562 void
10563 complete_vars (tree type)
10564 {
10565   tree *list = &incomplete_vars;
10566
10567   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
10568   while (*list)
10569     {
10570       if (same_type_p (type, TREE_PURPOSE (*list)))
10571         {
10572           tree var = TREE_VALUE (*list);
10573           /* Complete the type of the variable.  The VAR_DECL itself
10574              will be laid out in expand_expr.  */
10575           complete_type (TREE_TYPE (var));
10576           /* Remove this entry from the list.  */
10577           *list = TREE_CHAIN (*list);
10578         }
10579       else
10580         list = &TREE_CHAIN (*list);
10581     }
10582
10583   /* Check for pending declarations which may have abstract type.  */
10584   complete_type_check_abstract (type);
10585 }
10586
10587 /* If DECL is of a type which needs a cleanup, build that cleanup
10588    here.  */
10589
10590 tree
10591 cxx_maybe_build_cleanup (tree decl)
10592 {
10593   tree type = TREE_TYPE (decl);
10594
10595   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
10596     {
10597       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
10598       tree rval;
10599
10600       if (TREE_CODE (type) == ARRAY_TYPE)
10601         rval = decl;
10602       else
10603         {
10604           cxx_mark_addressable (decl);
10605           rval = build_unary_op (ADDR_EXPR, decl, 0);
10606         }
10607
10608       /* Optimize for space over speed here.  */
10609       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
10610           || flag_expensive_optimizations)
10611         flags |= LOOKUP_NONVIRTUAL;
10612
10613       rval = build_delete (TREE_TYPE (rval), rval,
10614                            sfk_complete_destructor, flags, 0);
10615
10616       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
10617           && ! TYPE_HAS_DESTRUCTOR (type))
10618         rval = build_compound_expr (rval, build_vbase_delete (type, decl));
10619
10620       return rval;
10621     }
10622   return NULL_TREE;
10623 }
10624 \f
10625 /* When a stmt has been parsed, this function is called.  */
10626
10627 void
10628 finish_stmt (void)
10629 {
10630 }
10631
10632 /* DECL was originally constructed as a non-static member function,
10633    but turned out to be static.  Update it accordingly.  */
10634
10635 void
10636 revert_static_member_fn (tree decl)
10637 {
10638   tree tmp;
10639   tree function = TREE_TYPE (decl);
10640   tree args = TYPE_ARG_TYPES (function);
10641
10642   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
10643       != TYPE_UNQUALIFIED)
10644     error ("static member function `%#D' declared with type qualifiers",
10645               decl);
10646
10647   args = TREE_CHAIN (args);
10648   tmp = build_function_type (TREE_TYPE (function), args);
10649   tmp = build_qualified_type (tmp, cp_type_quals (function));
10650   tmp = build_exception_variant (tmp,
10651                                  TYPE_RAISES_EXCEPTIONS (function));
10652   TREE_TYPE (decl) = tmp;
10653   if (DECL_ARGUMENTS (decl))
10654     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
10655   DECL_STATIC_FUNCTION_P (decl) = 1;
10656 }
10657
10658 /* Initialize the variables used during compilation of a C++
10659    function.  */
10660
10661 void
10662 cxx_push_function_context (struct function * f)
10663 {
10664   struct language_function *p
10665     = ggc_alloc_cleared (sizeof (struct language_function));
10666   f->language = p;
10667
10668   /* Whenever we start a new function, we destroy temporaries in the
10669      usual way.  */
10670   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
10671
10672   if (f->decl)
10673     {
10674       tree fn = f->decl;
10675
10676       if (DECL_SAVED_FUNCTION_DATA (fn))
10677         {
10678           /* If we already parsed this function, and we're just expanding it
10679              now, restore saved state.  */
10680           *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
10681
10682           /* We don't need the saved data anymore.  Unless this is an inline
10683              function; we need the named return value info for
10684              cp_copy_res_decl_for_inlining.  */
10685           if (! DECL_INLINE (fn))
10686             DECL_SAVED_FUNCTION_DATA (fn) = NULL;
10687         }
10688     }
10689 }
10690
10691 /* Free the language-specific parts of F, now that we've finished
10692    compiling the function.  */
10693
10694 void
10695 cxx_pop_function_context (struct function * f)
10696 {
10697   f->language = 0;
10698 }
10699
10700 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
10701    one of the language-independent trees.  */
10702
10703 enum cp_tree_node_structure_enum
10704 cp_tree_node_structure (union lang_tree_node * t)
10705 {
10706   switch (TREE_CODE (&t->generic))
10707     {
10708     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
10709     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
10710     case OVERLOAD:              return TS_CP_OVERLOAD;
10711     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
10712     case PTRMEM_CST:            return TS_CP_PTRMEM;
10713     case BASELINK:              return TS_CP_BASELINK;
10714     default:                    return TS_CP_GENERIC;
10715     }
10716 }
10717
10718 /* Build the void_list_node (void_type_node having been created).  */
10719 tree
10720 build_void_list_node (void)
10721 {
10722   tree t = build_tree_list (NULL_TREE, void_type_node);
10723   return t;
10724 }
10725
10726 bool
10727 cp_missing_noreturn_ok_p (tree decl)
10728 {
10729   /* A missing noreturn is ok for the `main' function.  */
10730   return DECL_MAIN_P (decl);
10731 }
10732
10733 #include "gt-cp-decl.h"
10734 #include "gtype-cp.h"