gcc/cp/decl.c

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