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