gcc/cp/decl.c

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