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