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