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