gcc/cp/decl.c

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