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