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