gcc/cp/decl.c

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