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