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