gcc/cp/decl.c

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