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