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