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