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