gcc/cp/decl.c

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