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