gcc/cp/decl.c

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