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