gcc/cp/decl.c

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