gcc/cp/decl.c

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