gcc/cp/decl.c

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