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, TREE_TYPE (cond),
2448                         low_value, high_value);
2449
2450   check_switch_goto (switch_stack->level);
2451
2452   /* After labels, make any new cleanups in the function go into their
2453      own new (temporary) binding contour.  */
2454   for (p = current_binding_level;
2455        p->kind != sk_function_parms;
2456        p = p->level_chain)
2457     p->more_cleanups_ok = 0;
2458
2459   return r;
2460 }
2461 \f
2462 /* Hash a TYPENAME_TYPE.  K is really of type `tree'.  */
2463
2464 static hashval_t
2465 typename_hash (const void* k)
2466 {
2467   hashval_t hash;
2468   tree t = (tree) k;
2469
2470   hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2471           ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2472
2473   return hash;
2474 }
2475
2476 /* Compare two TYPENAME_TYPEs.  K1 and K2 are really of type `tree'.  */
2477
2478 static int
2479 typename_compare (const void * k1, const void * k2)
2480 {
2481   tree t1;
2482   tree t2;
2483   tree d1;
2484   tree d2;
2485
2486   t1 = (tree) k1;
2487   t2 = (tree) k2;
2488   d1 = TYPE_NAME (t1);
2489   d2 = TYPE_NAME (t2);
2490
2491   return (DECL_NAME (d1) == DECL_NAME (d2)
2492           && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
2493           && ((TREE_TYPE (t1) != NULL_TREE)
2494               == (TREE_TYPE (t2) != NULL_TREE))
2495           && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2496           && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
2497 }
2498
2499 /* Build a TYPENAME_TYPE.  If the type is `typename T::t', CONTEXT is
2500    the type of `T', NAME is the IDENTIFIER_NODE for `t'.  If BASE_TYPE
2501    is non-NULL, this type is being created by the implicit typename
2502    extension, and BASE_TYPE is a type named `t' in some base class of
2503    `T' which depends on template parameters.
2504
2505    Returns the new TYPENAME_TYPE.  */
2506
2507 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2508
2509 static tree
2510 build_typename_type (tree context, tree name, tree fullname)
2511 {
2512   tree t;
2513   tree d;
2514   void **e;
2515
2516   if (typename_htab == NULL)
2517     {
2518       typename_htab = htab_create_ggc (61, &typename_hash,
2519                                        &typename_compare, NULL);
2520     }
2521
2522   /* Build the TYPENAME_TYPE.  */
2523   t = make_aggr_type (TYPENAME_TYPE);
2524   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2525   TYPENAME_TYPE_FULLNAME (t) = fullname;
2526
2527   /* Build the corresponding TYPE_DECL.  */
2528   d = build_decl (TYPE_DECL, name, t);
2529   TYPE_NAME (TREE_TYPE (d)) = d;
2530   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2531   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2532   DECL_ARTIFICIAL (d) = 1;
2533
2534   /* See if we already have this type.  */
2535   e = htab_find_slot (typename_htab, t, INSERT);
2536   if (*e)
2537     t = (tree) *e;
2538   else
2539     *e = t;
2540
2541   return t;
2542 }
2543
2544 /* Resolve `typename CONTEXT::NAME'.  Returns an appropriate type,
2545    unless an error occurs, in which case error_mark_node is returned.
2546    If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2547    set, we return that, rather than the _TYPE it corresponds to, in
2548    other cases we look through the type decl.  If TF_ERROR is set,
2549    complain about errors, otherwise be quiet.  */
2550
2551 tree
2552 make_typename_type (tree context, tree name, tsubst_flags_t complain)
2553 {
2554   tree fullname;
2555
2556   if (name == error_mark_node
2557       || context == NULL_TREE
2558       || context == error_mark_node)
2559     return error_mark_node;
2560
2561   if (TYPE_P (name))
2562     {
2563       if (!(TYPE_LANG_SPECIFIC (name)
2564             && (CLASSTYPE_IS_TEMPLATE (name)
2565                 || CLASSTYPE_USE_TEMPLATE (name))))
2566         name = TYPE_IDENTIFIER (name);
2567       else
2568         /* Create a TEMPLATE_ID_EXPR for the type.  */
2569         name = build_nt (TEMPLATE_ID_EXPR,
2570                          CLASSTYPE_TI_TEMPLATE (name),
2571                          CLASSTYPE_TI_ARGS (name));
2572     }
2573   else if (TREE_CODE (name) == TYPE_DECL)
2574     name = DECL_NAME (name);
2575
2576   fullname = name;
2577
2578   if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2579     {
2580       name = TREE_OPERAND (name, 0);
2581       if (TREE_CODE (name) == TEMPLATE_DECL)
2582         name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2583     }
2584   if (TREE_CODE (name) == TEMPLATE_DECL)
2585     {
2586       error ("`%D' used without template parameters", name);
2587       return error_mark_node;
2588     }
2589   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802);
2590
2591   if (TREE_CODE (context) == NAMESPACE_DECL)
2592     {
2593       /* We can get here from typename_sub0 in the explicit_template_type
2594          expansion.  Just fail.  */
2595       if (complain & tf_error)
2596         error ("no class template named `%#T' in `%#T'",
2597                   name, context);
2598       return error_mark_node;
2599     }
2600
2601   if (!dependent_type_p (context)
2602       || currently_open_class (context))
2603     {
2604       if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2605         {
2606           tree tmpl = NULL_TREE;
2607           if (IS_AGGR_TYPE (context))
2608             tmpl = lookup_field (context, name, 0, false);
2609           if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2610             {
2611               if (complain & tf_error)
2612                 error ("no class template named `%#T' in `%#T'",
2613                           name, context);
2614               return error_mark_node;
2615             }
2616
2617           if (complain & tf_error)
2618             perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2619
2620           return lookup_template_class (tmpl,
2621                                         TREE_OPERAND (fullname, 1),
2622                                         NULL_TREE, context,
2623                                         /*entering_scope=*/0,
2624                                         tf_error | tf_warning | tf_user);
2625         }
2626       else
2627         {
2628           tree t;
2629
2630           if (!IS_AGGR_TYPE (context))
2631             {
2632               if (complain & tf_error)
2633                 error ("no type named `%#T' in `%#T'", name, context);
2634               return error_mark_node;
2635             }
2636
2637           t = lookup_field (context, name, 0, true);
2638           if (t)
2639             {
2640               if (TREE_CODE (t) != TYPE_DECL)
2641                 {
2642                   if (complain & tf_error)
2643                     error ("no type named `%#T' in `%#T'", name, context);
2644                   return error_mark_node;
2645                 }
2646
2647               if (complain & tf_error)
2648                 perform_or_defer_access_check (TYPE_BINFO (context), t);
2649
2650               if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2651                 t = TREE_TYPE (t);
2652
2653               return t;
2654             }
2655         }
2656     }
2657
2658   /* If the CONTEXT is not a template type, then either the field is
2659      there now or its never going to be.  */
2660   if (!dependent_type_p (context))
2661     {
2662       if (complain & tf_error)
2663         error ("no type named `%#T' in `%#T'", name, context);
2664       return error_mark_node;
2665     }
2666
2667   return build_typename_type (context, name, fullname);
2668 }
2669
2670 /* Resolve `CONTEXT::template NAME'.  Returns an appropriate type,
2671    unless an error occurs, in which case error_mark_node is returned.
2672    If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2673    corresponds to.  If COMPLAIN zero, don't complain about any errors
2674    that occur.  */
2675
2676 tree
2677 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
2678 {
2679   tree t;
2680   tree d;
2681
2682   if (TYPE_P (name))
2683     name = TYPE_IDENTIFIER (name);
2684   else if (DECL_P (name))
2685     name = DECL_NAME (name);
2686   if (TREE_CODE (name) != IDENTIFIER_NODE)
2687     abort ();
2688
2689   if (!dependent_type_p (context)
2690       || currently_open_class (context))
2691     {
2692       tree tmpl = NULL_TREE;
2693
2694       if (IS_AGGR_TYPE (context))
2695         tmpl = lookup_field (context, name, 0, false);
2696
2697       if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2698         {
2699           if (complain & tf_error)
2700             error ("no class template named `%#T' in `%#T'", name, context);
2701           return error_mark_node;
2702         }
2703
2704       if (complain & tf_error)
2705         perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2706
2707       return tmpl;
2708     }
2709
2710   /* Build the UNBOUND_CLASS_TEMPLATE.  */
2711   t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2712   TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2713   TREE_TYPE (t) = NULL_TREE;
2714
2715   /* Build the corresponding TEMPLATE_DECL.  */
2716   d = build_decl (TEMPLATE_DECL, name, t);
2717   TYPE_NAME (TREE_TYPE (d)) = d;
2718   TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2719   DECL_CONTEXT (d) = FROB_CONTEXT (context);
2720   DECL_ARTIFICIAL (d) = 1;
2721
2722   return t;
2723 }
2724
2725 \f
2726
2727 /* Push the declarations of builtin types into the namespace.
2728    RID_INDEX is the index of the builtin type in the array
2729    RID_POINTERS.  NAME is the name used when looking up the builtin
2730    type.  TYPE is the _TYPE node for the builtin type.  */
2731
2732 void
2733 record_builtin_type (enum rid rid_index,
2734                      const char* name,
2735                      tree type)
2736 {
2737   tree rname = NULL_TREE, tname = NULL_TREE;
2738   tree tdecl = NULL_TREE;
2739
2740   if ((int) rid_index < (int) RID_MAX)
2741     rname = ridpointers[(int) rid_index];
2742   if (name)
2743     tname = get_identifier (name);
2744
2745   /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2746      eliminated.  Built-in types should not be looked up name; their
2747      names are keywords that the parser can recognize.  However, there
2748      is code in c-common.c that uses identifier_global_value to look
2749      up built-in types by name.  */
2750   if (tname)
2751     {
2752       tdecl = build_decl (TYPE_DECL, tname, type);
2753       DECL_ARTIFICIAL (tdecl) = 1;
2754       SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2755     }
2756   if (rname)
2757     {
2758       if (!tdecl)
2759         {
2760           tdecl = build_decl (TYPE_DECL, rname, type);
2761           DECL_ARTIFICIAL (tdecl) = 1;
2762         }
2763       SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2764     }
2765
2766   if (!TYPE_NAME (type))
2767     TYPE_NAME (type) = tdecl;
2768
2769   if (tdecl)
2770     debug_hooks->type_decl (tdecl, 0);
2771 }
2772
2773 /* Record one of the standard Java types.
2774  * Declare it as having the given NAME.
2775  * If SIZE > 0, it is the size of one of the integral types;
2776  * otherwise it is the negative of the size of one of the other types.  */
2777
2778 static tree
2779 record_builtin_java_type (const char* name, int size)
2780 {
2781   tree type, decl;
2782   if (size > 0)
2783     type = make_signed_type (size);
2784   else if (size > -32)
2785     { /* "__java_char" or ""__java_boolean".  */
2786       type = make_unsigned_type (-size);
2787       /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2788     }
2789   else
2790     { /* "__java_float" or ""__java_double".  */
2791       type = make_node (REAL_TYPE);
2792       TYPE_PRECISION (type) = - size;
2793       layout_type (type);
2794     }
2795   record_builtin_type (RID_MAX, name, type);
2796   decl = TYPE_NAME (type);
2797
2798   /* Suppress generate debug symbol entries for these types,
2799      since for normal C++ they are just clutter.
2800      However, push_lang_context undoes this if extern "Java" is seen.  */
2801   DECL_IGNORED_P (decl) = 1;
2802
2803   TYPE_FOR_JAVA (type) = 1;
2804   return type;
2805 }
2806
2807 /* Push a type into the namespace so that the back-ends ignore it.  */
2808
2809 static void
2810 record_unknown_type (tree type, const char* name)
2811 {
2812   tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2813   /* Make sure the "unknown type" typedecl gets ignored for debug info.  */
2814   DECL_IGNORED_P (decl) = 1;
2815   TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2816   TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2817   TYPE_ALIGN (type) = 1;
2818   TYPE_USER_ALIGN (type) = 0;
2819   TYPE_MODE (type) = TYPE_MODE (void_type_node);
2820 }
2821
2822 /* An string for which we should create an IDENTIFIER_NODE at
2823    startup.  */
2824
2825 typedef struct predefined_identifier
2826 {
2827   /* The name of the identifier.  */
2828   const char *const name;
2829   /* The place where the IDENTIFIER_NODE should be stored.  */
2830   tree *const node;
2831   /* Nonzero if this is the name of a constructor or destructor.  */
2832   const int ctor_or_dtor_p;
2833 } predefined_identifier;
2834
2835 /* Create all the predefined identifiers.  */
2836
2837 static void
2838 initialize_predefined_identifiers (void)
2839 {
2840   const predefined_identifier *pid;
2841
2842   /* A table of identifiers to create at startup.  */
2843   static const predefined_identifier predefined_identifiers[] = {
2844     { "C++", &lang_name_cplusplus, 0 },
2845     { "C", &lang_name_c, 0 },
2846     { "Java", &lang_name_java, 0 },
2847     { CTOR_NAME, &ctor_identifier, 1 },
2848     { "__base_ctor", &base_ctor_identifier, 1 },
2849     { "__comp_ctor", &complete_ctor_identifier, 1 },
2850     { DTOR_NAME, &dtor_identifier, 1 },
2851     { "__comp_dtor", &complete_dtor_identifier, 1 },
2852     { "__base_dtor", &base_dtor_identifier, 1 },
2853     { "__deleting_dtor", &deleting_dtor_identifier, 1 },
2854     { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2855     { "nelts", &nelts_identifier, 0 },
2856     { THIS_NAME, &this_identifier, 0 },
2857     { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2858     { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2859     { "_vptr", &vptr_identifier, 0 },
2860     { "__vtt_parm", &vtt_parm_identifier, 0 },
2861     { "::", &global_scope_name, 0 },
2862     { "std", &std_identifier, 0 },
2863     { NULL, NULL, 0 }
2864   };
2865
2866   for (pid = predefined_identifiers; pid->name; ++pid)
2867     {
2868       *pid->node = get_identifier (pid->name);
2869       if (pid->ctor_or_dtor_p)
2870         IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2871     }
2872 }
2873
2874 /* Create the predefined scalar types of C,
2875    and some nodes representing standard constants (0, 1, (void *)0).
2876    Initialize the global binding level.
2877    Make definitions for built-in primitive functions.  */
2878
2879 void
2880 cxx_init_decl_processing (void)
2881 {
2882   tree void_ftype;
2883   tree void_ftype_ptr;
2884
2885   build_common_tree_nodes (flag_signed_char);
2886
2887   /* Create all the identifiers we need.  */
2888   initialize_predefined_identifiers ();
2889
2890   /* Create the global variables.  */
2891   push_to_top_level ();
2892
2893   current_function_decl = NULL_TREE;
2894   current_binding_level = NULL;
2895   /* Enter the global namespace.  */
2896   my_friendly_assert (global_namespace == NULL_TREE, 375);
2897   global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2898                                       void_type_node);
2899   begin_scope (sk_namespace, global_namespace);
2900
2901   current_lang_name = NULL_TREE;
2902
2903   /* Adjust various flags based on command-line settings.  */
2904   if (!flag_permissive)
2905     flag_pedantic_errors = 1;
2906   if (!flag_no_inline)
2907     {
2908       flag_inline_trees = 1;
2909       flag_no_inline = 1;
2910     }
2911   if (flag_inline_functions)
2912     {
2913       flag_inline_trees = 2;
2914       flag_inline_functions = 0;
2915     }
2916
2917   /* Force minimum function alignment if using the least significant
2918      bit of function pointers to store the virtual bit.  */
2919   if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2920       && force_align_functions_log < 1)
2921     force_align_functions_log = 1;
2922
2923   /* Initially, C.  */
2924   current_lang_name = lang_name_c;
2925
2926   error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2927   TREE_TYPE (error_mark_list) = error_mark_node;
2928
2929   /* Create the `std' namespace.  */
2930   push_namespace (std_identifier);
2931   std_node = current_namespace;
2932   pop_namespace ();
2933
2934   c_common_nodes_and_builtins ();
2935
2936   java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2937   java_short_type_node = record_builtin_java_type ("__java_short", 16);
2938   java_int_type_node = record_builtin_java_type ("__java_int", 32);
2939   java_long_type_node = record_builtin_java_type ("__java_long", 64);
2940   java_float_type_node = record_builtin_java_type ("__java_float", -32);
2941   java_double_type_node = record_builtin_java_type ("__java_double", -64);
2942   java_char_type_node = record_builtin_java_type ("__java_char", -16);
2943   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2944
2945   integer_two_node = build_int_2 (2, 0);
2946   TREE_TYPE (integer_two_node) = integer_type_node;
2947   integer_three_node = build_int_2 (3, 0);
2948   TREE_TYPE (integer_three_node) = integer_type_node;
2949
2950   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2951   truthvalue_type_node = boolean_type_node;
2952   truthvalue_false_node = boolean_false_node;
2953   truthvalue_true_node = boolean_true_node;
2954
2955   empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
2956
2957 #if 0
2958   record_builtin_type (RID_MAX, NULL, string_type_node);
2959 #endif
2960
2961   delta_type_node = ptrdiff_type_node;
2962   vtable_index_type = ptrdiff_type_node;
2963
2964   vtt_parm_type = build_pointer_type (const_ptr_type_node);
2965   void_ftype = build_function_type (void_type_node, void_list_node);
2966   void_ftype_ptr = build_function_type (void_type_node,
2967                                         tree_cons (NULL_TREE,
2968                                                    ptr_type_node,
2969                                                    void_list_node));
2970   void_ftype_ptr
2971     = build_exception_variant (void_ftype_ptr, empty_except_spec);
2972
2973   /* C++ extensions */
2974
2975   unknown_type_node = make_node (UNKNOWN_TYPE);
2976   record_unknown_type (unknown_type_node, "unknown type");
2977
2978   /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node.  */
2979   TREE_TYPE (unknown_type_node) = unknown_type_node;
2980
2981   /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
2982      result.  */
2983   TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
2984   TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
2985
2986   {
2987     /* Make sure we get a unique function type, so we can give
2988        its pointer type a name.  (This wins for gdb.) */
2989     tree vfunc_type = make_node (FUNCTION_TYPE);
2990     TREE_TYPE (vfunc_type) = integer_type_node;
2991     TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
2992     layout_type (vfunc_type);
2993
2994     vtable_entry_type = build_pointer_type (vfunc_type);
2995   }
2996   record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
2997
2998   vtbl_type_node
2999     = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3000   layout_type (vtbl_type_node);
3001   vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3002   record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3003   vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3004   layout_type (vtbl_ptr_type_node);
3005   record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3006
3007   push_namespace (get_identifier ("__cxxabiv1"));
3008   abi_node = current_namespace;
3009   pop_namespace ();
3010
3011   global_type_node = make_node (LANG_TYPE);
3012   record_unknown_type (global_type_node, "global type");
3013
3014   /* Now, C++.  */
3015   current_lang_name = lang_name_cplusplus;
3016
3017   {
3018     tree bad_alloc_id;
3019     tree bad_alloc_type_node;
3020     tree bad_alloc_decl;
3021     tree newtype, deltype;
3022     tree ptr_ftype_sizetype;
3023
3024     push_namespace (std_identifier);
3025     bad_alloc_id = get_identifier ("bad_alloc");
3026     bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3027     TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3028     bad_alloc_decl
3029       = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3030     DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3031     TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3032     pop_namespace ();
3033
3034     ptr_ftype_sizetype
3035       = build_function_type (ptr_type_node,
3036                              tree_cons (NULL_TREE,
3037                                         size_type_node,
3038                                         void_list_node));
3039     newtype = build_exception_variant
3040       (ptr_ftype_sizetype, add_exception_specifier
3041        (NULL_TREE, bad_alloc_type_node, -1));
3042     deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3043     push_cp_library_fn (NEW_EXPR, newtype);
3044     push_cp_library_fn (VEC_NEW_EXPR, newtype);
3045     global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3046     push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3047   }
3048
3049   abort_fndecl
3050     = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3051
3052   /* Perform other language dependent initializations.  */
3053   init_class_processing ();
3054   init_rtti_processing ();
3055
3056   if (flag_exceptions)
3057     init_exception_processing ();
3058
3059   if (! supports_one_only ())
3060     flag_weak = 0;
3061
3062   make_fname_decl = cp_make_fname_decl;
3063   start_fname_decls ();
3064
3065   /* Show we use EH for cleanups.  */
3066   if (flag_exceptions)
3067     using_eh_for_cleanups ();
3068 }
3069
3070 /* Generate an initializer for a function naming variable from
3071    NAME. NAME may be NULL, to indicate a dependent name.  TYPE_P is
3072    filled in with the type of the init.  */
3073
3074 tree
3075 cp_fname_init (const char* name, tree *type_p)
3076 {
3077   tree domain = NULL_TREE;
3078   tree type;
3079   tree init = NULL_TREE;
3080   size_t length = 0;
3081
3082   if (name)
3083     {
3084       length = strlen (name);
3085       domain = build_index_type (size_int (length));
3086       init = build_string (length + 1, name);
3087     }
3088
3089   type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3090   type = build_cplus_array_type (type, domain);
3091
3092   *type_p = type;
3093
3094   if (init)
3095     TREE_TYPE (init) = type;
3096   else
3097     init = error_mark_node;
3098
3099   return init;
3100 }
3101
3102 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3103    decl, NAME is the initialization string and TYPE_DEP indicates whether
3104    NAME depended on the type of the function. We make use of that to detect
3105    __PRETTY_FUNCTION__ inside a template fn. This is being done
3106    lazily at the point of first use, so we mustn't push the decl now.  */
3107
3108 static tree
3109 cp_make_fname_decl (tree id, int type_dep)
3110 {
3111   const char *const name = (type_dep && processing_template_decl
3112                             ? NULL : fname_as_string (type_dep));
3113   tree type;
3114   tree init = cp_fname_init (name, &type);
3115   tree decl = build_decl (VAR_DECL, id, type);
3116
3117   if (name)
3118     free ((char *) name);
3119
3120   /* As we're using pushdecl_with_scope, we must set the context.  */
3121   DECL_CONTEXT (decl) = current_function_decl;
3122   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3123
3124   TREE_STATIC (decl) = 1;
3125   TREE_READONLY (decl) = 1;
3126   DECL_ARTIFICIAL (decl) = 1;
3127   DECL_INITIAL (decl) = init;
3128
3129   TREE_USED (decl) = 1;
3130
3131   if (current_function_decl)
3132     {
3133       struct cp_binding_level *b = current_binding_level;
3134       while (b->level_chain->kind != sk_function_parms)
3135         b = b->level_chain;
3136       pushdecl_with_scope (decl, b);
3137       cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3138     }
3139   else
3140     pushdecl_top_level_and_finish (decl, init);
3141
3142   return decl;
3143 }
3144
3145 /* Make a definition for a builtin function named NAME in the current
3146    namespace, whose data type is TYPE and whose context is CONTEXT.
3147    TYPE should be a function type with argument types.
3148
3149    CLASS and CODE tell later passes how to compile calls to this function.
3150    See tree.h for possible values.
3151
3152    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3153    the name to be called if we can't opencode the function.
3154    If ATTRS is nonzero, use that for the function's attribute
3155    list.  */
3156
3157 static tree
3158 builtin_function_1 (const char* name,
3159                     tree type,
3160                     tree context,
3161                     int code,
3162                     enum built_in_class class,
3163                     const char* libname,
3164                     tree attrs)
3165 {
3166   tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3167   DECL_BUILT_IN_CLASS (decl) = class;
3168   DECL_FUNCTION_CODE (decl) = code;
3169   DECL_CONTEXT (decl) = context;
3170
3171   pushdecl (decl);
3172
3173   /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3174      we cannot change DECL_ASSEMBLER_NAME until we have installed this
3175      function in the namespace.  */
3176   if (libname)
3177     SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3178
3179   /* Warn if a function in the namespace for users
3180      is used without an occasion to consider it declared.  */
3181   if (name[0] != '_' || name[1] != '_')
3182     DECL_ANTICIPATED (decl) = 1;
3183
3184   /* Possibly apply some default attributes to this built-in function.  */
3185   if (attrs)
3186     decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3187   else
3188     decl_attributes (&decl, NULL_TREE, 0);
3189
3190   return decl;
3191 }
3192
3193 /* Entry point for the benefit of c_common_nodes_and_builtins.
3194
3195    Make a definition for a builtin function named NAME and whose data type
3196    is TYPE.  TYPE should be a function type with argument types.  This
3197    function places the anticipated declaration in the global namespace
3198    and additionally in the std namespace if appropriate.
3199
3200    CLASS and CODE tell later passes how to compile calls to this function.
3201    See tree.h for possible values.
3202
3203    If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3204    the name to be called if we can't opencode the function.
3205
3206    If ATTRS is nonzero, use that for the function's attribute
3207    list.  */
3208
3209 tree
3210 builtin_function (const char* name,
3211                   tree type,
3212                   int code,
3213                   enum built_in_class class,
3214                   const char* libname,
3215                   tree attrs)
3216 {
3217   /* All builtins that don't begin with an '_' should additionally
3218      go in the 'std' namespace.  */
3219   if (name[0] != '_')
3220     {
3221       push_namespace (std_identifier);
3222       builtin_function_1 (name, type, std_node, code, class, libname, attrs);
3223       pop_namespace ();
3224     }
3225
3226   return builtin_function_1 (name, type, NULL_TREE, code,
3227                              class, libname, attrs);
3228 }
3229
3230 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3231    function.  Not called directly.  */
3232
3233 static tree
3234 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3235 {
3236   tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3237   DECL_EXTERNAL (fn) = 1;
3238   TREE_PUBLIC (fn) = 1;
3239   DECL_ARTIFICIAL (fn) = 1;
3240   TREE_NOTHROW (fn) = 1;
3241   SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3242   SET_DECL_LANGUAGE (fn, lang_c);
3243   return fn;
3244 }
3245
3246 /* Returns the _DECL for a library function with C linkage.
3247    We assume that such functions never throw; if this is incorrect,
3248    callers should unset TREE_NOTHROW.  */
3249
3250 tree
3251 build_library_fn (tree name, tree type)
3252 {
3253   return build_library_fn_1 (name, ERROR_MARK, type);
3254 }
3255
3256 /* Returns the _DECL for a library function with C++ linkage.  */
3257
3258 static tree
3259 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3260 {
3261   tree fn = build_library_fn_1 (name, operator_code, type);
3262   TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3263   DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3264   SET_DECL_LANGUAGE (fn, lang_cplusplus);
3265   return fn;
3266 }
3267
3268 /* Like build_library_fn, but takes a C string instead of an
3269    IDENTIFIER_NODE.  */
3270
3271 tree
3272 build_library_fn_ptr (const char* name, tree type)
3273 {
3274   return build_library_fn (get_identifier (name), type);
3275 }
3276
3277 /* Like build_cp_library_fn, but takes a C string instead of an
3278    IDENTIFIER_NODE.  */
3279
3280 tree
3281 build_cp_library_fn_ptr (const char* name, tree type)
3282 {
3283   return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3284 }
3285
3286 /* Like build_library_fn, but also pushes the function so that we will
3287    be able to find it via IDENTIFIER_GLOBAL_VALUE.  */
3288
3289 tree
3290 push_library_fn (tree name, tree type)
3291 {
3292   tree fn = build_library_fn (name, type);
3293   pushdecl_top_level (fn);
3294   return fn;
3295 }
3296
3297 /* Like build_cp_library_fn, but also pushes the function so that it
3298    will be found by normal lookup.  */
3299
3300 static tree
3301 push_cp_library_fn (enum tree_code operator_code, tree type)
3302 {
3303   tree fn = build_cp_library_fn (ansi_opname (operator_code),
3304                                  operator_code,
3305                                  type);
3306   pushdecl (fn);
3307   return fn;
3308 }
3309
3310 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3311    a FUNCTION_TYPE.  */
3312
3313 tree
3314 push_void_library_fn (tree name, tree parmtypes)
3315 {
3316   tree type = build_function_type (void_type_node, parmtypes);
3317   return push_library_fn (name, type);
3318 }
3319
3320 /* Like push_library_fn, but also note that this function throws
3321    and does not return.  Used for __throw_foo and the like.  */
3322
3323 tree
3324 push_throw_library_fn (tree name, tree type)
3325 {
3326   tree fn = push_library_fn (name, type);
3327   TREE_THIS_VOLATILE (fn) = 1;
3328   TREE_NOTHROW (fn) = 0;
3329   return fn;
3330 }
3331 \f
3332 /* When we call finish_struct for an anonymous union, we create
3333    default copy constructors and such.  But, an anonymous union
3334    shouldn't have such things; this function undoes the damage to the
3335    anonymous union type T.
3336
3337    (The reason that we create the synthesized methods is that we don't
3338    distinguish `union { int i; }' from `typedef union { int i; } U'.
3339    The first is an anonymous union; the second is just an ordinary
3340    union type.)  */
3341
3342 void
3343 fixup_anonymous_aggr (tree t)
3344 {
3345   tree *q;
3346
3347   /* Wipe out memory of synthesized methods.  */
3348   TYPE_HAS_CONSTRUCTOR (t) = 0;
3349   TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3350   TYPE_HAS_INIT_REF (t) = 0;
3351   TYPE_HAS_CONST_INIT_REF (t) = 0;
3352   TYPE_HAS_ASSIGN_REF (t) = 0;
3353   TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3354
3355   /* Splice the implicitly generated functions out of the TYPE_METHODS
3356      list.  */
3357   q = &TYPE_METHODS (t);
3358   while (*q)
3359     {
3360       if (DECL_ARTIFICIAL (*q))
3361         *q = TREE_CHAIN (*q);
3362       else
3363         q = &TREE_CHAIN (*q);
3364     }
3365
3366   /* ISO C++ 9.5.3.  Anonymous unions may not have function members.  */
3367   if (TYPE_METHODS (t))
3368     error ("%Jan anonymous union cannot have function members",
3369            TYPE_MAIN_DECL (t));
3370
3371   /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3372      assignment operators (because they cannot have these methods themselves).
3373      For anonymous unions this is already checked because they are not allowed
3374      in any union, otherwise we have to check it.  */
3375   if (TREE_CODE (t) != UNION_TYPE)
3376     {
3377       tree field, type;
3378
3379       for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3380         if (TREE_CODE (field) == FIELD_DECL)
3381           {
3382             type = TREE_TYPE (field);
3383             if (CLASS_TYPE_P (type))
3384               {
3385                 if (TYPE_NEEDS_CONSTRUCTING (type))
3386                   cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3387                                field);
3388                 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3389                   cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3390                                field);
3391                 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3392                   cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3393                                field);
3394               }
3395           }
3396     }
3397 }
3398
3399 /* Make sure that a declaration with no declarator is well-formed, i.e.
3400    just declares a tagged type or anonymous union.
3401
3402    Returns the type declared; or NULL_TREE if none.  */
3403
3404 tree
3405 check_tag_decl (cp_decl_specifier_seq *declspecs)
3406 {
3407   int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3408   int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3409   /* If a class, struct, or enum type is declared by the DECLSPECS
3410      (i.e, if a class-specifier, enum-specifier, or non-typename
3411      elaborated-type-specifier appears in the DECLSPECS),
3412      DECLARED_TYPE is set to the corresponding type.  */
3413   tree declared_type = NULL_TREE;
3414   bool error_p = false;
3415
3416   if (declspecs->multiple_types_p)
3417     error ("multiple types in one declaration");
3418   else if (declspecs->redefined_builtin_type)
3419     {
3420       if (!in_system_header)
3421         pedwarn ("redeclaration of C++ built-in type %qT",
3422                  declspecs->redefined_builtin_type);
3423       return NULL_TREE;
3424     }
3425
3426   if (TYPE_P (declspecs->type)
3427       && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3428            && IS_AGGR_TYPE (declspecs->type))
3429           || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3430     declared_type = declspecs->type;
3431   else if (declspecs->type == error_mark_node)
3432     error_p = true;
3433   if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3434     pedwarn ("declaration does not declare anything");
3435   /* Check for an anonymous union.  */
3436   else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3437            && TYPE_ANONYMOUS_P (declared_type))
3438     {
3439       /* 7/3 In a simple-declaration, the optional init-declarator-list
3440          can be omitted only when declaring a class (clause 9) or
3441          enumeration (7.2), that is, when the decl-specifier-seq contains
3442          either a class-specifier, an elaborated-type-specifier with
3443          a class-key (9.1), or an enum-specifier.  In these cases and
3444          whenever a class-specifier or enum-specifier is present in the
3445          decl-specifier-seq, the identifiers in these specifiers are among
3446          the names being declared by the declaration (as class-name,
3447          enum-names, or enumerators, depending on the syntax).  In such
3448          cases, and except for the declaration of an unnamed bit-field (9.6),
3449          the decl-specifier-seq shall introduce one or more names into the
3450          program, or shall redeclare a name introduced by a previous
3451          declaration.  [Example:
3452              enum { };            // ill-formed
3453              typedef class { };   // ill-formed
3454          --end example]  */
3455       if (saw_typedef)
3456         {
3457           error ("missing type-name in typedef-declaration");
3458           return NULL_TREE;
3459         }
3460       /* Anonymous unions are objects, so they can have specifiers.  */;
3461       SET_ANON_AGGR_TYPE_P (declared_type);
3462
3463       if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3464           && !in_system_header)
3465         pedwarn ("ISO C++ prohibits anonymous structs");
3466     }
3467
3468   else
3469     {
3470       if (declspecs->specs[(int)ds_inline]
3471           || declspecs->specs[(int)ds_virtual])
3472         error ("`%s' can only be specified for functions",
3473                declspecs->specs[(int)ds_inline]
3474                ? "inline" : "virtual");
3475       else if (saw_friend
3476                && (!current_class_type
3477                    || current_scope () != current_class_type))
3478         error ("`friend' can only be specified inside a class");
3479       else if (declspecs->specs[(int)ds_explicit])
3480         error ("`explicit' can only be specified for constructors");
3481       else if (declspecs->storage_class)
3482         error ("a storage class can only be specified for objects "
3483                "and functions");
3484       else if (declspecs->specs[(int)ds_const]
3485                || declspecs->specs[(int)ds_volatile]
3486                || declspecs->specs[(int)ds_restrict]
3487                || declspecs->specs[(int)ds_thread])
3488         error ("qualifiers can only be specified for objects "
3489                "and functions");
3490     }
3491
3492   return declared_type;
3493 }
3494
3495 /* Called when a declaration is seen that contains no names to declare.
3496    If its type is a reference to a structure, union or enum inherited
3497    from a containing scope, shadow that tag name for the current scope
3498    with a forward reference.
3499    If its type defines a new named structure or union
3500    or defines an enum, it is valid but we need not do anything here.
3501    Otherwise, it is an error.
3502
3503    C++: may have to grok the declspecs to learn about static,
3504    complain for anonymous unions.
3505
3506    Returns the TYPE declared -- or NULL_TREE if none.  */
3507
3508 tree
3509 shadow_tag (cp_decl_specifier_seq *declspecs)
3510 {
3511   tree t = check_tag_decl (declspecs);
3512
3513   if (!t)
3514     return NULL_TREE;
3515
3516   maybe_process_partial_specialization (t);
3517
3518   /* This is where the variables in an anonymous union are
3519      declared.  An anonymous union declaration looks like:
3520      union { ... } ;
3521      because there is no declarator after the union, the parser
3522      sends that declaration here.  */
3523   if (ANON_AGGR_TYPE_P (t))
3524     {
3525       fixup_anonymous_aggr (t);
3526
3527       if (TYPE_FIELDS (t))
3528         {
3529           tree decl = grokdeclarator (/*declarator=*/NULL,
3530                                       declspecs, NORMAL, 0, NULL);
3531           finish_anon_union (decl);
3532         }
3533     }
3534
3535   return t;
3536 }
3537 \f
3538 /* Decode a "typename", such as "int **", returning a ..._TYPE node.  */
3539
3540 tree
3541 groktypename (cp_decl_specifier_seq *type_specifiers,
3542               const cp_declarator *declarator)
3543 {
3544   tree attrs;
3545   tree type;
3546   attrs = type_specifiers->attributes;
3547   type_specifiers->attributes = NULL_TREE;
3548   type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3549   if (attrs)
3550     cplus_decl_attributes (&type, attrs, 0);
3551   return type;
3552 }
3553
3554 /* Decode a declarator in an ordinary declaration or data definition.
3555    This is called as soon as the type information and variable name
3556    have been parsed, before parsing the initializer if any.
3557    Here we create the ..._DECL node, fill in its type,
3558    and put it on the list of decls for the current context.
3559    The ..._DECL node is returned as the value.
3560
3561    Exception: for arrays where the length is not specified,
3562    the type is left null, to be filled in by `cp_finish_decl'.
3563
3564    Function definitions do not come here; they go to start_function
3565    instead.  However, external and forward declarations of functions
3566    do go through here.  Structure field declarations are done by
3567    grokfield and not through here.  */
3568
3569 tree
3570 start_decl (const cp_declarator *declarator,
3571             cp_decl_specifier_seq *declspecs,
3572             int initialized,
3573             tree attributes,
3574             tree prefix_attributes)
3575 {
3576   tree decl;
3577   tree type, tem;
3578   tree context;
3579
3580   /* This should only be done once on the top most decl.  */
3581   if (have_extern_spec)
3582     {
3583       declspecs->storage_class = sc_extern;
3584       have_extern_spec = false;
3585     }
3586
3587   /* An object declared as __attribute__((deprecated)) suppresses
3588      warnings of uses of other deprecated items.  */
3589   if (lookup_attribute ("deprecated", attributes))
3590     deprecated_state = DEPRECATED_SUPPRESS;
3591
3592   attributes = chainon (attributes, prefix_attributes);
3593
3594   decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3595                          &attributes);
3596
3597   deprecated_state = DEPRECATED_NORMAL;
3598
3599   if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3600     return NULL_TREE;
3601
3602   type = TREE_TYPE (decl);
3603
3604   if (type == error_mark_node)
3605     return NULL_TREE;
3606
3607   context = DECL_CONTEXT (decl);
3608
3609   if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
3610       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
3611     {
3612       /* When parsing the initializer, lookup should use the object's
3613          namespace.  */
3614       push_decl_namespace (context);
3615     }
3616
3617   /* We are only interested in class contexts, later.  */
3618   if (context && TREE_CODE (context) == NAMESPACE_DECL)
3619     context = NULL_TREE;
3620
3621   if (initialized)
3622     /* Is it valid for this decl to have an initializer at all?
3623        If not, set INITIALIZED to zero, which will indirectly
3624        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3625     switch (TREE_CODE (decl))
3626       {
3627       case TYPE_DECL:
3628         error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
3629         initialized = 0;
3630         break;
3631
3632       case FUNCTION_DECL:
3633         error ("function `%#D' is initialized like a variable", decl);
3634         initialized = 0;
3635         break;
3636
3637       default:
3638         break;
3639       }
3640
3641   if (initialized)
3642     {
3643       if (! toplevel_bindings_p ()
3644           && DECL_EXTERNAL (decl))
3645         warning ("declaration of `%#D' has `extern' and is initialized",
3646                     decl);
3647       DECL_EXTERNAL (decl) = 0;
3648       if (toplevel_bindings_p ())
3649         TREE_STATIC (decl) = 1;
3650
3651       /* Tell `pushdecl' this is an initialized decl
3652          even though we don't yet have the initializer expression.
3653          Also tell `cp_finish_decl' it may store the real initializer.  */
3654       DECL_INITIAL (decl) = error_mark_node;
3655     }
3656
3657   /* Set attributes here so if duplicate decl, will have proper attributes.  */
3658   cplus_decl_attributes (&decl, attributes, 0);
3659
3660   /* If #pragma weak was used, mark the decl weak now.  */
3661   if (global_scope_p (current_binding_level))
3662     maybe_apply_pragma_weak (decl);
3663
3664   if (TREE_CODE (decl) == FUNCTION_DECL
3665       && DECL_DECLARED_INLINE_P (decl)
3666       && DECL_UNINLINABLE (decl)
3667       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3668     warning ("%Jinline function '%D' given attribute noinline", decl, decl);
3669
3670   if (context && COMPLETE_TYPE_P (complete_type (context)))
3671     {
3672       push_nested_class (context);
3673
3674       if (TREE_CODE (decl) == VAR_DECL)
3675         {
3676           tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3677           if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3678             error ("`%#D' is not a static member of `%#T'", decl, context);
3679           else
3680             {
3681               if (DECL_CONTEXT (field) != context)
3682                 {
3683                   if (!same_type_p (DECL_CONTEXT (field), context))
3684                     pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3685                              DECL_CONTEXT (field), DECL_NAME (decl),
3686                              context, DECL_NAME (decl));
3687                   DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3688                 }
3689               /* Static data member are tricky; an in-class initialization
3690                  still doesn't provide a definition, so the in-class
3691                  declaration will have DECL_EXTERNAL set, but will have an
3692                  initialization.  Thus, duplicate_decls won't warn
3693                  about this situation, and so we check here.  */
3694               if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3695                 error ("duplicate initialization of %D", decl);
3696               if (duplicate_decls (decl, field))
3697                 decl = field;
3698             }
3699         }
3700       else
3701         {
3702           tree field = check_classfn (context, decl,
3703                                       (processing_template_decl
3704                                        > template_class_depth (context))
3705                                       ? current_template_parms
3706                                       : NULL_TREE);
3707           if (field && duplicate_decls (decl, field))
3708             decl = field;
3709         }
3710
3711       /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set.  */
3712       DECL_IN_AGGR_P (decl) = 0;
3713       if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3714           || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3715         {
3716           SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3717           /* [temp.expl.spec] An explicit specialization of a static data
3718              member of a template is a definition if the declaration
3719              includes an initializer; otherwise, it is a declaration.
3720
3721              We check for processing_specialization so this only applies
3722              to the new specialization syntax.  */
3723           if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3724             DECL_EXTERNAL (decl) = 1;
3725         }
3726
3727       if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3728         pedwarn ("declaration of `%#D' outside of class is not definition",
3729                     decl);
3730     }
3731
3732   /* Enter this declaration into the symbol table.  */
3733   tem = maybe_push_decl (decl);
3734
3735   if (processing_template_decl)
3736     tem = push_template_decl (tem);
3737   if (tem == error_mark_node)
3738     return error_mark_node;
3739
3740 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3741   /* Tell the back-end to use or not use .common as appropriate.  If we say
3742      -fconserve-space, we want this to save .data space, at the expense of
3743      wrong semantics.  If we say -fno-conserve-space, we want this to
3744      produce errors about redefs; to do this we force variables into the
3745      data segment.  */
3746   DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3747                         || !DECL_THREAD_LOCAL (tem))
3748                        && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3749 #endif
3750
3751   if (! processing_template_decl)
3752     start_decl_1 (tem);
3753
3754   return tem;
3755 }
3756
3757 void
3758 start_decl_1 (tree decl)
3759 {
3760   tree type = TREE_TYPE (decl);
3761   int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3762
3763   if (type == error_mark_node)
3764     return;
3765
3766   if (initialized)
3767     /* Is it valid for this decl to have an initializer at all?
3768        If not, set INITIALIZED to zero, which will indirectly
3769        tell `cp_finish_decl' to ignore the initializer once it is parsed.  */
3770     {
3771       /* Don't allow initializations for incomplete types except for
3772          arrays which might be completed by the initialization.  */
3773       if (COMPLETE_TYPE_P (complete_type (type)))
3774         ;                       /* A complete type is ok.  */
3775       else if (TREE_CODE (type) != ARRAY_TYPE)
3776         {
3777           error ("variable `%#D' has initializer but incomplete type",
3778                     decl);
3779           initialized = 0;
3780           type = TREE_TYPE (decl) = error_mark_node;
3781         }
3782       else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3783         {
3784           if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3785             error ("elements of array `%#D' have incomplete type", decl);
3786           /* else we already gave an error in start_decl.  */
3787           initialized = 0;
3788         }
3789     }
3790
3791   if (!initialized
3792       && TREE_CODE (decl) != TYPE_DECL
3793       && TREE_CODE (decl) != TEMPLATE_DECL
3794       && type != error_mark_node
3795       && IS_AGGR_TYPE (type)
3796       && ! DECL_EXTERNAL (decl))
3797     {
3798       if ((! processing_template_decl || ! uses_template_parms (type))
3799           && !COMPLETE_TYPE_P (complete_type (type)))
3800         {
3801           error ("aggregate `%#D' has incomplete type and cannot be defined",
3802                  decl);
3803           /* Change the type so that assemble_variable will give
3804              DECL an rtl we can live with: (mem (const_int 0)).  */
3805           type = TREE_TYPE (decl) = error_mark_node;
3806         }
3807       else
3808         {
3809           /* If any base type in the hierarchy of TYPE needs a constructor,
3810              then we set initialized to 1.  This way any nodes which are
3811              created for the purposes of initializing this aggregate
3812              will live as long as it does.  This is necessary for global
3813              aggregates which do not have their initializers processed until
3814              the end of the file.  */
3815           initialized = TYPE_NEEDS_CONSTRUCTING (type);
3816         }
3817     }
3818
3819   if (! initialized)
3820     DECL_INITIAL (decl) = NULL_TREE;
3821
3822   /* Create a new scope to hold this declaration if necessary.
3823      Whether or not a new scope is necessary cannot be determined
3824      until after the type has been completed; if the type is a
3825      specialization of a class template it is not until after
3826      instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3827      will be set correctly.  */
3828   maybe_push_cleanup_level (type);
3829 }
3830
3831 /* Handle initialization of references.  DECL, TYPE, and INIT have the
3832    same meaning as in cp_finish_decl.  *CLEANUP must be NULL on entry,
3833    but will be set to a new CLEANUP_STMT if a temporary is created
3834    that must be destroyed subsequently.
3835
3836    Returns an initializer expression to use to initialize DECL, or
3837    NULL if the initialization can be performed statically.
3838
3839    Quotes on semantics can be found in ARM 8.4.3.  */
3840
3841 static tree
3842 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3843 {
3844   tree tmp;
3845
3846   if (init == NULL_TREE)
3847     {
3848       if ((DECL_LANG_SPECIFIC (decl) == 0
3849            || DECL_IN_AGGR_P (decl) == 0)
3850           && ! DECL_THIS_EXTERN (decl))
3851         error ("`%D' declared as reference but not initialized", decl);
3852       return NULL_TREE;
3853     }
3854
3855   if (TREE_CODE (init) == CONSTRUCTOR)
3856     {
3857       error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
3858       return NULL_TREE;
3859     }
3860
3861   if (TREE_CODE (init) == TREE_LIST)
3862     init = build_x_compound_expr_from_list (init, "initializer");
3863
3864   if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
3865     init = convert_from_reference (init);
3866
3867   if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3868       && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3869     /* Note: default conversion is only called in very special cases.  */
3870     init = decay_conversion (init);
3871
3872   /* Convert INIT to the reference type TYPE.  This may involve the
3873      creation of a temporary, whose lifetime must be the same as that
3874      of the reference.  If so, a DECL_EXPR for the temporary will be
3875      added just after the DECL_EXPR for DECL.  That's why we don't set
3876      DECL_INITIAL for local references (instead assigning to them
3877      explicitly); we need to allow the temporary to be initialized
3878      first.  */
3879   tmp = initialize_reference (type, init, decl, cleanup);
3880
3881   if (tmp == error_mark_node)
3882     return NULL_TREE;
3883   else if (tmp == NULL_TREE)
3884     {
3885       error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
3886       return NULL_TREE;
3887     }
3888
3889   if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3890     return tmp;
3891
3892   DECL_INITIAL (decl) = tmp;
3893
3894   return NULL_TREE;
3895 }
3896
3897 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3898    array until we finish parsing the initializer.  If that's the
3899    situation we're in, update DECL accordingly.  */
3900
3901 static void
3902 maybe_deduce_size_from_array_init (tree decl, tree init)
3903 {
3904   tree type = TREE_TYPE (decl);
3905
3906   if (TREE_CODE (type) == ARRAY_TYPE
3907       && TYPE_DOMAIN (type) == NULL_TREE
3908       && TREE_CODE (decl) != TYPE_DECL)
3909     {
3910       /* do_default is really a C-ism to deal with tentative definitions.
3911          But let's leave it here to ease the eventual merge.  */
3912       int do_default = !DECL_EXTERNAL (decl);
3913       tree initializer = init ? init : DECL_INITIAL (decl);
3914       int failure = complete_array_type (type, initializer, do_default);
3915
3916       if (failure == 1)
3917         error ("initializer fails to determine size of `%D'", decl);
3918
3919       if (failure == 2)
3920         {
3921           if (do_default)
3922             error ("array size missing in `%D'", decl);
3923           /* If a `static' var's size isn't known, make it extern as
3924              well as static, so it does not get allocated.  If it's not
3925              `static', then don't mark it extern; finish_incomplete_decl
3926              will give it a default size and it will get allocated.  */
3927           else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3928             DECL_EXTERNAL (decl) = 1;
3929         }
3930
3931       if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
3932           && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3933                               integer_zero_node))
3934         error ("zero-size array `%D'", decl);
3935
3936       layout_decl (decl, 0);
3937     }
3938 }
3939
3940 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3941    any appropriate error messages regarding the layout.  */
3942
3943 static void
3944 layout_var_decl (tree decl)
3945 {
3946   tree type = TREE_TYPE (decl);
3947 #if 0
3948   tree ttype = target_type (type);
3949 #endif
3950
3951   /* If we haven't already layed out this declaration, do so now.
3952      Note that we must not call complete type for an external object
3953      because it's type might involve templates that we are not
3954      supposed to instantiate yet.  (And it's perfectly valid to say
3955      `extern X x' for some incomplete type `X'.)  */
3956   if (!DECL_EXTERNAL (decl))
3957     complete_type (type);
3958   if (!DECL_SIZE (decl)
3959       && TREE_TYPE (decl) != error_mark_node
3960       && (COMPLETE_TYPE_P (type)
3961           || (TREE_CODE (type) == ARRAY_TYPE
3962               && !TYPE_DOMAIN (type)
3963               && COMPLETE_TYPE_P (TREE_TYPE (type)))))
3964     layout_decl (decl, 0);
3965
3966   if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
3967     {
3968       /* An automatic variable with an incomplete type: that is an error.
3969          Don't talk about array types here, since we took care of that
3970          message in grokdeclarator.  */
3971       error ("storage size of `%D' isn't known", decl);
3972       TREE_TYPE (decl) = error_mark_node;
3973     }
3974 #if 0
3975   /* Keep this code around in case we later want to control debug info
3976      based on whether a type is "used".  (jason 1999-11-11) */
3977
3978   else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
3979     /* Let debugger know it should output info for this type.  */
3980     note_debug_info_needed (ttype);
3981
3982   if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
3983     note_debug_info_needed (DECL_CONTEXT (decl));
3984 #endif
3985
3986   if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3987       && DECL_SIZE (decl) != NULL_TREE
3988       && ! TREE_CONSTANT (DECL_SIZE (decl)))
3989     {
3990       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3991         constant_expression_warning (DECL_SIZE (decl));
3992       else
3993         error ("storage size of `%D' isn't constant", decl);
3994     }
3995
3996   if (TREE_STATIC (decl)
3997       && !DECL_ARTIFICIAL (decl)
3998       && current_function_decl
3999       && DECL_CONTEXT (decl) == current_function_decl)
4000     push_local_name (decl);
4001 }
4002
4003 /* If a local static variable is declared in an inline function, or if
4004    we have a weak definition, we must endeavor to create only one
4005    instance of the variable at link-time.  */
4006
4007 static void
4008 maybe_commonize_var (tree decl)
4009 {
4010   /* Static data in a function with comdat linkage also has comdat
4011      linkage.  */
4012   if (TREE_STATIC (decl)
4013       /* Don't mess with __FUNCTION__.  */
4014       && ! DECL_ARTIFICIAL (decl)
4015       && DECL_FUNCTION_SCOPE_P (decl)
4016       /* Unfortunately, import_export_decl has not always been called
4017          before the function is processed, so we cannot simply check
4018          DECL_COMDAT.  */
4019       && (DECL_COMDAT (DECL_CONTEXT (decl))
4020           || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4021                || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4022               && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4023     {
4024       if (flag_weak)
4025         {
4026           /* With weak symbols, we simply make the variable COMDAT;
4027              that will cause copies in multiple translations units to
4028              be merged.  */
4029           comdat_linkage (decl);
4030         }
4031       else
4032         {
4033           if (DECL_INITIAL (decl) == NULL_TREE
4034               || DECL_INITIAL (decl) == error_mark_node)
4035             {
4036               /* Without weak symbols, we can use COMMON to merge
4037                  uninitialized variables.  */
4038               TREE_PUBLIC (decl) = 1;
4039               DECL_COMMON (decl) = 1;
4040             }
4041           else
4042             {
4043               /* While for initialized variables, we must use internal
4044                  linkage -- which means that multiple copies will not
4045                  be merged.  */
4046               TREE_PUBLIC (decl) = 0;
4047               DECL_COMMON (decl) = 0;
4048               cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
4049               warning ("%J  you can work around this by removing the initializer",
4050                        decl);
4051             }
4052         }
4053     }
4054   else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4055     /* Set it up again; we might have set DECL_INITIAL since the last
4056        time.  */
4057     comdat_linkage (decl);
4058 }
4059
4060 /* Issue an error message if DECL is an uninitialized const variable.  */
4061
4062 static void
4063 check_for_uninitialized_const_var (tree decl)
4064 {
4065   tree type = TREE_TYPE (decl);
4066
4067   /* ``Unless explicitly declared extern, a const object does not have
4068      external linkage and must be initialized. ($8.4; $12.1)'' ARM
4069      7.1.6 */
4070   if (TREE_CODE (decl) == VAR_DECL
4071       && TREE_CODE (type) != REFERENCE_TYPE
4072       && CP_TYPE_CONST_P (type)
4073       && !TYPE_NEEDS_CONSTRUCTING (type)
4074       && !DECL_INITIAL (decl))
4075     error ("uninitialized const `%D'", decl);
4076 }
4077
4078 /* FIELD is a FIELD_DECL or NULL.  In the former case, the value
4079    returned is the next FIELD_DECL (possibly FIELD itself) that can be
4080    initialized.  If there are no more such fields, the return value
4081    will be NULL.  */
4082
4083 static tree
4084 next_initializable_field (tree field)
4085 {
4086   while (field
4087          && (TREE_CODE (field) != FIELD_DECL
4088              || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4089              || DECL_ARTIFICIAL (field)))
4090     field = TREE_CHAIN (field);
4091
4092   return field;
4093 }
4094
4095 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4096    brace-enclosed aggregate initializer.
4097
4098    *INITP is one of a list of initializers describing a brace-enclosed
4099    initializer for an entity of the indicated aggregate TYPE.  It may
4100    not presently match the shape of the TYPE; for example:
4101
4102      struct S { int a; int b; };
4103      struct S a[] = { 1, 2, 3, 4 };
4104
4105    Here *INITP will point to TREE_LIST of four elements, rather than a
4106    list of two elements, each itself a list of two elements.  This
4107    routine transforms INIT from the former form into the latter.  The
4108    revised initializer is returned.  */
4109
4110 static tree
4111 reshape_init (tree type, tree *initp)
4112 {
4113   tree inits;
4114   tree old_init;
4115   tree old_init_value;
4116   tree new_init;
4117   bool brace_enclosed_p;
4118
4119   old_init = *initp;
4120   old_init_value = (TREE_CODE (*initp) == TREE_LIST
4121                     ? TREE_VALUE (*initp) : old_init);
4122
4123   my_friendly_assert (old_init_value, 20030723);
4124
4125   /* If the initializer is brace-enclosed, pull initializers from the
4126      enclosed elements.  Advance past the brace-enclosed initializer
4127      now.  */
4128   if (TREE_CODE (old_init_value) == CONSTRUCTOR
4129       && BRACE_ENCLOSED_INITIALIZER_P (old_init_value))
4130     {
4131       *initp = TREE_CHAIN (old_init);
4132       TREE_CHAIN (old_init) = NULL_TREE;
4133       inits = CONSTRUCTOR_ELTS (old_init_value);
4134       initp = &inits;
4135       brace_enclosed_p = true;
4136     }
4137   else
4138     {
4139       inits = NULL_TREE;
4140       brace_enclosed_p = false;
4141     }
4142
4143   /* A non-aggregate type is always initialized with a single
4144      initializer.  */
4145   if (!CP_AGGREGATE_TYPE_P (type))
4146       {
4147         *initp = TREE_CHAIN (old_init);
4148         TREE_CHAIN (old_init) = NULL_TREE;
4149         /* It is invalid to initialize a non-aggregate type with a
4150            brace-enclosed initializer.  */
4151         if (brace_enclosed_p)
4152           {
4153             error ("brace-enclosed initializer used to initialize `%T'",
4154                    type);
4155             if (TREE_CODE (old_init) == TREE_LIST)
4156               TREE_VALUE (old_init) = error_mark_node;
4157             else
4158               old_init = error_mark_node;
4159           }
4160
4161         return old_init;
4162       }
4163
4164   /* [dcl.init.aggr]
4165
4166      All implicit type conversions (clause _conv_) are considered when
4167      initializing the aggregate member with an initializer from an
4168      initializer-list.  If the initializer can initialize a member,
4169      the member is initialized.  Otherwise, if the member is itself a
4170      non-empty subaggregate, brace elision is assumed and the
4171      initializer is considered for the initialization of the first
4172      member of the subaggregate.  */
4173   if (!brace_enclosed_p
4174       && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4175     {
4176       *initp = TREE_CHAIN (old_init);
4177       TREE_CHAIN (old_init) = NULL_TREE;
4178       return old_init;
4179     }
4180
4181   if (TREE_CODE (old_init_value) == STRING_CST
4182       && TREE_CODE (type) == ARRAY_TYPE
4183       && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4184     {
4185       /* [dcl.init.string]
4186
4187          A char array (whether plain char, signed char, or unsigned char)
4188          can be initialized by a string-literal (optionally enclosed in
4189          braces); a wchar_t array can be initialized by a wide
4190          string-literal (optionally enclosed in braces).  */
4191       new_init = old_init;
4192       /* Move past the initializer.  */
4193       *initp = TREE_CHAIN (old_init);
4194       TREE_CHAIN (old_init) = NULL_TREE;
4195     }
4196   else
4197     {
4198       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */
4199       new_init = build_constructor (NULL_TREE, NULL_TREE);
4200
4201       if (CLASS_TYPE_P (type))
4202         {
4203           tree field;
4204
4205           field = next_initializable_field (TYPE_FIELDS (type));
4206
4207           if (!field)
4208             {
4209               /* [dcl.init.aggr]
4210
4211                  An initializer for an aggregate member that is an
4212                  empty class shall have the form of an empty
4213                  initializer-list {}.  */
4214               if (!brace_enclosed_p)
4215                 {
4216                   error ("initializer for `%T' must be brace-enclosed",
4217                          type);
4218                   return error_mark_node;
4219                 }
4220             }
4221           else
4222             {
4223               /* Loop through the initializable fields, gathering
4224                  initializers.  */
4225               while (*initp)
4226                 {
4227                   tree field_init;
4228
4229                   /* Handle designated initializers, as an extension.  */
4230                   if (TREE_PURPOSE (*initp))
4231                     {
4232                       if (pedantic)
4233                         pedwarn ("ISO C++ does not allow designated initializers");
4234                       field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4235                                               /*want_type=*/false);
4236                       if (!field || TREE_CODE (field) != FIELD_DECL)
4237                         error ("`%T' has no non-static data member named `%D'",
4238                                type, TREE_PURPOSE (*initp));
4239                     }
4240                   if (!field)
4241                     break;
4242
4243                   field_init = reshape_init (TREE_TYPE (field), initp);
4244                   if (field_init == error_mark_node)
4245                     return error_mark_node;
4246                   TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4247                   CONSTRUCTOR_ELTS (new_init) = field_init;
4248                   /* [dcl.init.aggr]
4249
4250                      When a union  is  initialized with a brace-enclosed
4251                      initializer, the braces shall only contain an
4252                      initializer for the first member of the union.  */
4253                   if (TREE_CODE (type) == UNION_TYPE)
4254                     break;
4255                   field = next_initializable_field (TREE_CHAIN (field));
4256                 }
4257             }
4258         }
4259       else if (TREE_CODE (type) == ARRAY_TYPE
4260                || TREE_CODE (type) == VECTOR_TYPE)
4261         {
4262           tree index;
4263           tree max_index;
4264
4265           /* If the bound of the array is known, take no more initializers
4266              than are allowed.  */
4267           max_index = NULL_TREE;
4268           if (TREE_CODE (type) == ARRAY_TYPE)
4269             {
4270               if (TYPE_DOMAIN (type))
4271                 max_index = array_type_nelts (type);
4272             }
4273           else
4274             {
4275               /* For a vector, the representation type is a struct
4276                  containing a single member which is an array of the
4277                  appropriate size.  */
4278               tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4279               if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4280                 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4281             }
4282
4283           /* Loop through the array elements, gathering initializers.  */
4284           for (index = size_zero_node;
4285                *initp && (!max_index || !tree_int_cst_lt (max_index, index));
4286                index = size_binop (PLUS_EXPR, index, size_one_node))
4287             {
4288               tree element_init;
4289
4290               element_init = reshape_init (TREE_TYPE (type), initp);
4291               if (element_init == error_mark_node)
4292                 return error_mark_node;
4293               TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4294               CONSTRUCTOR_ELTS (new_init) = element_init;
4295               if (TREE_PURPOSE (element_init))
4296                 {
4297                   tree next_index = TREE_PURPOSE (element_init);
4298                   if (TREE_CODE (next_index) == IDENTIFIER_NODE)
4299                     {
4300                       error ("name `%D' used in a GNU-style designated "
4301                              "initializer for an array", next_index);
4302                       TREE_PURPOSE (element_init) = NULL_TREE;
4303                     }
4304                   else
4305                     index = next_index;
4306                 }
4307             }
4308         }
4309       else
4310         abort ();
4311
4312       /* The initializers were placed in reverse order in the
4313          CONSTRUCTOR.  */
4314       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4315
4316       if (TREE_CODE (old_init) == TREE_LIST)
4317         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4318     }
4319
4320   /* If this was a brace-enclosed initializer and all of the
4321      initializers were not used up, there is a problem.  */
4322   if (brace_enclosed_p && *initp)
4323     error ("too many initializers for `%T'", type);
4324
4325   return new_init;
4326 }
4327
4328 /* Verify INIT (the initializer for DECL), and record the
4329    initialization in DECL_INITIAL, if appropriate.  CLEANUP is as for
4330    grok_reference_init.
4331
4332    If the return value is non-NULL, it is an expression that must be
4333    evaluated dynamically to initialize DECL.  */
4334
4335 static tree
4336 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4337 {
4338   tree type = TREE_TYPE (decl);
4339   tree init_code = NULL;
4340
4341   /* If `start_decl' didn't like having an initialization, ignore it now.  */
4342   if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4343     init = NULL_TREE;
4344
4345   /* If an initializer is present, DECL_INITIAL has been
4346      error_mark_node, to indicate that an as-of-yet unevaluated
4347      initialization will occur.  From now on, DECL_INITIAL reflects
4348      the static initialization -- if any -- of DECL.  */
4349   DECL_INITIAL (decl) = NULL_TREE;
4350
4351   /* Things that are going to be initialized need to have complete
4352      type.  */
4353   TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4354
4355   if (type == error_mark_node)
4356     /* We will have already complained.  */
4357     init = NULL_TREE;
4358   else if (init && COMPLETE_TYPE_P (type)
4359            && !TREE_CONSTANT (TYPE_SIZE (type)))
4360     {
4361       error ("variable-sized object `%D' may not be initialized", decl);
4362       init = NULL_TREE;
4363     }
4364   else if (TREE_CODE (type) == ARRAY_TYPE
4365            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4366     {
4367       error ("elements of array `%#D' have incomplete type", decl);
4368       init = NULL_TREE;
4369     }
4370   else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4371     {
4372       error ("`%D' has incomplete type", decl);
4373       TREE_TYPE (decl) = error_mark_node;
4374       init = NULL_TREE;
4375     }
4376
4377   if (TREE_CODE (decl) == CONST_DECL)
4378     {
4379       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
4380
4381       DECL_INITIAL (decl) = init;
4382
4383       my_friendly_assert (init != NULL_TREE, 149);
4384       init = NULL_TREE;
4385     }
4386   else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4387     init = grok_reference_init (decl, type, init, cleanup);
4388   else if (init)
4389     {
4390       if (TREE_CODE (init) == CONSTRUCTOR
4391           && BRACE_ENCLOSED_INITIALIZER_P (init))
4392         {
4393           /* [dcl.init] paragraph 13,
4394              If T is a scalar type, then a declaration of the form
4395              T x = { a };
4396              is equivalent to
4397              T x = a;
4398
4399              reshape_init will complain about the extra braces,
4400              and doesn't do anything useful in the case where TYPE is
4401              scalar, so just don't call it.  */
4402           if (CP_AGGREGATE_TYPE_P (type))
4403             init = reshape_init (type, &init);
4404
4405           if ((*targetm.vector_opaque_p) (type))
4406             {
4407               error ("opaque vector types cannot be initialized");
4408               init = error_mark_node;
4409             }
4410         }
4411
4412       /* If DECL has an array type without a specific bound, deduce the
4413          array size from the initializer.  */
4414       maybe_deduce_size_from_array_init (decl, init);
4415       type = TREE_TYPE (decl);
4416
4417       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4418         {
4419           if (TREE_CODE (type) == ARRAY_TYPE)
4420             goto initialize_aggr;
4421           else if (TREE_CODE (init) == CONSTRUCTOR
4422                    && BRACE_ENCLOSED_INITIALIZER_P (init))
4423             {
4424               if (TYPE_NON_AGGREGATE_CLASS (type))
4425                 {
4426                   error ("`%D' must be initialized by constructor, not by `{...}'",
4427                          decl);
4428                   init = error_mark_node;
4429                 }
4430               else
4431                 goto dont_use_constructor;
4432             }
4433           else
4434             {
4435               int saved_stmts_are_full_exprs_p;
4436
4437             initialize_aggr:
4438               saved_stmts_are_full_exprs_p = 0;
4439               if (building_stmt_tree ())
4440                 {
4441                   saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4442                   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4443                 }
4444               init = build_aggr_init (decl, init, flags);
4445               if (building_stmt_tree ())
4446                 current_stmt_tree ()->stmts_are_full_exprs_p =
4447                   saved_stmts_are_full_exprs_p;
4448               return init;
4449             }
4450         }
4451       else
4452         {
4453         dont_use_constructor:
4454           if (TREE_CODE (init) != TREE_VEC)
4455             {
4456               init_code = store_init_value (decl, init);
4457               init = NULL;
4458             }
4459         }
4460     }
4461   else if (DECL_EXTERNAL (decl))
4462     ;
4463   else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4464     goto initialize_aggr;
4465   else if (IS_AGGR_TYPE (type))
4466     {
4467       tree core_type = strip_array_types (type);
4468
4469       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4470         error ("structure `%D' with uninitialized const members", decl);
4471       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4472         error ("structure `%D' with uninitialized reference members",
4473                decl);
4474
4475       check_for_uninitialized_const_var (decl);
4476     }
4477   else
4478     check_for_uninitialized_const_var (decl);
4479
4480   if (init && init != error_mark_node)
4481     init_code = build (INIT_EXPR, type, decl, init);
4482
4483   return init_code;
4484 }
4485
4486 /* If DECL is not a local variable, give it RTL.  */
4487
4488 static void
4489 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4490 {
4491   int toplev = toplevel_bindings_p ();
4492   int defer_p;
4493
4494   /* Handle non-variables up front.  */
4495   if (TREE_CODE (decl) != VAR_DECL)
4496     {
4497       rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4498       return;
4499     }
4500
4501   /* If we see a class member here, it should be a static data
4502      member.  */
4503   if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4504     {
4505       my_friendly_assert (TREE_STATIC (decl), 19990828);
4506       /* An in-class declaration of a static data member should be
4507          external; it is only a declaration, and not a definition.  */
4508       if (init == NULL_TREE)
4509         my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
4510     }
4511
4512   /* Set the DECL_ASSEMBLER_NAME for the variable.  */
4513   if (asmspec)
4514     {
4515       change_decl_assembler_name (decl, get_identifier (asmspec));
4516       /* The `register' keyword, when used together with an
4517          asm-specification, indicates that the variable should be
4518          placed in a particular register.  */
4519       if (DECL_REGISTER (decl))
4520         DECL_HARD_REGISTER (decl) = 1;
4521     }
4522
4523   /* We don't create any RTL for local variables.  */
4524   if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4525     return;
4526
4527   /* We defer emission of local statics until the corresponding
4528      DECL_EXPR is expanded.  */
4529   defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4530
4531   /* We try to defer namespace-scope static constants so that they are
4532      not emitted into the object file unnecessarily.  */
4533   if (!DECL_VIRTUAL_P (decl)
4534       && TREE_READONLY (decl)
4535       && DECL_INITIAL (decl) != NULL_TREE
4536       && DECL_INITIAL (decl) != error_mark_node
4537       && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4538       && toplev
4539       && !TREE_PUBLIC (decl))
4540     {
4541       /* Fool with the linkage of static consts according to #pragma
4542          interface.  */
4543       if (!interface_unknown && !TREE_PUBLIC (decl))
4544         {
4545           TREE_PUBLIC (decl) = 1;
4546           DECL_EXTERNAL (decl) = interface_only;
4547         }
4548
4549       defer_p = 1;
4550     }
4551   /* Likewise for template instantiations.  */
4552   else if (DECL_COMDAT (decl))
4553     defer_p = 1;
4554
4555   /* If we're deferring the variable, we only need to make RTL if
4556      there's an ASMSPEC.  Otherwise, we'll lazily create it later when
4557      we need it.  (There's no way to lazily create RTL for things that
4558      have assembly specs because the information about the specifier
4559      isn't stored in the tree, yet)  */
4560   if (defer_p && asmspec)
4561     make_decl_rtl (decl, asmspec);
4562   /* If we're not deferring, go ahead and assemble the variable.  */
4563   else if (!defer_p)
4564     rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4565 }
4566
4567 /* Generate code to initialize DECL (a local variable).  */
4568
4569 static void
4570 initialize_local_var (tree decl, tree init)
4571 {
4572   tree type = TREE_TYPE (decl);
4573   tree cleanup;
4574
4575   my_friendly_assert (TREE_CODE (decl) == VAR_DECL
4576                       || TREE_CODE (decl) == RESULT_DECL,
4577                       20021010);
4578   my_friendly_assert (!TREE_STATIC (decl), 20021010);
4579
4580   if (DECL_SIZE (decl) == NULL_TREE)
4581     {
4582       /* If we used it already as memory, it must stay in memory.  */
4583       DECL_INITIAL (decl) = NULL_TREE;
4584       TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4585     }
4586
4587   if (DECL_SIZE (decl) && type != error_mark_node)
4588     {
4589       int already_used;
4590
4591       /* Compute and store the initial value.  */
4592       already_used = TREE_USED (decl) || TREE_USED (type);
4593
4594       /* Perform the initialization.  */
4595       if (init)
4596         {
4597           int saved_stmts_are_full_exprs_p;
4598
4599           my_friendly_assert (building_stmt_tree (), 20000906);
4600           saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4601           current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4602           finish_expr_stmt (init);
4603           current_stmt_tree ()->stmts_are_full_exprs_p =
4604             saved_stmts_are_full_exprs_p;
4605         }
4606
4607       /* Set this to 0 so we can tell whether an aggregate which was
4608          initialized was ever used.  Don't do this if it has a
4609          destructor, so we don't complain about the 'resource
4610          allocation is initialization' idiom.  Now set
4611          attribute((unused)) on types so decls of that type will be
4612          marked used. (see TREE_USED, above.)  */
4613       if (TYPE_NEEDS_CONSTRUCTING (type)
4614           && ! already_used
4615           && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4616           && DECL_NAME (decl))
4617         TREE_USED (decl) = 0;
4618       else if (already_used)
4619         TREE_USED (decl) = 1;
4620     }
4621
4622   /* Generate a cleanup, if necessary.  */
4623   cleanup = cxx_maybe_build_cleanup (decl);
4624   if (DECL_SIZE (decl) && cleanup)
4625     finish_decl_cleanup (decl, cleanup);
4626 }
4627
4628 /* Finish processing of a declaration;
4629    install its line number and initial value.
4630    If the length of an array type is not known before,
4631    it must be determined now, from the initial value, or it is an error.
4632
4633    INIT holds the value of an initializer that should be allowed to escape
4634    the normal rules.
4635
4636    FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4637    if the (init) syntax was used.  */
4638
4639 void
4640 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4641 {
4642   tree type;
4643   tree ttype = NULL_TREE;
4644   tree cleanup;
4645   const char *asmspec = NULL;
4646   int was_readonly = 0;
4647
4648   if (decl == error_mark_node)
4649     return;
4650   else if (! decl)
4651     {
4652       if (init)
4653         error ("assignment (not initialization) in declaration");
4654       return;
4655     }
4656
4657   my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);
4658
4659   /* Assume no cleanup is required.  */
4660   cleanup = NULL_TREE;
4661
4662   /* If a name was specified, get the string.  */
4663   if (global_scope_p (current_binding_level))
4664     asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4665   if (asmspec_tree)
4666     asmspec = TREE_STRING_POINTER (asmspec_tree);
4667
4668   if (init && TREE_CODE (init) == NAMESPACE_DECL)
4669     {
4670       error ("cannot initialize `%D' to namespace `%D'",
4671                 decl, init);
4672       init = NULL_TREE;
4673     }
4674
4675   if (current_class_type
4676       && CP_DECL_CONTEXT (decl) == current_class_type
4677       && TYPE_BEING_DEFINED (current_class_type)
4678       && (DECL_INITIAL (decl) || init))
4679     DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4680
4681   if (TREE_CODE (decl) == VAR_DECL
4682       && DECL_CONTEXT (decl)
4683       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
4684       && DECL_CONTEXT (decl) != current_namespace
4685       && init)
4686     {
4687       /* Leave the namespace of the object.  */
4688       pop_decl_namespace ();
4689     }
4690
4691   type = TREE_TYPE (decl);
4692
4693   if (type == error_mark_node)
4694     goto finish_end0;
4695
4696   if (TYPE_HAS_MUTABLE_P (type))
4697     TREE_READONLY (decl) = 0;
4698
4699   if (processing_template_decl)
4700     {
4701       /* Add this declaration to the statement-tree.  */
4702       if (at_function_scope_p ())
4703         add_decl_expr (decl);
4704
4705       if (init && DECL_INITIAL (decl))
4706         DECL_INITIAL (decl) = init;
4707       if (TREE_CODE (decl) == VAR_DECL
4708           && !DECL_PRETTY_FUNCTION_P (decl)
4709           && !dependent_type_p (TREE_TYPE (decl)))
4710         maybe_deduce_size_from_array_init (decl, init);
4711       goto finish_end0;
4712     }
4713
4714   /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */
4715   my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
4716
4717   /* Take care of TYPE_DECLs up front.  */
4718   if (TREE_CODE (decl) == TYPE_DECL)
4719     {
4720       if (type != error_mark_node
4721           && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4722         {
4723           if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4724             warning ("shadowing previous type declaration of `%#D'", decl);
4725           set_identifier_type_value (DECL_NAME (decl), decl);
4726         }
4727
4728       /* If we have installed this as the canonical typedef for this
4729          type, and that type has not been defined yet, delay emitting
4730          the debug information for it, as we will emit it later.  */
4731       if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4732           && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4733         TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4734
4735       rest_of_decl_compilation (decl, NULL,
4736                                 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
4737       goto finish_end;
4738     }
4739
4740   if (TREE_CODE (decl) != FUNCTION_DECL)
4741     ttype = target_type (type);
4742
4743
4744   /* Currently, GNU C++ puts constants in text space, making them
4745      impossible to initialize.  In the future, one would hope for
4746      an operating system which understood the difference between
4747      initialization and the running of a program.  */
4748   if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl))
4749     {
4750       was_readonly = 1;
4751       if (TYPE_NEEDS_CONSTRUCTING (type)
4752           || TREE_CODE (type) == REFERENCE_TYPE)
4753         TREE_READONLY (decl) = 0;
4754     }
4755
4756   if (TREE_CODE (decl) == VAR_DECL)
4757     {
4758       /* Only PODs can have thread-local storage.  Other types may require
4759          various kinds of non-trivial initialization.  */
4760       if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4761         error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4762                decl, TREE_TYPE (decl));
4763       /* Convert the initializer to the type of DECL, if we have not
4764          already initialized DECL.  */
4765       if (!DECL_INITIALIZED_P (decl)
4766           /* If !DECL_EXTERNAL then DECL is being defined.  In the
4767              case of a static data member initialized inside the
4768              class-specifier, there can be an initializer even if DECL
4769              is *not* defined.  */
4770           && (!DECL_EXTERNAL (decl) || init))
4771         {
4772           init = check_initializer (decl, init, flags, &cleanup);
4773           /* Thread-local storage cannot be dynamically initialized.  */
4774           if (DECL_THREAD_LOCAL (decl) && init)
4775             {
4776               error ("`%D' is thread-local and so cannot be dynamically "
4777                      "initialized", decl);
4778               init = NULL_TREE;
4779             }
4780           /* Handle:
4781
4782              [dcl.init]
4783
4784              The memory occupied by any object of static storage
4785              duration is zero-initialized at program startup before
4786              any other initialization takes place.
4787
4788              We cannot create an appropriate initializer until after
4789              the type of DECL is finalized.  If DECL_INITIAL is set,
4790              then the DECL is statically initialized, and any
4791              necessary zero-initialization has already been performed.  */
4792           if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4793             DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4794                                                    /*nelts=*/NULL_TREE,
4795                                                    /*static_storage_p=*/true);
4796           /* Remember that the initialization for this variable has
4797              taken place.  */
4798           DECL_INITIALIZED_P (decl) = 1;
4799         }
4800       /* If the variable has an array type, lay out the type, even if
4801          there is no initializer.  It is valid to index through the
4802          array, and we must get TYPE_ALIGN set correctly on the array
4803          type.  */
4804       else if (TREE_CODE (type) == ARRAY_TYPE)
4805         layout_type (type);
4806     }
4807
4808   /* Add this declaration to the statement-tree.  This needs to happen
4809      after the call to check_initializer so that the DECL_EXPR for a
4810      reference temp is added before the DECL_EXPR for the reference itself.  */
4811   if (at_function_scope_p ())
4812     add_decl_expr (decl);
4813
4814   if (TREE_CODE (decl) == VAR_DECL)
4815     layout_var_decl (decl);
4816
4817   /* Output the assembler code and/or RTL code for variables and functions,
4818      unless the type is an undefined structure or union.
4819      If not, it will get done when the type is completed.  */
4820   if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4821     {
4822       if (TREE_CODE (decl) == VAR_DECL)
4823         maybe_commonize_var (decl);
4824
4825       make_rtl_for_nonlocal_decl (decl, init, asmspec);
4826
4827       /* Check for abstractness of the type. Notice that there is no
4828          need to strip array types here since the check for those types
4829          is already done within create_array_type_for_decl.  */
4830       if (TREE_CODE (type) == FUNCTION_TYPE
4831           || TREE_CODE (type) == METHOD_TYPE)
4832         abstract_virtuals_error (decl, TREE_TYPE (type));
4833       else
4834         abstract_virtuals_error (decl, type);
4835
4836       if (TREE_CODE (decl) == FUNCTION_DECL
4837           || TREE_TYPE (decl) == error_mark_node)
4838         /* No initialization required.  */
4839         ;
4840       else if (DECL_EXTERNAL (decl)
4841                && ! (DECL_LANG_SPECIFIC (decl)
4842                      && DECL_NOT_REALLY_EXTERN (decl)))
4843         {
4844           if (init)
4845             DECL_INITIAL (decl) = init;
4846         }
4847       else
4848         {
4849           /* A variable definition.  */
4850           if (DECL_FUNCTION_SCOPE_P (decl))
4851             {
4852               /* Initialize the local variable.  */
4853               if (processing_template_decl)
4854                 {
4855                   if (init || DECL_INITIAL (decl) == error_mark_node)
4856                     DECL_INITIAL (decl) = init;
4857                 }
4858               else if (!TREE_STATIC (decl))
4859                 initialize_local_var (decl, init);
4860             }
4861
4862           if (TREE_STATIC (decl))
4863             expand_static_init (decl, init);
4864         }
4865     finish_end0:
4866
4867       /* Undo call to `pushclass' that was done in `start_decl'
4868          due to initialization of qualified member variable.
4869          I.e., Foo::x = 10;  */
4870       {
4871         tree context = CP_DECL_CONTEXT (decl);
4872         if (context
4873             && TYPE_P (context)
4874             && (TREE_CODE (decl) == VAR_DECL
4875                 /* We also have a pushclass done that we need to undo here
4876                    if we're at top level and declare a method.  */
4877                 || TREE_CODE (decl) == FUNCTION_DECL)
4878             /* If size hasn't been set, we're still defining it,
4879                and therefore inside the class body; don't pop
4880                the binding level..  */
4881             && COMPLETE_TYPE_P (context)
4882             && context == current_class_type)
4883           pop_nested_class ();
4884       }
4885     }
4886
4887   /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4888      reference, insert it in the statement-tree now.  */
4889   if (cleanup)
4890     push_cleanup (decl, cleanup, false);
4891
4892  finish_end:
4893
4894   if (was_readonly)
4895     TREE_READONLY (decl) = 1;
4896
4897   /* If this was marked 'used', be sure it will be output.  */
4898   if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
4899     mark_decl_referenced (decl);
4900 }
4901
4902 /* This is here for a midend callback from c-common.c.  */
4903
4904 void
4905 finish_decl (tree decl, tree init, tree asmspec_tree)
4906 {
4907   cp_finish_decl (decl, init, asmspec_tree, 0);
4908 }
4909
4910 /* Returns a declaration for a VAR_DECL as if:
4911
4912      extern "C" TYPE NAME;
4913
4914    had been seen.  Used to create compiler-generated global
4915    variables.  */
4916
4917 tree
4918 declare_global_var (tree name, tree type)
4919 {
4920   tree decl;
4921
4922   push_to_top_level ();
4923   decl = build_decl (VAR_DECL, name, type);
4924   TREE_PUBLIC (decl) = 1;
4925   DECL_EXTERNAL (decl) = 1;
4926   DECL_ARTIFICIAL (decl) = 1;
4927   pushdecl (decl);
4928   cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
4929   pop_from_top_level ();
4930
4931   return decl;
4932 }
4933
4934 /* Returns a pointer to the `atexit' function.  Note that if
4935    FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4936    `__cxa_atexit' function specified in the IA64 C++ ABI.  */
4937
4938 static tree
4939 get_atexit_node (void)
4940 {
4941   tree atexit_fndecl;
4942   tree arg_types;
4943   tree fn_type;
4944   tree fn_ptr_type;
4945   const char *name;
4946
4947   if (atexit_node)
4948     return atexit_node;
4949
4950   if (flag_use_cxa_atexit)
4951     {
4952       /* The declaration for `__cxa_atexit' is:
4953
4954            int __cxa_atexit (void (*)(void *), void *, void *)
4955
4956          We build up the argument types and then then function type
4957          itself.  */
4958
4959       /* First, build the pointer-to-function type for the first
4960          argument.  */
4961       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
4962       fn_type = build_function_type (void_type_node, arg_types);
4963       fn_ptr_type = build_pointer_type (fn_type);
4964       /* Then, build the rest of the argument types.  */
4965       arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
4966       arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
4967       arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
4968       /* And the final __cxa_atexit type.  */
4969       fn_type = build_function_type (integer_type_node, arg_types);
4970       fn_ptr_type = build_pointer_type (fn_type);
4971       name = "__cxa_atexit";
4972     }
4973   else
4974     {
4975       /* The declaration for `atexit' is:
4976
4977            int atexit (void (*)());
4978
4979          We build up the argument types and then then function type
4980          itself.  */
4981       fn_type = build_function_type (void_type_node, void_list_node);
4982       fn_ptr_type = build_pointer_type (fn_type);
4983       arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
4984       /* Build the final atexit type.  */
4985       fn_type = build_function_type (integer_type_node, arg_types);
4986       name = "atexit";
4987     }
4988
4989   /* Now, build the function declaration.  */
4990   push_lang_context (lang_name_c);
4991   atexit_fndecl = build_library_fn_ptr (name, fn_type);
4992   mark_used (atexit_fndecl);
4993   pop_lang_context ();
4994   atexit_node = decay_conversion (atexit_fndecl);
4995
4996   return atexit_node;
4997 }
4998
4999 /* Returns the __dso_handle VAR_DECL.  */
5000
5001 static tree
5002 get_dso_handle_node (void)
5003 {
5004   if (dso_handle_node)
5005     return dso_handle_node;
5006
5007   /* Declare the variable.  */
5008   dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5009                                         ptr_type_node);
5010
5011   return dso_handle_node;
5012 }
5013
5014 /* Begin a new function with internal linkage whose job will be simply
5015    to destroy some particular variable.  */
5016
5017 static GTY(()) int start_cleanup_cnt;
5018
5019 static tree
5020 start_cleanup_fn (void)
5021 {
5022   int old_interface_only = interface_only;
5023   int old_interface_unknown = interface_unknown;
5024   char name[32];
5025   tree parmtypes;
5026   tree fntype;
5027   tree fndecl;
5028
5029   push_to_top_level ();
5030
5031   /* No need to mangle this.  */
5032   push_lang_context (lang_name_c);
5033
5034   interface_only = 0;
5035   interface_unknown = 1;
5036
5037   /* Build the parameter-types.  */
5038   parmtypes = void_list_node;
5039   /* Functions passed to __cxa_atexit take an additional parameter.
5040      We'll just ignore it.  After we implement the new calling
5041      convention for destructors, we can eliminate the use of
5042      additional cleanup functions entirely in the -fnew-abi case.  */
5043   if (flag_use_cxa_atexit)
5044     parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5045   /* Build the function type itself.  */
5046   fntype = build_function_type (void_type_node, parmtypes);
5047   /* Build the name of the function.  */
5048   sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5049   /* Build the function declaration.  */
5050   fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5051   /* It's a function with internal linkage, generated by the
5052      compiler.  */
5053   TREE_PUBLIC (fndecl) = 0;
5054   DECL_ARTIFICIAL (fndecl) = 1;
5055   /* Make the function `inline' so that it is only emitted if it is
5056      actually needed.  It is unlikely that it will be inlined, since
5057      it is only called via a function pointer, but we avoid unnecessary
5058      emissions this way.  */
5059   DECL_INLINE (fndecl) = 1;
5060   DECL_DECLARED_INLINE_P (fndecl) = 1;
5061   DECL_INTERFACE_KNOWN (fndecl) = 1;
5062   /* Build the parameter.  */
5063   if (flag_use_cxa_atexit)
5064     {
5065       tree parmdecl;
5066
5067       parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5068       DECL_CONTEXT (parmdecl) = fndecl;
5069       TREE_USED (parmdecl) = 1;
5070       DECL_ARGUMENTS (fndecl) = parmdecl;
5071     }
5072
5073   pushdecl (fndecl);
5074   start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5075
5076   interface_unknown = old_interface_unknown;
5077   interface_only = old_interface_only;
5078
5079   pop_lang_context ();
5080
5081   return current_function_decl;
5082 }
5083
5084 /* Finish the cleanup function begun by start_cleanup_fn.  */
5085
5086 static void
5087 end_cleanup_fn (void)
5088 {
5089   expand_or_defer_fn (finish_function (0));
5090
5091   pop_from_top_level ();
5092 }
5093
5094 /* Generate code to handle the destruction of DECL, an object with
5095    static storage duration.  */
5096
5097 void
5098 register_dtor_fn (tree decl)
5099 {
5100   tree cleanup;
5101   tree compound_stmt;
5102   tree args;
5103   tree fcall;
5104
5105   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5106     return;
5107
5108   /* Call build_cleanup before we enter the anonymous function so that
5109      any access checks will be done relative to the current scope,
5110      rather than the scope of the anonymous function.  */
5111   build_cleanup (decl);
5112
5113   /* Now start the function.  */
5114   cleanup = start_cleanup_fn ();
5115
5116   /* Now, recompute the cleanup.  It may contain SAVE_EXPRs that refer
5117      to the original function, rather than the anonymous one.  That
5118      will make the back-end think that nested functions are in use,
5119      which causes confusion.  */
5120
5121   push_deferring_access_checks (dk_no_check);
5122   fcall = build_cleanup (decl);
5123   pop_deferring_access_checks ();
5124
5125   /* Create the body of the anonymous function.  */
5126   compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5127   finish_expr_stmt (fcall);
5128   finish_compound_stmt (compound_stmt);
5129   end_cleanup_fn ();
5130
5131   /* Call atexit with the cleanup function.  */
5132   cxx_mark_addressable (cleanup);
5133   mark_used (cleanup);
5134   cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5135   if (flag_use_cxa_atexit)
5136     {
5137       args = tree_cons (NULL_TREE,
5138                         build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5139                         NULL_TREE);
5140       args = tree_cons (NULL_TREE, null_pointer_node, args);
5141       args = tree_cons (NULL_TREE, cleanup, args);
5142     }
5143   else
5144     args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5145   finish_expr_stmt (build_function_call (get_atexit_node (), args));
5146 }
5147
5148 /* DECL is a VAR_DECL with static storage duration.  INIT, if present,
5149    is its initializer.  Generate code to handle the construction
5150    and destruction of DECL.  */
5151
5152 static void
5153 expand_static_init (tree decl, tree init)
5154 {
5155   my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
5156   my_friendly_assert (TREE_STATIC (decl), 20021010);
5157
5158   /* Some variables require no initialization.  */
5159   if (!init
5160       && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5161       && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5162     return;
5163
5164   if (! toplevel_bindings_p ())
5165     {
5166       /* Emit code to perform this initialization but once.  */
5167       tree if_stmt;
5168       tree then_clause;
5169       tree assignment;
5170       tree guard;
5171       tree guard_init;
5172
5173       /* Emit code to perform this initialization but once.  This code
5174          looks like:
5175
5176            static int guard = 0;
5177            if (!guard) {
5178              // Do initialization.
5179              guard = 1;
5180              // Register variable for destruction at end of program.
5181            }
5182
5183          Note that the `temp' variable is only set to 1 *after* the
5184          initialization is complete.  This ensures that an exception,
5185          thrown during the construction, will cause the variable to
5186          reinitialized when we pass through this code again, as per:
5187
5188            [stmt.dcl]
5189
5190            If the initialization exits by throwing an exception, the
5191            initialization is not complete, so it will be tried again
5192            the next time control enters the declaration.
5193
5194          In theory, this process should be thread-safe, too; multiple
5195          threads should not be able to initialize the variable more
5196          than once.  We don't yet attempt to ensure thread-safety.  */
5197
5198       /* Create the guard variable.  */
5199       guard = get_guard (decl);
5200
5201       /* Begin the conditional initialization.  */
5202       if_stmt = begin_if_stmt ();
5203       finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5204       then_clause = begin_compound_stmt (0);
5205
5206       /* Do the initialization itself.  */
5207       assignment = init ? init : NULL_TREE;
5208
5209       /* Once the assignment is complete, set TEMP to 1.  Since the
5210          construction of the static object is complete at this point,
5211          we want to make sure TEMP is set to 1 even if a temporary
5212          constructed during the initialization throws an exception
5213          when it is destroyed.  So, we combine the initialization and
5214          the assignment to TEMP into a single expression, ensuring
5215          that when we call finish_expr_stmt the cleanups will not be
5216          run until after TEMP is set to 1.  */
5217       guard_init = set_guard (guard);
5218       if (assignment)
5219         assignment = build_compound_expr (assignment, guard_init);
5220       else
5221         assignment = guard_init;
5222       finish_expr_stmt (assignment);
5223
5224       /* Use atexit to register a function for destroying this static
5225          variable.  */
5226       register_dtor_fn (decl);
5227
5228       finish_compound_stmt (then_clause);
5229       finish_then_clause (if_stmt);
5230       finish_if_stmt (if_stmt);
5231     }
5232   else
5233     static_aggregates = tree_cons (init, decl, static_aggregates);
5234 }
5235
5236 \f
5237 /* Make TYPE a complete type based on INITIAL_VALUE.
5238    Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5239    2 if there was no information (in which case assume 0 if DO_DEFAULT).  */
5240
5241 int
5242 complete_array_type (tree type, tree initial_value, int do_default)
5243 {
5244   tree maxindex = NULL_TREE;
5245   int value = 0;
5246
5247   if (initial_value)
5248     {
5249       /* An array of character type can be initialized from a
5250          brace-enclosed string constant.  */
5251       if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
5252           && TREE_CODE (initial_value) == CONSTRUCTOR
5253           && CONSTRUCTOR_ELTS (initial_value)
5254           && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
5255               == STRING_CST)
5256           && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
5257         initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
5258
5259       /* Note MAXINDEX is really the maximum index, one less than the
5260          size.  */
5261       if (TREE_CODE (initial_value) == STRING_CST)
5262         {
5263           int eltsize
5264             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5265           maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
5266                                    / eltsize) - 1, 0);
5267         }
5268       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5269         {
5270           tree elts = CONSTRUCTOR_ELTS (initial_value);
5271
5272           maxindex = ssize_int (-1);
5273           for (; elts; elts = TREE_CHAIN (elts))
5274             {
5275               if (TREE_PURPOSE (elts))
5276                 maxindex = TREE_PURPOSE (elts);
5277               else
5278                 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
5279             }
5280           maxindex = copy_node (maxindex);
5281         }
5282       else
5283         {
5284           /* Make an error message unless that happened already.  */
5285           if (initial_value != error_mark_node)
5286             value = 1;
5287           else
5288             initial_value = NULL_TREE;
5289
5290           /* Prevent further error messages.  */
5291           maxindex = build_int_2 (0, 0);
5292         }
5293     }
5294
5295   if (!maxindex)
5296     {
5297       if (do_default)
5298         maxindex = build_int_2 (0, 0);
5299       value = 2;
5300     }
5301
5302   if (maxindex)
5303     {
5304       tree itype;
5305       tree domain;
5306       tree elt_type;
5307
5308       domain = build_index_type (maxindex);
5309       TYPE_DOMAIN (type) = domain;
5310
5311       if (! TREE_TYPE (maxindex))
5312         TREE_TYPE (maxindex) = domain;
5313       if (initial_value)
5314         itype = TREE_TYPE (initial_value);
5315       else
5316         itype = NULL;
5317       if (itype && !TYPE_DOMAIN (itype))
5318         TYPE_DOMAIN (itype) = domain;
5319       /* The type of the main variant should never be used for arrays
5320          of different sizes.  It should only ever be completed with the
5321          size of the array.  */
5322       if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
5323         TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
5324
5325       elt_type = TREE_TYPE (type);
5326       TYPE_NEEDS_CONSTRUCTING (type)
5327         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
5328       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5329         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
5330     }
5331
5332   /* Lay out the type now that we can get the real answer.  */
5333
5334   layout_type (type);
5335
5336   return value;
5337 }
5338 \f
5339 /* Return zero if something is declared to be a member of type
5340    CTYPE when in the context of CUR_TYPE.  STRING is the error
5341    message to print in that case.  Otherwise, quietly return 1.  */
5342
5343 static int
5344 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5345 {
5346   if (ctype && ctype != cur_type)
5347     {
5348       if (flags == DTOR_FLAG)
5349         error ("destructor for alien class `%T' cannot be a member",
5350                   ctype);
5351       else
5352         error ("constructor for alien class `%T' cannot be a member",
5353                   ctype);
5354       return 0;
5355     }
5356   return 1;
5357 }
5358 \f
5359 /* Subroutine of `grokdeclarator'.  */
5360
5361 /* Generate errors possibly applicable for a given set of specifiers.
5362    This is for ARM $7.1.2.  */
5363
5364 static void
5365 bad_specifiers (tree object,
5366                 const char* type,
5367                 int virtualp,
5368                 int quals,
5369                 int inlinep,
5370                 int friendp,
5371                 int raises)
5372 {
5373   if (virtualp)
5374     error ("`%D' declared as a `virtual' %s", object, type);
5375   if (inlinep)
5376     error ("`%D' declared as an `inline' %s", object, type);
5377   if (quals)
5378     error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5379               object, type);
5380   if (friendp)
5381     cp_error_at ("`%D' declared as a friend", object);
5382   if (raises
5383       && (TREE_CODE (object) == TYPE_DECL
5384           || (!TYPE_PTRFN_P (TREE_TYPE (object))
5385               && !TYPE_REFFN_P (TREE_TYPE (object))
5386               && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5387     cp_error_at ("`%D' declared with an exception specification", object);
5388 }
5389
5390 /* CTYPE is class type, or null if non-class.
5391    TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5392    or METHOD_TYPE.
5393    DECLARATOR is the function's name.
5394    PARMS is a chain of PARM_DECLs for the function.
5395    VIRTUALP is truthvalue of whether the function is virtual or not.
5396    FLAGS are to be passed through to `grokclassfn'.
5397    QUALS are qualifiers indicating whether the function is `const'
5398    or `volatile'.
5399    RAISES is a list of exceptions that this function can raise.
5400    CHECK is 1 if we must find this method in CTYPE, 0 if we should
5401    not look, and -1 if we should not call `grokclassfn' at all.
5402
5403    Returns `NULL_TREE' if something goes wrong, after issuing
5404    applicable error messages.  */
5405
5406 static tree
5407 grokfndecl (tree ctype,
5408             tree type,
5409             tree declarator,
5410             tree parms,
5411             tree orig_declarator,
5412             int virtualp,
5413             enum overload_flags flags,
5414             cp_cv_quals quals,
5415             tree raises,
5416             int check,
5417             int friendp,
5418             int publicp,
5419             int inlinep,
5420             int funcdef_flag,
5421             int template_count,
5422             tree in_namespace)
5423 {
5424   tree decl;
5425   int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5426   int has_default_arg = 0;
5427   tree t;
5428
5429   if (raises)
5430     type = build_exception_variant (type, raises);
5431
5432   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5433   DECL_ARGUMENTS (decl) = parms;
5434   /* Propagate volatile out from type to decl.  */
5435   if (TYPE_VOLATILE (type))
5436     TREE_THIS_VOLATILE (decl) = 1;
5437
5438   /* If this decl has namespace scope, set that up.  */
5439   if (in_namespace)
5440     set_decl_namespace (decl, in_namespace, friendp);
5441   else if (!ctype)
5442     DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5443
5444   /* `main' and builtins have implicit 'C' linkage.  */
5445   if ((MAIN_NAME_P (declarator)
5446        || (IDENTIFIER_LENGTH (declarator) > 10
5447            && IDENTIFIER_POINTER (declarator)[0] == '_'
5448            && IDENTIFIER_POINTER (declarator)[1] == '_'
5449            && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5450       && current_lang_name == lang_name_cplusplus
5451       && ctype == NULL_TREE
5452       /* NULL_TREE means global namespace.  */
5453       && DECL_CONTEXT (decl) == NULL_TREE)
5454     SET_DECL_LANGUAGE (decl, lang_c);
5455
5456   /* Should probably propagate const out from type to decl I bet (mrs).  */
5457   if (staticp)
5458     {
5459       DECL_STATIC_FUNCTION_P (decl) = 1;
5460       DECL_CONTEXT (decl) = ctype;
5461     }
5462
5463   if (ctype)
5464     DECL_CONTEXT (decl) = ctype;
5465
5466   if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5467     {
5468       if (processing_template_decl)
5469         error ("cannot declare `::main' to be a template");
5470       if (inlinep)
5471         error ("cannot declare `::main' to be inline");
5472       if (!publicp)
5473         error ("cannot declare `::main' to be static");
5474       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5475                         integer_type_node))
5476         error ("`main' must return `int'");
5477       inlinep = 0;
5478       publicp = 1;
5479     }
5480
5481   /* Members of anonymous types and local classes have no linkage; make
5482      them internal.  If a typedef is made later, this will be changed.  */
5483   if (ctype && (TYPE_ANONYMOUS_P (ctype)
5484                 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5485     publicp = 0;
5486
5487   if (publicp)
5488     {
5489       /* [basic.link]: A name with no linkage (notably, the name of a class
5490          or enumeration declared in a local scope) shall not be used to
5491          declare an entity with linkage.
5492
5493          Only check this for public decls for now.  See core 319, 389.  */
5494       t = no_linkage_check (TREE_TYPE (decl));
5495       if (t)
5496         {
5497           if (TYPE_ANONYMOUS_P (t))
5498             {
5499               if (DECL_EXTERN_C_P (decl))
5500                 /* Allow this; it's pretty common in C.  */;
5501               else
5502                 {
5503                   pedwarn ("non-local function `%#D' uses anonymous type",
5504                               decl);
5505                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5506                     cp_pedwarn_at ("\
5507 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5508                                 TYPE_NAME (t));
5509                 }
5510             }
5511           else
5512             pedwarn ("non-local function `%#D' uses local type `%T'",
5513                         decl, t);
5514         }
5515     }
5516
5517   TREE_PUBLIC (decl) = publicp;
5518   if (! publicp)
5519     {
5520       DECL_INTERFACE_KNOWN (decl) = 1;
5521       DECL_NOT_REALLY_EXTERN (decl) = 1;
5522     }
5523
5524   /* If the declaration was declared inline, mark it as such.  */
5525   if (inlinep)
5526     DECL_DECLARED_INLINE_P (decl) = 1;
5527   /* We inline functions that are explicitly declared inline, or, when
5528      the user explicitly asks us to, all functions.  */
5529   if (DECL_DECLARED_INLINE_P (decl)
5530       || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5531     DECL_INLINE (decl) = 1;
5532
5533   DECL_EXTERNAL (decl) = 1;
5534   if (quals && TREE_CODE (type) == FUNCTION_TYPE)
5535     {
5536       error ("%smember function `%D' cannot have cv-qualifier",
5537              (ctype ? "static " : "non-"), decl);
5538       quals = TYPE_UNQUALIFIED;
5539     }
5540
5541   if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5542     grok_op_properties (decl, friendp, /*complain=*/true);
5543
5544   if (ctype && decl_function_context (decl))
5545     DECL_NO_STATIC_CHAIN (decl) = 1;
5546
5547   for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5548     if (TREE_PURPOSE (t)
5549         && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5550       {
5551         has_default_arg = 1;
5552         break;
5553       }
5554
5555   if (friendp
5556       && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5557     {
5558       if (funcdef_flag)
5559         error
5560           ("defining explicit specialization `%D' in friend declaration",
5561            orig_declarator);
5562       else
5563         {
5564           tree fns = TREE_OPERAND (orig_declarator, 0);
5565           tree args = TREE_OPERAND (orig_declarator, 1);
5566
5567           if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5568             {
5569               /* Something like `template <class T> friend void f<T>()'.  */
5570               error ("invalid use of template-id `%D' in declaration of primary template",
5571                         orig_declarator);
5572               return NULL_TREE;
5573             }
5574
5575
5576           /* A friend declaration of the form friend void f<>().  Record
5577              the information in the TEMPLATE_ID_EXPR.  */
5578           SET_DECL_IMPLICIT_INSTANTIATION (decl);
5579
5580           if (TREE_CODE (fns) == COMPONENT_REF)
5581             {
5582               /* Due to bison parser ickiness, we will have already looked
5583                  up an operator_name or PFUNCNAME within the current class
5584                  (see template_id in parse.y). If the current class contains
5585                  such a name, we'll get a COMPONENT_REF here. Undo that.  */
5586
5587               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5588                                   == current_class_type, 20001120);
5589               fns = TREE_OPERAND (fns, 1);
5590             }
5591           my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5592                               || TREE_CODE (fns) == OVERLOAD, 20001120);
5593           DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5594
5595           if (has_default_arg)
5596             {
5597               error ("default arguments are not allowed in declaration of friend template specialization `%D'",
5598                         decl);
5599               return NULL_TREE;
5600             }
5601
5602           if (inlinep)
5603             {
5604               error ("`inline' is not allowed in declaration of friend template specialization `%D'",
5605                         decl);
5606               return NULL_TREE;
5607             }
5608         }
5609     }
5610
5611   if (funcdef_flag)
5612     /* Make the init_value nonzero so pushdecl knows this is not
5613        tentative.  error_mark_node is replaced later with the BLOCK.  */
5614     DECL_INITIAL (decl) = error_mark_node;
5615
5616   if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5617     TREE_NOTHROW (decl) = 1;
5618
5619   /* Caller will do the rest of this.  */
5620   if (check < 0)
5621     return decl;
5622
5623   if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
5624     DECL_CONSTRUCTOR_P (decl) = 1;
5625
5626   /* Function gets the ugly name, field gets the nice one.  This call
5627      may change the type of the function (because of default
5628      parameters)!  */
5629   if (ctype != NULL_TREE)
5630     grokclassfn (ctype, decl, flags, quals);
5631
5632   decl = check_explicit_specialization (orig_declarator, decl,
5633                                         template_count,
5634                                         2 * (funcdef_flag != 0) +
5635                                         4 * (friendp != 0));
5636   if (decl == error_mark_node)
5637     return NULL_TREE;
5638
5639   if (ctype != NULL_TREE
5640       && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5641       && check)
5642     {
5643       tree old_decl;
5644
5645       old_decl = check_classfn (ctype, decl,
5646                                 (processing_template_decl
5647                                  > template_class_depth (ctype))
5648                                 ? current_template_parms
5649                                 : NULL_TREE);
5650
5651       if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5652         /* Because grokfndecl is always supposed to return a
5653            FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5654            here.  We depend on our callers to figure out that its
5655            really a template that's being returned.  */
5656         old_decl = DECL_TEMPLATE_RESULT (old_decl);
5657
5658       if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5659           && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5660         /* Remove the `this' parm added by grokclassfn.
5661            XXX Isn't this done in start_function, too?  */
5662         revert_static_member_fn (decl);
5663       if (old_decl && DECL_ARTIFICIAL (old_decl))
5664         error ("definition of implicitly-declared `%D'", old_decl);
5665
5666       if (old_decl)
5667         {
5668           tree ok;
5669           bool pop_p;
5670
5671           /* Since we've smashed OLD_DECL to its
5672              DECL_TEMPLATE_RESULT, we must do the same to DECL.  */
5673           if (TREE_CODE (decl) == TEMPLATE_DECL)
5674             decl = DECL_TEMPLATE_RESULT (decl);
5675
5676           /* Attempt to merge the declarations.  This can fail, in
5677              the case of some invalid specialization declarations.  */
5678           pop_p = push_scope (ctype);
5679           ok = duplicate_decls (decl, old_decl);
5680           if (pop_p)
5681             pop_scope (ctype);
5682           if (!ok)
5683             {
5684               error ("no `%#D' member function declared in class `%T'",
5685                      decl, ctype);
5686               return NULL_TREE;
5687             }
5688           return old_decl;
5689         }
5690     }
5691
5692   if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
5693     return NULL_TREE;
5694
5695   if (ctype == NULL_TREE || check)
5696     return decl;
5697
5698   if (virtualp)
5699     DECL_VIRTUAL_P (decl) = 1;
5700
5701   return decl;
5702 }
5703
5704 /* Create a VAR_DECL named NAME with the indicated TYPE.
5705
5706    If SCOPE is non-NULL, it is the class type or namespace containing
5707    the variable.  If SCOPE is NULL, the variable should is created in
5708    the innermost enclosings scope.  */
5709
5710 static tree
5711 grokvardecl (tree type,
5712              tree name,
5713              const cp_decl_specifier_seq *declspecs,
5714              int initialized,
5715              int constp,
5716              tree scope)
5717 {
5718   tree decl;
5719
5720   my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
5721                       20020808);
5722
5723   /* Compute the scope in which to place the variable.  */
5724   if (!scope)
5725     {
5726       /* An explicit "extern" specifier indicates a namespace-scope
5727          variable.  */
5728       if (declspecs->storage_class == sc_extern)
5729         scope = current_namespace;
5730       else if (!at_function_scope_p ())
5731         {
5732           scope = current_scope ();
5733           if (!scope)
5734             scope = current_namespace;
5735         }
5736     }
5737
5738   if (scope
5739       && (/* If the variable is a namespace-scope variable declared in a
5740              template, we need DECL_LANG_SPECIFIC.  */
5741           (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
5742           /* Similarly for namespace-scope variables with language linkage
5743              other than C++.  */
5744           || (TREE_CODE (scope) == NAMESPACE_DECL
5745               && current_lang_name != lang_name_cplusplus)
5746           /* Similarly for static data members.  */
5747           || TYPE_P (scope)))
5748     decl = build_lang_decl (VAR_DECL, name, type);
5749   else
5750     decl = build_decl (VAR_DECL, name, type);
5751
5752   if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
5753     set_decl_namespace (decl, scope, 0);
5754   else
5755     DECL_CONTEXT (decl) = scope;
5756
5757   if (declspecs->storage_class == sc_extern)
5758     {
5759       DECL_THIS_EXTERN (decl) = 1;
5760       DECL_EXTERNAL (decl) = !initialized;
5761     }
5762
5763   /* In class context, static means one per class,
5764      public access, and static storage.  */
5765   if (DECL_CLASS_SCOPE_P (decl))
5766     {
5767       TREE_PUBLIC (decl) = 1;
5768       TREE_STATIC (decl) = 1;
5769       DECL_EXTERNAL (decl) = 0;
5770     }
5771   /* At top level, either `static' or no s.c. makes a definition
5772      (perhaps tentative), and absence of `static' makes it public.  */
5773   else if (toplevel_bindings_p ())
5774     {
5775       TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
5776                             && (DECL_THIS_EXTERN (decl) || ! constp));
5777       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5778     }
5779   /* Not at top level, only `static' makes a static definition.  */
5780   else
5781     {
5782       TREE_STATIC (decl) = declspecs->storage_class == sc_static;
5783       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5784     }
5785
5786   if (declspecs->specs[(int)ds_thread])
5787     {
5788       if (targetm.have_tls)
5789         DECL_THREAD_LOCAL (decl) = 1;
5790       else
5791         /* A mere warning is sure to result in improper semantics
5792            at runtime.  Don't bother to allow this to compile.  */
5793         error ("thread-local storage not supported for this target");
5794     }
5795
5796   if (TREE_PUBLIC (decl))
5797     {
5798       /* [basic.link]: A name with no linkage (notably, the name of a class
5799          or enumeration declared in a local scope) shall not be used to
5800          declare an entity with linkage.
5801
5802          Only check this for public decls for now.  */
5803       tree t = no_linkage_check (TREE_TYPE (decl));
5804       if (t)
5805         {
5806           if (TYPE_ANONYMOUS_P (t))
5807             {
5808               if (DECL_EXTERN_C_P (decl))
5809                 /* Allow this; it's pretty common in C.  */;
5810               else
5811                 {
5812                   pedwarn ("non-local variable `%#D' uses anonymous type",
5813                            decl);
5814                   if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5815                     cp_pedwarn_at ("\
5816 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5817                                    TYPE_NAME (t));
5818                 }
5819             }
5820           else
5821             pedwarn ("non-local variable `%#D' uses local type `%T'",
5822                         decl, t);
5823         }
5824     }
5825
5826   return decl;
5827 }
5828
5829 /* Create and return a canonical pointer to member function type, for
5830    TYPE, which is a POINTER_TYPE to a METHOD_TYPE.  */
5831
5832 tree
5833 build_ptrmemfunc_type (tree type)
5834 {
5835   tree field, fields;
5836   tree t;
5837   tree unqualified_variant = NULL_TREE;
5838
5839   if (type == error_mark_node)
5840     return type;
5841
5842   /* If a canonical type already exists for this type, use it.  We use
5843      this method instead of type_hash_canon, because it only does a
5844      simple equality check on the list of field members.  */
5845
5846   if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
5847     return t;
5848
5849   /* Make sure that we always have the unqualified pointer-to-member
5850      type first.  */
5851   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5852     unqualified_variant
5853       = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
5854
5855   t = make_aggr_type (RECORD_TYPE);
5856   xref_basetypes (t, NULL_TREE);
5857
5858   /* Let the front-end know this is a pointer to member function...  */
5859   TYPE_PTRMEMFUNC_FLAG (t) = 1;
5860   /* ... and not really an aggregate.  */
5861   SET_IS_AGGR_TYPE (t, 0);
5862
5863   field = build_decl (FIELD_DECL, pfn_identifier, type);
5864   fields = field;
5865
5866   field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
5867   TREE_CHAIN (field) = fields;
5868   fields = field;
5869
5870   finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
5871
5872   /* Zap out the name so that the back-end will give us the debugging
5873      information for this anonymous RECORD_TYPE.  */
5874   TYPE_NAME (t) = NULL_TREE;
5875
5876   /* If this is not the unqualified form of this pointer-to-member
5877      type, set the TYPE_MAIN_VARIANT for this type to be the
5878      unqualified type.  Since they are actually RECORD_TYPEs that are
5879      not variants of each other, we must do this manually.  */
5880   if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5881     {
5882       t = build_qualified_type (t, cp_type_quals (type));
5883       TYPE_MAIN_VARIANT (t) = unqualified_variant;
5884       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
5885       TYPE_NEXT_VARIANT (unqualified_variant) = t;
5886     }
5887
5888   /* Cache this pointer-to-member type so that we can find it again
5889      later.  */
5890   TYPE_SET_PTRMEMFUNC_TYPE (type, t);
5891
5892   return t;
5893 }
5894
5895 /* Create and return a pointer to data member type.  */
5896
5897 tree
5898 build_ptrmem_type (tree class_type, tree member_type)
5899 {
5900   if (TREE_CODE (member_type) == METHOD_TYPE)
5901     {
5902       tree arg_types;
5903
5904       arg_types = TYPE_ARG_TYPES (member_type);
5905       class_type = (cp_build_qualified_type
5906                     (class_type,
5907                      cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
5908       member_type
5909         = build_method_type_directly (class_type,
5910                                       TREE_TYPE (member_type),
5911                                       TREE_CHAIN (arg_types));
5912       return build_ptrmemfunc_type (build_pointer_type (member_type));
5913     }
5914   else
5915     {
5916       my_friendly_assert (TREE_CODE (member_type) != FUNCTION_TYPE,
5917                           20030716);
5918       return build_offset_type (class_type, member_type);
5919     }
5920 }
5921
5922 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5923    Check to see that the definition is valid.  Issue appropriate error
5924    messages.  Return 1 if the definition is particularly bad, or 0
5925    otherwise.  */
5926
5927 int
5928 check_static_variable_definition (tree decl, tree type)
5929 {
5930   /* Motion 10 at San Diego: If a static const integral data member is
5931      initialized with an integral constant expression, the initializer
5932      may appear either in the declaration (within the class), or in
5933      the definition, but not both.  If it appears in the class, the
5934      member is a member constant.  The file-scope definition is always
5935      required.  */
5936   if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
5937     {
5938       error ("invalid in-class initialization of static data member of non-integral type `%T'",
5939              type);
5940       /* If we just return the declaration, crashes will sometimes
5941          occur.  We therefore return void_type_node, as if this were a
5942          friend declaration, to cause callers to completely ignore
5943          this declaration.  */
5944       return 1;
5945     }
5946   else if (!CP_TYPE_CONST_P (type))
5947     error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
5948               decl);
5949   else if (pedantic && !INTEGRAL_TYPE_P (type))
5950     pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
5951
5952   return 0;
5953 }
5954
5955 /* Given the SIZE (i.e., number of elements) in an array, compute an
5956    appropriate index type for the array.  If non-NULL, NAME is the
5957    name of the thing being declared.  */
5958
5959 tree
5960 compute_array_index_type (tree name, tree size)
5961 {
5962   tree type = TREE_TYPE (size);
5963   tree itype;
5964
5965   /* The array bound must be an integer type.  */
5966   if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
5967     {
5968       if (name)
5969         error ("size of array `%D' has non-integral type `%T'", name, type);
5970       else
5971         error ("size of array has non-integral type `%T'", type);
5972       size = integer_one_node;
5973       type = TREE_TYPE (size);
5974     }
5975
5976   if (abi_version_at_least (2)
5977       /* We should only handle value dependent expressions specially.  */
5978       ? value_dependent_expression_p (size)
5979       /* But for abi-1, we handled all instances in templates. This
5980          effects the manglings produced.  */
5981       : processing_template_decl)
5982     return build_index_type (build_min (MINUS_EXPR, sizetype,
5983                                         size, integer_one_node));
5984
5985   /* The size might be the result of a cast.  */
5986   STRIP_TYPE_NOPS (size);
5987
5988   /* It might be a const variable or enumeration constant.  */
5989   size = decl_constant_value (size);
5990
5991   /* Normally, the array-bound will be a constant.  */
5992   if (TREE_CODE (size) == INTEGER_CST)
5993     {
5994       /* Check to see if the array bound overflowed.  Make that an
5995          error, no matter how generous we're being.  */
5996       int old_flag_pedantic_errors = flag_pedantic_errors;
5997       int old_pedantic = pedantic;
5998       pedantic = flag_pedantic_errors = 1;
5999       constant_expression_warning (size);
6000       pedantic = old_pedantic;
6001       flag_pedantic_errors = old_flag_pedantic_errors;
6002
6003       /* An array must have a positive number of elements.  */
6004       if (INT_CST_LT (size, integer_zero_node))
6005         {
6006           if (name)
6007             error ("size of array `%D' is negative", name);
6008           else
6009             error ("size of array is negative");
6010           size = integer_one_node;
6011         }
6012       /* As an extension we allow zero-sized arrays.  We always allow
6013          them in system headers because glibc uses them.  */
6014       else if (integer_zerop (size) && pedantic && !in_system_header)
6015         {
6016           if (name)
6017             pedwarn ("ISO C++ forbids zero-size array `%D'", name);
6018           else
6019             pedwarn ("ISO C++ forbids zero-size array");
6020         }
6021     }
6022   else if (TREE_CONSTANT (size))
6023     {
6024       /* `(int) &fn' is not a valid array bound.  */
6025       if (name)
6026         error ("size of array `%D' is not an integral constant-expression",
6027                   name);
6028       else
6029         error ("size of array is not an integral constant-expression");
6030     }
6031   else if (pedantic)
6032     {
6033       if (name)
6034         pedwarn ("ISO C++ forbids variable-size array `%D'", name);
6035       else
6036         pedwarn ("ISO C++ forbids variable-size array");
6037     }
6038
6039   if (processing_template_decl && !TREE_CONSTANT (size))
6040     /* A variable sized array.  */
6041     itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6042   else
6043     {
6044       /* Compute the index of the largest element in the array.  It is
6045          one less than the number of elements in the array.  */
6046       itype
6047         = fold (cp_build_binary_op (MINUS_EXPR,
6048                                     cp_convert (ssizetype, size),
6049                                     cp_convert (ssizetype, integer_one_node)));
6050       if (!TREE_CONSTANT (itype))
6051         /* A variable sized array.  */
6052         itype = variable_size (itype);
6053       /* Make sure that there was no overflow when creating to a signed
6054          index type.  (For example, on a 32-bit machine, an array with
6055          size 2^32 - 1 is too big.)  */
6056       else if (TREE_OVERFLOW (itype))
6057         {
6058           error ("overflow in array dimension");
6059           TREE_OVERFLOW (itype) = 0;
6060         }
6061     }
6062
6063   /* Create and return the appropriate index type.  */
6064   return build_index_type (itype);
6065 }
6066
6067 /* Returns the scope (if any) in which the entity declared by
6068    DECLARATOR will be located.  If the entity was declared with an
6069    unqualified name, NULL_TREE is returned.  */
6070
6071 tree
6072 get_scope_of_declarator (const cp_declarator *declarator)
6073 {
6074   while (declarator && declarator->kind != cdk_id)
6075     declarator = declarator->declarator;
6076
6077   /* If the declarator-id is a SCOPE_REF, the scope in which the
6078      declaration occurs is the first operand.  */
6079   if (declarator
6080       && declarator->u.id.name
6081       && TREE_CODE (declarator->u.id.name) == SCOPE_REF)
6082     return TREE_OPERAND (declarator->u.id.name, 0);
6083
6084   /* Otherwise, the declarator is not a quablified name; the entity will
6085      be declared in the current scope.  */
6086   return NULL_TREE;
6087 }
6088
6089 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6090    indicated TYPE.  If non-NULL, NAME is the NAME of the declaration
6091    with this type.  */
6092
6093 static tree
6094 create_array_type_for_decl (tree name, tree type, tree size)
6095 {
6096   tree itype = NULL_TREE;
6097   const char* error_msg;
6098
6099   /* If things have already gone awry, bail now.  */
6100   if (type == error_mark_node || size == error_mark_node)
6101     return error_mark_node;
6102
6103   /* Assume that everything will go OK.  */
6104   error_msg = NULL;
6105
6106   /* There are some types which cannot be array elements.  */
6107   switch (TREE_CODE (type))
6108     {
6109     case VOID_TYPE:
6110       error_msg = "array of void";
6111       break;
6112
6113     case FUNCTION_TYPE:
6114       error_msg = "array of functions";
6115       break;
6116
6117     case REFERENCE_TYPE:
6118       error_msg = "array of references";
6119       break;
6120
6121     case METHOD_TYPE:
6122       error_msg = "array of function members";
6123       break;
6124
6125     default:
6126       break;
6127     }
6128
6129   /* If something went wrong, issue an error-message and return.  */
6130   if (error_msg)
6131     {
6132       if (name)
6133         error ("declaration of `%D' as %s", name, error_msg);
6134       else
6135         error ("creating %s", error_msg);
6136
6137       return error_mark_node;
6138     }
6139
6140   /* [dcl.array]
6141
6142      The constant expressions that specify the bounds of the arrays
6143      can be omitted only for the first member of the sequence.  */
6144   if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6145     {
6146       if (name)
6147         error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
6148                   name);
6149       else
6150         error ("multidimensional array must have bounds for all dimensions except the first");
6151
6152       return error_mark_node;
6153     }
6154
6155   /* Figure out the index type for the array.  */
6156   if (size)
6157     itype = compute_array_index_type (name, size);
6158
6159   /* [dcl.array]
6160      T is called the array element type; this type shall not be [...] an
6161      abstract class type.  */
6162   abstract_virtuals_error (name, type);
6163
6164   return build_cplus_array_type (type, itype);
6165 }
6166
6167 /* Check that it's OK to declare a function with the indicated TYPE.
6168    SFK indicates the kind of special function (if any) that this
6169    function is.  OPTYPE is the type given in a conversion operator
6170    declaration.  Returns the actual return type of the function; that
6171    may be different than TYPE if an error occurs, or for certain
6172    special functions.  */
6173
6174 static tree
6175 check_special_function_return_type (special_function_kind sfk,
6176                                     tree type,
6177                                     tree optype)
6178 {
6179   switch (sfk)
6180     {
6181     case sfk_constructor:
6182       if (type)
6183         error ("return type specification for constructor invalid");
6184
6185       type = void_type_node;
6186       break;
6187
6188     case sfk_destructor:
6189       if (type)
6190         error ("return type specification for destructor invalid");
6191       type = void_type_node;
6192       break;
6193
6194     case sfk_conversion:
6195       if (type && !same_type_p (type, optype))
6196         error ("operator `%T' declared to return `%T'", optype, type);
6197       else if (type)
6198         pedwarn ("return type specified for `operator %T'",  optype);
6199       type = optype;
6200       break;
6201
6202     default:
6203       abort ();
6204       break;
6205     }
6206
6207   return type;
6208 }
6209
6210 /* Given declspecs and a declarator (abstract or otherwise), determine
6211    the name and type of the object declared and construct a DECL node
6212    for it.
6213
6214    DECLSPECS is a chain of tree_list nodes whose value fields
6215     are the storage classes and type specifiers.
6216
6217    DECL_CONTEXT says which syntactic context this declaration is in:
6218      NORMAL for most contexts.  Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6219      FUNCDEF for a function definition.  Like NORMAL but a few different
6220       error messages in each case.  Return value may be zero meaning
6221       this definition is too screwy to try to parse.
6222      MEMFUNCDEF for a function definition.  Like FUNCDEF but prepares to
6223       handle member functions (which have FIELD context).
6224       Return value may be zero meaning this definition is too screwy to
6225       try to parse.
6226      PARM for a parameter declaration (either within a function prototype
6227       or before a function body).  Make a PARM_DECL, or return void_type_node.
6228      CATCHPARM for a parameter declaration before a catch clause.
6229      TYPENAME if for a typename (in a cast or sizeof).
6230       Don't make a DECL node; just return the ..._TYPE node.
6231      FIELD for a struct or union field; make a FIELD_DECL.
6232      BITFIELD for a field with specified width.
6233    INITIALIZED is 1 if the decl has an initializer.
6234
6235    ATTRLIST is a pointer to the list of attributes, which may be NULL
6236    if there are none; *ATTRLIST may be modified if attributes from inside
6237    the declarator should be applied to the declaration.
6238
6239    When this function is called, scoping variables (such as
6240    CURRENT_CLASS_TYPE) should reflect the scope in which the
6241    declaration occurs, not the scope in which the new declaration will
6242    be placed.  For example, on:
6243
6244      void S::f() { ... }
6245
6246    when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6247    should not be `S'.  */
6248
6249 tree
6250 grokdeclarator (const cp_declarator *declarator,
6251                 const cp_decl_specifier_seq *declspecs,
6252                 enum decl_context decl_context,
6253                 int initialized,
6254                 tree* attrlist)
6255 {
6256   tree type = NULL_TREE;
6257   int longlong = 0;
6258   int type_quals;
6259   int virtualp, explicitp, friendp, inlinep, staticp;
6260   int explicit_int = 0;
6261   int explicit_char = 0;
6262   int defaulted_int = 0;
6263   tree dependant_name = NULL_TREE;
6264
6265   tree typedef_decl = NULL_TREE;
6266   const char *name = NULL;
6267   tree typedef_type = NULL_TREE;
6268   int funcdef_flag = 0;
6269   cp_declarator_kind innermost_code = cdk_error;
6270   int bitfield = 0;
6271 #if 0
6272   /* See the code below that used this.  */
6273   tree decl_attr = NULL_TREE;
6274 #endif
6275
6276   /* Keep track of what sort of function is being processed
6277      so that we can warn about default return values, or explicit
6278      return values which do not match prescribed defaults.  */
6279   special_function_kind sfk = sfk_none;
6280
6281   tree dname = NULL_TREE;
6282   tree ctor_return_type = NULL_TREE;
6283   enum overload_flags flags = NO_SPECIAL;
6284   cp_cv_quals quals = TYPE_UNQUALIFIED;
6285   tree raises = NULL_TREE;
6286   int template_count = 0;
6287   tree returned_attrs = NULL_TREE;
6288   tree parms = NULL_TREE;
6289   const cp_declarator *id_declarator;
6290   /* The unqualified name of the declarator; either an
6291      IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR.  */
6292   tree unqualified_id;
6293   /* The class type, if any, in which this entity is located,
6294      or NULL_TREE if none.  Note that this value may be different from
6295      the current class type; for example if an attempt is made to declare
6296      "A::f" inside "B", this value will be "A".  */
6297   tree ctype = current_class_type;
6298   /* The NAMESPACE_DECL for the namespace in which this entity is
6299      located.  If an unqualified name is used to declare the entity,
6300      this value will be NULL_TREE, even if the entity is located at
6301      namespace scope.  */
6302   tree in_namespace = NULL_TREE;
6303   cp_decl_spec ds;
6304   cp_storage_class storage_class;
6305   bool unsigned_p, signed_p, short_p, long_p, thread_p;
6306
6307   signed_p = declspecs->specs[(int)ds_signed];
6308   unsigned_p = declspecs->specs[(int)ds_unsigned];
6309   short_p = declspecs->specs[(int)ds_short];
6310   long_p = declspecs->specs[(int)ds_long];
6311   thread_p = declspecs->specs[(int)ds_thread];
6312
6313   if (decl_context == FUNCDEF)
6314     funcdef_flag = 1, decl_context = NORMAL;
6315   else if (decl_context == MEMFUNCDEF)
6316     funcdef_flag = -1, decl_context = FIELD;
6317   else if (decl_context == BITFIELD)
6318     bitfield = 1, decl_context = FIELD;
6319
6320   /* Look inside a declarator for the name being declared
6321      and get it as a string, for an error message.  */
6322   for (id_declarator = declarator;
6323        id_declarator;
6324        id_declarator = id_declarator->declarator)
6325     {
6326       if (id_declarator->kind != cdk_id)
6327         innermost_code = id_declarator->kind;
6328
6329       switch (id_declarator->kind)
6330         {
6331         case cdk_function:
6332           if (id_declarator->declarator
6333               && id_declarator->declarator->kind == cdk_id)
6334             {
6335               sfk = id_declarator->declarator->u.id.sfk;
6336               if (sfk == sfk_destructor)
6337                 flags = DTOR_FLAG;
6338             }
6339           break;
6340
6341         case cdk_id:
6342           {
6343             tree decl = id_declarator->u.id.name;
6344             if (!decl)
6345               break;
6346             if (TREE_CODE (decl) == SCOPE_REF)
6347               {
6348                 tree qualifying_scope = TREE_OPERAND (decl, 0);
6349 ;
6350                 /* It is valid to write:
6351
6352                    class C { void f(); };
6353                    typedef C D;
6354                    void D::f();
6355
6356                  The standard is not clear about whether `typedef const C D' is
6357                  legal; as of 2002-09-15 the committee is considering
6358                  that question.  EDG 3.0 allows that syntax.
6359                  Therefore, we do as well.  */
6360                 if (qualifying_scope && TYPE_P (qualifying_scope))
6361                   {
6362                     ctype = TYPE_MAIN_VARIANT (qualifying_scope);
6363                     if (innermost_code != cdk_function
6364                         && current_class_type
6365                         && !UNIQUELY_DERIVED_FROM_P (ctype,
6366                                                      current_class_type))
6367                       {
6368                         error ("type `%T' is not derived from type `%T'",
6369                                ctype, current_class_type);
6370                         ctype = NULL_TREE;
6371                       }
6372                     TREE_OPERAND (decl, 0) = ctype;
6373                   }
6374                 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6375                   in_namespace = qualifying_scope;
6376                 decl = TREE_OPERAND (decl, 1);
6377               }
6378             if (TREE_CODE (decl) == BASELINK)
6379               decl = BASELINK_FUNCTIONS (decl);
6380             if (decl == error_mark_node)
6381               return error_mark_node;
6382             switch (TREE_CODE (decl))
6383               {
6384               case BIT_NOT_EXPR:
6385                 {
6386                   tree type = TREE_OPERAND (decl, 0);
6387                   type = constructor_name (type);
6388                   name = IDENTIFIER_POINTER (type);
6389                 }
6390                 break;
6391
6392               case TEMPLATE_ID_EXPR:
6393                 {
6394                   tree fns = TREE_OPERAND (decl, 0);
6395
6396                   dname = fns;
6397                   if (TREE_CODE (dname) == COMPONENT_REF)
6398                     dname = TREE_OPERAND (dname, 1);
6399                   if (TREE_CODE (dname) != IDENTIFIER_NODE)
6400                     {
6401                       my_friendly_assert (is_overloaded_fn (dname),
6402                                           19990331);
6403                       dname = DECL_NAME (get_first_fn (dname));
6404                     }
6405                 }
6406                 /* Fall through.  */
6407
6408               case IDENTIFIER_NODE:
6409                 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6410                   dname = decl;
6411
6412                 if (C_IS_RESERVED_WORD (dname))
6413                   {
6414                     error ("declarator-id missing; using reserved word `%D'",
6415                            dname);
6416                     name = IDENTIFIER_POINTER (dname);
6417                   }
6418                 else if (!IDENTIFIER_TYPENAME_P (dname))
6419                   name = IDENTIFIER_POINTER (dname);
6420                 else
6421                   {
6422                     my_friendly_assert (flags == NO_SPECIAL, 154);
6423                     flags = TYPENAME_FLAG;
6424                     ctor_return_type = TREE_TYPE (dname);
6425                     sfk = sfk_conversion;
6426                     if (is_typename_at_global_scope (dname))
6427                       name = IDENTIFIER_POINTER (dname);
6428                     else
6429                       name = "<invalid operator>";
6430                   }
6431                 break;
6432
6433               case TYPE_DECL:
6434                 dname = constructor_name (TREE_TYPE (decl));
6435                 name = IDENTIFIER_POINTER (dname);
6436                 break;
6437
6438               default:
6439                 abort ();
6440               }
6441             break;
6442
6443           case cdk_array:
6444           case cdk_pointer:
6445           case cdk_reference:
6446           case cdk_ptrmem:
6447             break;
6448
6449           case cdk_error:
6450             break;
6451
6452           default:
6453             abort ();
6454           }
6455         }
6456       if (id_declarator->kind == cdk_id)
6457         break;
6458     }
6459
6460   /* A function definition's declarator must have the form of
6461      a function declarator.  */
6462
6463   if (funcdef_flag && innermost_code != cdk_function)
6464     return 0;
6465
6466   if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6467       && innermost_code != cdk_function
6468       && ! (ctype && !declspecs->any_specifiers_p))
6469     {
6470       error ("declaration of `%D' as non-function", dname);
6471       return void_type_node;
6472     }
6473
6474   /* Anything declared one level down from the top level
6475      must be one of the parameters of a function
6476      (because the body is at least two levels down).  */
6477
6478   /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6479      by not allowing C++ class definitions to specify their parameters
6480      with xdecls (must be spec.d in the parmlist).
6481
6482      Since we now wait to push a class scope until we are sure that
6483      we are in a legitimate method context, we must set oldcname
6484      explicitly (since current_class_name is not yet alive).
6485
6486      We also want to avoid calling this a PARM if it is in a namespace.  */
6487
6488   if (decl_context == NORMAL && !toplevel_bindings_p ())
6489     {
6490       struct cp_binding_level *b = current_binding_level;
6491       current_binding_level = b->level_chain;
6492       if (current_binding_level != 0 && toplevel_bindings_p ())
6493         decl_context = PARM;
6494       current_binding_level = b;
6495     }
6496
6497   if (name == NULL)
6498     name = decl_context == PARM ? "parameter" : "type name";
6499
6500   /* If there were multiple types specified in the decl-specifier-seq,
6501      issue an error message.  */
6502   if (declspecs->multiple_types_p)
6503     error ("two or more data types in declaration of `%s'", name);
6504   /* Extract the basic type from the decl-specifier-seq.  */
6505   type = declspecs->type;
6506   if (type == error_mark_node)
6507     type = NULL_TREE;
6508   /* If the entire declaration is itself tagged as deprecated then
6509      suppress reports of deprecated items.  */
6510   if (type && TREE_DEPRECATED (type)
6511       && deprecated_state != DEPRECATED_SUPPRESS)
6512     warn_deprecated_use (type);
6513   if (type && TREE_CODE (type) == TYPE_DECL)
6514     {
6515       typedef_decl = type;
6516       type = TREE_TYPE (typedef_decl);
6517     }
6518   /* No type at all: default to `int', and set DEFAULTED_INT
6519      because it was not a user-defined typedef.  */
6520   if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
6521     {
6522       /* These imply 'int'.  */
6523       type = integer_type_node;
6524       defaulted_int = 1;
6525     }
6526   /* Gather flags.  */
6527   explicit_int = declspecs->explicit_int_p;
6528   explicit_char = declspecs->explicit_char_p;
6529
6530   /* Check for repeated decl-specifiers.  */
6531   for (ds = ds_first; ds != ds_last; ++ds)
6532     {
6533       unsigned count = declspecs->specs[(int)ds];
6534       if (count < 2)
6535         continue;
6536       /* The "long" specifier is a special case because of
6537          "long long".  */
6538       if (ds == ds_long)
6539         {
6540           if (count > 2)
6541             error ("`long long long' is too long for GCC");
6542           else if (pedantic && !in_system_header && warn_long_long)
6543             pedwarn ("ISO C++ does not support `long long'");
6544           else
6545             longlong = 1;
6546         }
6547       else if (declspecs->specs[(int)ds] > 1)
6548         {
6549           static const char *const decl_spec_names[] = {
6550             "signed",
6551             "unsigned",
6552             "short",
6553             "long",
6554             "const",
6555             "volatile",
6556             "restrict",
6557             "inline",
6558             "virtual",
6559             "explicit",
6560             "friend",
6561             "typedef",
6562             "__complex",
6563             "__thread"
6564           };
6565           error ("duplicate `%s'", decl_spec_names[(int)ds]);
6566         }
6567     }
6568
6569 #if 0
6570   /* See the code below that used this.  */
6571   if (typedef_decl)
6572     decl_attr = DECL_ATTRIBUTES (typedef_decl);
6573 #endif
6574   typedef_type = type;
6575
6576
6577   if (sfk != sfk_none)
6578     type = check_special_function_return_type (sfk, type,
6579                                                ctor_return_type);
6580   else if (type == NULL_TREE)
6581     {
6582       int is_main;
6583
6584       explicit_int = -1;
6585
6586       /* We handle `main' specially here, because 'main () { }' is so
6587          common.  With no options, it is allowed.  With -Wreturn-type,
6588          it is a warning.  It is only an error with -pedantic-errors.  */
6589       is_main = (funcdef_flag
6590                  && dname && MAIN_NAME_P (dname)
6591                  && ctype == NULL_TREE
6592                  && in_namespace == NULL_TREE
6593                  && current_namespace == global_namespace);
6594
6595       if (in_system_header || flag_ms_extensions)
6596         /* Allow it, sigh.  */;
6597       else if (pedantic || ! is_main)
6598         pedwarn ("ISO C++ forbids declaration of `%s' with no type",
6599                     name);
6600       else if (warn_return_type)
6601         warning ("ISO C++ forbids declaration of `%s' with no type",
6602                     name);
6603
6604       type = integer_type_node;
6605     }
6606
6607   ctype = NULL_TREE;
6608
6609   /* Now process the modifiers that were specified
6610      and check for invalid combinations.  */
6611
6612   /* Long double is a special combination.  */
6613   if (long_p && TYPE_MAIN_VARIANT (type) == double_type_node)
6614     {
6615       long_p = false;
6616       type = build_qualified_type (long_double_type_node,
6617                                    cp_type_quals (type));
6618     }
6619
6620   /* Check all other uses of type modifiers.  */
6621
6622   if (unsigned_p || signed_p || long_p || short_p)
6623     {
6624       int ok = 0;
6625
6626       if (TREE_CODE (type) == REAL_TYPE)
6627         error ("short, signed or unsigned invalid for `%s'", name);
6628       else if (TREE_CODE (type) != INTEGER_TYPE)
6629         error ("long, short, signed or unsigned invalid for `%s'", name);
6630       else if (long_p && short_p)
6631         error ("long and short specified together for `%s'", name);
6632       else if ((long_p || short_p) && explicit_char)
6633         error ("long or short specified with char for `%s'", name);
6634       else if ((long_p|| short_p) && TREE_CODE (type) == REAL_TYPE)
6635         error ("long or short specified with floating type for `%s'", name);
6636       else if (signed_p && unsigned_p)
6637         error ("signed and unsigned given together for `%s'", name);
6638       else
6639         {
6640           ok = 1;
6641           if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6642             {
6643               pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
6644                        name);
6645               if (flag_pedantic_errors)
6646                 ok = 0;
6647             }
6648         }
6649
6650       /* Discard the type modifiers if they are invalid.  */
6651       if (! ok)
6652         {
6653           unsigned_p = false;
6654           signed_p = false;
6655           long_p = false;
6656           short_p = false;
6657           longlong = 0;
6658         }
6659     }
6660
6661   /* Decide whether an integer type is signed or not.
6662      Optionally treat bitfields as signed by default.  */
6663   if (unsigned_p
6664       /* [class.bit]
6665
6666          It is implementation-defined whether a plain (neither
6667          explicitly signed or unsigned) char, short, int, or long
6668          bit-field is signed or unsigned.
6669
6670          Naturally, we extend this to long long as well.  Note that
6671          this does not include wchar_t.  */
6672       || (bitfield && !flag_signed_bitfields
6673           && !signed_p
6674           /* A typedef for plain `int' without `signed' can be
6675              controlled just like plain `int', but a typedef for
6676              `signed int' cannot be so controlled.  */
6677           && !(typedef_decl
6678                && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
6679           && (TREE_CODE (type) == INTEGER_TYPE
6680               || TREE_CODE (type) == CHAR_TYPE)
6681           && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
6682     {
6683       if (longlong)
6684         type = long_long_unsigned_type_node;
6685       else if (long_p)
6686         type = long_unsigned_type_node;
6687       else if (short_p)
6688         type = short_unsigned_type_node;
6689       else if (type == char_type_node)
6690         type = unsigned_char_type_node;
6691       else if (typedef_decl)
6692         type = c_common_unsigned_type (type);
6693       else
6694         type = unsigned_type_node;
6695     }
6696   else if (signed_p && type == char_type_node)
6697     type = signed_char_type_node;
6698   else if (longlong)
6699     type = long_long_integer_type_node;
6700   else if (long_p)
6701     type = long_integer_type_node;
6702   else if (short_p)
6703     type = short_integer_type_node;
6704
6705   if (declspecs->specs[(int)ds_complex])
6706     {
6707       if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
6708         error ("complex invalid for `%s'", name);
6709       /* If we just have "complex", it is equivalent to
6710          "complex double", but if any modifiers at all are specified it is
6711          the complex form of TYPE.  E.g, "complex short" is
6712          "complex short int".  */
6713
6714       else if (defaulted_int && ! longlong
6715                && ! (long_p || short_p || signed_p || unsigned_p))
6716         type = complex_double_type_node;
6717       else if (type == integer_type_node)
6718         type = complex_integer_type_node;
6719       else if (type == float_type_node)
6720         type = complex_float_type_node;
6721       else if (type == double_type_node)
6722         type = complex_double_type_node;
6723       else if (type == long_double_type_node)
6724         type = complex_long_double_type_node;
6725       else
6726         type = build_complex_type (type);
6727     }
6728
6729   type_quals = TYPE_UNQUALIFIED;
6730   if (declspecs->specs[(int)ds_const])
6731     type_quals |= TYPE_QUAL_CONST;
6732   if (declspecs->specs[(int)ds_volatile])
6733     type_quals |= TYPE_QUAL_VOLATILE;
6734   if (declspecs->specs[(int)ds_restrict])
6735     type_quals |= TYPE_QUAL_RESTRICT;
6736   if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
6737     error ("qualifiers are not allowed on declaration of `operator %T'",
6738               ctor_return_type);
6739
6740   type_quals |= cp_type_quals (type);
6741   type = cp_build_qualified_type_real
6742     (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
6743                          ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
6744   /* We might have ignored or rejected some of the qualifiers.  */
6745   type_quals = cp_type_quals (type);
6746
6747   staticp = 0;
6748   inlinep = !! declspecs->specs[(int)ds_inline];
6749   virtualp = !! declspecs->specs[(int)ds_virtual];
6750   explicitp = !! declspecs->specs[(int)ds_explicit];
6751
6752   storage_class = declspecs->storage_class;
6753   if (storage_class == sc_static)
6754     staticp = 1 + (decl_context == FIELD);
6755
6756   if (virtualp && staticp == 2)
6757     {
6758       error ("member `%D' cannot be declared both virtual and static",
6759                 dname);
6760       staticp = 0;
6761     }
6762   friendp = !! declspecs->specs[(int)ds_friend];
6763
6764   if (dependant_name && !friendp)
6765     {
6766       error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
6767       return void_type_node;
6768     }
6769
6770   /* Issue errors about use of storage classes for parameters.  */
6771   if (decl_context == PARM)
6772     {
6773       if (declspecs->specs[(int)ds_typedef])
6774         error ("typedef declaration invalid in parameter declaration");
6775       else if (storage_class == sc_static
6776                || storage_class == sc_extern
6777                || thread_p)
6778         error ("storage class specifiers invalid in parameter declarations");
6779     }
6780
6781   /* Give error if `virtual' is used outside of class declaration.  */
6782   if (virtualp
6783       && (current_class_name == NULL_TREE || decl_context != FIELD))
6784     {
6785       error ("virtual outside class declaration");
6786       virtualp = 0;
6787     }
6788
6789   /* Static anonymous unions are dealt with here.  */
6790   if (staticp && decl_context == TYPENAME
6791       && declspecs->type
6792       && ANON_AGGR_TYPE_P (declspecs->type))
6793     decl_context = FIELD;
6794
6795   /* Warn about storage classes that are invalid for certain
6796      kinds of declarations (parameters, typenames, etc.).  */
6797   if (declspecs->multiple_storage_classes_p)
6798     error ("multiple storage classes in declaration of `%s'", name);
6799   else if (thread_p
6800            && ((storage_class
6801                 && storage_class != sc_extern
6802                 && storage_class != sc_static)
6803                || declspecs->specs[(int)ds_typedef]))
6804     {
6805       error ("multiple storage classes in declaration of `%s'", name);
6806       thread_p = false;
6807     }
6808   else if (decl_context != NORMAL
6809            && ((storage_class != sc_none
6810                 && storage_class != sc_mutable)
6811                || thread_p))
6812     {
6813       if ((decl_context == PARM || decl_context == CATCHPARM)
6814           && (storage_class == sc_register
6815               || storage_class == sc_auto))
6816         ;
6817       else if (declspecs->specs[(int)ds_typedef])
6818         ;
6819       else if (decl_context == FIELD
6820                /* C++ allows static class elements.  */
6821                && storage_class == sc_static)
6822         /* C++ also allows inlines and signed and unsigned elements,
6823            but in those cases we don't come in here.  */
6824         ;
6825       else
6826         {
6827           if (decl_context == FIELD)
6828             {
6829               tree tmp = NULL_TREE;
6830               int op = 0;
6831
6832               if (declarator)
6833                 {
6834                   /* Avoid trying to get an operand off an identifier node.  */
6835                   if (declarator->kind != cdk_id)
6836                     tmp = declarator->declarator->u.id.name;
6837                   else
6838                     tmp = declarator->u.id.name;
6839                   op = IDENTIFIER_OPNAME_P (tmp);
6840                   if (IDENTIFIER_TYPENAME_P (tmp))
6841                     {
6842                       if (is_typename_at_global_scope (tmp))
6843                         name = IDENTIFIER_POINTER (tmp);
6844                       else
6845                         name = "<invalid operator>";
6846                     }
6847                 }
6848               error ("storage class specified for %s `%s'",
6849                      op ? "member operator" : "field",
6850                      name);
6851             }
6852           else
6853             {
6854               if (decl_context == PARM || decl_context == CATCHPARM)
6855                 error ("storage class specified for parameter `%s'", name);
6856               else
6857                 error ("storage class specified for typename");
6858             }
6859           if (storage_class == sc_register
6860               || storage_class == sc_auto
6861               || storage_class == sc_extern
6862               || thread_p)
6863             storage_class = sc_none;
6864         }
6865     }
6866   else if (storage_class == sc_extern && initialized
6867            && !funcdef_flag)
6868     {
6869       if (toplevel_bindings_p ())
6870         {
6871           /* It's common practice (and completely valid) to have a const
6872              be initialized and declared extern.  */
6873           if (!(type_quals & TYPE_QUAL_CONST))
6874             warning ("`%s' initialized and declared `extern'", name);
6875         }
6876       else
6877         error ("`%s' has both `extern' and initializer", name);
6878     }
6879   else if (storage_class == sc_extern && funcdef_flag
6880            && ! toplevel_bindings_p ())
6881     error ("nested function `%s' declared `extern'", name);
6882   else if (toplevel_bindings_p ())
6883     {
6884       if (storage_class == sc_auto)
6885         error ("top-level declaration of `%s' specifies `auto'", name);
6886     }
6887   else if (thread_p
6888            && storage_class != sc_extern
6889            && storage_class != sc_static)
6890     {
6891       error ("function-scope `%s' implicitly auto and declared `__thread'",
6892              name);
6893       thread_p = false;
6894     }
6895
6896   if (storage_class && friendp)
6897     error ("storage class specifiers invalid in friend function declarations");
6898
6899   if (!id_declarator)
6900     unqualified_id = NULL_TREE;
6901   else
6902     {
6903       unqualified_id = id_declarator->u.id.name;
6904       if (TREE_CODE (unqualified_id) == SCOPE_REF)
6905         unqualified_id = TREE_OPERAND (unqualified_id, 1);
6906       if (TREE_CODE (unqualified_id) == BASELINK)
6907         unqualified_id = BASELINK_FUNCTIONS (unqualified_id);
6908       switch (TREE_CODE (unqualified_id))
6909         {
6910         case BIT_NOT_EXPR:
6911           unqualified_id
6912             = constructor_name (TREE_OPERAND (unqualified_id, 0));
6913           break;
6914
6915         case TYPE_DECL:
6916           unqualified_id
6917             = constructor_name (TREE_TYPE (unqualified_id));
6918           break;
6919
6920         case IDENTIFIER_NODE:
6921         case TEMPLATE_ID_EXPR:
6922           break;
6923
6924         default:
6925           abort ();
6926         }
6927     }
6928
6929   /* Determine the type of the entity declared by recurring on the
6930      declarator.  */
6931   for (;
6932        declarator && declarator->kind != cdk_id;
6933        declarator = declarator->declarator)
6934     {
6935       const cp_declarator *inner_declarator;
6936       tree attrs;
6937
6938       if (type == error_mark_node)
6939         return error_mark_node;
6940
6941       inner_declarator = declarator->declarator;
6942
6943       attrs = declarator->attributes;
6944       if (attrs)
6945         {
6946           int attr_flags;
6947
6948           attr_flags = 0;
6949           if (declarator == NULL || declarator->kind == cdk_id)
6950             attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
6951           if (declarator->kind == cdk_function)
6952             attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
6953           if (declarator->kind == cdk_array)
6954             attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
6955           returned_attrs = decl_attributes (&type,
6956                                             chainon (returned_attrs, attrs),
6957                                             attr_flags);
6958         }
6959
6960       switch (declarator->kind)
6961         {
6962         case cdk_array:
6963           type = create_array_type_for_decl (dname, type,
6964                                              declarator->u.array.bounds);
6965           if (inner_declarator
6966               && (inner_declarator->kind == cdk_pointer
6967                   || inner_declarator->kind == cdk_reference
6968                   || inner_declarator->kind == cdk_ptrmem))
6969             /* We can never complete an array type which is the
6970                target of a pointer, so go ahead and lay it out.  */
6971             layout_type (type);
6972           break;
6973
6974         case cdk_function:
6975           {
6976             tree arg_types;
6977             int funcdecl_p;
6978
6979             /* Declaring a function type.
6980                Make sure we have a valid type for the function to return.  */
6981
6982             /* We now know that the TYPE_QUALS don't apply to the
6983                decl, but to its return type.  */
6984             type_quals = TYPE_UNQUALIFIED;
6985
6986             /* Warn about some types functions can't return.  */
6987
6988             if (TREE_CODE (type) == FUNCTION_TYPE)
6989               {
6990                 error ("`%s' declared as function returning a function", name);
6991                 type = integer_type_node;
6992               }
6993             if (TREE_CODE (type) == ARRAY_TYPE)
6994               {
6995                 error ("`%s' declared as function returning an array", name);
6996                 type = integer_type_node;
6997               }
6998
6999             /* Pick up type qualifiers which should be applied to `this'.  */
7000             quals = declarator->u.function.qualifiers;
7001
7002             /* Pick up the exception specifications.  */
7003             raises = declarator->u.function.exception_specification;
7004
7005             /* Say it's a definition only for the CALL_EXPR
7006                closest to the identifier.  */
7007             funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7008
7009             if (ctype == NULL_TREE
7010                 && decl_context == FIELD
7011                 && funcdecl_p
7012                 && (friendp == 0 || dname == current_class_name))
7013               ctype = current_class_type;
7014
7015             if (ctype && sfk == sfk_conversion)
7016               TYPE_HAS_CONVERSION (ctype) = 1;
7017             if (ctype && (sfk == sfk_constructor
7018                           || sfk == sfk_destructor))
7019               {
7020                 /* We are within a class's scope. If our declarator name
7021                    is the same as the class name, and we are defining
7022                    a function, then it is a constructor/destructor, and
7023                    therefore returns a void type.  */
7024
7025                 if (flags == DTOR_FLAG)
7026                   {
7027                     /* ISO C++ 12.4/2.  A destructor may not be
7028                        declared const or volatile.  A destructor may
7029                        not be static.  */
7030                     if (staticp == 2)
7031                       error ("destructor cannot be static member function");
7032                     if (quals)
7033                       {
7034                         error ("destructors may not be cv-qualified");
7035                         quals = TYPE_UNQUALIFIED;
7036                       }
7037                     if (decl_context == FIELD)
7038                       {
7039                         if (! member_function_or_else (ctype,
7040                                                        current_class_type,
7041                                                        flags))
7042                           return void_type_node;
7043                       }
7044                   }
7045                 else            /* It's a constructor.  */
7046                   {
7047                     if (explicitp == 1)
7048                       explicitp = 2;
7049                     /* ISO C++ 12.1.  A constructor may not be
7050                        declared const or volatile.  A constructor may
7051                        not be virtual.  A constructor may not be
7052                        static.  */
7053                     if (staticp == 2)
7054                       error ("constructor cannot be static member function");
7055                     if (virtualp)
7056                       {
7057                         pedwarn ("constructors cannot be declared virtual");
7058                         virtualp = 0;
7059                       }
7060                     if (quals)
7061                       {
7062                         error ("constructors may not be cv-qualified");
7063                         quals = TYPE_UNQUALIFIED;
7064                       }
7065                     if (decl_context == FIELD)
7066                       {
7067                         if (! member_function_or_else (ctype,
7068                                                        current_class_type,
7069                                                        flags))
7070                           return void_type_node;
7071                         TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7072                         if (sfk != sfk_constructor)
7073                           return NULL_TREE;
7074                       }
7075                   }
7076                 if (decl_context == FIELD)
7077                   staticp = 0;
7078               }
7079             else if (friendp)
7080               {
7081                 if (initialized)
7082                   error ("can't initialize friend function `%s'", name);
7083                 if (virtualp)
7084                   {
7085                     /* Cannot be both friend and virtual.  */
7086                     error ("virtual functions cannot be friends");
7087                     friendp = 0;
7088                   }
7089                 if (decl_context == NORMAL)
7090                   error ("friend declaration not in class definition");
7091                 if (current_function_decl && funcdef_flag)
7092                   error ("can't define friend function `%s' in a local class definition",
7093                             name);
7094               }
7095
7096             arg_types = grokparms (declarator->u.function.parameters,
7097                                    &parms);
7098
7099             if (inner_declarator
7100                 && inner_declarator->kind == cdk_id
7101                 && inner_declarator->u.id.sfk == sfk_destructor
7102                 && arg_types != void_list_node)
7103               {
7104                 error ("destructors may not have parameters");
7105                 arg_types = void_list_node;
7106                 parms = NULL_TREE;
7107               }
7108
7109             type = build_function_type (type, arg_types);
7110           }
7111           break;
7112
7113         case cdk_pointer:
7114         case cdk_reference:
7115         case cdk_ptrmem:
7116           /* Filter out pointers-to-references and references-to-references.
7117              We can get these if a TYPE_DECL is used.  */
7118
7119           if (TREE_CODE (type) == REFERENCE_TYPE)
7120             {
7121               error (declarator->kind == cdk_reference
7122                      ? "cannot declare reference to `%#T'"
7123                      : "cannot declare pointer to `%#T'", type);
7124               type = TREE_TYPE (type);
7125             }
7126           else if (VOID_TYPE_P (type))
7127             {
7128               if (declarator->kind == cdk_reference)
7129                 error ("cannot declare reference to `%#T'", type);
7130               else if (declarator->kind == cdk_ptrmem)
7131                 error ("cannot declare pointer to `%#T' member", type);
7132             }
7133
7134           /* We now know that the TYPE_QUALS don't apply to the decl,
7135              but to the target of the pointer.  */
7136           type_quals = TYPE_UNQUALIFIED;
7137
7138           if (declarator->kind == cdk_ptrmem
7139               && (TREE_CODE (type) == FUNCTION_TYPE
7140                   || (quals && TREE_CODE (type) == METHOD_TYPE)))
7141             {
7142               tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7143               grok_method_quals (declarator->u.pointer.class_type,
7144                                  dummy, quals);
7145               type = TREE_TYPE (dummy);
7146               quals = TYPE_UNQUALIFIED;
7147             }
7148
7149           if (declarator->kind == cdk_reference)
7150             {
7151               if (!VOID_TYPE_P (type))
7152                 type = build_reference_type (type);
7153             }
7154           else if (TREE_CODE (type) == METHOD_TYPE)
7155             type = build_ptrmemfunc_type (build_pointer_type (type));
7156           else if (declarator->kind == cdk_ptrmem)
7157             type = build_ptrmem_type (declarator->u.pointer.class_type,
7158                                       type);
7159           else
7160             type = build_pointer_type (type);
7161
7162           /* Process a list of type modifier keywords (such as
7163              const or volatile) that were given inside the `*' or `&'.  */
7164
7165           if (declarator->u.pointer.qualifiers)
7166             {
7167               type
7168                 = cp_build_qualified_type (type,
7169                                            declarator->u.pointer.qualifiers);
7170               type_quals = cp_type_quals (type);
7171             }
7172           ctype = NULL_TREE;
7173           break;
7174
7175         case cdk_error:
7176           break;
7177
7178         default:
7179           abort ();
7180         }
7181     }
7182
7183   if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7184       && TREE_CODE (type) != FUNCTION_TYPE
7185       && TREE_CODE (type) != METHOD_TYPE)
7186     {
7187       error ("template-id `%D' used as a declarator",
7188              unqualified_id);
7189       unqualified_id = dname;
7190     }
7191
7192   /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7193      otherwise, we would not have exited the loop above.  */
7194   if (declarator
7195       && TREE_CODE (declarator->u.id.name) == SCOPE_REF
7196       /* If the qualifying scope was invalid, it will have been set to
7197          NULL_TREE above.  */
7198       && TREE_OPERAND (declarator->u.id.name, 0)
7199       && TYPE_P (TREE_OPERAND (declarator->u.id.name, 0)))
7200     {
7201       tree t;
7202
7203       ctype = TREE_OPERAND (declarator->u.id.name, 0);
7204       if (TYPE_P (ctype))
7205         ctype = TYPE_MAIN_VARIANT (ctype);
7206       t = ctype;
7207       while (t != NULL_TREE && CLASS_TYPE_P (t))
7208         {
7209           /* You're supposed to have one `template <...>' for every
7210              template class, but you don't need one for a full
7211              specialization.  For example:
7212
7213                template <class T> struct S{};
7214                template <> struct S<int> { void f(); };
7215                void S<int>::f () {}
7216
7217              is correct; there shouldn't be a `template <>' for the
7218              definition of `S<int>::f'.  */
7219           if (CLASSTYPE_TEMPLATE_INFO (t)
7220               && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
7221                   || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
7222               && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7223             template_count += 1;
7224
7225           t = TYPE_MAIN_DECL (t);
7226           t = DECL_CONTEXT (t);
7227         }
7228
7229       if (ctype == current_class_type)
7230         {
7231           /* class A {
7232                void A::f ();
7233              };
7234
7235              Is this ill-formed?  */
7236
7237           if (pedantic)
7238             pedwarn ("extra qualification `%T::' on member `%s' ignored",
7239                         ctype, name);
7240         }
7241       else if (TREE_CODE (type) == FUNCTION_TYPE)
7242         {
7243           tree sname = TREE_OPERAND (declarator->u.id.name, 1);
7244
7245           if (TREE_CODE (sname) == IDENTIFIER_NODE
7246               && NEW_DELETE_OPNAME_P (sname))
7247             /* Overloaded operator new and operator delete
7248                are always static functions.  */
7249             ;
7250           else if (current_class_type == NULL_TREE || friendp)
7251             type
7252               = build_method_type_directly (ctype,
7253                                             TREE_TYPE (type),
7254                                             TYPE_ARG_TYPES (type));
7255           else
7256             {
7257               error ("cannot declare member function `%T::%s' within `%T'",
7258                      ctype, name, current_class_type);
7259               return error_mark_node;
7260             }
7261         }
7262       else if (declspecs->specs[(int)ds_typedef]
7263                || COMPLETE_TYPE_P (complete_type (ctype)))
7264         {
7265           /* Have to move this code elsewhere in this function.
7266              this code is used for i.e., typedef int A::M; M *pm;
7267
7268              It is?  How? jason 10/2/94 */
7269
7270           if (current_class_type)
7271             {
7272               error ("cannot declare member `%T::%s' within `%T'",
7273                      ctype, name, current_class_type);
7274               return void_type_node;
7275             }
7276         }
7277       else
7278         {
7279           cxx_incomplete_type_error (NULL_TREE, ctype);
7280           return error_mark_node;
7281         }
7282     }
7283
7284   if (returned_attrs)
7285     {
7286       if (attrlist)
7287         *attrlist = chainon (returned_attrs, *attrlist);
7288       else
7289         attrlist = &returned_attrs;
7290     }
7291
7292   /* Now TYPE has the actual type.  */
7293
7294   /* Did array size calculations overflow?  */
7295
7296   if (TREE_CODE (type) == ARRAY_TYPE
7297       && COMPLETE_TYPE_P (type)
7298       && TREE_OVERFLOW (TYPE_SIZE (type)))
7299     {
7300       error ("size of array `%s' is too large", name);
7301       /* If we proceed with the array type as it is, we'll eventually
7302          crash in tree_low_cst().  */
7303       type = error_mark_node;
7304     }
7305
7306   if ((decl_context == FIELD || decl_context == PARM)
7307       && !processing_template_decl
7308       && variably_modified_type_p (type, NULL_TREE))
7309     {
7310       if (decl_context == FIELD)
7311         error ("data member may not have variably modified type `%T'", type);
7312       else
7313         error ("parameter may not have variably modified type `%T'", type);
7314       type = error_mark_node;
7315     }
7316
7317   if (explicitp == 1 || (explicitp && friendp))
7318     {
7319       /* [dcl.fct.spec] The explicit specifier shall only be used in
7320          declarations of constructors within a class definition.  */
7321       error ("only declarations of constructors can be `explicit'");
7322       explicitp = 0;
7323     }
7324
7325   if (storage_class == sc_mutable)
7326     {
7327       if (decl_context != FIELD || friendp)
7328         {
7329           error ("non-member `%s' cannot be declared `mutable'", name);
7330           storage_class = sc_none;
7331         }
7332       else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7333         {
7334           error ("non-object member `%s' cannot be declared `mutable'", name);
7335           storage_class = sc_none;
7336         }
7337       else if (TREE_CODE (type) == FUNCTION_TYPE
7338                || TREE_CODE (type) == METHOD_TYPE)
7339         {
7340           error ("function `%s' cannot be declared `mutable'", name);
7341           storage_class = sc_none;
7342         }
7343       else if (staticp)
7344         {
7345           error ("static `%s' cannot be declared `mutable'", name);
7346           storage_class = sc_none;
7347         }
7348       else if (type_quals & TYPE_QUAL_CONST)
7349         {
7350           error ("const `%s' cannot be declared `mutable'", name);
7351           storage_class = sc_none;
7352         }
7353     }
7354
7355   /* If this is declaring a typedef name, return a TYPE_DECL.  */
7356   if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7357     {
7358       tree decl;
7359
7360       /* Note that the grammar rejects storage classes
7361          in typenames, fields or parameters.  */
7362       if (current_lang_name == lang_name_java)
7363         TYPE_FOR_JAVA (type) = 1;
7364
7365       if (decl_context == FIELD)
7366         {
7367           if (constructor_name_p (unqualified_id, current_class_type))
7368             pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7369                      unqualified_id);
7370           decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7371         }
7372       else
7373         {
7374           decl = build_decl (TYPE_DECL, unqualified_id, type);
7375           if (in_namespace || ctype)
7376             error ("%Jtypedef name may not be a nested-name-specifier", decl);
7377           if (!current_function_decl)
7378             DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7379         }
7380
7381       /* If the user declares "typedef struct {...} foo" then the
7382          struct will have an anonymous name.  Fill that name in now.
7383          Nothing can refer to it, so nothing needs know about the name
7384          change.  */
7385       if (type != error_mark_node
7386           && unqualified_id
7387           && TYPE_NAME (type)
7388           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7389           && TYPE_ANONYMOUS_P (type)
7390           /* Don't do this if there are attributes.  */
7391           && (!attrlist || !*attrlist)
7392           && cp_type_quals (type) == TYPE_UNQUALIFIED)
7393         {
7394           tree oldname = TYPE_NAME (type);
7395           tree t;
7396
7397           /* Replace the anonymous name with the real name everywhere.  */
7398           lookup_tag_reverse (type, unqualified_id);
7399           for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7400             if (TYPE_NAME (t) == oldname)
7401               TYPE_NAME (t) = decl;
7402
7403           if (TYPE_LANG_SPECIFIC (type))
7404             TYPE_WAS_ANONYMOUS (type) = 1;
7405
7406           /* If this is a typedef within a template class, the nested
7407              type is a (non-primary) template.  The name for the
7408              template needs updating as well.  */
7409           if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7410             DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7411               = TYPE_IDENTIFIER (type);
7412
7413           /* FIXME remangle member functions; member functions of a
7414              type with external linkage have external linkage.  */
7415         }
7416
7417       if (quals)
7418         {
7419           if (ctype == NULL_TREE)
7420             {
7421               if (TREE_CODE (type) != METHOD_TYPE)
7422                 error ("%Jinvalid type qualifier for non-member function type",
7423                        decl);
7424               else
7425                 ctype = TYPE_METHOD_BASETYPE (type);
7426             }
7427           if (ctype != NULL_TREE)
7428             grok_method_quals (ctype, decl, quals);
7429         }
7430
7431       if (signed_p
7432           || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7433         C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7434
7435       bad_specifiers (decl, "type", virtualp, quals != TYPE_UNQUALIFIED,
7436                       inlinep, friendp, raises != NULL_TREE);
7437
7438       return decl;
7439     }
7440
7441   /* Detect the case of an array type of unspecified size
7442      which came, as such, direct from a typedef name.
7443      We must copy the type, so that the array's domain can be
7444      individually set by the object's initializer.  */
7445
7446   if (type && typedef_type
7447       && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7448       && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7449     type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7450
7451   /* Detect where we're using a typedef of function type to declare a
7452      function. PARMS will not be set, so we must create it now.  */
7453
7454   if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7455     {
7456       tree decls = NULL_TREE;
7457       tree args;
7458
7459       for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7460         {
7461           tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7462
7463           TREE_CHAIN (decl) = decls;
7464           decls = decl;
7465         }
7466
7467       parms = nreverse (decls);
7468     }
7469
7470   /* If this is a type name (such as, in a cast or sizeof),
7471      compute the type and return it now.  */
7472
7473   if (decl_context == TYPENAME)
7474     {
7475       /* Note that the grammar rejects storage classes
7476          in typenames, fields or parameters.  */
7477       if (type_quals != TYPE_UNQUALIFIED)
7478         type_quals = TYPE_UNQUALIFIED;
7479
7480       /* Special case: "friend class foo" looks like a TYPENAME context.  */
7481       if (friendp)
7482         {
7483           if (type_quals != TYPE_UNQUALIFIED)
7484             {
7485               error ("type qualifiers specified for friend class declaration");
7486               type_quals = TYPE_UNQUALIFIED;
7487             }
7488           if (inlinep)
7489             {
7490               error ("`inline' specified for friend class declaration");
7491               inlinep = 0;
7492             }
7493
7494           if (!current_aggr)
7495             {
7496               /* Don't allow friend declaration without a class-key.  */
7497               if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7498                 pedwarn ("template parameters cannot be friends");
7499               else if (TREE_CODE (type) == TYPENAME_TYPE)
7500                 pedwarn ("friend declaration requires class-key, "
7501                          "i.e. `friend class %T::%D'",
7502                          TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7503               else
7504                 pedwarn ("friend declaration requires class-key, "
7505                          "i.e. `friend %#T'",
7506                          type);
7507             }
7508
7509           /* Only try to do this stuff if we didn't already give up.  */
7510           if (type != integer_type_node)
7511             {
7512               /* A friendly class?  */
7513               if (current_class_type)
7514                 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7515                                    /*complain=*/true);
7516               else
7517                 error ("trying to make class `%T' a friend of global scope",
7518                           type);
7519
7520               type = void_type_node;
7521             }
7522         }
7523       else if (quals)
7524         {
7525           if (ctype == NULL_TREE)
7526             {
7527               if (TREE_CODE (type) != METHOD_TYPE)
7528                 error ("invalid qualifiers on non-member function type");
7529               else
7530                 ctype = TYPE_METHOD_BASETYPE (type);
7531             }
7532           if (ctype)
7533             {
7534               tree dummy = build_decl (TYPE_DECL, unqualified_id, type);
7535               grok_method_quals (ctype, dummy, quals);
7536               type = TREE_TYPE (dummy);
7537             }
7538         }
7539
7540       return type;
7541     }
7542   else if (unqualified_id == NULL_TREE && decl_context != PARM
7543            && decl_context != CATCHPARM
7544            && TREE_CODE (type) != UNION_TYPE
7545            && ! bitfield)
7546     {
7547       error ("abstract declarator `%T' used as declaration", type);
7548       unqualified_id = make_anon_name ();
7549     }
7550
7551   /* `void' at top level (not within pointer)
7552      is allowed only in typedefs or type names.
7553      We don't complain about parms either, but that is because
7554      a better error message can be made later.  */
7555
7556   if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
7557     {
7558       if (! unqualified_id)
7559         error ("unnamed variable or field declared void");
7560       else if (TREE_CODE (unqualified_id) == IDENTIFIER_NODE)
7561         {
7562           if (IDENTIFIER_OPNAME_P (unqualified_id))
7563             abort ();
7564           else
7565             error ("variable or field `%s' declared void", name);
7566         }
7567       else
7568         error ("variable or field declared void");
7569       type = integer_type_node;
7570     }
7571
7572   /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7573      or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE.  */
7574
7575   if (decl_context == PARM || decl_context == CATCHPARM)
7576     {
7577       if (ctype || in_namespace)
7578         error ("cannot use `::' in parameter declaration");
7579
7580       /* A parameter declared as an array of T is really a pointer to T.
7581          One declared as a function is really a pointer to a function.
7582          One declared as a member is really a pointer to member.  */
7583
7584       if (TREE_CODE (type) == ARRAY_TYPE)
7585         {
7586           /* Transfer const-ness of array into that of type pointed to.  */
7587           type = build_pointer_type (TREE_TYPE (type));
7588           type_quals = TYPE_UNQUALIFIED;
7589         }
7590       else if (TREE_CODE (type) == FUNCTION_TYPE)
7591         type = build_pointer_type (type);
7592     }
7593
7594   {
7595     tree decl;
7596
7597     if (decl_context == PARM)
7598       {
7599         decl = cp_build_parm_decl (unqualified_id, type);
7600
7601         bad_specifiers (decl, "parameter", virtualp, quals != TYPE_UNQUALIFIED,
7602                         inlinep, friendp, raises != NULL_TREE);
7603       }
7604     else if (decl_context == FIELD)
7605       {
7606         /* The C99 flexible array extension.  */
7607         if (!staticp && TREE_CODE (type) == ARRAY_TYPE
7608             && TYPE_DOMAIN (type) == NULL_TREE)
7609           {
7610             tree itype = compute_array_index_type (dname, integer_zero_node);
7611             type = build_cplus_array_type (TREE_TYPE (type), itype);
7612           }
7613
7614         if (type == error_mark_node)
7615           {
7616             /* Happens when declaring arrays of sizes which
7617                are error_mark_node, for example.  */
7618             decl = NULL_TREE;
7619           }
7620         else if (in_namespace && !friendp)
7621           {
7622             /* Something like struct S { int N::j; };  */
7623             error ("invalid use of `::'");
7624             decl = NULL_TREE;
7625           }
7626         else if (TREE_CODE (type) == FUNCTION_TYPE)
7627           {
7628             int publicp = 0;
7629             tree function_context;
7630
7631             /* We catch the others as conflicts with the builtin
7632                typedefs.  */
7633             if (friendp && unqualified_id == ridpointers[(int) RID_SIGNED])
7634               {
7635                 error ("function `%D' cannot be declared friend",
7636                        unqualified_id);
7637                 friendp = 0;
7638               }
7639
7640             if (friendp == 0)
7641               {
7642                 if (ctype == NULL_TREE)
7643                   ctype = current_class_type;
7644
7645                 if (ctype == NULL_TREE)
7646                   {
7647                     error ("can't make `%D' into a method -- not in a class",
7648                            unqualified_id);
7649                     return void_type_node;
7650                   }
7651
7652                 /* ``A union may [ ... ] not [ have ] virtual functions.''
7653                    ARM 9.5 */
7654                 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
7655                   {
7656                     error ("function `%D' declared virtual inside a union",
7657                            unqualified_id);
7658                     return void_type_node;
7659                   }
7660
7661                 if (NEW_DELETE_OPNAME_P (unqualified_id))
7662                   {
7663                     if (virtualp)
7664                       {
7665                         error ("`%D' cannot be declared virtual, since it is always static",
7666                                unqualified_id);
7667                         virtualp = 0;
7668                       }
7669                   }
7670                 else if (staticp < 2)
7671                   type = build_method_type_directly (ctype,
7672                                                      TREE_TYPE (type),
7673                                                      TYPE_ARG_TYPES (type));
7674               }
7675
7676             /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node.  */
7677             function_context = (ctype != NULL_TREE) ?
7678               decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
7679             publicp = (! friendp || ! staticp)
7680               && function_context == NULL_TREE;
7681             decl = grokfndecl (ctype, type,
7682                                TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7683                                ? unqualified_id : dname,
7684                                parms,
7685                                unqualified_id,
7686                                virtualp, flags, quals, raises,
7687                                friendp ? -1 : 0, friendp, publicp, inlinep,
7688                                funcdef_flag, template_count, in_namespace);
7689             if (decl == NULL_TREE)
7690               return decl;
7691 #if 0
7692             /* This clobbers the attrs stored in `decl' from `attrlist'.  */
7693             /* The decl and setting of decl_attr is also turned off.  */
7694             decl = build_decl_attribute_variant (decl, decl_attr);
7695 #endif
7696
7697             /* [class.conv.ctor]
7698
7699                A constructor declared without the function-specifier
7700                explicit that can be called with a single parameter
7701                specifies a conversion from the type of its first
7702                parameter to the type of its class.  Such a constructor
7703                is called a converting constructor.  */
7704             if (explicitp == 2)
7705               DECL_NONCONVERTING_P (decl) = 1;
7706             else if (DECL_CONSTRUCTOR_P (decl))
7707               {
7708                 /* The constructor can be called with exactly one
7709                    parameter if there is at least one parameter, and
7710                    any subsequent parameters have default arguments.
7711                    Ignore any compiler-added parms.  */
7712                 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
7713
7714                 if (arg_types == void_list_node
7715                     || (arg_types
7716                         && TREE_CHAIN (arg_types)
7717                         && TREE_CHAIN (arg_types) != void_list_node
7718                         && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
7719                   DECL_NONCONVERTING_P (decl) = 1;
7720               }
7721           }
7722         else if (TREE_CODE (type) == METHOD_TYPE)
7723           {
7724             /* We only get here for friend declarations of
7725                members of other classes.  */
7726             /* All method decls are public, so tell grokfndecl to set
7727                TREE_PUBLIC, also.  */
7728             decl = grokfndecl (ctype, type,
7729                                TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7730                                ? unqualified_id : dname,
7731                                parms,
7732                                unqualified_id,
7733                                virtualp, flags, quals, raises,
7734                                friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
7735                                template_count, in_namespace);
7736             if (decl == NULL_TREE)
7737               return NULL_TREE;
7738           }
7739         else if (!staticp && !dependent_type_p (type)
7740                  && !COMPLETE_TYPE_P (complete_type (type))
7741                  && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
7742           {
7743             if (unqualified_id)
7744               error ("field `%D' has incomplete type", unqualified_id);
7745             else
7746               error ("name `%T' has incomplete type", type);
7747
7748             /* If we're instantiating a template, tell them which
7749                instantiation made the field's type be incomplete.  */
7750             if (current_class_type
7751                 && TYPE_NAME (current_class_type)
7752                 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
7753                 && declspecs->type
7754                 && declspecs->type == type)
7755               error ("  in instantiation of template `%T'",
7756                         current_class_type);
7757
7758             type = error_mark_node;
7759             decl = NULL_TREE;
7760           }
7761         else
7762           {
7763             if (friendp)
7764               {
7765                 error ("`%E' is neither function nor member function; "
7766                        "cannot be declared friend", unqualified_id);
7767                 friendp = 0;
7768               }
7769             decl = NULL_TREE;
7770           }
7771
7772         if (friendp)
7773           {
7774             /* Friends are treated specially.  */
7775             if (ctype == current_class_type)
7776               warning ("member functions are implicitly friends of their class");
7777             else if (decl && DECL_NAME (decl))
7778               {
7779                 if (template_class_depth (current_class_type) == 0)
7780                   {
7781                     decl = check_explicit_specialization
7782                       (unqualified_id, decl, template_count,
7783                        2 * (funcdef_flag != 0) + 4);
7784                     if (decl == error_mark_node)
7785                       return error_mark_node;
7786                   }
7787
7788                 decl = do_friend (ctype, unqualified_id, decl,
7789                                   *attrlist, flags, quals, funcdef_flag);
7790                 return decl;
7791               }
7792             else
7793               return void_type_node;
7794           }
7795
7796         /* Structure field.  It may not be a function, except for C++.  */
7797
7798         if (decl == NULL_TREE)
7799           {
7800             if (initialized)
7801               {
7802                 if (!staticp)
7803                   {
7804                     /* An attempt is being made to initialize a non-static
7805                        member.  But, from [class.mem]:
7806
7807                        4 A member-declarator can contain a
7808                        constant-initializer only if it declares a static
7809                        member (_class.static_) of integral or enumeration
7810                        type, see _class.static.data_.
7811
7812                        This used to be relatively common practice, but
7813                        the rest of the compiler does not correctly
7814                        handle the initialization unless the member is
7815                        static so we make it static below.  */
7816                     pedwarn ("ISO C++ forbids initialization of member `%D'",
7817                              unqualified_id);
7818                     pedwarn ("making `%D' static", unqualified_id);
7819                     staticp = 1;
7820                   }
7821
7822                 if (uses_template_parms (type))
7823                   /* We'll check at instantiation time.  */
7824                   ;
7825                 else if (check_static_variable_definition (unqualified_id,
7826                                                            type))
7827                   /* If we just return the declaration, crashes
7828                      will sometimes occur.  We therefore return
7829                      void_type_node, as if this was a friend
7830                      declaration, to cause callers to completely
7831                      ignore this declaration.  */
7832                   return void_type_node;
7833               }
7834
7835             if (staticp)
7836               {
7837                 /* C++ allows static class members.  All other work
7838                    for this is done by grokfield.  */
7839                 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
7840                 TREE_STATIC (decl) = 1;
7841                 /* In class context, 'static' means public access.  */
7842                 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
7843               }
7844             else
7845               {
7846                 decl = build_decl (FIELD_DECL, unqualified_id, type);
7847                 DECL_NONADDRESSABLE_P (decl) = bitfield;
7848                 if (storage_class == sc_mutable)
7849                   {
7850                     DECL_MUTABLE_P (decl) = 1;
7851                     storage_class = sc_none;
7852                   }
7853               }
7854
7855             bad_specifiers (decl, "field", virtualp, quals != TYPE_UNQUALIFIED,
7856                             inlinep, friendp, raises != NULL_TREE);
7857           }
7858       }
7859     else if (TREE_CODE (type) == FUNCTION_TYPE
7860              || TREE_CODE (type) == METHOD_TYPE)
7861       {
7862         tree original_name;
7863         int publicp = 0;
7864
7865         if (!unqualified_id)
7866           return NULL_TREE;
7867
7868         if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
7869           original_name = dname;
7870         else
7871           original_name = unqualified_id;
7872
7873         if (storage_class == sc_auto)
7874           error ("storage class `auto' invalid for function `%s'", name);
7875         else if (storage_class == sc_register)
7876           error ("storage class `register' invalid for function `%s'", name);
7877         else if (thread_p)
7878           error ("storage class `__thread' invalid for function `%s'", name);
7879
7880         /* Function declaration not at top level.
7881            Storage classes other than `extern' are not allowed
7882            and `extern' makes no difference.  */
7883         if (! toplevel_bindings_p ()
7884             && (storage_class == sc_static
7885                 || declspecs->specs[(int)ds_inline])
7886             && pedantic)
7887           {
7888             if (storage_class == sc_static)
7889               pedwarn ("`static' specified invalid for function `%s' declared out of global scope", name);
7890             else
7891               pedwarn ("`inline' specifier invalid for function `%s' declared out of global scope", name);
7892           }
7893
7894         if (ctype == NULL_TREE)
7895           {
7896             if (virtualp)
7897               {
7898                 error ("virtual non-class function `%s'", name);
7899                 virtualp = 0;
7900               }
7901           }
7902         else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
7903                  && !NEW_DELETE_OPNAME_P (original_name))
7904           type = build_method_type_directly (ctype,
7905                                              TREE_TYPE (type),
7906                                              TYPE_ARG_TYPES (type));
7907
7908         /* Record presence of `static'.  */
7909         publicp = (ctype != NULL_TREE
7910                    || storage_class == sc_extern
7911                    || storage_class != sc_static);
7912
7913         decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
7914                            virtualp, flags, quals, raises,
7915                            1, friendp,
7916                            publicp, inlinep, funcdef_flag,
7917                            template_count, in_namespace);
7918         if (decl == NULL_TREE)
7919           return NULL_TREE;
7920
7921         if (staticp == 1)
7922           {
7923             int invalid_static = 0;
7924
7925             /* Don't allow a static member function in a class, and forbid
7926                declaring main to be static.  */
7927             if (TREE_CODE (type) == METHOD_TYPE)
7928               {
7929                 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
7930                 invalid_static = 1;
7931               }
7932             else if (current_function_decl)
7933               {
7934                 /* FIXME need arm citation */
7935                 error ("cannot declare static function inside another function");
7936                 invalid_static = 1;
7937               }
7938
7939             if (invalid_static)
7940               {
7941                 staticp = 0;
7942                 storage_class = sc_none;
7943               }
7944           }
7945       }
7946     else
7947       {
7948         /* It's a variable.  */
7949
7950         /* An uninitialized decl with `extern' is a reference.  */
7951         decl = grokvardecl (type, unqualified_id,
7952                             declspecs,
7953                             initialized,
7954                             (type_quals & TYPE_QUAL_CONST) != 0,
7955                             ctype ? ctype : in_namespace);
7956         bad_specifiers (decl, "variable", virtualp, quals != TYPE_UNQUALIFIED,
7957                         inlinep, friendp, raises != NULL_TREE);
7958
7959         if (ctype)
7960           {
7961             DECL_CONTEXT (decl) = ctype;
7962             if (staticp == 1)
7963               {
7964                 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
7965                 staticp = 0;
7966                 storage_class = sc_none;
7967               }
7968             if (storage_class == sc_register && TREE_STATIC (decl))
7969               {
7970                 error ("static member `%D' declared `register'", decl);
7971                 storage_class = sc_none;
7972               }
7973             if (storage_class == sc_extern && pedantic)
7974               {
7975                 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
7976                             decl);
7977                 storage_class = sc_none;
7978               }
7979           }
7980       }
7981
7982     /* Record `register' declaration for warnings on &
7983        and in case doing stupid register allocation.  */
7984
7985     if (storage_class == sc_register)
7986       DECL_REGISTER (decl) = 1;
7987     else if (storage_class == sc_extern)
7988       DECL_THIS_EXTERN (decl) = 1;
7989     else if (storage_class == sc_static)
7990       DECL_THIS_STATIC (decl) = 1;
7991
7992     /* Record constancy and volatility.  There's no need to do this
7993        when processing a template; we'll do this for the instantiated
7994        declaration based on the type of DECL.  */
7995     if (!processing_template_decl)
7996       c_apply_type_quals_to_decl (type_quals, decl);
7997
7998     return decl;
7999   }
8000 }
8001 \f
8002 /* Subroutine of start_function.  Ensure that each of the parameter
8003    types (as listed in PARMS) is complete, as is required for a
8004    function definition.  */
8005
8006 static void
8007 require_complete_types_for_parms (tree parms)
8008 {
8009   for (; parms; parms = TREE_CHAIN (parms))
8010     {
8011       if (VOID_TYPE_P (TREE_TYPE (parms)))
8012         /* grokparms will have already issued an error.  */
8013         TREE_TYPE (parms) = error_mark_node;
8014       else if (complete_type_or_else (TREE_TYPE (parms), parms))
8015         {
8016           layout_decl (parms, 0);
8017           DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8018         }
8019     }
8020 }
8021
8022 /* Returns nonzero if T is a local variable.  */
8023
8024 int
8025 local_variable_p (tree t)
8026 {
8027   if ((TREE_CODE (t) == VAR_DECL
8028        /* A VAR_DECL with a context that is a _TYPE is a static data
8029           member.  */
8030        && !TYPE_P (CP_DECL_CONTEXT (t))
8031        /* Any other non-local variable must be at namespace scope.  */
8032        && !DECL_NAMESPACE_SCOPE_P (t))
8033       || (TREE_CODE (t) == PARM_DECL))
8034     return 1;
8035
8036   return 0;
8037 }
8038
8039 /* Returns nonzero if T is an automatic local variable or a label.
8040    (These are the declarations that need to be remapped when the code
8041    containing them is duplicated.)  */
8042
8043 int
8044 nonstatic_local_decl_p (tree t)
8045 {
8046   return ((local_variable_p (t) && !TREE_STATIC (t))
8047           || TREE_CODE (t) == LABEL_DECL
8048           || TREE_CODE (t) == RESULT_DECL);
8049 }
8050
8051 /* Like local_variable_p, but suitable for use as a tree-walking
8052    function.  */
8053
8054 static tree
8055 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8056                          void *data ATTRIBUTE_UNUSED)
8057 {
8058   if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8059     return *tp;
8060   else if (TYPE_P (*tp))
8061     *walk_subtrees = 0;
8062
8063   return NULL_TREE;
8064 }
8065
8066
8067 /* Check that ARG, which is a default-argument expression for a
8068    parameter DECL, is valid.  Returns ARG, or ERROR_MARK_NODE, if
8069    something goes wrong.  DECL may also be a _TYPE node, rather than a
8070    DECL, if there is no DECL available.  */
8071
8072 tree
8073 check_default_argument (tree decl, tree arg)
8074 {
8075   tree var;
8076   tree decl_type;
8077
8078   if (TREE_CODE (arg) == DEFAULT_ARG)
8079     /* We get a DEFAULT_ARG when looking at an in-class declaration
8080        with a default argument.  Ignore the argument for now; we'll
8081        deal with it after the class is complete.  */
8082     return arg;
8083
8084   if (processing_template_decl || uses_template_parms (arg))
8085     /* We don't do anything checking until instantiation-time.  Note
8086        that there may be uninstantiated arguments even for an
8087        instantiated function, since default arguments are not
8088        instantiated until they are needed.  */
8089     return arg;
8090
8091   if (TYPE_P (decl))
8092     {
8093       decl_type = decl;
8094       decl = NULL_TREE;
8095     }
8096   else
8097     decl_type = TREE_TYPE (decl);
8098
8099   if (arg == error_mark_node
8100       || decl == error_mark_node
8101       || TREE_TYPE (arg) == error_mark_node
8102       || decl_type == error_mark_node)
8103     /* Something already went wrong.  There's no need to check
8104        further.  */
8105     return error_mark_node;
8106
8107   /* [dcl.fct.default]
8108
8109      A default argument expression is implicitly converted to the
8110      parameter type.  */
8111   if (!TREE_TYPE (arg)
8112       || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
8113     {
8114       if (decl)
8115         error ("default argument for `%#D' has type `%T'",
8116                   decl, TREE_TYPE (arg));
8117       else
8118         error ("default argument for parameter of type `%T' has type `%T'",
8119                   decl_type, TREE_TYPE (arg));
8120
8121       return error_mark_node;
8122     }
8123
8124   /* [dcl.fct.default]
8125
8126      Local variables shall not be used in default argument
8127      expressions.
8128
8129      The keyword `this' shall not be used in a default argument of a
8130      member function.  */
8131   var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8132                                       NULL);
8133   if (var)
8134     {
8135       error ("default argument `%E' uses local variable `%D'",
8136                 arg, var);
8137       return error_mark_node;
8138     }
8139
8140   /* All is well.  */
8141   return arg;
8142 }
8143
8144 /* Decode the list of parameter types for a function type.
8145    Given the list of things declared inside the parens,
8146    return a list of types.
8147
8148    If this parameter does not end with an ellipsis, we append
8149    void_list_node.
8150
8151    *PARMS is set to the chain of PARM_DECLs created.  */
8152
8153 static tree
8154 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8155 {
8156   tree result = NULL_TREE;
8157   tree decls = NULL_TREE;
8158   int ellipsis = !first_parm || first_parm->ellipsis_p;
8159   cp_parameter_declarator *parm;
8160   int any_error = 0;
8161
8162   for (parm = first_parm; parm != NULL; parm = parm->next)
8163     {
8164       tree type = NULL_TREE;
8165       tree init = parm->default_argument;
8166       tree attrs;
8167       tree decl;
8168
8169       if (parm == no_parameters)
8170         break;
8171
8172       attrs = parm->decl_specifiers.attributes;
8173       parm->decl_specifiers.attributes = NULL_TREE;
8174       decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8175                              PARM, init != NULL_TREE, &attrs);
8176       if (! decl || TREE_TYPE (decl) == error_mark_node)
8177         continue;
8178
8179       if (attrs)
8180         cplus_decl_attributes (&decl, attrs, 0);
8181
8182       type = TREE_TYPE (decl);
8183       if (VOID_TYPE_P (type))
8184         {
8185           if (same_type_p (type, void_type_node)
8186               && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8187             /* this is a parmlist of `(void)', which is ok.  */
8188             break;
8189           cxx_incomplete_type_error (decl, type);
8190           /* It's not a good idea to actually create parameters of
8191              type `void'; other parts of the compiler assume that a
8192              void type terminates the parameter list.  */
8193           type = error_mark_node;
8194           TREE_TYPE (decl) = error_mark_node;
8195         }
8196
8197       if (type != error_mark_node)
8198         {
8199           /* Top-level qualifiers on the parameters are
8200              ignored for function types.  */
8201           type = cp_build_qualified_type (type, 0);
8202           if (TREE_CODE (type) == METHOD_TYPE)
8203             {
8204               error ("parameter `%D' invalidly declared method type", decl);
8205               type = build_pointer_type (type);
8206               TREE_TYPE (decl) = type;
8207             }
8208           else if (abstract_virtuals_error (decl, type))
8209             any_error = 1;  /* Seems like a good idea.  */
8210           else if (POINTER_TYPE_P (type))
8211             {
8212               /* [dcl.fct]/6, parameter types cannot contain pointers
8213                  (references) to arrays of unknown bound.  */
8214               tree t = TREE_TYPE (type);
8215               int ptr = TYPE_PTR_P (type);
8216
8217               while (1)
8218                 {
8219                   if (TYPE_PTR_P (t))
8220                     ptr = 1;
8221                   else if (TREE_CODE (t) != ARRAY_TYPE)
8222                     break;
8223                   else if (!TYPE_DOMAIN (t))
8224                     break;
8225                   t = TREE_TYPE (t);
8226                 }
8227               if (TREE_CODE (t) == ARRAY_TYPE)
8228                 error ("parameter `%D' includes %s to array of unknown bound `%T'",
8229                           decl, ptr ? "pointer" : "reference", t);
8230             }
8231
8232           if (!any_error && init)
8233             init = check_default_argument (decl, init);
8234           else
8235             init = NULL_TREE;
8236         }
8237
8238       TREE_CHAIN (decl) = decls;
8239       decls = decl;
8240       result = tree_cons (init, type, result);
8241     }
8242   decls = nreverse (decls);
8243   result = nreverse (result);
8244   if (!ellipsis)
8245     result = chainon (result, void_list_node);
8246   *parms = decls;
8247
8248   return result;
8249 }
8250
8251 \f
8252 /* D is a constructor or overloaded `operator='.
8253
8254    Let T be the class in which D is declared. Then, this function
8255    returns:
8256
8257    -1 if D's is an ill-formed constructor or copy assignment operator
8258       whose first parameter is of type `T'.
8259    0  if D is not a copy constructor or copy assignment
8260       operator.
8261    1  if D is a copy constructor or copy assignment operator whose
8262       first parameter is a reference to const qualified T.
8263    2  if D is a copy constructor or copy assignment operator whose
8264       first parameter is a reference to non-const qualified T.
8265
8266    This function can be used as a predicate. Positive values indicate
8267    a copy constructor and nonzero values indicate a copy assignment
8268    operator.  */
8269
8270 int
8271 copy_fn_p (tree d)
8272 {
8273   tree args;
8274   tree arg_type;
8275   int result = 1;
8276
8277   my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
8278
8279   if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
8280     /* Instantiations of template member functions are never copy
8281        functions.  Note that member functions of templated classes are
8282        represented as template functions internally, and we must
8283        accept those as copy functions.  */
8284     return 0;
8285
8286   args = FUNCTION_FIRST_USER_PARMTYPE (d);
8287   if (!args)
8288     return 0;
8289
8290   arg_type = TREE_VALUE (args);
8291
8292   if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8293     {
8294       /* Pass by value copy assignment operator.  */
8295       result = -1;
8296     }
8297   else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8298            && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8299     {
8300       if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8301         result = 2;
8302     }
8303   else
8304     return 0;
8305
8306   args = TREE_CHAIN (args);
8307
8308   if (args && args != void_list_node && !TREE_PURPOSE (args))
8309     /* There are more non-optional args.  */
8310     return 0;
8311
8312   return result;
8313 }
8314
8315 /* Remember any special properties of member function DECL.  */
8316
8317 void grok_special_member_properties (tree decl)
8318 {
8319   if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8320     ; /* Not special.  */
8321   else if (DECL_CONSTRUCTOR_P (decl))
8322     {
8323       int ctor = copy_fn_p (decl);
8324
8325       if (ctor > 0)
8326         {
8327           /* [class.copy]
8328
8329              A non-template constructor for class X is a copy
8330              constructor if its first parameter is of type X&, const
8331              X&, volatile X& or const volatile X&, and either there
8332              are no other parameters or else all other parameters have
8333              default arguments.  */
8334           TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8335           if (ctor > 1)
8336             TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8337         }
8338       else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8339         TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8340     }
8341   else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8342     {
8343       /* [class.copy]
8344
8345          A non-template assignment operator for class X is a copy
8346          assignment operator if its parameter is of type X, X&, const
8347          X&, volatile X& or const volatile X&.  */
8348
8349       int assop = copy_fn_p (decl);
8350
8351       if (assop)
8352         {
8353           TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8354           if (assop != 1)
8355             TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8356         }
8357     }
8358 }
8359
8360 /* Check a constructor DECL has the correct form.  Complains
8361    if the class has a constructor of the form X(X).  */
8362
8363 int
8364 grok_ctor_properties (tree ctype, tree decl)
8365 {
8366   int ctor_parm = copy_fn_p (decl);
8367
8368   if (ctor_parm < 0)
8369     {
8370       /* [class.copy]
8371
8372          A declaration of a constructor for a class X is ill-formed if
8373          its first parameter is of type (optionally cv-qualified) X
8374          and either there are no other parameters or else all other
8375          parameters have default arguments.
8376
8377          We *don't* complain about member template instantiations that
8378          have this form, though; they can occur as we try to decide
8379          what constructor to use during overload resolution.  Since
8380          overload resolution will never prefer such a constructor to
8381          the non-template copy constructor (which is either explicitly
8382          or implicitly defined), there's no need to worry about their
8383          existence.  Theoretically, they should never even be
8384          instantiated, but that's hard to forestall.  */
8385       error ("invalid constructor; you probably meant `%T (const %T&)'",
8386                 ctype, ctype);
8387       return 0;
8388     }
8389
8390   return 1;
8391 }
8392
8393 /* An operator with this code is unary, but can also be binary.  */
8394
8395 static int
8396 ambi_op_p (enum tree_code code)
8397 {
8398   return (code == INDIRECT_REF
8399           || code == ADDR_EXPR
8400           || code == CONVERT_EXPR
8401           || code == NEGATE_EXPR
8402           || code == PREINCREMENT_EXPR
8403           || code == PREDECREMENT_EXPR);
8404 }
8405
8406 /* An operator with this name can only be unary.  */
8407
8408 static int
8409 unary_op_p (enum tree_code code)
8410 {
8411   return (code == TRUTH_NOT_EXPR
8412           || code == BIT_NOT_EXPR
8413           || code == COMPONENT_REF
8414           || code == TYPE_EXPR);
8415 }
8416
8417 /* DECL is a declaration for an overloaded operator.  Returns true if
8418    the declaration is valid; false otherwise.  If COMPLAIN is true,
8419    errors are issued for invalid declarations.  */
8420
8421 bool
8422 grok_op_properties (tree decl, int friendp, bool complain)
8423 {
8424   tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8425   tree argtype;
8426   int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8427   tree name = DECL_NAME (decl);
8428   enum tree_code operator_code;
8429   int arity;
8430   bool ok;
8431
8432   /* Assume that the declaration is valid.  */
8433   ok = true;
8434
8435   /* Count the number of arguments.  */
8436   for (argtype = argtypes, arity = 0;
8437        argtype && argtype != void_list_node;
8438        argtype = TREE_CHAIN (argtype))
8439     ++arity;
8440
8441   if (current_class_type == NULL_TREE)
8442     friendp = 1;
8443
8444   if (DECL_CONV_FN_P (decl))
8445     operator_code = TYPE_EXPR;
8446   else
8447     do
8448       {
8449 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P)       \
8450         if (ansi_opname (CODE) == name)                         \
8451           {                                                     \
8452             operator_code = (CODE);                             \
8453             break;                                              \
8454           }                                                     \
8455         else if (ansi_assopname (CODE) == name)                 \
8456           {                                                     \
8457             operator_code = (CODE);                             \
8458             DECL_ASSIGNMENT_OPERATOR_P (decl) = 1;              \
8459             break;                                              \
8460           }
8461
8462 #include "operators.def"
8463 #undef DEF_OPERATOR
8464
8465         abort ();
8466       }
8467     while (0);
8468   my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
8469   SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8470
8471   if (! friendp)
8472     {
8473       switch (operator_code)
8474         {
8475         case NEW_EXPR:
8476           TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8477           break;
8478
8479         case DELETE_EXPR:
8480           TYPE_GETS_DELETE (current_class_type) |= 1;
8481           break;
8482
8483         case VEC_NEW_EXPR:
8484           TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8485           break;
8486
8487         case VEC_DELETE_EXPR:
8488           TYPE_GETS_DELETE (current_class_type) |= 2;
8489           break;
8490
8491         default:
8492           break;
8493         }
8494     }
8495
8496     /* [basic.std.dynamic.allocation]/1:
8497
8498        A program is ill-formed if an allocation function is declared
8499        in a namespace scope other than global scope or declared static
8500        in global scope.
8501
8502        The same also holds true for deallocation functions.  */
8503   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
8504       || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8505     {
8506       if (DECL_NAMESPACE_SCOPE_P (decl))
8507         {
8508           if (CP_DECL_CONTEXT (decl) != global_namespace)
8509             error ("`%D' may not be declared within a namespace", decl);
8510           else if (!TREE_PUBLIC (decl))
8511             error ("`%D' may not be declared as static", decl);
8512         }
8513     }
8514
8515   if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8516     TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8517   else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8518     TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8519   else
8520     {
8521       /* An operator function must either be a non-static member function
8522          or have at least one parameter of a class, a reference to a class,
8523          an enumeration, or a reference to an enumeration.  13.4.0.6 */
8524       if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8525         {
8526           if (operator_code == TYPE_EXPR
8527               || operator_code == CALL_EXPR
8528               || operator_code == COMPONENT_REF
8529               || operator_code == ARRAY_REF
8530               || operator_code == NOP_EXPR)
8531             error ("`%D' must be a nonstatic member function", decl);
8532           else
8533             {
8534               tree p;
8535
8536               if (DECL_STATIC_FUNCTION_P (decl))
8537                 error ("`%D' must be either a non-static member function or a non-member function", decl);
8538
8539               for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8540                 {
8541                   tree arg = non_reference (TREE_VALUE (p));
8542                   /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8543                      because these checks are performed even on
8544                      template functions.  */
8545                   if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8546                     break;
8547                 }
8548
8549               if (!p || p == void_list_node)
8550                 {
8551                   if (!complain)
8552                     return false;
8553
8554                   error ("`%D' must have an argument of class or "
8555                          "enumerated type",
8556                          decl);
8557                   ok = false;
8558                 }
8559             }
8560         }
8561
8562       /* There are no restrictions on the arguments to an overloaded
8563          "operator ()".  */
8564       if (operator_code == CALL_EXPR)
8565         return ok;
8566
8567       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
8568         {
8569           tree t = TREE_TYPE (name);
8570           if (! friendp)
8571             {
8572               int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8573               const char *what = 0;
8574
8575               if (ref)
8576                 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8577
8578               if (TREE_CODE (t) == VOID_TYPE)
8579                 what = "void";
8580               else if (t == current_class_type)
8581                 what = "the same type";
8582               /* Don't force t to be complete here.  */
8583               else if (IS_AGGR_TYPE (t)
8584                        && COMPLETE_TYPE_P (t)
8585                        && DERIVED_FROM_P (t, current_class_type))
8586                 what = "a base class";
8587
8588               if (what && warn_conversion)
8589                 warning ("conversion to %s%s will never use a type conversion operator",
8590                          ref ? "a reference to " : "", what);
8591             }
8592         }
8593       if (operator_code == COND_EXPR)
8594         {
8595           /* 13.4.0.3 */
8596           error ("ISO C++ prohibits overloading operator ?:");
8597         }
8598       else if (ambi_op_p (operator_code))
8599         {
8600           if (arity == 1)
8601             /* We pick the one-argument operator codes by default, so
8602                we don't have to change anything.  */
8603             ;
8604           else if (arity == 2)
8605             {
8606               /* If we thought this was a unary operator, we now know
8607                  it to be a binary operator.  */
8608               switch (operator_code)
8609                 {
8610                 case INDIRECT_REF:
8611                   operator_code = MULT_EXPR;
8612                   break;
8613
8614                 case ADDR_EXPR:
8615                   operator_code = BIT_AND_EXPR;
8616                   break;
8617
8618                 case CONVERT_EXPR:
8619                   operator_code = PLUS_EXPR;
8620                   break;
8621
8622                 case NEGATE_EXPR:
8623                   operator_code = MINUS_EXPR;
8624                   break;
8625
8626                 case PREINCREMENT_EXPR:
8627                   operator_code = POSTINCREMENT_EXPR;
8628                   break;
8629
8630                 case PREDECREMENT_EXPR:
8631                   operator_code = POSTDECREMENT_EXPR;
8632                   break;
8633
8634                 default:
8635                   abort ();
8636                 }
8637
8638               SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8639
8640               if ((operator_code == POSTINCREMENT_EXPR
8641                    || operator_code == POSTDECREMENT_EXPR)
8642                   && ! processing_template_decl
8643                   && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8644                 {
8645                   if (methodp)
8646                     error ("postfix `%D' must take `int' as its argument",
8647                               decl);
8648                   else
8649                     error
8650                       ("postfix `%D' must take `int' as its second argument",
8651                        decl);
8652                 }
8653             }
8654           else
8655             {
8656               if (methodp)
8657                 error ("`%D' must take either zero or one argument", decl);
8658               else
8659                 error ("`%D' must take either one or two arguments", decl);
8660             }
8661
8662           /* More Effective C++ rule 6.  */
8663           if (warn_ecpp
8664               && (operator_code == POSTINCREMENT_EXPR
8665                   || operator_code == POSTDECREMENT_EXPR
8666                   || operator_code == PREINCREMENT_EXPR
8667                   || operator_code == PREDECREMENT_EXPR))
8668             {
8669               tree arg = TREE_VALUE (argtypes);
8670               tree ret = TREE_TYPE (TREE_TYPE (decl));
8671               if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
8672                 arg = TREE_TYPE (arg);
8673               arg = TYPE_MAIN_VARIANT (arg);
8674               if (operator_code == PREINCREMENT_EXPR
8675                   || operator_code == PREDECREMENT_EXPR)
8676                 {
8677                   if (TREE_CODE (ret) != REFERENCE_TYPE
8678                       || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
8679                                        arg))
8680                     warning ("prefix `%D' should return `%T'", decl,
8681                                 build_reference_type (arg));
8682                 }
8683               else
8684                 {
8685                   if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
8686                     warning ("postfix `%D' should return `%T'", decl, arg);
8687                 }
8688             }
8689         }
8690       else if (unary_op_p (operator_code))
8691         {
8692           if (arity != 1)
8693             {
8694               if (methodp)
8695                 error ("`%D' must take `void'", decl);
8696               else
8697                 error ("`%D' must take exactly one argument", decl);
8698             }
8699         }
8700       else /* if (binary_op_p (operator_code)) */
8701         {
8702           if (arity != 2)
8703             {
8704               if (methodp)
8705                 error ("`%D' must take exactly one argument", decl);
8706               else
8707                 error ("`%D' must take exactly two arguments", decl);
8708             }
8709
8710           /* More Effective C++ rule 7.  */
8711           if (warn_ecpp
8712               && (operator_code == TRUTH_ANDIF_EXPR
8713                   || operator_code == TRUTH_ORIF_EXPR
8714                   || operator_code == COMPOUND_EXPR))
8715             warning ("user-defined `%D' always evaluates both arguments",
8716                         decl);
8717         }
8718
8719       /* Effective C++ rule 23.  */
8720       if (warn_ecpp
8721           && arity == 2
8722           && !DECL_ASSIGNMENT_OPERATOR_P (decl)
8723           && (operator_code == PLUS_EXPR
8724               || operator_code == MINUS_EXPR
8725               || operator_code == TRUNC_DIV_EXPR
8726               || operator_code == MULT_EXPR
8727               || operator_code == TRUNC_MOD_EXPR)
8728           && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
8729         warning ("`%D' should return by value", decl);
8730
8731       /* [over.oper]/8 */
8732       for (; argtypes && argtypes != void_list_node;
8733           argtypes = TREE_CHAIN (argtypes))
8734         if (TREE_PURPOSE (argtypes))
8735           {
8736             TREE_PURPOSE (argtypes) = NULL_TREE;
8737             if (operator_code == POSTINCREMENT_EXPR
8738                 || operator_code == POSTDECREMENT_EXPR)
8739               {
8740                 if (pedantic)
8741                   pedwarn ("`%D' cannot have default arguments", decl);
8742               }
8743             else
8744               error ("`%D' cannot have default arguments", decl);
8745           }
8746
8747     }
8748
8749   return ok;
8750 }
8751 \f
8752 static const char *
8753 tag_name (enum tag_types code)
8754 {
8755   switch (code)
8756     {
8757     case record_type:
8758       return "struct";
8759     case class_type:
8760       return "class";
8761     case union_type:
8762       return "union ";
8763     case enum_type:
8764       return "enum";
8765     default:
8766       abort ();
8767     }
8768 }
8769
8770 /* Name lookup in an elaborated-type-specifier (after the keyword
8771    indicated by TAG_CODE) has found the TYPE_DECL DECL.  If the
8772    elaborated-type-specifier is invalid, issue a diagnostic and return
8773    error_mark_node; otherwise, return the *_TYPE to which it referred.
8774    If ALLOW_TEMPLATE_P is true, TYPE may be a class template.  */
8775
8776 tree
8777 check_elaborated_type_specifier (enum tag_types tag_code,
8778                                  tree decl,
8779                                  bool allow_template_p)
8780 {
8781   tree type;
8782
8783   /* In the case of:
8784
8785        struct S { struct S *p; };
8786
8787      name lookup will find the TYPE_DECL for the implicit "S::S"
8788      typedef.  Adjust for that here.  */
8789   if (DECL_SELF_REFERENCE_P (decl))
8790     decl = TYPE_NAME (TREE_TYPE (decl));
8791
8792   type = TREE_TYPE (decl);
8793
8794   /*   [dcl.type.elab]
8795
8796        If the identifier resolves to a typedef-name or a template
8797        type-parameter, the elaborated-type-specifier is ill-formed.
8798
8799      In other words, the only legitimate declaration to use in the
8800      elaborated type specifier is the implicit typedef created when
8801      the type is declared.  */
8802   if (!DECL_IMPLICIT_TYPEDEF_P (decl))
8803     {
8804       error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code));
8805       return IS_AGGR_TYPE (type) ? type : error_mark_node;
8806     }
8807
8808   if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8809     {
8810       error ("using template type parameter `%T' after `%s'",
8811              type, tag_name (tag_code));
8812       return error_mark_node;
8813     }
8814   else if (TREE_CODE (type) != RECORD_TYPE
8815            && TREE_CODE (type) != UNION_TYPE
8816            && tag_code != enum_type)
8817     {
8818       error ("`%T' referred to as `%s'", type, tag_name (tag_code));
8819       return error_mark_node;
8820     }
8821   else if (TREE_CODE (type) != ENUMERAL_TYPE
8822            && tag_code == enum_type)
8823     {
8824       error ("`%T' referred to as enum", type);
8825       return error_mark_node;
8826     }
8827   else if (!allow_template_p
8828            && TREE_CODE (type) == RECORD_TYPE
8829            && CLASSTYPE_IS_TEMPLATE (type))
8830     {
8831       /* If a class template appears as elaborated type specifier
8832          without a template header such as:
8833
8834            template <class T> class C {};
8835            void f(class C);             // No template header here
8836
8837          then the required template argument is missing.  */
8838
8839       error ("template argument required for `%s %T'",
8840              tag_name (tag_code),
8841              DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
8842       return error_mark_node;
8843     }
8844
8845   return type;
8846 }
8847
8848 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8849    Define the tag as a forward-reference if it is not defined.
8850
8851    If a declaration is given, process it here, and report an error if
8852    multiple declarations are not identical.
8853
8854    GLOBALIZE is false when this is also a definition.  Only look in
8855    the current frame for the name (since C++ allows new names in any
8856    scope.)
8857
8858    TEMPLATE_HEADER_P is true when this declaration is preceded by
8859    a set of template parameters.  */
8860
8861 tree
8862 xref_tag (enum tag_types tag_code, tree name,
8863           bool globalize, bool template_header_p)
8864 {
8865   enum tree_code code;
8866   tree t;
8867   struct cp_binding_level *b = current_binding_level;
8868   tree context = NULL_TREE;
8869
8870   timevar_push (TV_NAME_LOOKUP);
8871
8872   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
8873
8874   switch (tag_code)
8875     {
8876     case record_type:
8877     case class_type:
8878       code = RECORD_TYPE;
8879       break;
8880     case union_type:
8881       code = UNION_TYPE;
8882       break;
8883     case enum_type:
8884       code = ENUMERAL_TYPE;
8885       break;
8886     default:
8887       abort ();
8888     }
8889
8890   if (! globalize)
8891     {
8892       /* If we know we are defining this tag, only look it up in
8893          this scope and don't try to find it as a type.  */
8894       t = lookup_tag (code, name, b, 1);
8895     }
8896   else
8897     {
8898       tree decl = lookup_name (name, 2);
8899
8900       if (decl && DECL_CLASS_TEMPLATE_P (decl))
8901         decl = DECL_TEMPLATE_RESULT (decl);
8902
8903       if (decl && TREE_CODE (decl) == TYPE_DECL)
8904         {
8905           /* Two cases we need to consider when deciding if a class
8906              template is allowed as an elaborated type specifier:
8907              1. It is a self reference to its own class.
8908              2. It comes with a template header.
8909
8910              For example:
8911
8912                template <class T> class C {
8913                  class C *c1;           // DECL_SELF_REFERENCE_P is true
8914                  class D;
8915                };
8916                template <class U> class C; // template_header_p is true
8917                template <class T> class C<T>::D {
8918                  class C *c2;           // DECL_SELF_REFERENCE_P is true
8919                };  */
8920
8921           t = check_elaborated_type_specifier (tag_code,
8922                                                decl,
8923                                                template_header_p
8924                                                | DECL_SELF_REFERENCE_P (decl));
8925           if (t == error_mark_node)
8926             POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8927         }
8928       else
8929         t = NULL_TREE;
8930
8931       if (t && current_class_type
8932           && template_class_depth (current_class_type)
8933           && template_header_p)
8934         {
8935           /* Since GLOBALIZE is nonzero, we are not looking at a
8936              definition of this tag.  Since, in addition, we are currently
8937              processing a (member) template declaration of a template
8938              class, we must be very careful; consider:
8939
8940                template <class X>
8941                struct S1
8942
8943                template <class U>
8944                struct S2
8945                { template <class V>
8946                friend struct S1; };
8947
8948              Here, the S2::S1 declaration should not be confused with the
8949              outer declaration.  In particular, the inner version should
8950              have a template parameter of level 2, not level 1.  This
8951              would be particularly important if the member declaration
8952              were instead:
8953
8954                template <class V = U> friend struct S1;
8955
8956              say, when we should tsubst into `U' when instantiating
8957              S2.  On the other hand, when presented with:
8958
8959                  template <class T>
8960                  struct S1 {
8961                    template <class U>
8962                    struct S2 {};
8963                    template <class U>
8964                    friend struct S2;
8965                  };
8966
8967               we must find the inner binding eventually.  We
8968               accomplish this by making sure that the new type we
8969               create to represent this declaration has the right
8970               TYPE_CONTEXT.  */
8971           context = TYPE_CONTEXT (t);
8972           t = NULL_TREE;
8973         }
8974     }
8975
8976   if (! t)
8977     {
8978       /* If no such tag is yet defined, create a forward-reference node
8979          and record it as the "definition".
8980          When a real declaration of this type is found,
8981          the forward-reference will be altered into a real type.  */
8982       if (code == ENUMERAL_TYPE)
8983         {
8984           error ("use of enum `%#D' without previous declaration", name);
8985           POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8986         }
8987       else
8988         {
8989           t = make_aggr_type (code);
8990           TYPE_CONTEXT (t) = context;
8991           pushtag (name, t, globalize);
8992         }
8993     }
8994   else
8995     {
8996       if (!globalize && processing_template_decl && IS_AGGR_TYPE (t))
8997         redeclare_class_template (t, current_template_parms);
8998       else if (!processing_template_decl
8999                && CLASS_TYPE_P (t)
9000                && CLASSTYPE_IS_TEMPLATE (t))
9001         {
9002           error ("redeclaration of `%T' as a non-template", t);
9003           t = error_mark_node;
9004         }
9005     }
9006
9007   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9008 }
9009
9010 tree
9011 xref_tag_from_type (tree old, tree id, int globalize)
9012 {
9013   enum tag_types tag_kind;
9014
9015   if (TREE_CODE (old) == RECORD_TYPE)
9016     tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9017   else
9018     tag_kind  = union_type;
9019
9020   if (id == NULL_TREE)
9021     id = TYPE_IDENTIFIER (old);
9022
9023   return xref_tag (tag_kind, id, globalize, false);
9024 }
9025
9026 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9027    BASE_LIST.  For each element on BASE_LIST the TREE_PURPOSE is an
9028    access_* node, and the TREE_VALUE is the type of the base-class.
9029    Non-NULL TREE_TYPE indicates virtual inheritance.  */
9030
9031 void
9032 xref_basetypes (tree ref, tree base_list)
9033 {
9034   tree *basep;
9035   tree binfo;
9036   unsigned max_vbases = 0; /* Maxium direct & indirect virtual bases. */
9037   unsigned max_bases = 0;  /* Maxium direct bases.  */
9038   int i;
9039   tree default_access;
9040   tree igo_prev; /* Track Inheritance Graph Order.  */
9041
9042   if (ref == error_mark_node)
9043     return;
9044
9045   /* The base of a derived class is private by default, all others are
9046      public.  */
9047   default_access = (TREE_CODE (ref) == RECORD_TYPE
9048                     && CLASSTYPE_DECLARED_CLASS (ref)
9049                     ? access_private_node : access_public_node);
9050
9051   /* First, make sure that any templates in base-classes are
9052      instantiated.  This ensures that if we call ourselves recursively
9053      we do not get confused about which classes are marked and which
9054      are not.  */
9055   basep = &base_list;
9056   while (*basep)
9057     {
9058       tree basetype = TREE_VALUE (*basep);
9059
9060       if (!(processing_template_decl && uses_template_parms (basetype))
9061           && !complete_type_or_else (basetype, NULL))
9062         /* An incomplete type.  Remove it from the list.  */
9063         *basep = TREE_CHAIN (*basep);
9064       else
9065         {
9066           max_bases++;
9067           if (TREE_TYPE (*basep))
9068             max_vbases++;
9069           if (CLASS_TYPE_P (basetype))
9070             max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9071           basep = &TREE_CHAIN (*basep);
9072         }
9073     }
9074
9075   SET_CLASSTYPE_MARKED (ref);
9076
9077   /* The binfo slot should be empty, unless this is an (ill-formed)
9078      redefinition.  */
9079   my_friendly_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref), 20040706);
9080   my_friendly_assert (TYPE_MAIN_VARIANT (ref) == ref, 20040712);
9081
9082   binfo = make_tree_binfo (BINFO_LANG_SLOTS);
9083   TYPE_BINFO (ref) = binfo;
9084   BINFO_OFFSET (binfo) = size_zero_node;
9085   BINFO_TYPE (binfo) = ref;
9086
9087   if (max_bases)
9088     {
9089       BINFO_BASE_BINFOS (binfo) = make_tree_vec (max_bases);
9090       BINFO_BASE_ACCESSES (binfo) = make_tree_vec (max_bases);
9091       /* An aggregate cannot have baseclasses.  */
9092       CLASSTYPE_NON_AGGREGATE (ref) = 1;
9093
9094       if (TREE_CODE (ref) == UNION_TYPE)
9095         error ("derived union `%T' invalid", ref);
9096     }
9097
9098   if (max_bases > 1)
9099     {
9100       TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
9101       /* If there is more than one non-empty they cannot be at the
9102          same address.  */
9103       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9104
9105       if (TYPE_FOR_JAVA (ref))
9106         error ("Java class '%T' cannot have multiple bases", ref);
9107     }
9108
9109   if (max_vbases)
9110     {
9111       CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, max_vbases);
9112       TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
9113       /* Converting to a virtual base class requires looking up the
9114          offset of the virtual base.  */
9115       TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9116
9117       if (TYPE_FOR_JAVA (ref))
9118         error ("Java class '%T' cannot have virtual bases", ref);
9119     }
9120
9121   i = 0;
9122   for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9123     {
9124       tree access = TREE_PURPOSE (base_list);
9125       int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9126       tree basetype = TREE_VALUE (base_list);
9127       tree base_binfo = NULL_TREE;
9128
9129       if (access == access_default_node)
9130         access = default_access;
9131
9132       if (TREE_CODE (basetype) == TYPE_DECL)
9133         basetype = TREE_TYPE (basetype);
9134       if (TREE_CODE (basetype) != RECORD_TYPE
9135           && TREE_CODE (basetype) != TYPENAME_TYPE
9136           && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9137           && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9138         {
9139           error ("base type `%T' fails to be a struct or class type",
9140                  basetype);
9141           continue;
9142         }
9143
9144       if (CLASSTYPE_MARKED (basetype))
9145         {
9146           if (basetype == ref)
9147             error ("recursive type `%T' undefined", basetype);
9148           else
9149             error ("duplicate base type `%T' invalid", basetype);
9150           continue;
9151         }
9152       SET_CLASSTYPE_MARKED (basetype);
9153
9154       if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9155         TYPE_FOR_JAVA (ref) = 1;
9156
9157       if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9158         {
9159           base_binfo = TYPE_BINFO (basetype);
9160           /* The orignal basetype could have been a typedef'd type.  */
9161           basetype = BINFO_TYPE (base_binfo);
9162
9163           /* Inherit flags from the base.  */
9164           TYPE_HAS_NEW_OPERATOR (ref)
9165             |= TYPE_HAS_NEW_OPERATOR (basetype);
9166           TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9167             |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9168           TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9169           TYPE_USES_MULTIPLE_INHERITANCE (ref)
9170             |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
9171           TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
9172             |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
9173           TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9174         }
9175
9176       base_binfo = copy_binfo (base_binfo, basetype, ref,
9177                                &igo_prev, via_virtual);
9178       if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9179         BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9180
9181       TREE_VEC_ELT (BINFO_BASE_ACCESSES (binfo), i) = access;
9182       BINFO_BASE_BINFO (binfo, i) = base_binfo;
9183       i++;
9184     }
9185
9186   if (max_bases)
9187     {
9188       /* If any bases were invalid, we will have allocated too many
9189          slots.  */
9190       TREE_VEC_LENGTH (BINFO_BASE_ACCESSES (binfo)) = i;
9191       TREE_VEC_LENGTH (BINFO_BASE_BINFOS (binfo)) = i;
9192     }
9193
9194   /* Unmark all the types.  */
9195   for (i = 0; i != BINFO_N_BASE_BINFOS (binfo); i++)
9196     CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (BINFO_BASE_BINFO (binfo, i)));
9197   CLEAR_CLASSTYPE_MARKED (ref);
9198 }
9199
9200 \f
9201 /* Begin compiling the definition of an enumeration type.
9202    NAME is its name (or null if anonymous).
9203    Returns the type object, as yet incomplete.
9204    Also records info about it so that build_enumerator
9205    may be used to declare the individual values as they are read.  */
9206
9207 tree
9208 start_enum (tree name)
9209 {
9210   tree enumtype = NULL_TREE;
9211   struct cp_binding_level *b = current_binding_level;
9212
9213   /* If this is the real definition for a previous forward reference,
9214      fill in the contents in the same object that used to be the
9215      forward reference.  */
9216
9217   if (name != NULL_TREE)
9218     enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
9219
9220   if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9221     {
9222       error ("multiple definition of `%#T'", enumtype);
9223       error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9224       /* Clear out TYPE_VALUES, and start again.  */
9225       TYPE_VALUES (enumtype) = NULL_TREE;
9226     }
9227   else
9228     {
9229       enumtype = make_node (ENUMERAL_TYPE);
9230       pushtag (name, enumtype, 0);
9231     }
9232
9233   return enumtype;
9234 }
9235
9236 /* After processing and defining all the values of an enumeration type,
9237    install their decls in the enumeration type and finish it off.
9238    ENUMTYPE is the type object and VALUES a list of name-value pairs.  */
9239
9240 void
9241 finish_enum (tree enumtype)
9242 {
9243   tree values;
9244   tree decl;
9245   tree value;
9246   tree minnode;
9247   tree maxnode;
9248   tree t;
9249   bool unsignedp;
9250   int lowprec;
9251   int highprec;
9252   int precision;
9253   integer_type_kind itk;
9254   tree underlying_type = NULL_TREE;
9255
9256   /* We built up the VALUES in reverse order.  */
9257   TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9258
9259   /* For an enum defined in a template, just set the type of the values;
9260      all further processing is postponed until the template is
9261      instantiated.  We need to set the type so that tsubst of a CONST_DECL
9262      works.  */
9263   if (processing_template_decl)
9264     {
9265       for (values = TYPE_VALUES (enumtype);
9266            values;
9267            values = TREE_CHAIN (values))
9268         TREE_TYPE (TREE_VALUE (values)) = enumtype;
9269       if (at_function_scope_p ())
9270         add_stmt (build_min (TAG_DEFN, enumtype));
9271       return;
9272     }
9273
9274   /* Determine the minimum and maximum values of the enumerators.  */
9275   if (TYPE_VALUES (enumtype))
9276     {
9277       minnode = maxnode = NULL_TREE;
9278
9279       for (values = TYPE_VALUES (enumtype);
9280            values;
9281            values = TREE_CHAIN (values))
9282         {
9283           decl = TREE_VALUE (values);
9284
9285           /* [dcl.enum]: Following the closing brace of an enum-specifier,
9286              each enumerator has the type of its enumeration.  Prior to the
9287              closing brace, the type of each enumerator is the type of its
9288              initializing value.  */
9289           TREE_TYPE (decl) = enumtype;
9290
9291           /* Update the minimum and maximum values, if appropriate.  */
9292           value = DECL_INITIAL (decl);
9293           /* Figure out what the minimum and maximum values of the
9294              enumerators are.  */
9295           if (!minnode)
9296             minnode = maxnode = value;
9297           else if (tree_int_cst_lt (maxnode, value))
9298             maxnode = value;
9299           else if (tree_int_cst_lt (value, minnode))
9300             minnode = value;
9301
9302           /* Set the TREE_TYPE for the values as well.  That's so that when
9303              we call decl_constant_value we get an entity of the right type
9304              (but with the constant value).  But first make a copy so we
9305              don't clobber shared INTEGER_CSTs.  */
9306           if (TREE_TYPE (value) != enumtype)
9307             {
9308               value = DECL_INITIAL (decl) = copy_node (value);
9309               TREE_TYPE (value) = enumtype;
9310             }
9311         }
9312     }
9313   else
9314     /* [dcl.enum]
9315
9316        If the enumerator-list is empty, the underlying type is as if
9317        the enumeration had a single enumerator with value 0.  */
9318     minnode = maxnode = integer_zero_node;
9319
9320   /* Compute the number of bits require to represent all values of the
9321      enumeration.  We must do this before the type of MINNODE and
9322      MAXNODE are transformed, since min_precision relies on the
9323      TREE_TYPE of the value it is passed.  */
9324   unsignedp = tree_int_cst_sgn (minnode) >= 0;
9325   lowprec = min_precision (minnode, unsignedp);
9326   highprec = min_precision (maxnode, unsignedp);
9327   precision = MAX (lowprec, highprec);
9328
9329   /* Determine the underlying type of the enumeration.
9330
9331        [dcl.enum]
9332
9333        The underlying type of an enumeration is an integral type that
9334        can represent all the enumerator values defined in the
9335        enumeration.  It is implementation-defined which integral type is
9336        used as the underlying type for an enumeration except that the
9337        underlying type shall not be larger than int unless the value of
9338        an enumerator cannot fit in an int or unsigned int.
9339
9340      We use "int" or an "unsigned int" as the underlying type, even if
9341      a smaller integral type would work, unless the user has
9342      explicitly requested that we use the smallest possible type.  */
9343   for (itk = (flag_short_enums ? itk_char : itk_int);
9344        itk != itk_none;
9345        itk++)
9346     {
9347       underlying_type = integer_types[itk];
9348       if (TYPE_PRECISION (underlying_type) >= precision
9349           && TYPE_UNSIGNED (underlying_type) == unsignedp)
9350         break;
9351     }
9352   if (itk == itk_none)
9353     {
9354       /* DR 377
9355
9356          IF no integral type can represent all the enumerator values, the
9357          enumeration is ill-formed.  */
9358       error ("no integral type can represent all of the enumerator values "
9359              "for `%T'", enumtype);
9360       precision = TYPE_PRECISION (long_long_integer_type_node);
9361       underlying_type = integer_types[itk_unsigned_long_long];
9362     }
9363
9364   /* Compute the minium and maximum values for the type.
9365
9366      [dcl.enum]
9367
9368      For an enumeration where emin is the smallest enumerator and emax
9369      is the largest, the values of the enumeration are the values of the
9370      underlying type in the range bmin to bmax, where bmin and bmax are,
9371      respectively, the smallest and largest values of the smallest bit-
9372      field that can store emin and emax.  */
9373   TYPE_PRECISION (enumtype) = precision;
9374   set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9375
9376   /* [dcl.enum]
9377
9378      The value of sizeof() applied to an enumeration type, an object
9379      of an enumeration type, or an enumerator, is the value of sizeof()
9380      applied to the underlying type.  */
9381   TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9382   TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9383   TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9384   TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9385   TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9386   TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9387
9388   /* Convert each of the enumerators to the type of the underlying
9389      type of the enumeration.  */
9390   for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9391     {
9392       decl = TREE_VALUE (values);
9393       value = perform_implicit_conversion (underlying_type,
9394                                            DECL_INITIAL (decl));
9395       TREE_TYPE (value) = enumtype;
9396       DECL_INITIAL (decl) = value;
9397       TREE_VALUE (values) = value;
9398     }
9399
9400   /* Fix up all variant types of this enum type.  */
9401   for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9402     {
9403       TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9404       TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9405       TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9406       TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9407       TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9408       TYPE_MODE (t) = TYPE_MODE (enumtype);
9409       TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9410       TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9411       TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9412       TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9413     }
9414
9415   /* Finish debugging output for this type.  */
9416   rest_of_type_compilation (enumtype, namespace_bindings_p ());
9417 }
9418
9419 /* Build and install a CONST_DECL for an enumeration constant of the
9420    enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9421    Assignment of sequential values by default is handled here.  */
9422
9423 void
9424 build_enumerator (tree name, tree value, tree enumtype)
9425 {
9426   tree decl;
9427   tree context;
9428   tree type;
9429
9430   /* Remove no-op casts from the value.  */
9431   if (value)
9432     STRIP_TYPE_NOPS (value);
9433
9434   if (! processing_template_decl)
9435     {
9436       /* Validate and default VALUE.  */
9437       if (value != NULL_TREE)
9438         {
9439           value = decl_constant_value (value);
9440
9441           if (TREE_CODE (value) == INTEGER_CST)
9442             {
9443               value = perform_integral_promotions (value);
9444               constant_expression_warning (value);
9445             }
9446           else
9447             {
9448               error ("enumerator value for `%D' not integer constant", name);
9449               value = NULL_TREE;
9450             }
9451         }
9452
9453       /* Default based on previous value.  */
9454       if (value == NULL_TREE)
9455         {
9456           tree prev_value;
9457
9458           if (TYPE_VALUES (enumtype))
9459             {
9460               /* The next value is the previous value ...  */
9461               prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9462               /* ... plus one.  */
9463               value = cp_build_binary_op (PLUS_EXPR,
9464                                           prev_value,
9465                                           integer_one_node);
9466
9467               if (tree_int_cst_lt (value, prev_value))
9468                 error ("overflow in enumeration values at `%D'", name);
9469             }
9470           else
9471             value = integer_zero_node;
9472         }
9473
9474       /* Remove no-op casts from the value.  */
9475       STRIP_TYPE_NOPS (value);
9476     }
9477
9478   /* C++ associates enums with global, function, or class declarations.  */
9479   context = current_scope ();
9480   if (!context)
9481     context = current_namespace;
9482
9483   /* Build the actual enumeration constant.  Note that the enumeration
9484     constants have the type of their initializers until the
9485     enumeration is complete:
9486
9487       [ dcl.enum ]
9488
9489       Following the closing brace of an enum-specifier, each enumer-
9490       ator has the type of its enumeration.  Prior to the closing
9491       brace, the type of each enumerator is the type of its
9492       initializing value.
9493
9494     In finish_enum we will reset the type.  Of course, if we're
9495     processing a template, there may be no value.  */
9496   type = value ? TREE_TYPE (value) : NULL_TREE;
9497
9498   if (context && context == current_class_type)
9499     /* This enum declaration is local to the class.  We need the full
9500        lang_decl so that we can record DECL_CLASS_CONTEXT, for example.  */
9501     decl = build_lang_decl (CONST_DECL, name, type);
9502   else
9503     /* It's a global enum, or it's local to a function.  (Note local to
9504       a function could mean local to a class method.  */
9505     decl = build_decl (CONST_DECL, name, type);
9506
9507   DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9508   TREE_CONSTANT (decl) = 1;
9509   TREE_INVARIANT (decl) = 1;
9510   TREE_READONLY (decl) = 1;
9511   DECL_INITIAL (decl) = value;
9512
9513   if (context && context == current_class_type)
9514     /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9515        on the TYPE_FIELDS list for `S'.  (That's so that you can say
9516        things like `S::i' later.)  */
9517     finish_member_declaration (decl);
9518   else
9519     pushdecl (decl);
9520
9521   /* Add this enumeration constant to the list for this type.  */
9522   TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
9523 }
9524
9525 \f
9526 /* We're defining DECL.  Make sure that it's type is OK.  */
9527
9528 static void
9529 check_function_type (tree decl, tree current_function_parms)
9530 {
9531   tree fntype = TREE_TYPE (decl);
9532   tree return_type = complete_type (TREE_TYPE (fntype));
9533
9534   /* In a function definition, arg types must be complete.  */
9535   require_complete_types_for_parms (current_function_parms);
9536
9537   if (!COMPLETE_OR_VOID_TYPE_P (return_type))
9538     {
9539       error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
9540
9541       /* Make it return void instead, but don't change the
9542          type of the DECL_RESULT, in case we have a named return value.  */
9543       if (TREE_CODE (fntype) == METHOD_TYPE)
9544         {
9545           tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
9546           TREE_TYPE (decl)
9547             = build_method_type_directly (ctype,
9548                                           void_type_node,
9549                                           FUNCTION_ARG_CHAIN (decl));
9550         }
9551       else
9552         TREE_TYPE (decl)
9553           = build_function_type (void_type_node,
9554                                  TYPE_ARG_TYPES (TREE_TYPE (decl)));
9555       TREE_TYPE (decl)
9556         = build_exception_variant (fntype,
9557                                    TYPE_RAISES_EXCEPTIONS (fntype));
9558     }
9559   else
9560     abstract_virtuals_error (decl, TREE_TYPE (fntype));
9561 }
9562
9563 /* Create the FUNCTION_DECL for a function definition.
9564    DECLSPECS and DECLARATOR are the parts of the declaration;
9565    they describe the function's name and the type it returns,
9566    but twisted together in a fashion that parallels the syntax of C.
9567
9568    FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9569    DECLARATOR is really the DECL for the function we are about to
9570    process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9571    indicating that the function is an inline defined in-class.
9572
9573    This function creates a binding context for the function body
9574    as well as setting up the FUNCTION_DECL in current_function_decl.
9575
9576    For C++, we must first check whether that datum makes any sense.
9577    For example, "class A local_a(1,2);" means that variable local_a
9578    is an aggregate of type A, which should have a constructor
9579    applied to it with the argument list [1, 2].  */
9580
9581 void
9582 start_preparsed_function (tree decl1, tree attrs, int flags)
9583 {
9584   tree ctype = NULL_TREE;
9585   tree fntype;
9586   tree restype;
9587   int doing_friend = 0;
9588   struct cp_binding_level *bl;
9589   tree current_function_parms;
9590
9591   /* Sanity check.  */
9592   my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
9593   my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
9594
9595   fntype = TREE_TYPE (decl1);
9596   if (TREE_CODE (fntype) == METHOD_TYPE)
9597     ctype = TYPE_METHOD_BASETYPE (fntype);
9598
9599   /* ISO C++ 11.4/5.  A friend function defined in a class is in
9600      the (lexical) scope of the class in which it is defined.  */
9601   if (!ctype && DECL_FRIEND_P (decl1))
9602     {
9603       ctype = DECL_FRIEND_CONTEXT (decl1);
9604
9605       /* CTYPE could be null here if we're dealing with a template;
9606          for example, `inline friend float foo()' inside a template
9607          will have no CTYPE set.  */
9608       if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
9609         ctype = NULL_TREE;
9610       else
9611         doing_friend = 1;
9612     }
9613
9614   if (DECL_DECLARED_INLINE_P (decl1)
9615       && lookup_attribute ("noinline", attrs))
9616     warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
9617
9618   if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
9619     /* This is a constructor, we must ensure that any default args
9620        introduced by this definition are propagated to the clones
9621        now. The clones are used directly in overload resolution.  */
9622     adjust_clone_args (decl1);
9623
9624   /* Sometimes we don't notice that a function is a static member, and
9625      build a METHOD_TYPE for it.  Fix that up now.  */
9626   if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
9627       && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
9628     {
9629       revert_static_member_fn (decl1);
9630       ctype = NULL_TREE;
9631     }
9632
9633   /* Set up current_class_type, and enter the scope of the class, if
9634      appropriate.  */
9635   if (ctype)
9636     push_nested_class (ctype);
9637   else if (DECL_STATIC_FUNCTION_P (decl1))
9638     push_nested_class (DECL_CONTEXT (decl1));
9639
9640   /* Now that we have entered the scope of the class, we must restore
9641      the bindings for any template parameters surrounding DECL1, if it
9642      is an inline member template.  (Order is important; consider the
9643      case where a template parameter has the same name as a field of
9644      the class.)  It is not until after this point that
9645      PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly.  */
9646   if (flags & SF_INCLASS_INLINE)
9647     maybe_begin_member_template_processing (decl1);
9648
9649   /* Effective C++ rule 15.  */
9650   if (warn_ecpp
9651       && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9652       && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
9653     warning ("`operator=' should return a reference to `*this'");
9654
9655   /* Make the init_value nonzero so pushdecl knows this is not tentative.
9656      error_mark_node is replaced below (in poplevel) with the BLOCK.  */
9657   if (!DECL_INITIAL (decl1))
9658     DECL_INITIAL (decl1) = error_mark_node;
9659
9660   /* This function exists in static storage.
9661      (This does not mean `static' in the C sense!)  */
9662   TREE_STATIC (decl1) = 1;
9663
9664   /* We must call push_template_decl after current_class_type is set
9665      up.  (If we are processing inline definitions after exiting a
9666      class scope, current_class_type will be NULL_TREE until set above
9667      by push_nested_class.)  */
9668   if (processing_template_decl)
9669     decl1 = push_template_decl (decl1);
9670
9671   /* We are now in the scope of the function being defined.  */
9672   current_function_decl = decl1;
9673
9674   /* Save the parm names or decls from this function's declarator
9675      where store_parm_decls will find them.  */
9676   current_function_parms = DECL_ARGUMENTS (decl1);
9677
9678   /* Make sure the parameter and return types are reasonable.  When
9679      you declare a function, these types can be incomplete, but they
9680      must be complete when you define the function.  */
9681   if (! processing_template_decl)
9682     check_function_type (decl1, current_function_parms);
9683
9684   /* Build the return declaration for the function.  */
9685   restype = TREE_TYPE (fntype);
9686   /* Promote the value to int before returning it.  */
9687   if (c_promoting_integer_type_p (restype))
9688     restype = type_promotes_to (restype);
9689   if (DECL_RESULT (decl1) == NULL_TREE)
9690     {
9691       DECL_RESULT (decl1)
9692         = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
9693       c_apply_type_quals_to_decl (cp_type_quals (restype),
9694                                   DECL_RESULT (decl1));
9695     }
9696
9697   /* Initialize RTL machinery.  We cannot do this until
9698      CURRENT_FUNCTION_DECL and DECL_RESULT are set up.  We do this
9699      even when processing a template; this is how we get
9700      CFUN set up, and our per-function variables initialized.
9701      FIXME factor out the non-RTL stuff.  */
9702   bl = current_binding_level;
9703   allocate_struct_function (decl1);
9704   current_binding_level = bl;
9705
9706   /* Even though we're inside a function body, we still don't want to
9707      call expand_expr to calculate the size of a variable-sized array.
9708      We haven't necessarily assigned RTL to all variables yet, so it's
9709      not safe to try to expand expressions involving them.  */
9710   cfun->x_dont_save_pending_sizes_p = 1;
9711
9712   /* Start the statement-tree, start the tree now.  */
9713   DECL_SAVED_TREE (decl1) = push_stmt_list ();
9714
9715   /* Let the user know we're compiling this function.  */
9716   announce_function (decl1);
9717
9718   /* Record the decl so that the function name is defined.
9719      If we already have a decl for this name, and it is a FUNCTION_DECL,
9720      use the old decl.  */
9721   if (!processing_template_decl && !(flags & SF_PRE_PARSED))
9722     {
9723       /* A specialization is not used to guide overload resolution.  */
9724       if (!DECL_FUNCTION_MEMBER_P (decl1)
9725           && !(DECL_USE_TEMPLATE (decl1) &&
9726                PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
9727         {
9728           tree olddecl = pushdecl (decl1);
9729
9730           if (olddecl == error_mark_node)
9731             /* If something went wrong when registering the declaration,
9732                use DECL1; we have to have a FUNCTION_DECL to use when
9733                parsing the body of the function.  */
9734             ;
9735           else
9736             /* Otherwise, OLDDECL is either a previous declaration of
9737                the same function or DECL1 itself.  */
9738             decl1 = olddecl;
9739         }
9740       else
9741         {
9742           /* We need to set the DECL_CONTEXT.  */
9743           if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
9744             DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
9745           /* And make sure we have enough default args.  */
9746           check_default_args (decl1);
9747         }
9748       fntype = TREE_TYPE (decl1);
9749     }
9750
9751   /* Reset these in case the call to pushdecl changed them.  */
9752   current_function_decl = decl1;
9753   cfun->decl = decl1;
9754
9755   /* If we are (erroneously) defining a function that we have already
9756      defined before, wipe out what we knew before.  */
9757   if (!DECL_PENDING_INLINE_P (decl1))
9758     DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
9759
9760   if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
9761     {
9762       /* We know that this was set up by `grokclassfn'.  We do not
9763          wait until `store_parm_decls', since evil parse errors may
9764          never get us to that point.  Here we keep the consistency
9765          between `current_class_type' and `current_class_ptr'.  */
9766       tree t = DECL_ARGUMENTS (decl1);
9767
9768       my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
9769                           162);
9770       my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
9771                           19990811);
9772
9773       cp_function_chain->x_current_class_ref
9774         = build_indirect_ref (t, NULL);
9775       cp_function_chain->x_current_class_ptr = t;
9776
9777       /* Constructors and destructors need to know whether they're "in
9778          charge" of initializing virtual base classes.  */
9779       t = TREE_CHAIN (t);
9780       if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
9781         {
9782           current_in_charge_parm = t;
9783           t = TREE_CHAIN (t);
9784         }
9785       if (DECL_HAS_VTT_PARM_P (decl1))
9786         {
9787           if (DECL_NAME (t) != vtt_parm_identifier)
9788             abort ();
9789           current_vtt_parm = t;
9790         }
9791     }
9792
9793   if (DECL_INTERFACE_KNOWN (decl1))
9794     {
9795       tree ctx = decl_function_context (decl1);
9796
9797       if (DECL_NOT_REALLY_EXTERN (decl1))
9798         DECL_EXTERNAL (decl1) = 0;
9799
9800       if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
9801           && TREE_PUBLIC (ctx))
9802         /* This is a function in a local class in an extern inline
9803            function.  */
9804         comdat_linkage (decl1);
9805     }
9806   /* If this function belongs to an interface, it is public.
9807      If it belongs to someone else's interface, it is also external.
9808      This only affects inlines and template instantiations.  */
9809   else if (interface_unknown == 0
9810            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9811     {
9812       if (DECL_DECLARED_INLINE_P (decl1)
9813           || DECL_TEMPLATE_INSTANTIATION (decl1)
9814           || processing_template_decl)
9815         {
9816           DECL_EXTERNAL (decl1)
9817             = (interface_only
9818                || (DECL_DECLARED_INLINE_P (decl1)
9819                    && ! flag_implement_inlines
9820                    && !DECL_VINDEX (decl1)));
9821
9822           /* For WIN32 we also want to put these in linkonce sections.  */
9823           maybe_make_one_only (decl1);
9824         }
9825       else
9826         DECL_EXTERNAL (decl1) = 0;
9827       DECL_NOT_REALLY_EXTERN (decl1) = 0;
9828       DECL_INTERFACE_KNOWN (decl1) = 1;
9829     }
9830   else if (interface_unknown && interface_only
9831            && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9832     {
9833       /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
9834          interface, we will have interface_only set but not
9835          interface_known.  In that case, we don't want to use the normal
9836          heuristics because someone will supply a #pragma implementation
9837          elsewhere, and deducing it here would produce a conflict.  */
9838       comdat_linkage (decl1);
9839       DECL_EXTERNAL (decl1) = 0;
9840       DECL_INTERFACE_KNOWN (decl1) = 1;
9841       DECL_DEFER_OUTPUT (decl1) = 1;
9842     }
9843   else
9844     {
9845       /* This is a definition, not a reference.
9846          So clear DECL_EXTERNAL.  */
9847       DECL_EXTERNAL (decl1) = 0;
9848
9849       if ((DECL_DECLARED_INLINE_P (decl1)
9850            || DECL_TEMPLATE_INSTANTIATION (decl1))
9851           && ! DECL_INTERFACE_KNOWN (decl1)
9852           /* Don't try to defer nested functions for now.  */
9853           && ! decl_function_context (decl1))
9854         DECL_DEFER_OUTPUT (decl1) = 1;
9855       else
9856         DECL_INTERFACE_KNOWN (decl1) = 1;
9857     }
9858
9859   begin_scope (sk_function_parms, decl1);
9860
9861   ++function_depth;
9862
9863   if (DECL_DESTRUCTOR_P (decl1))
9864     {
9865       dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
9866       DECL_CONTEXT (dtor_label) = current_function_decl;
9867     }
9868
9869   start_fname_decls ();
9870
9871   store_parm_decls (current_function_parms);
9872 }
9873
9874
9875 /* Like start_preparsed_function, except that instead of a
9876    FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
9877
9878    Returns 1 on success.  If the DECLARATOR is not suitable for a function
9879    (it defines a datum instead), we return 0, which tells
9880    yyparse to report a parse error.  */
9881
9882 int
9883 start_function (cp_decl_specifier_seq *declspecs,
9884                 const cp_declarator *declarator,
9885                 tree attrs)
9886 {
9887   tree decl1;
9888
9889   if (have_extern_spec)
9890     {
9891       declspecs->storage_class = sc_extern;
9892       /* This should only be done once on the outermost decl.  */
9893       have_extern_spec = false;
9894     }
9895
9896   decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
9897   /* If the declarator is not suitable for a function definition,
9898      cause a syntax error.  */
9899   if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
9900     return 0;
9901
9902   cplus_decl_attributes (&decl1, attrs, 0);
9903
9904   /* If #pragma weak was used, mark the decl weak now.  */
9905   if (global_scope_p (current_binding_level))
9906     maybe_apply_pragma_weak (decl1);
9907
9908   if (DECL_MAIN_P (decl1))
9909     {
9910       /* If this doesn't return integer_type, or a typedef to
9911          integer_type, complain.  */
9912       if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node))
9913         {
9914           if (pedantic || warn_return_type)
9915             pedwarn ("return type for `main' changed to `int'");
9916           TREE_TYPE (decl1) = default_function_type;
9917         }
9918     }
9919
9920   start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
9921
9922   return 1;
9923 }
9924 \f
9925 /* Store the parameter declarations into the current function declaration.
9926    This is called after parsing the parameter declarations, before
9927    digesting the body of the function.
9928
9929    Also install to binding contour return value identifier, if any.  */
9930
9931 static void
9932 store_parm_decls (tree current_function_parms)
9933 {
9934   tree fndecl = current_function_decl;
9935   tree parm;
9936
9937   /* This is a chain of any other decls that came in among the parm
9938      declarations.  If a parm is declared with  enum {foo, bar} x;
9939      then CONST_DECLs for foo and bar are put here.  */
9940   tree nonparms = NULL_TREE;
9941
9942   if (current_function_parms)
9943     {
9944       /* This case is when the function was defined with an ANSI prototype.
9945          The parms already have decls, so we need not do anything here
9946          except record them as in effect
9947          and complain if any redundant old-style parm decls were written.  */
9948
9949       tree specparms = current_function_parms;
9950       tree next;
9951
9952       /* Must clear this because it might contain TYPE_DECLs declared
9953              at class level.  */
9954       current_binding_level->names = NULL;
9955
9956       /* If we're doing semantic analysis, then we'll call pushdecl
9957              for each of these.  We must do them in reverse order so that
9958              they end in the correct forward order.  */
9959       specparms = nreverse (specparms);
9960
9961       for (parm = specparms; parm; parm = next)
9962         {
9963           next = TREE_CHAIN (parm);
9964           if (TREE_CODE (parm) == PARM_DECL)
9965             {
9966               if (DECL_NAME (parm) == NULL_TREE
9967                   || TREE_CODE (parm) != VOID_TYPE)
9968                 pushdecl (parm);
9969               else
9970                 error ("parameter `%D' declared void", parm);
9971             }
9972           else
9973             {
9974               /* If we find an enum constant or a type tag,
9975                  put it aside for the moment.  */
9976               TREE_CHAIN (parm) = NULL_TREE;
9977               nonparms = chainon (nonparms, parm);
9978             }
9979         }
9980
9981       /* Get the decls in their original chain order and record in the
9982          function.  This is all and only the PARM_DECLs that were
9983          pushed into scope by the loop above.  */
9984       DECL_ARGUMENTS (fndecl) = getdecls ();
9985     }
9986   else
9987     DECL_ARGUMENTS (fndecl) = NULL_TREE;
9988
9989   /* Now store the final chain of decls for the arguments
9990      as the decl-chain of the current lexical scope.
9991      Put the enumerators in as well, at the front so that
9992      DECL_ARGUMENTS is not modified.  */
9993   current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
9994
9995   /* For a cloned function, we've already got all the code we need;
9996      there's no need to add any extra bits.  */
9997   if (!DECL_CLONED_FUNCTION_P (fndecl))
9998     {
9999       /* Do the starting of the exception specifications, if we have any.  */
10000       if (flag_exceptions && !processing_template_decl
10001           && flag_enforce_eh_specs
10002           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10003         current_eh_spec_block = begin_eh_spec_block ();
10004     }
10005 }
10006
10007 \f
10008 /* We have finished doing semantic analysis on DECL, but have not yet
10009    generated RTL for its body.  Save away our current state, so that
10010    when we want to generate RTL later we know what to do.  */
10011
10012 static void
10013 save_function_data (tree decl)
10014 {
10015   struct language_function *f;
10016
10017   /* Save the language-specific per-function data so that we can
10018      get it back when we really expand this function.  */
10019   my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
10020                       19990908);
10021
10022   /* Make a copy.  */
10023   f = ggc_alloc (sizeof (struct language_function));
10024   memcpy (f, cp_function_chain, sizeof (struct language_function));
10025   DECL_SAVED_FUNCTION_DATA (decl) = f;
10026
10027   /* Clear out the bits we don't need.  */
10028   f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10029   f->x_named_label_uses = NULL;
10030   f->bindings = NULL;
10031   f->x_local_names = NULL;
10032 }
10033
10034 /* Add a note to mark the beginning of the main body of the constructor.
10035    This is used to set up the data structures for the cleanup regions for
10036    fully-constructed bases and members.  */
10037
10038 static void
10039 begin_constructor_body (void)
10040 {
10041 }
10042
10043 /* Add a note to mark the end of the main body of the constructor.  This is
10044    used to end the cleanup regions for fully-constructed bases and
10045    members.  */
10046
10047 static void
10048 finish_constructor_body (void)
10049 {
10050 }
10051
10052 /* Do all the processing for the beginning of a destructor; set up the
10053    vtable pointers and cleanups for bases and members.  */
10054
10055 static void
10056 begin_destructor_body (void)
10057 {
10058   tree if_stmt;
10059   tree compound_stmt;
10060
10061   /* If the dtor is empty, and we know there is not any possible
10062      way we could use any vtable entries, before they are possibly
10063      set by a base class dtor, we don't have to setup the vtables,
10064      as we know that any base class dtor will set up any vtables
10065      it needs.  We avoid MI, because one base class dtor can do a
10066      virtual dispatch to an overridden function that would need to
10067      have a non-related vtable set up, we cannot avoid setting up
10068      vtables in that case.  We could change this to see if there
10069      is just one vtable.
10070
10071      ??? In the destructor for a class, the vtables are set
10072      appropriately for that class.  There will be no non-related
10073      vtables.  jason 2001-12-11.  */
10074   if_stmt = begin_if_stmt ();
10075
10076   /* If it is not safe to avoid setting up the vtables, then
10077      someone will change the condition to be boolean_true_node.
10078      (Actually, for now, we do not have code to set the condition
10079      appropriately, so we just assume that we always need to
10080      initialize the vtables.)  */
10081   finish_if_stmt_cond (boolean_true_node, if_stmt);
10082
10083   compound_stmt = begin_compound_stmt (0);
10084
10085   /* Make all virtual function table pointers in non-virtual base
10086      classes point to CURRENT_CLASS_TYPE's virtual function
10087      tables.  */
10088   initialize_vtbl_ptrs (current_class_ptr);
10089
10090   finish_compound_stmt (compound_stmt);
10091   finish_then_clause (if_stmt);
10092   finish_if_stmt (if_stmt);
10093
10094   /* And insert cleanups for our bases and members so that they
10095      will be properly destroyed if we throw.  */
10096   push_base_cleanups ();
10097 }
10098
10099 /* At the end of every destructor we generate code to delete the object if
10100    necessary.  Do that now.  */
10101
10102 static void
10103 finish_destructor_body (void)
10104 {
10105   tree exprstmt;
10106
10107   /* Any return from a destructor will end up here; that way all base
10108      and member cleanups will be run when the function returns.  */
10109   add_stmt (build_stmt (LABEL_EXPR, dtor_label));
10110
10111   /* In a virtual destructor, we must call delete.  */
10112   if (DECL_VIRTUAL_P (current_function_decl))
10113     {
10114       tree if_stmt;
10115       tree virtual_size = cxx_sizeof (current_class_type);
10116
10117       /* [class.dtor]
10118
10119       At the point of definition of a virtual destructor (including
10120       an implicit definition), non-placement operator delete shall
10121       be looked up in the scope of the destructor's class and if
10122       found shall be accessible and unambiguous.  */
10123       exprstmt = build_op_delete_call
10124         (DELETE_EXPR, current_class_ptr, virtual_size,
10125          /*global_p=*/false, NULL_TREE);
10126
10127       if_stmt = begin_if_stmt ();
10128       finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
10129                                   current_in_charge_parm,
10130                                   integer_one_node),
10131                            if_stmt);
10132       finish_expr_stmt (exprstmt);
10133       finish_then_clause (if_stmt);
10134       finish_if_stmt (if_stmt);
10135     }
10136 }
10137
10138 /* Do the necessary processing for the beginning of a function body, which
10139    in this case includes member-initializers, but not the catch clauses of
10140    a function-try-block.  Currently, this means opening a binding level
10141    for the member-initializers (in a ctor) and member cleanups (in a dtor).
10142    In other functions, this isn't necessary, but it doesn't hurt.  */
10143
10144 tree
10145 begin_function_body (void)
10146 {
10147   tree stmt;
10148
10149   if (processing_template_decl)
10150     /* Do nothing now.  */;
10151   else
10152     /* Always keep the BLOCK node associated with the outermost pair of
10153        curly braces of a function.  These are needed for correct
10154        operation of dwarfout.c.  */
10155     keep_next_level (true);
10156
10157   stmt = begin_compound_stmt (BCS_FN_BODY);
10158
10159   if (processing_template_decl)
10160     /* Do nothing now.  */;
10161   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10162     begin_constructor_body ();
10163   else if (DECL_DESTRUCTOR_P (current_function_decl))
10164     begin_destructor_body ();
10165
10166   return stmt;
10167 }
10168
10169 /* Do the processing for the end of a function body.  Currently, this means
10170    closing out the cleanups for fully-constructed bases and members, and in
10171    the case of the destructor, deleting the object if desired.  Again, this
10172    is only meaningful for [cd]tors, since they are the only functions where
10173    there is a significant distinction between the main body and any
10174    function catch clauses.  Handling, say, main() return semantics here
10175    would be wrong, as flowing off the end of a function catch clause for
10176    main() would also need to return 0.  */
10177
10178 void
10179 finish_function_body (tree compstmt)
10180 {
10181   /* Close the block.  */
10182   finish_compound_stmt (compstmt);
10183
10184   if (processing_template_decl)
10185     /* Do nothing now.  */;
10186   else if (DECL_CONSTRUCTOR_P (current_function_decl))
10187     finish_constructor_body ();
10188   else if (DECL_DESTRUCTOR_P (current_function_decl))
10189     finish_destructor_body ();
10190 }
10191
10192 /* Finish up a function declaration and compile that function
10193    all the way to assembler language output.  The free the storage
10194    for the function definition.
10195
10196    FLAGS is a bitwise or of the following values:
10197      2 - INCLASS_INLINE
10198        We just finished processing the body of an in-class inline
10199        function definition.  (This processing will have taken place
10200        after the class definition is complete.)  */
10201
10202 tree
10203 finish_function (int flags)
10204 {
10205   tree fndecl = current_function_decl;
10206   tree fntype, ctype = NULL_TREE;
10207   int inclass_inline = (flags & 2) != 0;
10208   int nested;
10209
10210   /* When we get some parse errors, we can end up without a
10211      current_function_decl, so cope.  */
10212   if (fndecl == NULL_TREE)
10213     return error_mark_node;
10214
10215   if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10216       && DECL_VIRTUAL_P (fndecl)
10217       && !processing_template_decl)
10218     {
10219       tree fnclass = DECL_CONTEXT (fndecl);
10220       if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10221         keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10222     }
10223
10224   nested = function_depth > 1;
10225   fntype = TREE_TYPE (fndecl);
10226
10227   /*  TREE_READONLY (fndecl) = 1;
10228       This caused &foo to be of type ptr-to-const-function
10229       which then got a warning when stored in a ptr-to-function variable.  */
10230
10231   my_friendly_assert (building_stmt_tree (), 20000911);
10232
10233   /* For a cloned function, we've already got all the code we need;
10234      there's no need to add any extra bits.  */
10235   if (!DECL_CLONED_FUNCTION_P (fndecl))
10236     {
10237       if (DECL_MAIN_P (current_function_decl))
10238         {
10239           /* Make it so that `main' always returns 0 by default.  */
10240 #if VMS_TARGET
10241           finish_return_stmt (integer_one_node);
10242 #else
10243           finish_return_stmt (integer_zero_node);
10244 #endif
10245         }
10246
10247       /* Finish dealing with exception specifiers.  */
10248       if (flag_exceptions && !processing_template_decl
10249           && flag_enforce_eh_specs
10250           && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10251         finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10252                               (TREE_TYPE (current_function_decl)),
10253                               current_eh_spec_block);
10254     }
10255
10256   /* If we're saving up tree structure, tie off the function now.  */
10257   DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10258
10259   finish_fname_decls ();
10260
10261   /* If this function can't throw any exceptions, remember that.  */
10262   if (!processing_template_decl
10263       && !cp_function_chain->can_throw
10264       && !flag_non_call_exceptions)
10265     TREE_NOTHROW (fndecl) = 1;
10266
10267   /* This must come after expand_function_end because cleanups might
10268      have declarations (from inline functions) that need to go into
10269      this function's blocks.  */
10270
10271   /* If the current binding level isn't the outermost binding level
10272      for this function, either there is a bug, or we have experienced
10273      syntax errors and the statement tree is malformed.  */
10274   if (current_binding_level->kind != sk_function_parms)
10275     {
10276       /* Make sure we have already experienced errors.  */
10277       if (errorcount == 0)
10278         abort ();
10279
10280       /* Throw away the broken statement tree and extra binding
10281          levels.  */
10282       DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10283
10284       while (current_binding_level->kind != sk_function_parms)
10285         {
10286           if (current_binding_level->kind == sk_class)
10287             pop_nested_class ();
10288           else
10289             poplevel (0, 0, 0);
10290         }
10291     }
10292   poplevel (1, 0, 1);
10293
10294   /* Statements should always be full-expressions at the outermost set
10295      of curly braces for a function.  */
10296   my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
10297
10298   /* Set up the named return value optimization, if we can.  Candidate
10299      variables are selected in check_return_value.  */
10300   if (current_function_return_value)
10301     {
10302       tree r = current_function_return_value;
10303       tree outer;
10304
10305       if (r != error_mark_node
10306           /* This is only worth doing for fns that return in memory--and
10307              simpler, since we don't have to worry about promoted modes.  */
10308           && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10309           /* Only allow this for variables declared in the outer scope of
10310              the function so we know that their lifetime always ends with a
10311              return; see g++.dg/opt/nrv6.C.  We could be more flexible if
10312              we were to do this optimization in tree-ssa.  */
10313           && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)))
10314           /* Skip the artificial function body block.  */
10315           && (outer = BLOCK_SUBBLOCKS (outer))
10316           && chain_member (r, BLOCK_VARS (outer)))
10317         finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10318
10319       current_function_return_value = NULL_TREE;
10320     }
10321
10322   /* Remember that we were in class scope.  */
10323   if (current_class_name)
10324     ctype = current_class_type;
10325
10326   /* Must mark the RESULT_DECL as being in this function.  */
10327   DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10328
10329   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10330      to the FUNCTION_DECL node itself.  */
10331   BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10332
10333   /* Save away current state, if appropriate.  */
10334   if (!processing_template_decl)
10335     save_function_data (fndecl);
10336
10337   /* Complain if there's just no return statement.  */
10338   if (warn_return_type
10339       && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10340       && !dependent_type_p (TREE_TYPE (fntype))
10341       && !current_function_returns_value && !current_function_returns_null
10342       /* Don't complain if we abort or throw.  */
10343       && !current_function_returns_abnormally
10344       && !DECL_NAME (DECL_RESULT (fndecl))
10345       /* Normally, with -Wreturn-type, flow will complain.  Unless we're an
10346          inline function, as we might never be compiled separately.  */
10347       && (DECL_INLINE (fndecl) || processing_template_decl))
10348     warning ("no return statement in function returning non-void");
10349
10350   /* Store the end of the function, so that we get good line number
10351      info for the epilogue.  */
10352   cfun->function_end_locus = input_location;
10353
10354   /* Genericize before inlining.  */
10355   if (!processing_template_decl)
10356     {
10357       cp_genericize (fndecl);
10358
10359       /* Handle attribute((warn_unused_result)).  Relies on gimple input.  */
10360       c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10361     }
10362
10363   /* We're leaving the context of this function, so zap cfun.  It's still in
10364      DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation.  */
10365   cfun = NULL;
10366   current_function_decl = NULL;
10367
10368   /* If this is an in-class inline definition, we may have to pop the
10369      bindings for the template parameters that we added in
10370      maybe_begin_member_template_processing when start_function was
10371      called.  */
10372   if (inclass_inline)
10373     maybe_end_member_template_processing ();
10374
10375   /* Leave the scope of the class.  */
10376   if (ctype)
10377     pop_nested_class ();
10378
10379   --function_depth;
10380
10381   /* Clean up.  */
10382   if (! nested)
10383     /* Let the error reporting routines know that we're outside a
10384        function.  For a nested function, this value is used in
10385        cxx_pop_function_context and then reset via pop_function_context.  */
10386     current_function_decl = NULL_TREE;
10387
10388   return fndecl;
10389 }
10390 \f
10391 /* Create the FUNCTION_DECL for a function definition.
10392    DECLSPECS and DECLARATOR are the parts of the declaration;
10393    they describe the return type and the name of the function,
10394    but twisted together in a fashion that parallels the syntax of C.
10395
10396    This function creates a binding context for the function body
10397    as well as setting up the FUNCTION_DECL in current_function_decl.
10398
10399    Returns a FUNCTION_DECL on success.
10400
10401    If the DECLARATOR is not suitable for a function (it defines a datum
10402    instead), we return 0, which tells yyparse to report a parse error.
10403
10404    May return void_type_node indicating that this method is actually
10405    a friend.  See grokfield for more details.
10406
10407    Came here with a `.pushlevel' .
10408
10409    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10410    CHANGES TO CODE IN `grokfield'.  */
10411
10412 tree
10413 start_method (cp_decl_specifier_seq *declspecs,
10414               const cp_declarator *declarator, tree attrlist)
10415 {
10416   tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10417                                 &attrlist);
10418
10419   if (fndecl == error_mark_node)
10420     return error_mark_node;
10421
10422   if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10423     {
10424       error ("invalid member function declaration");
10425       return error_mark_node;
10426     }
10427
10428   if (attrlist)
10429     cplus_decl_attributes (&fndecl, attrlist, 0);
10430
10431   /* Pass friends other than inline friend functions back.  */
10432   if (fndecl == void_type_node)
10433     return fndecl;
10434
10435   if (DECL_IN_AGGR_P (fndecl))
10436     {
10437       if (DECL_CONTEXT (fndecl)
10438           && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10439         error ("`%D' is already defined in class `%T'", fndecl,
10440                DECL_CONTEXT (fndecl));
10441       return void_type_node;
10442     }
10443
10444   check_template_shadow (fndecl);
10445
10446   DECL_DECLARED_INLINE_P (fndecl) = 1;
10447   if (flag_default_inline)
10448     DECL_INLINE (fndecl) = 1;
10449
10450   /* We process method specializations in finish_struct_1.  */
10451   if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10452     {
10453       fndecl = push_template_decl (fndecl);
10454       if (fndecl == error_mark_node)
10455         return fndecl;
10456     }
10457
10458   if (! DECL_FRIEND_P (fndecl))
10459     {
10460       if (TREE_CHAIN (fndecl))
10461         {
10462           fndecl = copy_node (fndecl);
10463           TREE_CHAIN (fndecl) = NULL_TREE;
10464         }
10465       grok_special_member_properties (fndecl);
10466     }
10467
10468   cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10469
10470   /* Make a place for the parms.  */
10471   begin_scope (sk_function_parms, fndecl);
10472
10473   DECL_IN_AGGR_P (fndecl) = 1;
10474   return fndecl;
10475 }
10476
10477 /* Go through the motions of finishing a function definition.
10478    We don't compile this method until after the whole class has
10479    been processed.
10480
10481    FINISH_METHOD must return something that looks as though it
10482    came from GROKFIELD (since we are defining a method, after all).
10483
10484    This is called after parsing the body of the function definition.
10485    STMTS is the chain of statements that makes up the function body.
10486
10487    DECL is the ..._DECL that `start_method' provided.  */
10488
10489 tree
10490 finish_method (tree decl)
10491 {
10492   tree fndecl = decl;
10493   tree old_initial;
10494
10495   tree link;
10496
10497   if (decl == void_type_node)
10498     return decl;
10499
10500   old_initial = DECL_INITIAL (fndecl);
10501
10502   /* Undo the level for the parms (from start_method).
10503      This is like poplevel, but it causes nothing to be
10504      saved.  Saving information here confuses symbol-table
10505      output routines.  Besides, this information will
10506      be correctly output when this method is actually
10507      compiled.  */
10508
10509   /* Clear out the meanings of the local variables of this level;
10510      also record in each decl which block it belongs to.  */
10511
10512   for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
10513     {
10514       if (DECL_NAME (link) != NULL_TREE)
10515         pop_binding (DECL_NAME (link), link);
10516       my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
10517       DECL_CONTEXT (link) = NULL_TREE;
10518     }
10519
10520   poplevel (0, 0, 0);
10521
10522   DECL_INITIAL (fndecl) = old_initial;
10523
10524   /* We used to check if the context of FNDECL was different from
10525      current_class_type as another way to get inside here.  This didn't work
10526      for String.cc in libg++.  */
10527   if (DECL_FRIEND_P (fndecl))
10528     {
10529       CLASSTYPE_INLINE_FRIENDS (current_class_type)
10530         = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
10531       decl = void_type_node;
10532     }
10533
10534   return decl;
10535 }
10536 \f
10537
10538 /* VAR is a VAR_DECL.  If its type is incomplete, remember VAR so that
10539    we can lay it out later, when and if its type becomes complete.  */
10540
10541 void
10542 maybe_register_incomplete_var (tree var)
10543 {
10544   my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
10545
10546   /* Keep track of variables with incomplete types.  */
10547   if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
10548       && DECL_EXTERNAL (var))
10549     {
10550       tree inner_type = TREE_TYPE (var);
10551
10552       while (TREE_CODE (inner_type) == ARRAY_TYPE)
10553         inner_type = TREE_TYPE (inner_type);
10554       inner_type = TYPE_MAIN_VARIANT (inner_type);
10555
10556       if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
10557           /* RTTI TD entries are created while defining the type_info.  */
10558           || (TYPE_LANG_SPECIFIC (inner_type)
10559               && TYPE_BEING_DEFINED (inner_type)))
10560         incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
10561     }
10562 }
10563
10564 /* Called when a class type (given by TYPE) is defined.  If there are
10565    any existing VAR_DECLs whose type hsa been completed by this
10566    declaration, update them now.  */
10567
10568 void
10569 complete_vars (tree type)
10570 {
10571   tree *list = &incomplete_vars;
10572
10573   my_friendly_assert (CLASS_TYPE_P (type), 20020406);
10574   while (*list)
10575     {
10576       if (same_type_p (type, TREE_PURPOSE (*list)))
10577         {
10578           tree var = TREE_VALUE (*list);
10579           /* Complete the type of the variable.  The VAR_DECL itself
10580              will be laid out in expand_expr.  */
10581           complete_type (TREE_TYPE (var));
10582           /* Remove this entry from the list.  */
10583           *list = TREE_CHAIN (*list);
10584         }
10585       else
10586         list = &TREE_CHAIN (*list);
10587     }
10588
10589   /* Check for pending declarations which may have abstract type.  */
10590   complete_type_check_abstract (type);
10591 }
10592
10593 /* If DECL is of a type which needs a cleanup, build that cleanup
10594    here.  */
10595
10596 tree
10597 cxx_maybe_build_cleanup (tree decl)
10598 {
10599   tree type = TREE_TYPE (decl);
10600
10601   if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
10602     {
10603       int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
10604       tree rval;
10605
10606       if (TREE_CODE (type) == ARRAY_TYPE)
10607         rval = decl;
10608       else
10609         {
10610           cxx_mark_addressable (decl);
10611           rval = build_unary_op (ADDR_EXPR, decl, 0);
10612         }
10613
10614       /* Optimize for space over speed here.  */
10615       if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
10616           || flag_expensive_optimizations)
10617         flags |= LOOKUP_NONVIRTUAL;
10618
10619       rval = build_delete (TREE_TYPE (rval), rval,
10620                            sfk_complete_destructor, flags, 0);
10621
10622       if (TYPE_USES_VIRTUAL_BASECLASSES (type)
10623           && ! TYPE_HAS_DESTRUCTOR (type))
10624         rval = build_compound_expr (rval, build_vbase_delete (type, decl));
10625
10626       return rval;
10627     }
10628   return NULL_TREE;
10629 }
10630 \f
10631 /* When a stmt has been parsed, this function is called.  */
10632
10633 void
10634 finish_stmt (void)
10635 {
10636 }
10637
10638 /* DECL was originally constructed as a non-static member function,
10639    but turned out to be static.  Update it accordingly.  */
10640
10641 void
10642 revert_static_member_fn (tree decl)
10643 {
10644   tree tmp;
10645   tree function = TREE_TYPE (decl);
10646   tree args = TYPE_ARG_TYPES (function);
10647
10648   if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
10649       != TYPE_UNQUALIFIED)
10650     error ("static member function `%#D' declared with type qualifiers",
10651               decl);
10652
10653   args = TREE_CHAIN (args);
10654   tmp = build_function_type (TREE_TYPE (function), args);
10655   tmp = build_qualified_type (tmp, cp_type_quals (function));
10656   tmp = build_exception_variant (tmp,
10657                                  TYPE_RAISES_EXCEPTIONS (function));
10658   TREE_TYPE (decl) = tmp;
10659   if (DECL_ARGUMENTS (decl))
10660     DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
10661   DECL_STATIC_FUNCTION_P (decl) = 1;
10662 }
10663
10664 /* Initialize the variables used during compilation of a C++
10665    function.  */
10666
10667 void
10668 cxx_push_function_context (struct function * f)
10669 {
10670   struct language_function *p
10671     = ggc_alloc_cleared (sizeof (struct language_function));
10672   f->language = p;
10673
10674   /* Whenever we start a new function, we destroy temporaries in the
10675      usual way.  */
10676   current_stmt_tree ()->stmts_are_full_exprs_p = 1;
10677
10678   if (f->decl)
10679     {
10680       tree fn = f->decl;
10681
10682       if (DECL_SAVED_FUNCTION_DATA (fn))
10683         {
10684           /* If we already parsed this function, and we're just expanding it
10685              now, restore saved state.  */
10686           *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
10687
10688           /* We don't need the saved data anymore.  Unless this is an inline
10689              function; we need the named return value info for
10690              declare_return_variable.  */
10691           if (! DECL_INLINE (fn))
10692             DECL_SAVED_FUNCTION_DATA (fn) = NULL;
10693         }
10694     }
10695 }
10696
10697 /* Free the language-specific parts of F, now that we've finished
10698    compiling the function.  */
10699
10700 void
10701 cxx_pop_function_context (struct function * f)
10702 {
10703   f->language = 0;
10704 }
10705
10706 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
10707    one of the language-independent trees.  */
10708
10709 enum cp_tree_node_structure_enum
10710 cp_tree_node_structure (union lang_tree_node * t)
10711 {
10712   switch (TREE_CODE (&t->generic))
10713     {
10714     case DEFAULT_ARG:           return TS_CP_DEFAULT_ARG;
10715     case IDENTIFIER_NODE:       return TS_CP_IDENTIFIER;
10716     case OVERLOAD:              return TS_CP_OVERLOAD;
10717     case TEMPLATE_PARM_INDEX:   return TS_CP_TPI;
10718     case PTRMEM_CST:            return TS_CP_PTRMEM;
10719     case BASELINK:              return TS_CP_BASELINK;
10720     default:                    return TS_CP_GENERIC;
10721     }
10722 }
10723
10724 /* Build the void_list_node (void_type_node having been created).  */
10725 tree
10726 build_void_list_node (void)
10727 {
10728   tree t = build_tree_list (NULL_TREE, void_type_node);
10729   return t;
10730 }
10731
10732 bool
10733 cp_missing_noreturn_ok_p (tree decl)
10734 {
10735   /* A missing noreturn is ok for the `main' function.  */
10736   return DECL_MAIN_P (decl);
10737 }
10738
10739 #include "gt-cp-decl.h"
10740 #include "gtype-cp.h"