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