gcc/cp/decl2.c

   1 /* Process declarations and variables for C++ compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   4    Hacked 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 "decl.h"
  41 #include "lex.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "timevar.h"
  46 #include "cpplib.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49 extern cpp_reader *parse_in;
  50
  51 /* This structure contains information about the initializations
  52    and/or destructions required for a particular priority level.  */
  53 typedef struct priority_info_s {
  54   /* Nonzero if there have been any initializations at this priority
  55      throughout the translation unit.  */
  56   int initializations_p;
  57   /* Nonzero if there have been any destructions at this priority
  58      throughout the translation unit.  */
  59   int destructions_p;
  60 } *priority_info;
  61
  62 static void mark_vtable_entries (tree);
  63 static void grok_function_init (tree, tree);
  64 static bool maybe_emit_vtables (tree);
  65 static void add_using_namespace (tree, tree, bool);
  66 static cxx_binding *ambiguous_decl (tree, cxx_binding *, cxx_binding *, int);
  67 static tree build_anon_union_vars (tree);
  68 static bool acceptable_java_type (tree);
  69 static void output_vtable_inherit (tree);
  70 static tree start_objects (int, int);
  71 static void finish_objects (int, int, tree);
  72 static tree merge_functions (tree, tree);
  73 static tree decl_namespace (tree);
  74 static tree validate_nonmember_using_decl (tree, tree *, tree *);
  75 static void do_nonmember_using_decl (tree, tree, tree, tree, tree *, tree *);
  76 static tree start_static_storage_duration_function (unsigned);
  77 static void finish_static_storage_duration_function (tree);
  78 static priority_info get_priority_info (int);
  79 static void do_static_initialization (tree, tree);
  80 static void do_static_destruction (tree);
  81 static tree start_static_initialization_or_destruction (tree, int);
  82 static void finish_static_initialization_or_destruction (tree);
  83 static void generate_ctor_or_dtor_function (bool, int, location_t *);
  84 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
  85                                                           void *);
  86 static tree prune_vars_needing_no_initialization (tree *);
  87 static void write_out_vars (tree);
  88 static void import_export_class (tree);
  89 static tree get_guard_bits (tree);
  90
  91 /* A list of static class variables.  This is needed, because a
  92    static class variable can be declared inside the class without
  93    an initializer, and then initialized, statically, outside the class.  */
  94 static GTY(()) varray_type pending_statics;
  95 #define pending_statics_used \
  96   (pending_statics ? pending_statics->elements_used : 0)
  97
  98 /* A list of functions which were declared inline, but which we
  99    may need to emit outline anyway.  */
 100 static GTY(()) varray_type deferred_fns;
 101 #define deferred_fns_used \
 102   (deferred_fns ? deferred_fns->elements_used : 0)
 103
 104 /* Flag used when debugging spew.c */
 105
 106 extern int spew_debug;
 107
 108 /* Nonzero if we're done parsing and into end-of-file activities.  */
 109
 110 int at_eof;
 111
 112 /* Functions called along with real static constructors and destructors.  */
 113
 114 tree static_ctors;
 115 tree static_dtors;
 116
 117 /* The :: namespace.  */
 118
 119 tree global_namespace;
 120 \f
 121 /* Incorporate `const' and `volatile' qualifiers for member functions.
 122    FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
 123    QUALS is a list of qualifiers.  Returns any explicit
 124    top-level qualifiers of the method's this pointer, anything other than
 125    TYPE_UNQUALIFIED will be an extension.  */
 126
 127 int
 128 grok_method_quals (tree ctype, tree function, tree quals)
 129 {
 130   tree fntype = TREE_TYPE (function);
 131   tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
 132   int type_quals = TYPE_UNQUALIFIED;
 133   int dup_quals = TYPE_UNQUALIFIED;
 134   int this_quals = TYPE_UNQUALIFIED;
 135
 136   do
 137     {
 138       int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
 139
 140       if ((type_quals | this_quals) & tq)
 141         dup_quals |= tq;
 142       else if (tq & TYPE_QUAL_RESTRICT)
 143         this_quals |= tq;
 144       else
 145         type_quals |= tq;
 146       quals = TREE_CHAIN (quals);
 147     }
 148   while (quals);
 149
 150   if (dup_quals != TYPE_UNQUALIFIED)
 151     error ("duplicate type qualifiers in %s declaration",
 152               TREE_CODE (function) == FUNCTION_DECL
 153               ? "member function" : "type");
 154
 155   ctype = cp_build_qualified_type (ctype, type_quals);
 156   fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype),
 157                                     (TREE_CODE (fntype) == METHOD_TYPE
 158                                      ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
 159                                      : TYPE_ARG_TYPES (fntype)));
 160   if (raises)
 161     fntype = build_exception_variant (fntype, raises);
 162
 163   TREE_TYPE (function) = fntype;
 164   return this_quals;
 165 }
 166
 167 /* Warn when -fexternal-templates is used and #pragma
 168    interface/implementation is not used all the times it should be,
 169    inform the user.  */
 170
 171 void
 172 warn_if_unknown_interface (tree decl)
 173 {
 174   static int already_warned = 0;
 175   if (already_warned++)
 176     return;
 177
 178   if (flag_alt_external_templates)
 179     {
 180       tree til = tinst_for_decl ();
 181       location_t saved_loc = input_location;
 182
 183       if (til)
 184         {
 185           input_line = TINST_LINE (til);
 186           input_filename = TINST_FILE (til);
 187         }
 188       warning ("template `%#D' instantiated in file without #pragma interface",
 189                   decl);
 190       input_location = saved_loc;
 191     }
 192   else
 193     cp_warning_at ("template `%#D' defined in file without #pragma interface",
 194                    decl);
 195 }
 196
 197 /* A subroutine of the parser, to handle a component list.  */
 198
 199 void
 200 grok_x_components (tree specs)
 201 {
 202   tree t;
 203
 204   specs = strip_attrs (specs);
 205
 206   check_tag_decl (specs);
 207   t = groktypename (build_tree_list (specs, NULL_TREE));
 208
 209   /* The only case where we need to do anything additional here is an
 210      anonymous union field, e.g.: `struct S { union { int i; }; };'.  */
 211   if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t))
 212     return;
 213
 214   fixup_anonymous_aggr (t);
 215   finish_member_declaration (build_decl (FIELD_DECL, NULL_TREE, t));
 216 }
 217
 218 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
 219    appropriately.  */
 220
 221 tree
 222 cp_build_parm_decl (tree name, tree type)
 223 {
 224   tree parm = build_decl (PARM_DECL, name, type);
 225   DECL_ARG_TYPE (parm) = type_passed_as (type);
 226   return parm;
 227 }
 228
 229 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
 230    indicated NAME.  */
 231
 232 tree
 233 build_artificial_parm (tree name, tree type)
 234 {
 235   tree parm = cp_build_parm_decl (name, type);
 236   DECL_ARTIFICIAL (parm) = 1;
 237   /* All our artificial parms are implicitly `const'; they cannot be
 238      assigned to.  */
 239   TREE_READONLY (parm) = 1;
 240   return parm;
 241 }
 242
 243 /* Constructors for types with virtual baseclasses need an "in-charge" flag
 244    saying whether this constructor is responsible for initialization of
 245    virtual baseclasses or not.  All destructors also need this "in-charge"
 246    flag, which additionally determines whether or not the destructor should
 247    free the memory for the object.
 248
 249    This function adds the "in-charge" flag to member function FN if
 250    appropriate.  It is called from grokclassfn and tsubst.
 251    FN must be either a constructor or destructor.
 252
 253    The in-charge flag follows the 'this' parameter, and is followed by the
 254    VTT parm (if any), then the user-written parms.  */
 255
 256 void
 257 maybe_retrofit_in_chrg (tree fn)
 258 {
 259   tree basetype, arg_types, parms, parm, fntype;
 260
 261   /* If we've already add the in-charge parameter don't do it again.  */
 262   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
 263     return;
 264
 265   /* When processing templates we can't know, in general, whether or
 266      not we're going to have virtual baseclasses.  */
 267   if (uses_template_parms (fn))
 268     return;
 269
 270   /* We don't need an in-charge parameter for constructors that don't
 271      have virtual bases.  */
 272   if (DECL_CONSTRUCTOR_P (fn)
 273       && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
 274     return;
 275
 276   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
 277   basetype = TREE_TYPE (TREE_VALUE (arg_types));
 278   arg_types = TREE_CHAIN (arg_types);
 279
 280   parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
 281
 282   /* If this is a subobject constructor or destructor, our caller will
 283      pass us a pointer to our VTT.  */
 284   if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
 285     {
 286       parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
 287
 288       /* First add it to DECL_ARGUMENTS between 'this' and the real args...  */
 289       TREE_CHAIN (parm) = parms;
 290       parms = parm;
 291
 292       /* ...and then to TYPE_ARG_TYPES.  */
 293       arg_types = hash_tree_chain (vtt_parm_type, arg_types);
 294
 295       DECL_HAS_VTT_PARM_P (fn) = 1;
 296     }
 297
 298   /* Then add the in-charge parm (before the VTT parm).  */
 299   parm = build_artificial_parm (in_charge_identifier, integer_type_node);
 300   TREE_CHAIN (parm) = parms;
 301   parms = parm;
 302   arg_types = hash_tree_chain (integer_type_node, arg_types);
 303
 304   /* Insert our new parameter(s) into the list.  */
 305   TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
 306
 307   /* And rebuild the function type.  */
 308   fntype = build_cplus_method_type (basetype, TREE_TYPE (TREE_TYPE (fn)),
 309                                     arg_types);
 310   if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
 311     fntype = build_exception_variant (fntype,
 312                                       TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
 313   TREE_TYPE (fn) = fntype;
 314
 315   /* Now we've got the in-charge parameter.  */
 316   DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
 317 }
 318
 319 /* Classes overload their constituent function names automatically.
 320    When a function name is declared in a record structure,
 321    its name is changed to it overloaded name.  Since names for
 322    constructors and destructors can conflict, we place a leading
 323    '$' for destructors.
 324
 325    CNAME is the name of the class we are grokking for.
 326
 327    FUNCTION is a FUNCTION_DECL.  It was created by `grokdeclarator'.
 328
 329    FLAGS contains bits saying what's special about today's
 330    arguments.  1 == DESTRUCTOR.  2 == OPERATOR.
 331
 332    If FUNCTION is a destructor, then we must add the `auto-delete' field
 333    as a second parameter.  There is some hair associated with the fact
 334    that we must "declare" this variable in the manner consistent with the
 335    way the rest of the arguments were declared.
 336
 337    QUALS are the qualifiers for the this pointer.  */
 338
 339 void
 340 grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals)
 341 {
 342   tree fn_name = DECL_NAME (function);
 343   int this_quals = TYPE_UNQUALIFIED;
 344
 345   /* Even within an `extern "C"' block, members get C++ linkage.  See
 346      [dcl.link] for details.  */
 347   SET_DECL_LANGUAGE (function, lang_cplusplus);
 348
 349   if (fn_name == NULL_TREE)
 350     {
 351       error ("name missing for member function");
 352       fn_name = get_identifier ("<anonymous>");
 353       DECL_NAME (function) = fn_name;
 354     }
 355
 356   if (quals)
 357     this_quals = grok_method_quals (ctype, function, quals);
 358
 359   if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
 360     {
 361       /* Must add the class instance variable up front.  */
 362       /* Right now we just make this a pointer.  But later
 363          we may wish to make it special.  */
 364       tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function)));
 365       tree qual_type;
 366       tree parm;
 367
 368       /* The `this' parameter is implicitly `const'; it cannot be
 369          assigned to.  */
 370       this_quals |= TYPE_QUAL_CONST;
 371       qual_type = cp_build_qualified_type (type, this_quals);
 372       parm = build_artificial_parm (this_identifier, qual_type);
 373       c_apply_type_quals_to_decl (this_quals, parm);
 374       TREE_CHAIN (parm) = last_function_parms;
 375       last_function_parms = parm;
 376     }
 377
 378   DECL_ARGUMENTS (function) = last_function_parms;
 379   DECL_CONTEXT (function) = ctype;
 380
 381   if (flags == DTOR_FLAG)
 382     DECL_DESTRUCTOR_P (function) = 1;
 383
 384   if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
 385     maybe_retrofit_in_chrg (function);
 386
 387   if (flags == DTOR_FLAG)
 388     {
 389       DECL_DESTRUCTOR_P (function) = 1;
 390       TYPE_HAS_DESTRUCTOR (ctype) = 1;
 391     }
 392 }
 393
 394 /* Create an ARRAY_REF, checking for the user doing things backwards
 395    along the way.  */
 396
 397 tree
 398 grok_array_decl (tree array_expr, tree index_exp)
 399 {
 400   tree type = TREE_TYPE (array_expr);
 401   tree p1, p2, i1, i2;
 402
 403   if (type == error_mark_node || index_exp == error_mark_node)
 404     return error_mark_node;
 405   if (processing_template_decl)
 406     return build_min (ARRAY_REF, type ? TREE_TYPE (type) : NULL_TREE,
 407                       array_expr, index_exp);
 408
 409   if (type == NULL_TREE)
 410     {
 411       /* Something has gone very wrong.  Assume we are mistakenly reducing
 412          an expression instead of a declaration.  */
 413       error ("parser may be lost: is there a '{' missing somewhere?");
 414       return NULL_TREE;
 415     }
 416
 417   if (TREE_CODE (type) == OFFSET_TYPE
 418       || TREE_CODE (type) == REFERENCE_TYPE)
 419     type = TREE_TYPE (type);
 420
 421   /* If they have an `operator[]', use that.  */
 422   if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
 423     return build_new_op (ARRAY_REF, LOOKUP_NORMAL,
 424                          array_expr, index_exp, NULL_TREE);
 425
 426   /* Otherwise, create an ARRAY_REF for a pointer or array type.  It
 427      is a little-known fact that, if `a' is an array and `i' is an
 428      int, you can write `i[a]', which means the same thing as `a[i]'.  */
 429
 430   if (TREE_CODE (type) == ARRAY_TYPE)
 431     p1 = array_expr;
 432   else
 433     p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
 434
 435   if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
 436     p2 = index_exp;
 437   else
 438     p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
 439
 440   i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, false);
 441   i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, false);
 442
 443   if ((p1 && i2) && (i1 && p2))
 444     error ("ambiguous conversion for array subscript");
 445
 446   if (p1 && i2)
 447     array_expr = p1, index_exp = i2;
 448   else if (i1 && p2)
 449     array_expr = p2, index_exp = i1;
 450   else
 451     {
 452       error ("invalid types `%T[%T]' for array subscript",
 453                 type, TREE_TYPE (index_exp));
 454       return error_mark_node;
 455     }
 456
 457   if (array_expr == error_mark_node || index_exp == error_mark_node)
 458     error ("ambiguous conversion for array subscript");
 459
 460   return build_array_ref (array_expr, index_exp);
 461 }
 462
 463 /* Given the cast expression EXP, checking out its validity.   Either return
 464    an error_mark_node if there was an unavoidable error, return a cast to
 465    void for trying to delete a pointer w/ the value 0, or return the
 466    call to delete.  If DOING_VEC is 1, we handle things differently
 467    for doing an array delete.  If DOING_VEC is 2, they gave us the
 468    array size as an argument to delete.
 469    Implements ARM $5.3.4.  This is called from the parser.  */
 470
 471 tree
 472 delete_sanity (tree exp, tree size, int doing_vec, int use_global_delete)
 473 {
 474   tree t, type;
 475   /* For a regular vector delete (aka, no size argument) we will pass
 476      this down as a NULL_TREE into build_vec_delete.  */
 477   tree maxindex = NULL_TREE;
 478
 479   if (exp == error_mark_node)
 480     return exp;
 481
 482   if (processing_template_decl)
 483     {
 484       t = build_min (DELETE_EXPR, void_type_node, exp, size);
 485       DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
 486       DELETE_EXPR_USE_VEC (t) = doing_vec;
 487       return t;
 488     }
 489
 490   if (TREE_CODE (exp) == OFFSET_REF)
 491     exp = resolve_offset_ref (exp);
 492   exp = convert_from_reference (exp);
 493   t = build_expr_type_conversion (WANT_POINTER, exp, true);
 494
 495   if (t == NULL_TREE || t == error_mark_node)
 496     {
 497       error ("type `%#T' argument given to `delete', expected pointer",
 498                 TREE_TYPE (exp));
 499       return error_mark_node;
 500     }
 501
 502   if (doing_vec == 2)
 503     {
 504       maxindex = cp_build_binary_op (MINUS_EXPR, size, integer_one_node);
 505       pedwarn ("anachronistic use of array size in vector delete");
 506     }
 507
 508   type = TREE_TYPE (t);
 509
 510   /* As of Valley Forge, you can delete a pointer to const.  */
 511
 512   /* You can't delete functions.  */
 513   if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 514     {
 515       error ("cannot delete a function.  Only pointer-to-objects are valid arguments to `delete'");
 516       return error_mark_node;
 517     }
 518
 519   /* Deleting ptr to void is undefined behavior [expr.delete/3].  */
 520   if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
 521     {
 522       warning ("deleting `%T' is undefined", type);
 523       doing_vec = 0;
 524     }
 525
 526   /* An array can't have been allocated by new, so complain.  */
 527   if (TREE_CODE (t) == ADDR_EXPR
 528       && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
 529       && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE)
 530     warning ("deleting array `%#D'", TREE_OPERAND (t, 0));
 531
 532   /* Deleting a pointer with the value zero is valid and has no effect.  */
 533   if (integer_zerop (t))
 534     return build1 (NOP_EXPR, void_type_node, t);
 535
 536   if (doing_vec)
 537     return build_vec_delete (t, maxindex, sfk_deleting_destructor,
 538                              use_global_delete);
 539   else
 540     return build_delete (type, t, sfk_deleting_destructor,
 541                          LOOKUP_NORMAL, use_global_delete);
 542 }
 543
 544 /* Report an error if the indicated template declaration is not the
 545    sort of thing that should be a member template.  */
 546
 547 void
 548 check_member_template (tree tmpl)
 549 {
 550   tree decl;
 551
 552   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
 553   decl = DECL_TEMPLATE_RESULT (tmpl);
 554
 555   if (TREE_CODE (decl) == FUNCTION_DECL
 556       || (TREE_CODE (decl) == TYPE_DECL
 557           && IS_AGGR_TYPE (TREE_TYPE (decl))))
 558     {
 559       if (current_function_decl)
 560         /* 14.5.2.2 [temp.mem]
 561
 562            A local class shall not have member templates.  */
 563         error ("invalid declaration of member template `%#D' in local class",
 564                   decl);
 565
 566       if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
 567         {
 568           /* 14.5.2.3 [temp.mem]
 569
 570              A member function template shall not be virtual.  */
 571           error
 572             ("invalid use of `virtual' in template declaration of `%#D'",
 573              decl);
 574           DECL_VIRTUAL_P (decl) = 0;
 575         }
 576
 577       /* The debug-information generating code doesn't know what to do
 578          with member templates.  */
 579       DECL_IGNORED_P (tmpl) = 1;
 580     }
 581   else
 582     error ("template declaration of `%#D'", decl);
 583 }
 584
 585 /* Return true iff TYPE is a valid Java parameter or return type.  */
 586
 587 static bool
 588 acceptable_java_type (tree type)
 589 {
 590   if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
 591     return 1;
 592   if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
 593     {
 594       type = TREE_TYPE (type);
 595       if (TREE_CODE (type) == RECORD_TYPE)
 596         {
 597           tree args;  int i;
 598           if (! TYPE_FOR_JAVA (type))
 599             return false;
 600           if (! CLASSTYPE_TEMPLATE_INFO (type))
 601             return true;
 602           args = CLASSTYPE_TI_ARGS (type);
 603           i = TREE_VEC_LENGTH (args);
 604           while (--i >= 0)
 605             {
 606               type = TREE_VEC_ELT (args, i);
 607               if (TREE_CODE (type) == POINTER_TYPE)
 608                 type = TREE_TYPE (type);
 609               if (! TYPE_FOR_JAVA (type))
 610                 return false;
 611             }
 612           return true;
 613         }
 614     }
 615   return false;
 616 }
 617
 618 /* For a METHOD in a Java class CTYPE, return true if
 619    the parameter and return types are valid Java types.
 620    Otherwise, print appropriate error messages, and return false.  */
 621
 622 bool
 623 check_java_method (tree method)
 624 {
 625   bool jerr = false;
 626   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
 627   tree ret_type = TREE_TYPE (TREE_TYPE (method));
 628   if (!acceptable_java_type (ret_type))
 629     {
 630       error ("Java method '%D' has non-Java return type `%T'",
 631                 method, ret_type);
 632       jerr = true;
 633     }
 634   for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
 635     {
 636       tree type = TREE_VALUE (arg_types);
 637       if (!acceptable_java_type (type))
 638         {
 639           error ("Java method '%D' has non-Java parameter type `%T'",
 640                     method, type);
 641           jerr = true;
 642         }
 643     }
 644   return !jerr;
 645 }
 646
 647 /* Sanity check: report error if this function FUNCTION is not
 648    really a member of the class (CTYPE) it is supposed to belong to.
 649    CNAME is the same here as it is for grokclassfn above.  */
 650
 651 tree
 652 check_classfn (tree ctype, tree function)
 653 {
 654   int ix;
 655   int is_template;
 656
 657   if (DECL_USE_TEMPLATE (function)
 658       && !(TREE_CODE (function) == TEMPLATE_DECL
 659            && DECL_TEMPLATE_SPECIALIZATION (function))
 660       && is_member_template (DECL_TI_TEMPLATE (function)))
 661     /* Since this is a specialization of a member template,
 662        we're not going to find the declaration in the class.
 663        For example, in:
 664
 665          struct S { template <typename T> void f(T); };
 666          template <> void S::f(int);
 667
 668        we're not going to find `S::f(int)', but there's no
 669        reason we should, either.  We let our callers know we didn't
 670        find the method, but we don't complain.  */
 671     return NULL_TREE;
 672
 673   /* OK, is this a definition of a member template?  */
 674   is_template = (TREE_CODE (function) == TEMPLATE_DECL
 675                  || (processing_template_decl - template_class_depth (ctype)));
 676
 677   ix = lookup_fnfields_1 (complete_type (ctype),
 678                           DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
 679                           DECL_DESTRUCTOR_P (function) ? dtor_identifier :
 680                           DECL_NAME (function));
 681
 682   if (ix >= 0)
 683     {
 684       tree methods = CLASSTYPE_METHOD_VEC (ctype);
 685       tree fndecls, fndecl = 0;
 686       bool is_conv_op;
 687       const char *format = NULL;
 688
 689       push_scope (ctype);
 690       for (fndecls = TREE_VEC_ELT (methods, ix);
 691            fndecls; fndecls = OVL_NEXT (fndecls))
 692         {
 693           tree p1, p2;
 694
 695           fndecl = OVL_CURRENT (fndecls);
 696           p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
 697           p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
 698
 699           /* We cannot simply call decls_match because this doesn't
 700              work for static member functions that are pretending to
 701              be methods, and because the name may have been changed by
 702              asm("new_name").  */
 703
 704            /* Get rid of the this parameter on functions that become
 705               static.  */
 706           if (DECL_STATIC_FUNCTION_P (fndecl)
 707               && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
 708             p1 = TREE_CHAIN (p1);
 709
 710           /* A member template definition only matches a member template
 711              declaration.  */
 712           if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
 713             continue;
 714
 715           if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
 716                            TREE_TYPE (TREE_TYPE (fndecl)))
 717               && compparms (p1, p2)
 718               && (DECL_TEMPLATE_SPECIALIZATION (function)
 719                   == DECL_TEMPLATE_SPECIALIZATION (fndecl))
 720               && (!DECL_TEMPLATE_SPECIALIZATION (function)
 721                   || (DECL_TI_TEMPLATE (function)
 722                       == DECL_TI_TEMPLATE (fndecl))))
 723             break;
 724         }
 725       pop_scope (ctype);
 726       if (fndecls)
 727         return OVL_CURRENT (fndecls);
 728       error ("prototype for `%#D' does not match any in class `%T'",
 729              function, ctype);
 730       is_conv_op = DECL_CONV_FN_P (fndecl);
 731
 732       if (is_conv_op)
 733         ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
 734       fndecls = TREE_VEC_ELT (methods, ix);
 735       while (fndecls)
 736         {
 737           fndecl = OVL_CURRENT (fndecls);
 738           fndecls = OVL_NEXT (fndecls);
 739
 740           if (!fndecls && is_conv_op)
 741             {
 742               if (TREE_VEC_LENGTH (methods) > ix)
 743                 {
 744                   ix++;
 745                   fndecls = TREE_VEC_ELT (methods, ix);
 746                   if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
 747                     {
 748                       fndecls = NULL_TREE;
 749                       is_conv_op = false;
 750                     }
 751                 }
 752               else
 753                 is_conv_op = false;
 754             }
 755           if (format)
 756             format = "                %#D";
 757           else if (fndecls)
 758             format = "candidates are: %#D";
 759           else
 760             format = "candidate is: %#D";
 761           cp_error_at (format, fndecl);
 762         }
 763     }
 764   else if (!COMPLETE_TYPE_P (ctype))
 765     cxx_incomplete_type_error (function, ctype);
 766   else
 767     error ("no `%#D' member function declared in class `%T'",
 768            function, ctype);
 769
 770   /* If we did not find the method in the class, add it to avoid
 771      spurious errors (unless the CTYPE is not yet defined, in which
 772      case we'll only confuse ourselves when the function is declared
 773      properly within the class.  */
 774   if (COMPLETE_TYPE_P (ctype))
 775     add_method (ctype, function, /*error_p=*/1);
 776   return NULL_TREE;
 777 }
 778
 779 /* We have just processed the DECL, which is a static data member.
 780    Its initializer, if present, is INIT.  The ASMSPEC_TREE, if
 781    present, is the assembly-language name for the data member.
 782    FLAGS is as for cp_finish_decl.  */
 783
 784 void
 785 finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree,
 786                                 int flags)
 787 {
 788   my_friendly_assert (TREE_PUBLIC (decl), 0);
 789
 790   DECL_CONTEXT (decl) = current_class_type;
 791
 792   /* We cannot call pushdecl here, because that would fill in the
 793      TREE_CHAIN of our decl.  Instead, we modify cp_finish_decl to do
 794      the right thing, namely, to put this decl out straight away.  */
 795   /* current_class_type can be NULL_TREE in case of error.  */
 796   if (!asmspec_tree && current_class_type)
 797     DECL_INITIAL (decl) = error_mark_node;
 798
 799   if (! processing_template_decl)
 800     {
 801       if (!pending_statics)
 802         VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
 803       VARRAY_PUSH_TREE (pending_statics, decl);
 804     }
 805
 806   if (LOCAL_CLASS_P (current_class_type))
 807     pedwarn ("local class `%#T' shall not have static data member `%#D'",
 808              current_class_type, decl);
 809
 810   /* Static consts need not be initialized in the class definition.  */
 811   if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 812     {
 813       static int explained = 0;
 814
 815       error ("initializer invalid for static member with constructor");
 816       if (!explained)
 817         {
 818           error ("(an out of class initialization is required)");
 819           explained = 1;
 820         }
 821       init = NULL_TREE;
 822     }
 823   /* Force the compiler to know when an uninitialized static const
 824      member is being used.  */
 825   if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0)
 826     TREE_USED (decl) = 1;
 827   DECL_INITIAL (decl) = init;
 828   DECL_IN_AGGR_P (decl) = 1;
 829
 830   cp_finish_decl (decl, init, asmspec_tree, flags);
 831 }
 832
 833 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
 834    of a structure component, returning a _DECL node.
 835    QUALS is a list of type qualifiers for this decl (such as for declaring
 836    const member functions).
 837
 838    This is done during the parsing of the struct declaration.
 839    The _DECL nodes are chained together and the lot of them
 840    are ultimately passed to `build_struct' to make the RECORD_TYPE node.
 841
 842    If class A defines that certain functions in class B are friends, then
 843    the way I have set things up, it is B who is interested in permission
 844    granted by A.  However, it is in A's context that these declarations
 845    are parsed.  By returning a void_type_node, class A does not attempt
 846    to incorporate the declarations of the friends within its structure.
 847
 848    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
 849    CHANGES TO CODE IN `start_method'.  */
 850
 851 tree
 852 grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree,
 853            tree attrlist)
 854 {
 855   tree value;
 856   const char *asmspec = 0;
 857   int flags = LOOKUP_ONLYCONVERTING;
 858
 859   if (declspecs == NULL_TREE
 860       && TREE_CODE (declarator) == SCOPE_REF
 861       && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
 862     {
 863       /* Access declaration */
 864       if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
 865         ;
 866       else if (TREE_COMPLEXITY (declarator) == current_class_depth)
 867         pop_nested_class ();
 868       return do_class_using_decl (declarator);
 869     }
 870
 871   if (init
 872       && TREE_CODE (init) == TREE_LIST
 873       && TREE_VALUE (init) == error_mark_node
 874       && TREE_CHAIN (init) == NULL_TREE)
 875     init = NULL_TREE;
 876
 877   value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
 878   if (! value || value == error_mark_node)
 879     /* friend or constructor went bad.  */
 880     return value;
 881   if (TREE_TYPE (value) == error_mark_node)
 882     return error_mark_node;
 883
 884   if (TREE_CODE (value) == TYPE_DECL && init)
 885     {
 886       error ("typedef `%D' is initialized (use __typeof__ instead)", value);
 887       init = NULL_TREE;
 888     }
 889
 890   /* Pass friendly classes back.  */
 891   if (TREE_CODE (value) == VOID_TYPE)
 892     return void_type_node;
 893
 894   if (DECL_NAME (value) != NULL_TREE
 895       && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
 896       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
 897     error ("member `%D' conflicts with virtual function table field name",
 898               value);
 899
 900   /* Stash away type declarations.  */
 901   if (TREE_CODE (value) == TYPE_DECL)
 902     {
 903       DECL_NONLOCAL (value) = 1;
 904       DECL_CONTEXT (value) = current_class_type;
 905
 906       if (CLASS_TYPE_P (TREE_TYPE (value)))
 907         CLASSTYPE_GOT_SEMICOLON (TREE_TYPE (value)) = 1;
 908
 909       if (processing_template_decl)
 910         value = push_template_decl (value);
 911
 912       return value;
 913     }
 914
 915   if (DECL_IN_AGGR_P (value))
 916     {
 917       error ("`%D' is already defined in `%T'", value,
 918                 DECL_CONTEXT (value));
 919       return void_type_node;
 920     }
 921
 922   if (asmspec_tree)
 923     asmspec = TREE_STRING_POINTER (asmspec_tree);
 924
 925   if (init)
 926     {
 927       if (TREE_CODE (value) == FUNCTION_DECL)
 928         {
 929           grok_function_init (value, init);
 930           init = NULL_TREE;
 931         }
 932       else if (pedantic && TREE_CODE (value) != VAR_DECL)
 933         /* Already complained in grokdeclarator.  */
 934         init = NULL_TREE;
 935       else
 936         {
 937           /* We allow initializers to become parameters to base
 938              initializers.  */
 939           if (TREE_CODE (init) == TREE_LIST)
 940             {
 941               if (TREE_CHAIN (init) == NULL_TREE)
 942                 init = TREE_VALUE (init);
 943               else
 944                 init = digest_init (TREE_TYPE (value), init, (tree *)0);
 945             }
 946
 947           if (!processing_template_decl)
 948             {
 949               if (TREE_CODE (init) == CONST_DECL)
 950                 init = DECL_INITIAL (init);
 951               else if (TREE_READONLY_DECL_P (init))
 952                 init = decl_constant_value (init);
 953               else if (TREE_CODE (init) == CONSTRUCTOR)
 954                 init = digest_init (TREE_TYPE (value), init, (tree *)0);
 955               if (init == error_mark_node)
 956                 /* We must make this look different than `error_mark_node'
 957                    because `decl_const_value' would mis-interpret it
 958                    as only meaning that this VAR_DECL is defined.  */
 959                 init = build1 (NOP_EXPR, TREE_TYPE (value), init);
 960               else if (! TREE_CONSTANT (init))
 961                 {
 962                   /* We can allow references to things that are effectively
 963                      static, since references are initialized with the
 964                      address.  */
 965                   if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
 966                       || (TREE_STATIC (init) == 0
 967                           && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
 968                     {
 969                       error ("field initializer is not constant");
 970                       init = error_mark_node;
 971                     }
 972                 }
 973             }
 974         }
 975     }
 976
 977   if (processing_template_decl && ! current_function_decl
 978       && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
 979     value = push_template_decl (value);
 980
 981   if (attrlist)
 982     cplus_decl_attributes (&value, attrlist, 0);
 983
 984   if (TREE_CODE (value) == VAR_DECL)
 985     {
 986       finish_static_data_member_decl (value, init, asmspec_tree,
 987                                       flags);
 988       return value;
 989     }
 990   if (TREE_CODE (value) == FIELD_DECL)
 991     {
 992       if (asmspec)
 993         error ("`asm' specifiers are not permitted on non-static data members");
 994       if (DECL_INITIAL (value) == error_mark_node)
 995         init = error_mark_node;
 996       cp_finish_decl (value, init, NULL_TREE, flags);
 997       DECL_INITIAL (value) = init;
 998       DECL_IN_AGGR_P (value) = 1;
 999       return value;
1000     }
1001   if (TREE_CODE (value) == FUNCTION_DECL)
1002     {
1003       if (asmspec)
1004         {
1005           /* This must override the asm specifier which was placed
1006              by grokclassfn.  Lay this out fresh.  */
1007           SET_DECL_RTL (value, NULL_RTX);
1008           SET_DECL_ASSEMBLER_NAME (value, get_identifier (asmspec));
1009         }
1010       if (!DECL_FRIEND_P (value))
1011         grok_special_member_properties (value);
1012
1013       cp_finish_decl (value, init, asmspec_tree, flags);
1014
1015       /* Pass friends back this way.  */
1016       if (DECL_FRIEND_P (value))
1017         return void_type_node;
1018
1019       DECL_IN_AGGR_P (value) = 1;
1020       return value;
1021     }
1022   abort ();
1023   /* NOTREACHED */
1024   return NULL_TREE;
1025 }
1026
1027 /* Like `grokfield', but for bitfields.
1028    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.  */
1029
1030 tree
1031 grokbitfield (tree declarator, tree declspecs, tree width)
1032 {
1033   register tree value = grokdeclarator (declarator, declspecs, BITFIELD,
1034                                         0, NULL);
1035
1036   if (! value) return NULL_TREE; /* friends went bad.  */
1037
1038   /* Pass friendly classes back.  */
1039   if (TREE_CODE (value) == VOID_TYPE)
1040     return void_type_node;
1041
1042   if (TREE_CODE (value) == TYPE_DECL)
1043     {
1044       error ("cannot declare `%D' to be a bit-field type", value);
1045       return NULL_TREE;
1046     }
1047
1048   /* Usually, finish_struct_1 catches bitfields with invalid types.
1049      But, in the case of bitfields with function type, we confuse
1050      ourselves into thinking they are member functions, so we must
1051      check here.  */
1052   if (TREE_CODE (value) == FUNCTION_DECL)
1053     {
1054       error ("cannot declare bit-field `%D' with function type",
1055              DECL_NAME (value));
1056       return NULL_TREE;
1057     }
1058
1059   if (DECL_IN_AGGR_P (value))
1060     {
1061       error ("`%D' is already defined in the class %T", value,
1062                   DECL_CONTEXT (value));
1063       return void_type_node;
1064     }
1065
1066   if (TREE_STATIC (value))
1067     {
1068       error ("static member `%D' cannot be a bit-field", value);
1069       return NULL_TREE;
1070     }
1071   cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
1072
1073   if (width != error_mark_node)
1074     {
1075       constant_expression_warning (width);
1076       DECL_INITIAL (value) = width;
1077       SET_DECL_C_BIT_FIELD (value);
1078     }
1079
1080   DECL_IN_AGGR_P (value) = 1;
1081   return value;
1082 }
1083
1084 /* When a function is declared with an initializer,
1085    do the right thing.  Currently, there are two possibilities:
1086
1087    class B
1088    {
1089     public:
1090      // initialization possibility #1.
1091      virtual void f () = 0;
1092      int g ();
1093    };
1094
1095    class D1 : B
1096    {
1097     public:
1098      int d1;
1099      // error, no f ();
1100    };
1101
1102    class D2 : B
1103    {
1104     public:
1105      int d2;
1106      void f ();
1107    };
1108
1109    class D3 : B
1110    {
1111     public:
1112      int d3;
1113      // initialization possibility #2
1114      void f () = B::f;
1115    };
1116
1117 */
1118
1119 static void
1120 grok_function_init (tree decl, tree init)
1121 {
1122   /* An initializer for a function tells how this function should
1123      be inherited.  */
1124   tree type = TREE_TYPE (decl);
1125
1126   if (TREE_CODE (type) == FUNCTION_TYPE)
1127     error ("initializer specified for non-member function `%D'", decl);
1128   else if (integer_zerop (init))
1129     DECL_PURE_VIRTUAL_P (decl) = 1;
1130   else
1131     error ("invalid initializer for virtual method `%D'", decl);
1132 }
1133 \f
1134 void
1135 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1136 {
1137   if (*decl == NULL_TREE || *decl == void_type_node)
1138     return;
1139
1140   if (TREE_CODE (*decl) == TEMPLATE_DECL)
1141     decl = &DECL_TEMPLATE_RESULT (*decl);
1142
1143   decl_attributes (decl, attributes, flags);
1144
1145   if (TREE_CODE (*decl) == TYPE_DECL)
1146     SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1147 }
1148 \f
1149 /* Return the name for the constructor (or destructor) for the
1150    specified class TYPE.  When given a template, this routine doesn't
1151    lose the specialization.  */
1152
1153 tree
1154 constructor_name_full (tree type)
1155 {
1156   type = TYPE_MAIN_VARIANT (type);
1157   if (CLASS_TYPE_P (type) && TYPE_WAS_ANONYMOUS (type)
1158       && TYPE_HAS_CONSTRUCTOR (type))
1159     return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type)));
1160   else
1161     return TYPE_IDENTIFIER (type);
1162 }
1163
1164 /* Return the name for the constructor (or destructor) for the
1165    specified class.  When given a template, return the plain
1166    unspecialized name.  */
1167
1168 tree
1169 constructor_name (tree type)
1170 {
1171   tree name;
1172   name = constructor_name_full (type);
1173   if (IDENTIFIER_TEMPLATE (name))
1174     name = IDENTIFIER_TEMPLATE (name);
1175   return name;
1176 }
1177
1178 /* Returns TRUE if NAME is the name for the constructor for TYPE.  */
1179
1180 bool
1181 constructor_name_p (tree name, tree type)
1182 {
1183   return (name == constructor_name (type)
1184           || name == constructor_name_full (type));
1185 }
1186
1187 \f
1188 /* Defer the compilation of the FN until the end of compilation.  */
1189
1190 void
1191 defer_fn (tree fn)
1192 {
1193   if (DECL_DEFERRED_FN (fn))
1194     return;
1195   DECL_DEFERRED_FN (fn) = 1;
1196   if (!deferred_fns)
1197     VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
1198
1199   VARRAY_PUSH_TREE (deferred_fns, fn);
1200 }
1201
1202 /* Walks through the namespace- or function-scope anonymous union OBJECT,
1203    building appropriate ALIAS_DECLs.  Returns one of the fields for use in
1204    the mangled name.  */
1205
1206 static tree
1207 build_anon_union_vars (tree object)
1208 {
1209   tree type = TREE_TYPE (object);
1210   tree main_decl = NULL_TREE;
1211   tree field;
1212
1213   /* Rather than write the code to handle the non-union case,
1214      just give an error.  */
1215   if (TREE_CODE (type) != UNION_TYPE)
1216     error ("anonymous struct not inside named type");
1217
1218   for (field = TYPE_FIELDS (type);
1219        field != NULL_TREE;
1220        field = TREE_CHAIN (field))
1221     {
1222       tree decl;
1223       tree ref;
1224
1225       if (DECL_ARTIFICIAL (field))
1226         continue;
1227       if (TREE_CODE (field) != FIELD_DECL)
1228         {
1229           cp_pedwarn_at ("\
1230 `%#D' invalid; an anonymous union can only have non-static data members",
1231                          field);
1232           continue;
1233         }
1234
1235       if (TREE_PRIVATE (field))
1236         cp_pedwarn_at ("private member `%#D' in anonymous union", field);
1237       else if (TREE_PROTECTED (field))
1238         cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
1239
1240       if (processing_template_decl)
1241         ref = build_min_nt (COMPONENT_REF, object, DECL_NAME (field));
1242       else
1243         ref = build_class_member_access_expr (object, field, NULL_TREE,
1244                                               false);
1245
1246       if (DECL_NAME (field))
1247         {
1248           decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field));
1249           DECL_INITIAL (decl) = ref;
1250           TREE_PUBLIC (decl) = 0;
1251           TREE_STATIC (decl) = 0;
1252           DECL_EXTERNAL (decl) = 1;
1253           decl = pushdecl (decl);
1254         }
1255       else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1256         decl = build_anon_union_vars (ref);
1257       else
1258         decl = 0;
1259
1260       if (main_decl == NULL_TREE)
1261         main_decl = decl;
1262     }
1263
1264   return main_decl;
1265 }
1266
1267 /* Finish off the processing of a UNION_TYPE structure.  If the union is an
1268    anonymous union, then all members must be laid out together.  PUBLIC_P
1269    is nonzero if this union is not declared static.  */
1270
1271 void
1272 finish_anon_union (tree anon_union_decl)
1273 {
1274   tree type = TREE_TYPE (anon_union_decl);
1275   tree main_decl;
1276   bool public_p = TREE_PUBLIC (anon_union_decl);
1277
1278   /* The VAR_DECL's context is the same as the TYPE's context.  */
1279   DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1280
1281   if (TYPE_FIELDS (type) == NULL_TREE)
1282     return;
1283
1284   if (public_p)
1285     {
1286       error ("namespace-scope anonymous aggregates must be static");
1287       return;
1288     }
1289
1290   main_decl = build_anon_union_vars (anon_union_decl);
1291   if (main_decl == NULL_TREE)
1292     {
1293       warning ("anonymous union with no members");
1294       return;
1295     }
1296
1297   if (!processing_template_decl)
1298     {
1299       /* Use main_decl to set the mangled name.  */
1300       DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1301       mangle_decl (anon_union_decl);
1302       DECL_NAME (anon_union_decl) = NULL_TREE;
1303     }
1304
1305   pushdecl (anon_union_decl);
1306   if (building_stmt_tree ()
1307       && at_function_scope_p ())
1308     add_decl_stmt (anon_union_decl);
1309   else if (!processing_template_decl)
1310     rest_of_decl_compilation (anon_union_decl, NULL,
1311                               toplevel_bindings_p (), at_eof);
1312 }
1313 \f
1314 /* Auxiliary functions to make type signatures for
1315    `operator new' and `operator delete' correspond to
1316    what compiler will be expecting.  */
1317
1318 tree
1319 coerce_new_type (tree type)
1320 {
1321   int e = 0;
1322   tree args = TYPE_ARG_TYPES (type);
1323
1324   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1325
1326   if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1327     e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
1328
1329   if (!args || args == void_list_node
1330       || !same_type_p (TREE_VALUE (args), size_type_node))
1331     {
1332       e = 2;
1333       if (args && args != void_list_node)
1334         args = TREE_CHAIN (args);
1335       pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node);
1336     }
1337   switch (e)
1338   {
1339     case 2:
1340       args = tree_cons (NULL_TREE, size_type_node, args);
1341       /* FALLTHROUGH */
1342     case 1:
1343       type = build_exception_variant
1344               (build_function_type (ptr_type_node, args),
1345                TYPE_RAISES_EXCEPTIONS (type));
1346       /* FALLTHROUGH */
1347     default:;
1348   }
1349   return type;
1350 }
1351
1352 tree
1353 coerce_delete_type (tree type)
1354 {
1355   int e = 0;
1356   tree args = TYPE_ARG_TYPES (type);
1357
1358   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1359
1360   if (!same_type_p (TREE_TYPE (type), void_type_node))
1361     e = 1, error ("`operator delete' must return type `%T'", void_type_node);
1362
1363   if (!args || args == void_list_node
1364       || !same_type_p (TREE_VALUE (args), ptr_type_node))
1365     {
1366       e = 2;
1367       if (args && args != void_list_node)
1368         args = TREE_CHAIN (args);
1369       error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
1370     }
1371   switch (e)
1372   {
1373     case 2:
1374       args = tree_cons (NULL_TREE, ptr_type_node, args);
1375       /* FALLTHROUGH */
1376     case 1:
1377       type = build_exception_variant
1378               (build_function_type (void_type_node, args),
1379                TYPE_RAISES_EXCEPTIONS (type));
1380       /* FALLTHROUGH */
1381     default:;
1382   }
1383
1384   return type;
1385 }
1386 \f
1387 static void
1388 mark_vtable_entries (tree decl)
1389 {
1390   tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
1391
1392   for (; entries; entries = TREE_CHAIN (entries))
1393     {
1394       tree fnaddr = TREE_VALUE (entries);
1395       tree fn;
1396
1397       STRIP_NOPS (fnaddr);
1398
1399       if (TREE_CODE (fnaddr) != ADDR_EXPR
1400           && TREE_CODE (fnaddr) != FDESC_EXPR)
1401         /* This entry is an offset: a virtual base class offset, a
1402            virtual call offset, an RTTI offset, etc.  */
1403         continue;
1404
1405       fn = TREE_OPERAND (fnaddr, 0);
1406       TREE_ADDRESSABLE (fn) = 1;
1407       /* When we don't have vcall offsets, we output thunks whenever
1408          we output the vtables that contain them.  With vcall offsets,
1409          we know all the thunks we'll need when we emit a virtual
1410          function, so we emit the thunks there instead.  */
1411       if (DECL_THUNK_P (fn))
1412         use_thunk (fn, /*emit_p=*/0);
1413       mark_used (fn);
1414     }
1415 }
1416
1417 /* Set DECL up to have the closest approximation of "initialized common"
1418    linkage available.  */
1419
1420 void
1421 comdat_linkage (tree decl)
1422 {
1423   if (flag_weak)
1424     make_decl_one_only (decl);
1425   else if (TREE_CODE (decl) == FUNCTION_DECL
1426            || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1427     /* We can just emit function and compiler-generated variables
1428        statically; having multiple copies is (for the most part) only
1429        a waste of space.
1430
1431        There are two correctness issues, however: the address of a
1432        template instantiation with external linkage should be the
1433        same, independent of what translation unit asks for the
1434        address, and this will not hold when we emit multiple copies of
1435        the function.  However, there's little else we can do.
1436
1437        Also, by default, the typeinfo implementation assumes that
1438        there will be only one copy of the string used as the name for
1439        each type.  Therefore, if weak symbols are unavailable, the
1440        run-time library should perform a more conservative check; it
1441        should perform a string comparison, rather than an address
1442        comparison.  */
1443     TREE_PUBLIC (decl) = 0;
1444   else
1445     {
1446       /* Static data member template instantiations, however, cannot
1447          have multiple copies.  */
1448       if (DECL_INITIAL (decl) == 0
1449           || DECL_INITIAL (decl) == error_mark_node)
1450         DECL_COMMON (decl) = 1;
1451       else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1452         {
1453           DECL_COMMON (decl) = 1;
1454           DECL_INITIAL (decl) = error_mark_node;
1455         }
1456       else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1457         {
1458           /* We can't do anything useful; leave vars for explicit
1459              instantiation.  */
1460           DECL_EXTERNAL (decl) = 1;
1461           DECL_NOT_REALLY_EXTERN (decl) = 0;
1462         }
1463     }
1464
1465   if (DECL_LANG_SPECIFIC (decl))
1466     DECL_COMDAT (decl) = 1;
1467 }
1468
1469 /* For win32 we also want to put explicit instantiations in
1470    linkonce sections, so that they will be merged with implicit
1471    instantiations; otherwise we get duplicate symbol errors.  */
1472
1473 void
1474 maybe_make_one_only (tree decl)
1475 {
1476   /* We used to say that this was not necessary on targets that support weak
1477      symbols, because the implicit instantiations will defer to the explicit
1478      one.  However, that's not actually the case in SVR4; a strong definition
1479      after a weak one is an error.  Also, not making explicit
1480      instantiations one_only means that we can end up with two copies of
1481      some template instantiations.  */
1482   if (! flag_weak)
1483     return;
1484
1485   /* We can't set DECL_COMDAT on functions, or finish_file will think
1486      we can get away with not emitting them if they aren't used.  We need
1487      to for variables so that cp_finish_decl will update their linkage,
1488      because their DECL_INITIAL may not have been set properly yet.  */
1489
1490   make_decl_one_only (decl);
1491
1492   if (TREE_CODE (decl) == VAR_DECL)
1493     {
1494       DECL_COMDAT (decl) = 1;
1495       /* Mark it needed so we don't forget to emit it.  */
1496       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
1497     }
1498 }
1499
1500 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
1501    based on TYPE and other static flags.
1502
1503    Note that anything public is tagged TREE_PUBLIC, whether
1504    it's public in this file or in another one.  */
1505
1506 void
1507 import_export_vtable (tree decl, tree type, int final)
1508 {
1509   if (DECL_INTERFACE_KNOWN (decl))
1510     return;
1511
1512   if (TYPE_FOR_JAVA (type))
1513     {
1514       TREE_PUBLIC (decl) = 1;
1515       DECL_EXTERNAL (decl) = 1;
1516       DECL_INTERFACE_KNOWN (decl) = 1;
1517     }
1518   else if (CLASSTYPE_INTERFACE_KNOWN (type))
1519     {
1520       TREE_PUBLIC (decl) = 1;
1521       DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
1522       DECL_INTERFACE_KNOWN (decl) = 1;
1523     }
1524   else
1525     {
1526       /* We can only wait to decide if we have real non-inline virtual
1527          functions in our class, or if we come from a template.  */
1528
1529       int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
1530                    || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);
1531
1532       if (final || ! found)
1533         {
1534           comdat_linkage (decl);
1535           DECL_EXTERNAL (decl) = 0;
1536         }
1537       else
1538         {
1539           TREE_PUBLIC (decl) = 1;
1540           DECL_EXTERNAL (decl) = 1;
1541         }
1542     }
1543 }
1544
1545 /* Determine whether or not we want to specifically import or export CTYPE,
1546    using various heuristics.  */
1547
1548 static void
1549 import_export_class (tree ctype)
1550 {
1551   /* -1 for imported, 1 for exported.  */
1552   int import_export = 0;
1553
1554   /* It only makes sense to call this function at EOF.  The reason is
1555      that this function looks at whether or not the first non-inline
1556      non-abstract virtual member function has been defined in this
1557      translation unit.  But, we can't possibly know that until we've
1558      seen the entire translation unit.  */
1559   my_friendly_assert (at_eof, 20000226);
1560
1561   if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1562     return;
1563
1564   /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
1565      we will have CLASSTYPE_INTERFACE_ONLY set but not
1566      CLASSTYPE_INTERFACE_KNOWN.  In that case, we don't want to use this
1567      heuristic because someone will supply a #pragma implementation
1568      elsewhere, and deducing it here would produce a conflict.  */
1569   if (CLASSTYPE_INTERFACE_ONLY (ctype))
1570     return;
1571
1572   if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1573     import_export = -1;
1574   else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1575     import_export = 1;
1576
1577   /* If we got -fno-implicit-templates, we import template classes that
1578      weren't explicitly instantiated.  */
1579   if (import_export == 0
1580       && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1581       && ! flag_implicit_templates)
1582     import_export = -1;
1583
1584   /* Base our import/export status on that of the first non-inline,
1585      non-pure virtual function, if any.  */
1586   if (import_export == 0
1587       && TYPE_POLYMORPHIC_P (ctype))
1588     {
1589       tree method = CLASSTYPE_KEY_METHOD (ctype);
1590       if (method)
1591         import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1592     }
1593
1594 #ifdef MULTIPLE_SYMBOL_SPACES
1595   if (import_export == -1)
1596     import_export = 0;
1597 #endif
1598
1599   if (import_export)
1600     {
1601       SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1602       CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1603     }
1604 }
1605
1606 /* We need to describe to the assembler the relationship between
1607    a vtable and the vtable of the parent class.  */
1608
1609 static void
1610 output_vtable_inherit (tree vars)
1611 {
1612   tree parent;
1613   rtx child_rtx, parent_rtx;
1614
1615   child_rtx = XEXP (DECL_RTL (vars), 0);          /* strip the mem ref  */
1616
1617   parent = binfo_for_vtable (vars);
1618
1619   if (parent == TYPE_BINFO (DECL_CONTEXT (vars)))
1620     parent_rtx = const0_rtx;
1621   else if (parent)
1622     {
1623       parent = get_vtbl_decl_for_binfo (TYPE_BINFO (BINFO_TYPE (parent)));
1624       parent_rtx = XEXP (DECL_RTL (parent), 0);  /* strip the mem ref  */
1625     }
1626   else
1627     abort ();
1628
1629   assemble_vtable_inherit (child_rtx, parent_rtx);
1630 }
1631
1632 /* If necessary, write out the vtables for the dynamic class CTYPE.
1633    Returns true if any vtables were emitted.  */
1634
1635 static bool
1636 maybe_emit_vtables (tree ctype)
1637 {
1638   tree vtbl;
1639   tree primary_vtbl;
1640
1641   /* If the vtables for this class have already been emitted there is
1642      nothing more to do.  */
1643   primary_vtbl = CLASSTYPE_VTABLES (ctype);
1644   if (TREE_ASM_WRITTEN (primary_vtbl))
1645     return false;
1646   /* Ignore dummy vtables made by get_vtable_decl.  */
1647   if (TREE_TYPE (primary_vtbl) == void_type_node)
1648     return false;
1649
1650   import_export_class (ctype);
1651   import_export_vtable (primary_vtbl, ctype, 1);
1652
1653   /* See if any of the vtables are needed.  */
1654   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1655     if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
1656       break;
1657
1658   if (!vtbl)
1659     {
1660       /* If the references to this class' vtables are optimized away,
1661          still emit the appropriate debugging information.  See
1662          dfs_debug_mark.  */
1663       if (DECL_COMDAT (primary_vtbl)
1664           && CLASSTYPE_DEBUG_REQUESTED (ctype))
1665         note_debug_info_needed (ctype);
1666       return false;
1667     }
1668
1669   /* The ABI requires that we emit all of the vtables if we emit any
1670      of them.  */
1671   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1672     {
1673       /* Write it out.  */
1674       import_export_vtable (vtbl, ctype, 1);
1675       mark_vtable_entries (vtbl);
1676       if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1677         store_init_value (vtbl, DECL_INITIAL (vtbl));
1678
1679       if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
1680         {
1681           /* Mark the VAR_DECL node representing the vtable itself as a
1682              "gratuitous" one, thereby forcing dwarfout.c to ignore it.
1683              It is rather important that such things be ignored because
1684              any effort to actually generate DWARF for them will run
1685              into trouble when/if we encounter code like:
1686
1687                 #pragma interface
1688                 struct S { virtual void member (); };
1689
1690               because the artificial declaration of the vtable itself (as
1691               manufactured by the g++ front end) will say that the vtable
1692               is a static member of `S' but only *after* the debug output
1693               for the definition of `S' has already been output.  This causes
1694               grief because the DWARF entry for the definition of the vtable
1695               will try to refer back to an earlier *declaration* of the
1696               vtable as a static member of `S' and there won't be one.
1697               We might be able to arrange to have the "vtable static member"
1698               attached to the member list for `S' before the debug info for
1699               `S' get written (which would solve the problem) but that would
1700               require more intrusive changes to the g++ front end.  */
1701
1702           DECL_IGNORED_P (vtbl) = 1;
1703         }
1704
1705       /* Always make vtables weak.  */
1706       if (flag_weak)
1707         comdat_linkage (vtbl);
1708
1709       rest_of_decl_compilation (vtbl, NULL, 1, 1);
1710
1711       if (flag_vtable_gc)
1712         output_vtable_inherit (vtbl);
1713
1714       /* Because we're only doing syntax-checking, we'll never end up
1715          actually marking the variable as written.  */
1716       if (flag_syntax_only)
1717         TREE_ASM_WRITTEN (vtbl) = 1;
1718     }
1719
1720   /* Since we're writing out the vtable here, also write the debug
1721      info.  */
1722   note_debug_info_needed (ctype);
1723
1724   return true;
1725 }
1726
1727 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
1728    inline function or template instantiation at end-of-file.  */
1729
1730 void
1731 import_export_decl (tree decl)
1732 {
1733   if (DECL_INTERFACE_KNOWN (decl))
1734     return;
1735
1736   if (DECL_TEMPLATE_INSTANTIATION (decl)
1737       || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1738     {
1739       DECL_NOT_REALLY_EXTERN (decl) = 1;
1740       if ((DECL_IMPLICIT_INSTANTIATION (decl)
1741            || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1742           && (flag_implicit_templates
1743               || (flag_implicit_inline_templates
1744                   && DECL_DECLARED_INLINE_P (decl))))
1745         {
1746           if (!TREE_PUBLIC (decl))
1747             /* Templates are allowed to have internal linkage.  See
1748                [basic.link].  */
1749             ;
1750           else
1751             comdat_linkage (decl);
1752         }
1753       else
1754         {
1755           DECL_EXTERNAL (decl) = 1;
1756           DECL_NOT_REALLY_EXTERN (decl) = 0;
1757         }
1758     }
1759   else if (DECL_FUNCTION_MEMBER_P (decl))
1760     {
1761       if (!DECL_DECLARED_INLINE_P (decl))
1762         {
1763           tree ctype = DECL_CONTEXT (decl);
1764           import_export_class (ctype);
1765           if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1766             {
1767               DECL_NOT_REALLY_EXTERN (decl)
1768                 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
1769                      || (DECL_DECLARED_INLINE_P (decl)
1770                          && ! flag_implement_inlines
1771                          && !DECL_VINDEX (decl)));
1772
1773               if (!DECL_NOT_REALLY_EXTERN (decl))
1774                 DECL_EXTERNAL (decl) = 1;
1775
1776               /* Always make artificials weak.  */
1777               if (DECL_ARTIFICIAL (decl) && flag_weak)
1778                 comdat_linkage (decl);
1779               else
1780                 maybe_make_one_only (decl);
1781             }
1782         }
1783       else
1784         comdat_linkage (decl);
1785     }
1786   else
1787     comdat_linkage (decl);
1788
1789   DECL_INTERFACE_KNOWN (decl) = 1;
1790 }
1791
1792 /* Here, we only decide whether or not the tinfo node should be
1793    emitted with the vtable.  IS_IN_LIBRARY is nonzero iff the
1794    typeinfo for TYPE should be in the runtime library.  */
1795
1796 void
1797 import_export_tinfo (tree decl, tree type, bool is_in_library)
1798 {
1799   if (DECL_INTERFACE_KNOWN (decl))
1800     return;
1801
1802   if (IS_AGGR_TYPE (type))
1803     import_export_class (type);
1804
1805   if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
1806       && TYPE_POLYMORPHIC_P (type)
1807       /* If -fno-rtti, we're not necessarily emitting this stuff with
1808          the class, so go ahead and emit it now.  This can happen when
1809          a class is used in exception handling.  */
1810       && flag_rtti)
1811     {
1812       DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
1813       DECL_COMDAT (decl) = 0;
1814     }
1815   else
1816     {
1817       DECL_NOT_REALLY_EXTERN (decl) = 1;
1818       DECL_COMDAT (decl) = 1;
1819     }
1820
1821   /* Now override some cases.  */
1822   if (flag_weak)
1823     DECL_COMDAT (decl) = 1;
1824   else if (is_in_library)
1825     DECL_COMDAT (decl) = 0;
1826
1827   DECL_INTERFACE_KNOWN (decl) = 1;
1828 }
1829
1830 /* Return an expression that performs the destruction of DECL, which
1831    must be a VAR_DECL whose type has a non-trivial destructor, or is
1832    an array whose (innermost) elements have a non-trivial destructor.  */
1833
1834 tree
1835 build_cleanup (tree decl)
1836 {
1837   tree temp;
1838   tree type = TREE_TYPE (decl);
1839
1840   /* This function should only be called for declarations that really
1841      require cleanups.  */
1842   my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
1843
1844   /* Treat all objects with destructors as used; the destructor may do
1845      something substantive.  */
1846   mark_used (decl);
1847
1848   if (TREE_CODE (type) == ARRAY_TYPE)
1849     temp = decl;
1850   else
1851     {
1852       cxx_mark_addressable (decl);
1853       temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
1854     }
1855   temp = build_delete (TREE_TYPE (temp), temp,
1856                        sfk_complete_destructor,
1857                        LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
1858   return temp;
1859 }
1860
1861 /* Returns the initialization guard variable for the variable DECL,
1862    which has static storage duration.  */
1863
1864 tree
1865 get_guard (tree decl)
1866 {
1867   tree sname;
1868   tree guard;
1869
1870   sname = mangle_guard_variable (decl);
1871   guard = IDENTIFIER_GLOBAL_VALUE (sname);
1872   if (! guard)
1873     {
1874       tree guard_type;
1875
1876       /* We use a type that is big enough to contain a mutex as well
1877          as an integer counter.  */
1878       guard_type = long_long_integer_type_node;
1879       guard = build_decl (VAR_DECL, sname, guard_type);
1880
1881       /* The guard should have the same linkage as what it guards.  */
1882       TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
1883       TREE_STATIC (guard) = TREE_STATIC (decl);
1884       DECL_COMMON (guard) = DECL_COMMON (decl);
1885       DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
1886       if (TREE_PUBLIC (decl))
1887         DECL_WEAK (guard) = DECL_WEAK (decl);
1888
1889       DECL_ARTIFICIAL (guard) = 1;
1890       TREE_USED (guard) = 1;
1891       pushdecl_top_level_and_finish (guard, NULL_TREE);
1892     }
1893   return guard;
1894 }
1895
1896 /* Return those bits of the GUARD variable that should be set when the
1897    guarded entity is actually initialized.  */
1898
1899 static tree
1900 get_guard_bits (tree guard)
1901 {
1902   /* We only set the first byte of the guard, in order to leave room
1903      for a mutex in the high-order bits.  */
1904   guard = build1 (ADDR_EXPR,
1905                   build_pointer_type (TREE_TYPE (guard)),
1906                   guard);
1907   guard = build1 (NOP_EXPR,
1908                   build_pointer_type (char_type_node),
1909                   guard);
1910   guard = build1 (INDIRECT_REF, char_type_node, guard);
1911
1912   return guard;
1913 }
1914
1915 /* Return an expression which determines whether or not the GUARD
1916    variable has already been initialized.  */
1917
1918 tree
1919 get_guard_cond (tree guard)
1920 {
1921   tree guard_value;
1922
1923   /* Check to see if the GUARD is zero.  */
1924   guard = get_guard_bits (guard);
1925   guard_value = integer_zero_node;
1926   if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1927     guard_value = convert (TREE_TYPE (guard), guard_value);
1928   return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1929 }
1930
1931 /* Return an expression which sets the GUARD variable, indicating that
1932    the variable being guarded has been initialized.  */
1933
1934 tree
1935 set_guard (tree guard)
1936 {
1937   tree guard_init;
1938
1939   /* Set the GUARD to one.  */
1940   guard = get_guard_bits (guard);
1941   guard_init = integer_one_node;
1942   if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1943     guard_init = convert (TREE_TYPE (guard), guard_init);
1944   return build_modify_expr (guard, NOP_EXPR, guard_init);
1945 }
1946
1947 /* Start the process of running a particular set of global constructors
1948    or destructors.  Subroutine of do_[cd]tors.  */
1949
1950 static tree
1951 start_objects (int method_type, int initp)
1952 {
1953   tree fnname;
1954   tree body;
1955   char type[10];
1956
1957   /* Make ctor or dtor function.  METHOD_TYPE may be 'I' or 'D'.  */
1958
1959   if (initp != DEFAULT_INIT_PRIORITY)
1960     {
1961       char joiner;
1962
1963 #ifdef JOINER
1964       joiner = JOINER;
1965 #else
1966       joiner = '_';
1967 #endif
1968
1969       sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1970     }
1971   else
1972     sprintf (type, "%c", method_type);
1973
1974   fnname = get_file_function_name_long (type);
1975
1976   start_function (void_list_node,
1977                   make_call_declarator (fnname, void_list_node, NULL_TREE,
1978                                         NULL_TREE),
1979                   NULL_TREE, SF_DEFAULT);
1980
1981   /* It can be a static function as long as collect2 does not have
1982      to scan the object file to find its ctor/dtor routine.  */
1983   TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1984
1985   /* Mark this declaration as used to avoid spurious warnings.  */
1986   TREE_USED (current_function_decl) = 1;
1987
1988   /* Mark this function as a global constructor or destructor.  */
1989   if (method_type == 'I')
1990     DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1991   else
1992     DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1993   DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1994
1995   body = begin_compound_stmt (/*has_no_scope=*/0);
1996
1997   /* We cannot allow these functions to be elided, even if they do not
1998      have external linkage.  And, there's no point in deferring
1999      copmilation of thes functions; they're all going to have to be
2000      out anyhow.  */
2001   current_function_cannot_inline
2002     = "static constructors and destructors cannot be inlined";
2003
2004   return body;
2005 }
2006
2007 /* Finish the process of running a particular set of global constructors
2008    or destructors.  Subroutine of do_[cd]tors.  */
2009
2010 static void
2011 finish_objects (int method_type, int initp, tree body)
2012 {
2013   tree fn;
2014
2015   /* Finish up.  */
2016   finish_compound_stmt (/*has_no_scope=*/0, body);
2017   fn = finish_function (0);
2018   expand_body (fn);
2019
2020   /* When only doing semantic analysis, and no RTL generation, we
2021      can't call functions that directly emit assembly code; there is
2022      no assembly file in which to put the code.  */
2023   if (flag_syntax_only)
2024     return;
2025
2026   if (targetm.have_ctors_dtors)
2027     {
2028       rtx fnsym = XEXP (DECL_RTL (fn), 0);
2029       if (method_type == 'I')
2030         (* targetm.asm_out.constructor) (fnsym, initp);
2031       else
2032         (* targetm.asm_out.destructor) (fnsym, initp);
2033     }
2034 }
2035
2036 /* The names of the parameters to the function created to handle
2037    initializations and destructions for objects with static storage
2038    duration.  */
2039 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2040 #define PRIORITY_IDENTIFIER "__priority"
2041
2042 /* The name of the function we create to handle initializations and
2043    destructions for objects with static storage duration.  */
2044 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2045
2046 /* The declaration for the __INITIALIZE_P argument.  */
2047 static GTY(()) tree initialize_p_decl;
2048
2049 /* The declaration for the __PRIORITY argument.  */
2050 static GTY(()) tree priority_decl;
2051
2052 /* The declaration for the static storage duration function.  */
2053 static GTY(()) tree ssdf_decl;
2054
2055 /* All the static storage duration functions created in this
2056    translation unit.  */
2057 static GTY(()) varray_type ssdf_decls;
2058
2059 /* A map from priority levels to information about that priority
2060    level.  There may be many such levels, so efficient lookup is
2061    important.  */
2062 static splay_tree priority_info_map;
2063
2064 /* Begins the generation of the function that will handle all
2065    initialization and destruction of objects with static storage
2066    duration.  The function generated takes two parameters of type
2067    `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
2068    nonzero, it performs initializations.  Otherwise, it performs
2069    destructions.  It only performs those initializations or
2070    destructions with the indicated __PRIORITY.  The generated function
2071    returns no value.
2072
2073    It is assumed that this function will only be called once per
2074    translation unit.  */
2075
2076 static tree
2077 start_static_storage_duration_function (unsigned count)
2078 {
2079   tree parm_types;
2080   tree type;
2081   tree body;
2082   char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2083
2084   /* Create the identifier for this function.  It will be of the form
2085      SSDF_IDENTIFIER_<number>.  */
2086   sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2087
2088   /* Create the parameters.  */
2089   parm_types = void_list_node;
2090   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2091   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2092   type = build_function_type (void_type_node, parm_types);
2093
2094   /* Create the FUNCTION_DECL itself.  */
2095   ssdf_decl = build_lang_decl (FUNCTION_DECL,
2096                                get_identifier (id),
2097                                type);
2098   TREE_PUBLIC (ssdf_decl) = 0;
2099   DECL_ARTIFICIAL (ssdf_decl) = 1;
2100
2101   /* Put this function in the list of functions to be called from the
2102      static constructors and destructors.  */
2103   if (!ssdf_decls)
2104     {
2105       VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2106
2107       /* Take this opportunity to initialize the map from priority
2108          numbers to information about that priority level.  */
2109       priority_info_map = splay_tree_new (splay_tree_compare_ints,
2110                                           /*delete_key_fn=*/0,
2111                                           /*delete_value_fn=*/
2112                                           (splay_tree_delete_value_fn) &free);
2113
2114       /* We always need to generate functions for the
2115          DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
2116          priorities later, we'll be sure to find the
2117          DEFAULT_INIT_PRIORITY.  */
2118       get_priority_info (DEFAULT_INIT_PRIORITY);
2119     }
2120
2121   VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2122
2123   /* Create the argument list.  */
2124   initialize_p_decl = cp_build_parm_decl
2125     (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2126   DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2127   TREE_USED (initialize_p_decl) = 1;
2128   priority_decl = cp_build_parm_decl
2129     (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2130   DECL_CONTEXT (priority_decl) = ssdf_decl;
2131   TREE_USED (priority_decl) = 1;
2132
2133   TREE_CHAIN (initialize_p_decl) = priority_decl;
2134   DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2135
2136   /* Put the function in the global scope.  */
2137   pushdecl (ssdf_decl);
2138
2139   /* Start the function itself.  This is equivalent to declarating the
2140      function as:
2141
2142        static void __ssdf (int __initialize_p, init __priority_p);
2143
2144      It is static because we only need to call this function from the
2145      various constructor and destructor functions for this module.  */
2146   start_function (/*specs=*/NULL_TREE,
2147                   ssdf_decl,
2148                   /*attrs=*/NULL_TREE,
2149                   SF_PRE_PARSED);
2150
2151   /* Set up the scope of the outermost block in the function.  */
2152   body = begin_compound_stmt (/*has_no_scope=*/0);
2153
2154   /* This function must not be deferred because we are depending on
2155      its compilation to tell us what is TREE_SYMBOL_REFERENCED.  */
2156   current_function_cannot_inline
2157     = "static storage duration functions cannot be inlined";
2158
2159   return body;
2160 }
2161
2162 /* Finish the generation of the function which performs initialization
2163    and destruction of objects with static storage duration.  After
2164    this point, no more such objects can be created.  */
2165
2166 static void
2167 finish_static_storage_duration_function (tree body)
2168 {
2169   /* Close out the function.  */
2170   finish_compound_stmt (/*has_no_scope=*/0, body);
2171   expand_body (finish_function (0));
2172 }
2173
2174 /* Return the information about the indicated PRIORITY level.  If no
2175    code to handle this level has yet been generated, generate the
2176    appropriate prologue.  */
2177
2178 static priority_info
2179 get_priority_info (int priority)
2180 {
2181   priority_info pi;
2182   splay_tree_node n;
2183
2184   n = splay_tree_lookup (priority_info_map,
2185                          (splay_tree_key) priority);
2186   if (!n)
2187     {
2188       /* Create a new priority information structure, and insert it
2189          into the map.  */
2190       pi = (priority_info) xmalloc (sizeof (struct priority_info_s));
2191       pi->initializations_p = 0;
2192       pi->destructions_p = 0;
2193       splay_tree_insert (priority_info_map,
2194                          (splay_tree_key) priority,
2195                          (splay_tree_value) pi);
2196     }
2197   else
2198     pi = (priority_info) n->value;
2199
2200   return pi;
2201 }
2202
2203 /* Set up to handle the initialization or destruction of DECL.  If
2204    INITP is nonzero, we are initializing the variable.  Otherwise, we
2205    are destroying it.  */
2206
2207 static tree
2208 start_static_initialization_or_destruction (tree decl, int initp)
2209 {
2210   tree guard_if_stmt = NULL_TREE;
2211   int priority;
2212   tree cond;
2213   tree guard;
2214   tree init_cond;
2215   priority_info pi;
2216
2217   /* Figure out the priority for this declaration.  */
2218   priority = DECL_INIT_PRIORITY (decl);
2219   if (!priority)
2220     priority = DEFAULT_INIT_PRIORITY;
2221
2222   /* Remember that we had an initialization or finalization at this
2223      priority.  */
2224   pi = get_priority_info (priority);
2225   if (initp)
2226     pi->initializations_p = 1;
2227   else
2228     pi->destructions_p = 1;
2229
2230   /* Trick the compiler into thinking we are at the file and line
2231      where DECL was declared so that error-messages make sense, and so
2232      that the debugger will show somewhat sensible file and line
2233      information.  */
2234   input_location = DECL_SOURCE_LOCATION (decl);
2235
2236   /* Because of:
2237
2238        [class.access.spec]
2239
2240        Access control for implicit calls to the constructors,
2241        the conversion functions, or the destructor called to
2242        create and destroy a static data member is performed as
2243        if these calls appeared in the scope of the member's
2244        class.
2245
2246      we pretend we are in a static member function of the class of
2247      which the DECL is a member.  */
2248   if (member_p (decl))
2249     {
2250       DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2251       DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2252     }
2253
2254   /* Conditionalize this initialization on being in the right priority
2255      and being initializing/finalizing appropriately.  */
2256   guard_if_stmt = begin_if_stmt ();
2257   cond = cp_build_binary_op (EQ_EXPR,
2258                              priority_decl,
2259                              build_int_2 (priority, 0));
2260   init_cond = initp ? integer_one_node : integer_zero_node;
2261   init_cond = cp_build_binary_op (EQ_EXPR,
2262                                   initialize_p_decl,
2263                                   init_cond);
2264   cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2265
2266   /* Assume we don't need a guard.  */
2267   guard = NULL_TREE;
2268   /* We need a guard if this is an object with external linkage that
2269      might be initialized in more than one place.  (For example, a
2270      static data member of a template, when the data member requires
2271      construction.)  */
2272   if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2273                              || DECL_ONE_ONLY (decl)
2274                              || DECL_WEAK (decl)))
2275     {
2276       tree guard_cond;
2277
2278       guard = get_guard (decl);
2279
2280       /* When using __cxa_atexit, we just check the GUARD as we would
2281          for a local static.  */
2282       if (flag_use_cxa_atexit)
2283         {
2284           /* When using __cxa_atexit, we never try to destroy
2285              anything from a static destructor.  */
2286           my_friendly_assert (initp, 20000629);
2287           guard_cond = get_guard_cond (guard);
2288         }
2289       /* If we don't have __cxa_atexit, then we will be running
2290          destructors from .fini sections, or their equivalents.  So,
2291          we need to know how many times we've tried to initialize this
2292          object.  We do initializations only if the GUARD is zero,
2293          i.e., if we are the first to initialize the variable.  We do
2294          destructions only if the GUARD is one, i.e., if we are the
2295          last to destroy the variable.  */
2296       else if (initp)
2297         guard_cond
2298           = cp_build_binary_op (EQ_EXPR,
2299                                 build_unary_op (PREINCREMENT_EXPR,
2300                                                 guard,
2301                                                 /*noconvert=*/1),
2302                                 integer_one_node);
2303       else
2304         guard_cond
2305           = cp_build_binary_op (EQ_EXPR,
2306                                 build_unary_op (PREDECREMENT_EXPR,
2307                                                 guard,
2308                                                 /*noconvert=*/1),
2309                                 integer_zero_node);
2310
2311       cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2312     }
2313
2314   finish_if_stmt_cond (cond, guard_if_stmt);
2315
2316   /* If we're using __cxa_atexit, we have not already set the GUARD,
2317      so we must do so now.  */
2318   if (guard && initp && flag_use_cxa_atexit)
2319     finish_expr_stmt (set_guard (guard));
2320
2321   return guard_if_stmt;
2322 }
2323
2324 /* We've just finished generating code to do an initialization or
2325    finalization.  GUARD_IF_STMT is the if-statement we used to guard
2326    the initialization.  */
2327
2328 static void
2329 finish_static_initialization_or_destruction (tree guard_if_stmt)
2330 {
2331   finish_then_clause (guard_if_stmt);
2332   finish_if_stmt ();
2333
2334   /* Now that we're done with DECL we don't need to pretend to be a
2335      member of its class any longer.  */
2336   DECL_CONTEXT (current_function_decl) = NULL_TREE;
2337   DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2338 }
2339
2340 /* Generate code to do the initialization of DECL, a VAR_DECL with
2341    static storage duration.  The initialization is INIT.  */
2342
2343 static void
2344 do_static_initialization (tree decl, tree init)
2345 {
2346   tree guard_if_stmt;
2347
2348   /* Set up for the initialization.  */
2349   guard_if_stmt
2350     = start_static_initialization_or_destruction (decl,
2351                                                   /*initp=*/1);
2352
2353   /* Perform the initialization.  */
2354   if (init)
2355     finish_expr_stmt (init);
2356
2357   /* If we're using __cxa_atexit, register a a function that calls the
2358      destructor for the object.  */
2359   if (flag_use_cxa_atexit)
2360     register_dtor_fn (decl);
2361
2362   /* Finsh up.  */
2363   finish_static_initialization_or_destruction (guard_if_stmt);
2364 }
2365
2366 /* Generate code to do the static destruction of DECL.  If DECL may be
2367    initialized more than once in different object files, GUARD is the
2368    guard variable to check.  PRIORITY is the priority for the
2369    destruction.  */
2370
2371 static void
2372 do_static_destruction (tree decl)
2373 {
2374   tree guard_if_stmt;
2375
2376   /* If we're using __cxa_atexit, then destructors are registered
2377      immediately after objects are initialized.  */
2378   my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2379
2380   /* If we don't need a destructor, there's nothing to do.  */
2381   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2382     return;
2383
2384   /* Actually do the destruction.  */
2385   guard_if_stmt = start_static_initialization_or_destruction (decl,
2386                                                               /*initp=*/0);
2387   finish_expr_stmt (build_cleanup (decl));
2388   finish_static_initialization_or_destruction (guard_if_stmt);
2389 }
2390
2391 /* VARS is a list of variables with static storage duration which may
2392    need initialization and/or finalization.  Remove those variables
2393    that don't really need to be initialized or finalized, and return
2394    the resulting list.  The order in which the variables appear in
2395    VARS is in reverse order of the order in which they should actually
2396    be initialized.  The list we return is in the unreversed order;
2397    i.e., the first variable should be initialized first.  */
2398
2399 static tree
2400 prune_vars_needing_no_initialization (tree *vars)
2401 {
2402   tree *var = vars;
2403   tree result = NULL_TREE;
2404
2405   while (*var)
2406     {
2407       tree t = *var;
2408       tree decl = TREE_VALUE (t);
2409       tree init = TREE_PURPOSE (t);
2410
2411       /* Deal gracefully with error.  */
2412       if (decl == error_mark_node)
2413         {
2414           var = &TREE_CHAIN (t);
2415           continue;
2416         }
2417
2418       /* The only things that can be initialized are variables.  */
2419       my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2420
2421       /* If this object is not defined, we don't need to do anything
2422          here.  */
2423       if (DECL_EXTERNAL (decl))
2424         {
2425           var = &TREE_CHAIN (t);
2426           continue;
2427         }
2428
2429       /* Also, if the initializer already contains errors, we can bail
2430          out now.  */
2431       if (init && TREE_CODE (init) == TREE_LIST
2432           && value_member (error_mark_node, init))
2433         {
2434           var = &TREE_CHAIN (t);
2435           continue;
2436         }
2437
2438       /* This variable is going to need initialization and/or
2439          finalization, so we add it to the list.  */
2440       *var = TREE_CHAIN (t);
2441       TREE_CHAIN (t) = result;
2442       result = t;
2443     }
2444
2445   return result;
2446 }
2447
2448 /* Make sure we have told the back end about all the variables in
2449    VARS.  */
2450
2451 static void
2452 write_out_vars (tree vars)
2453 {
2454   tree v;
2455
2456   for (v = vars; v; v = TREE_CHAIN (v))
2457     if (! TREE_ASM_WRITTEN (TREE_VALUE (v)))
2458       rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2459 }
2460
2461 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2462    (otherwise) that will initialize all gobal objects with static
2463    storage duration having the indicated PRIORITY.  */
2464
2465 static void
2466 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2467                                 location_t *locus)
2468 {
2469   char function_key;
2470   tree arguments;
2471   tree fndecl;
2472   tree body;
2473   size_t i;
2474
2475   input_location = *locus;
2476   locus->line++;
2477
2478   /* We use `I' to indicate initialization and `D' to indicate
2479      destruction.  */
2480   function_key = constructor_p ? 'I' : 'D';
2481
2482   /* We emit the function lazily, to avoid generating empty
2483      global constructors and destructors.  */
2484   body = NULL_TREE;
2485
2486   /* Call the static storage duration function with appropriate
2487      arguments.  */
2488   if (ssdf_decls)
2489     for (i = 0; i < ssdf_decls->elements_used; ++i)
2490       {
2491         fndecl = VARRAY_TREE (ssdf_decls, i);
2492
2493         /* Calls to pure or const functions will expand to nothing.  */
2494         if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2495           {
2496             if (! body)
2497               body = start_objects (function_key, priority);
2498
2499             arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2500                                    NULL_TREE);
2501             arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2502                                    arguments);
2503             finish_expr_stmt (build_function_call (fndecl, arguments));
2504           }
2505       }
2506
2507   /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2508      calls to any functions marked with attributes indicating that
2509      they should be called at initialization- or destruction-time.  */
2510   if (priority == DEFAULT_INIT_PRIORITY)
2511     {
2512       tree fns;
2513
2514       for (fns = constructor_p ? static_ctors : static_dtors;
2515            fns;
2516            fns = TREE_CHAIN (fns))
2517         {
2518           fndecl = TREE_VALUE (fns);
2519
2520           /* Calls to pure/const functions will expand to nothing.  */
2521           if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2522             {
2523               if (! body)
2524                 body = start_objects (function_key, priority);
2525               finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2526             }
2527         }
2528     }
2529
2530   /* Close out the function.  */
2531   if (body)
2532     finish_objects (function_key, priority, body);
2533 }
2534
2535 /* Generate constructor and destructor functions for the priority
2536    indicated by N.  */
2537
2538 static int
2539 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2540 {
2541   location_t *locus = data;
2542   int priority = (int) n->key;
2543   priority_info pi = (priority_info) n->value;
2544
2545   /* Generate the functions themselves, but only if they are really
2546      needed.  */
2547   if (pi->initializations_p
2548       || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2549     generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2550   if (pi->destructions_p
2551       || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2552     generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2553
2554   /* Keep iterating.  */
2555   return 0;
2556 }
2557
2558 /* This routine is called from the last rule in yyparse ().
2559    Its job is to create all the code needed to initialize and
2560    destroy the global aggregates.  We do the destruction
2561    first, since that way we only need to reverse the decls once.  */
2562
2563 void
2564 finish_file ()
2565 {
2566   tree vars;
2567   bool reconsider;
2568   size_t i;
2569   location_t locus;
2570   unsigned ssdf_count = 0;
2571
2572   locus = input_location;
2573   at_eof = 1;
2574
2575   /* Bad parse errors.  Just forget about it.  */
2576   if (! global_bindings_p () || current_class_type || decl_namespace_list)
2577     return;
2578
2579   if (pch_file)
2580     c_common_write_pch ();
2581
2582   /* Otherwise, GDB can get confused, because in only knows
2583      about source for LINENO-1 lines.  */
2584   input_line -= 1;
2585
2586   interface_unknown = 1;
2587   interface_only = 0;
2588
2589   /* We now have to write out all the stuff we put off writing out.
2590      These include:
2591
2592        o Template specializations that we have not yet instantiated,
2593          but which are needed.
2594        o Initialization and destruction for non-local objects with
2595          static storage duration.  (Local objects with static storage
2596          duration are initialized when their scope is first entered,
2597          and are cleaned up via atexit.)
2598        o Virtual function tables.
2599
2600      All of these may cause others to be needed.  For example,
2601      instantiating one function may cause another to be needed, and
2602      generating the initializer for an object may cause templates to be
2603      instantiated, etc., etc.  */
2604
2605   timevar_push (TV_VARCONST);
2606
2607   emit_support_tinfos ();
2608
2609   do
2610     {
2611       tree t;
2612       size_t n_old, n_new;
2613
2614       reconsider = false;
2615
2616       /* If there are templates that we've put off instantiating, do
2617          them now.  */
2618       instantiate_pending_templates ();
2619
2620       /* Write out virtual tables as required.  Note that writing out
2621          the virtual table for a template class may cause the
2622          instantiation of members of that class.  If we write out
2623          vtables then we remove the class from our list so we don't
2624          have to look at it again. */
2625
2626       while (keyed_classes != NULL_TREE
2627              && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2628         {
2629           reconsider = true;
2630           keyed_classes = TREE_CHAIN (keyed_classes);
2631         }
2632
2633       t = keyed_classes;
2634       if (t != NULL_TREE)
2635         {
2636           tree next = TREE_CHAIN (t);
2637
2638           while (next)
2639             {
2640               if (maybe_emit_vtables (TREE_VALUE (next)))
2641                 {
2642                   reconsider = true;
2643                   TREE_CHAIN (t) = TREE_CHAIN (next);
2644                 }
2645               else
2646                 t = next;
2647
2648               next = TREE_CHAIN (t);
2649             }
2650         }
2651
2652       /* Write out needed type info variables.  We have to be careful
2653          looping through unemitted decls, because emit_tinfo_decl may
2654          cause other variables to be needed.  We stick new elements
2655          (and old elements that we may need to reconsider) at the end
2656          of the array, then shift them back to the beginning once we're
2657          done. */
2658
2659       n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2660       for (i = 0; i < n_old; ++i)
2661         {
2662           tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2663           if (emit_tinfo_decl (tinfo_decl))
2664             reconsider = true;
2665           else
2666             VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2667         }
2668
2669       /* The only elements we want to keep are the new ones.  Copy
2670          them to the beginning of the array, then get rid of the
2671          leftovers. */
2672       n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2673       memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2674                &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2675                n_new * sizeof (tree));
2676       memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2677               0,
2678               n_old * sizeof (tree));
2679       VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2680
2681       /* The list of objects with static storage duration is built up
2682          in reverse order.  We clear STATIC_AGGREGATES so that any new
2683          aggregates added during the initialization of these will be
2684          initialized in the correct order when we next come around the
2685          loop.  */
2686       vars = prune_vars_needing_no_initialization (&static_aggregates);
2687
2688       if (vars)
2689         {
2690           tree v;
2691
2692           /* We need to start a new initialization function each time
2693              through the loop.  That's because we need to know which
2694              vtables have been referenced, and TREE_SYMBOL_REFERENCED
2695              isn't computed until a function is finished, and written
2696              out.  That's a deficiency in the back-end.  When this is
2697              fixed, these initialization functions could all become
2698              inline, with resulting performance improvements.  */
2699           tree ssdf_body;
2700
2701           /* Set the line and file, so that it is obviously not from
2702              the source file.  */
2703           input_location = locus;
2704           ssdf_body = start_static_storage_duration_function (ssdf_count);
2705
2706           /* Make sure the back end knows about all the variables.  */
2707           write_out_vars (vars);
2708
2709           /* First generate code to do all the initializations.  */
2710           for (v = vars; v; v = TREE_CHAIN (v))
2711             do_static_initialization (TREE_VALUE (v),
2712                                       TREE_PURPOSE (v));
2713
2714           /* Then, generate code to do all the destructions.  Do these
2715              in reverse order so that the most recently constructed
2716              variable is the first destroyed.  If we're using
2717              __cxa_atexit, then we don't need to do this; functions
2718              were registered at initialization time to destroy the
2719              local statics.  */
2720           if (!flag_use_cxa_atexit)
2721             {
2722               vars = nreverse (vars);
2723               for (v = vars; v; v = TREE_CHAIN (v))
2724                 do_static_destruction (TREE_VALUE (v));
2725             }
2726           else
2727             vars = NULL_TREE;
2728
2729           /* Finish up the static storage duration function for this
2730              round.  */
2731           input_location = locus;
2732           finish_static_storage_duration_function (ssdf_body);
2733
2734           /* All those initializations and finalizations might cause
2735              us to need more inline functions, more template
2736              instantiations, etc.  */
2737           reconsider = true;
2738           ssdf_count++;
2739           locus.line++;
2740         }
2741
2742       for (i = 0; i < deferred_fns_used; ++i)
2743         {
2744           tree decl = VARRAY_TREE (deferred_fns, i);
2745
2746           /* Does it need synthesizing?  */
2747           if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2748               && TREE_USED (decl)
2749               && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2750             {
2751               /* Even though we're already at the top-level, we push
2752                  there again.  That way, when we pop back a few lines
2753                  hence, all of our state is restored.  Otherwise,
2754                  finish_function doesn't clean things up, and we end
2755                  up with CURRENT_FUNCTION_DECL set.  */
2756               push_to_top_level ();
2757               synthesize_method (decl);
2758               pop_from_top_level ();
2759               reconsider = true;
2760             }
2761
2762           /* If the function has no body, avoid calling
2763              import_export_decl.  On a system without weak symbols,
2764              calling import_export_decl will make an inline template
2765              instantiation "static", which will result in errors about
2766              the use of undefined functions if there is no body for
2767              the function.  */
2768           if (!DECL_SAVED_TREE (decl))
2769             continue;
2770
2771           import_export_decl (decl);
2772
2773           /* We lie to the back-end, pretending that some functions
2774              are not defined when they really are.  This keeps these
2775              functions from being put out unnecessarily.  But, we must
2776              stop lying when the functions are referenced, or if they
2777              are not comdat since they need to be put out now.  This
2778              is done in a separate for cycle, because if some deferred
2779              function is contained in another deferred function later
2780              in deferred_fns varray, rest_of_compilation would skip
2781              this function and we really cannot expand the same
2782              function twice.  */
2783           if (DECL_NOT_REALLY_EXTERN (decl)
2784               && DECL_INITIAL (decl)
2785               && DECL_NEEDED_P (decl))
2786             DECL_EXTERNAL (decl) = 0;
2787
2788           /* If we're going to need to write this function out, and
2789              there's already a body for it, create RTL for it now.
2790              (There might be no body if this is a method we haven't
2791              gotten around to synthesizing yet.)  */
2792           if (!DECL_EXTERNAL (decl)
2793               && DECL_NEEDED_P (decl)
2794               && DECL_SAVED_TREE (decl)
2795               && !TREE_ASM_WRITTEN (decl))
2796             {
2797               int saved_not_really_extern;
2798
2799               /* When we call finish_function in expand_body, it will
2800                  try to reset DECL_NOT_REALLY_EXTERN so we save and
2801                  restore it here.  */
2802               saved_not_really_extern = DECL_NOT_REALLY_EXTERN (decl);
2803               /* Generate RTL for this function now that we know we
2804                  need it.  */
2805               expand_body (decl);
2806               /* Undo the damage done by finish_function.  */
2807               DECL_EXTERNAL (decl) = 0;
2808               DECL_NOT_REALLY_EXTERN (decl) = saved_not_really_extern;
2809               /* If we're compiling -fsyntax-only pretend that this
2810                  function has been written out so that we don't try to
2811                  expand it again.  */
2812               if (flag_syntax_only)
2813                 TREE_ASM_WRITTEN (decl) = 1;
2814               reconsider = true;
2815             }
2816         }
2817
2818       if (deferred_fns_used
2819           && wrapup_global_declarations (&VARRAY_TREE (deferred_fns, 0),
2820                                          deferred_fns_used))
2821         reconsider = true;
2822       if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2823         reconsider = true;
2824
2825       /* Static data members are just like namespace-scope globals.  */
2826       for (i = 0; i < pending_statics_used; ++i)
2827         {
2828           tree decl = VARRAY_TREE (pending_statics, i);
2829           if (TREE_ASM_WRITTEN (decl))
2830             continue;
2831           import_export_decl (decl);
2832           if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2833             DECL_EXTERNAL (decl) = 0;
2834         }
2835       if (pending_statics
2836           && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2837                                          pending_statics_used))
2838         reconsider = true;
2839     }
2840   while (reconsider);
2841
2842   /* All used inline functions must have a definition at this point. */
2843   for (i = 0; i < deferred_fns_used; ++i)
2844     {
2845       tree decl = VARRAY_TREE (deferred_fns, i);
2846
2847       if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
2848           && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
2849                /* An explicit instantiation can be used to specify
2850                   that the body is in another unit. It will have
2851                   already verified there was a definition.  */
2852                || DECL_EXPLICIT_INSTANTIATION (decl)))
2853         {
2854           cp_warning_at ("inline function `%D' used but never defined", decl);
2855           /* This symbol is effectively an "extern" declaration now.
2856              This is not strictly necessary, but removes a duplicate
2857              warning.  */
2858           TREE_PUBLIC (decl) = 1;
2859         }
2860
2861     }
2862
2863   /* We give C linkage to static constructors and destructors.  */
2864   push_lang_context (lang_name_c);
2865
2866   /* Generate initialization and destruction functions for all
2867      priorities for which they are required.  */
2868   if (priority_info_map)
2869     splay_tree_foreach (priority_info_map,
2870                         generate_ctor_and_dtor_functions_for_priority,
2871                         /*data=*/&locus);
2872   else
2873     {
2874
2875       if (static_ctors)
2876         generate_ctor_or_dtor_function (/*constructor_p=*/true,
2877                                         DEFAULT_INIT_PRIORITY, &locus);
2878       if (static_dtors)
2879         generate_ctor_or_dtor_function (/*constructor_p=*/false,
2880                                         DEFAULT_INIT_PRIORITY, &locus);
2881     }
2882
2883   /* We're done with the splay-tree now.  */
2884   if (priority_info_map)
2885     splay_tree_delete (priority_info_map);
2886
2887   /* We're done with static constructors, so we can go back to "C++"
2888      linkage now.  */
2889   pop_lang_context ();
2890
2891   /* Now, issue warnings about static, but not defined, functions,
2892      etc., and emit debugging information.  */
2893   walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2894   if (pending_statics)
2895     check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2896                                pending_statics_used);
2897
2898   finish_repo ();
2899
2900   /* The entire file is now complete.  If requested, dump everything
2901      to a file.  */
2902   {
2903     int flags;
2904     FILE *stream = dump_begin (TDI_all, &flags);
2905
2906     if (stream)
2907       {
2908         dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2909         dump_end (TDI_all, stream);
2910       }
2911   }
2912
2913   timevar_pop (TV_VARCONST);
2914
2915   if (flag_detailed_statistics)
2916     {
2917       dump_tree_statistics ();
2918       dump_time_statistics ();
2919     }
2920   input_location = locus;
2921 }
2922
2923 /* T is the parse tree for an expression.  Return the expression after
2924    performing semantic analysis.  */
2925
2926 tree
2927 build_expr_from_tree (t)
2928      tree t;
2929 {
2930   if (t == NULL_TREE || t == error_mark_node)
2931     return t;
2932
2933   switch (TREE_CODE (t))
2934     {
2935     case IDENTIFIER_NODE:
2936       return do_identifier (t, NULL_TREE);
2937
2938     case LOOKUP_EXPR:
2939       if (LOOKUP_EXPR_GLOBAL (t))
2940         {
2941           tree token = TREE_OPERAND (t, 0);
2942           return do_scoped_id (token, IDENTIFIER_GLOBAL_VALUE (token));
2943         }
2944       else
2945         {
2946           t = do_identifier (TREE_OPERAND (t, 0), NULL_TREE);
2947           if (TREE_CODE (t) == ALIAS_DECL)
2948             t = DECL_INITIAL (t);
2949           return t;
2950         }
2951
2952     case TEMPLATE_ID_EXPR:
2953       {
2954         tree template;
2955         tree args;
2956         tree object;
2957
2958         template = build_expr_from_tree (TREE_OPERAND (t, 0));
2959         args = build_expr_from_tree (TREE_OPERAND (t, 1));
2960
2961         if (TREE_CODE (template) == COMPONENT_REF)
2962           {
2963             object = TREE_OPERAND (template, 0);
2964             template = TREE_OPERAND (template, 1);
2965           }
2966         else
2967           object = NULL_TREE;
2968
2969         template = lookup_template_function (template, args);
2970         if (object)
2971           return build (COMPONENT_REF, TREE_TYPE (template),
2972                         object, template);
2973         else
2974           return template;
2975       }
2976
2977     case INDIRECT_REF:
2978       return build_x_indirect_ref
2979         (build_expr_from_tree (TREE_OPERAND (t, 0)), "unary *");
2980
2981     case CAST_EXPR:
2982       return build_functional_cast
2983         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2984
2985     case REINTERPRET_CAST_EXPR:
2986       return build_reinterpret_cast
2987         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2988
2989     case CONST_CAST_EXPR:
2990       return build_const_cast
2991         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2992
2993     case DYNAMIC_CAST_EXPR:
2994       return build_dynamic_cast
2995         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2996
2997     case STATIC_CAST_EXPR:
2998       return build_static_cast
2999         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3000
3001     case PREDECREMENT_EXPR:
3002     case PREINCREMENT_EXPR:
3003     case POSTDECREMENT_EXPR:
3004     case POSTINCREMENT_EXPR:
3005     case NEGATE_EXPR:
3006     case BIT_NOT_EXPR:
3007     case ABS_EXPR:
3008     case TRUTH_NOT_EXPR:
3009     case ADDR_EXPR:
3010     case CONVERT_EXPR:      /* Unary + */
3011     case REALPART_EXPR:
3012     case IMAGPART_EXPR:
3013       if (TREE_TYPE (t))
3014         return t;
3015       return build_x_unary_op (TREE_CODE (t),
3016                                build_expr_from_tree (TREE_OPERAND (t, 0)));
3017
3018     case PLUS_EXPR:
3019     case MINUS_EXPR:
3020     case MULT_EXPR:
3021     case TRUNC_DIV_EXPR:
3022     case CEIL_DIV_EXPR:
3023     case FLOOR_DIV_EXPR:
3024     case ROUND_DIV_EXPR:
3025     case EXACT_DIV_EXPR:
3026     case BIT_AND_EXPR:
3027     case BIT_ANDTC_EXPR:
3028     case BIT_IOR_EXPR:
3029     case BIT_XOR_EXPR:
3030     case TRUNC_MOD_EXPR:
3031     case FLOOR_MOD_EXPR:
3032     case TRUTH_ANDIF_EXPR:
3033     case TRUTH_ORIF_EXPR:
3034     case TRUTH_AND_EXPR:
3035     case TRUTH_OR_EXPR:
3036     case RSHIFT_EXPR:
3037     case LSHIFT_EXPR:
3038     case RROTATE_EXPR:
3039     case LROTATE_EXPR:
3040     case EQ_EXPR:
3041     case NE_EXPR:
3042     case MAX_EXPR:
3043     case MIN_EXPR:
3044     case LE_EXPR:
3045     case GE_EXPR:
3046     case LT_EXPR:
3047     case GT_EXPR:
3048     case MEMBER_REF:
3049       return build_x_binary_op
3050         (TREE_CODE (t),
3051          build_expr_from_tree (TREE_OPERAND (t, 0)),
3052          build_expr_from_tree (TREE_OPERAND (t, 1)));
3053
3054     case DOTSTAR_EXPR:
3055       return build_m_component_ref
3056         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3057          build_expr_from_tree (TREE_OPERAND (t, 1)));
3058
3059     case SCOPE_REF:
3060       return build_offset_ref (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
3061
3062     case ARRAY_REF:
3063       if (TREE_OPERAND (t, 0) == NULL_TREE)
3064         /* new-type-id */
3065         return build_nt (ARRAY_REF, NULL_TREE,
3066                          build_expr_from_tree (TREE_OPERAND (t, 1)));
3067       return grok_array_decl (build_expr_from_tree (TREE_OPERAND (t, 0)),
3068                               build_expr_from_tree (TREE_OPERAND (t, 1)));
3069
3070     case SIZEOF_EXPR:
3071     case ALIGNOF_EXPR:
3072       {
3073         tree r = build_expr_from_tree (TREE_OPERAND (t, 0));
3074         if (!TYPE_P (r))
3075           return TREE_CODE (t) == SIZEOF_EXPR ? expr_sizeof (r) : c_alignof_expr (r);
3076         else
3077           return cxx_sizeof_or_alignof_type (r, TREE_CODE (t), true);
3078       }
3079
3080     case MODOP_EXPR:
3081       return build_x_modify_expr
3082         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3083          TREE_CODE (TREE_OPERAND (t, 1)),
3084          build_expr_from_tree (TREE_OPERAND (t, 2)));
3085
3086     case ARROW_EXPR:
3087       return build_x_arrow
3088         (build_expr_from_tree (TREE_OPERAND (t, 0)));
3089
3090     case NEW_EXPR:
3091       return build_new
3092         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3093          build_expr_from_tree (TREE_OPERAND (t, 1)),
3094          build_expr_from_tree (TREE_OPERAND (t, 2)),
3095          NEW_EXPR_USE_GLOBAL (t));
3096
3097     case DELETE_EXPR:
3098       return delete_sanity
3099         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3100          build_expr_from_tree (TREE_OPERAND (t, 1)),
3101          DELETE_EXPR_USE_VEC (t), DELETE_EXPR_USE_GLOBAL (t));
3102
3103     case COMPOUND_EXPR:
3104       if (TREE_OPERAND (t, 1) == NULL_TREE)
3105         return build_x_compound_expr
3106           (build_expr_from_tree (TREE_OPERAND (t, 0)));
3107       else
3108         abort ();
3109
3110     case METHOD_CALL_EXPR:
3111       if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3112         {
3113           tree ref = TREE_OPERAND (t, 0);
3114           tree name = TREE_OPERAND (ref, 1);
3115
3116           if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3117             name = build_nt (TEMPLATE_ID_EXPR,
3118                              TREE_OPERAND (name, 0),
3119                              build_expr_from_tree (TREE_OPERAND (name, 1)));
3120
3121           return build_scoped_method_call
3122             (build_expr_from_tree (TREE_OPERAND (t, 1)),
3123              build_expr_from_tree (TREE_OPERAND (ref, 0)),
3124              name,
3125              build_expr_from_tree (TREE_OPERAND (t, 2)));
3126         }
3127       else
3128         {
3129           tree fn = TREE_OPERAND (t, 0);
3130
3131           /* We can get a TEMPLATE_ID_EXPR here on code like:
3132
3133                x->f<2>();
3134
3135              so we must resolve that.  However, we can also get things
3136              like a BIT_NOT_EXPR here, when referring to a destructor,
3137              and things like that are not correctly resolved by
3138              build_expr_from_tree.  So, just use build_expr_from_tree
3139              when we really need it.  */
3140           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3141             fn = lookup_template_function
3142               (TREE_OPERAND (fn, 0),
3143                build_expr_from_tree (TREE_OPERAND (fn, 1)));
3144
3145           return build_method_call
3146             (build_expr_from_tree (TREE_OPERAND (t, 1)),
3147              fn,
3148              build_expr_from_tree (TREE_OPERAND (t, 2)),
3149              NULL_TREE, LOOKUP_NORMAL);
3150         }
3151
3152     case CALL_EXPR:
3153       if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3154         {
3155           tree ref = TREE_OPERAND (t, 0);
3156           tree name = TREE_OPERAND (ref, 1);
3157           tree fn, scope, args;
3158
3159           if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3160             name = build_nt (TEMPLATE_ID_EXPR,
3161                              TREE_OPERAND (name, 0),
3162                              build_expr_from_tree (TREE_OPERAND (name, 1)));
3163
3164           scope = build_expr_from_tree (TREE_OPERAND (ref, 0));
3165           args = build_expr_from_tree (TREE_OPERAND (t, 1));
3166           fn = resolve_scoped_fn_name (scope, name);
3167
3168           return build_call_from_tree (fn, args, 1);
3169         }
3170       else
3171         {
3172           tree name = TREE_OPERAND (t, 0);
3173           tree id;
3174           tree args = build_expr_from_tree (TREE_OPERAND (t, 1));
3175           if (args != NULL_TREE && TREE_CODE (name) == LOOKUP_EXPR
3176               && !LOOKUP_EXPR_GLOBAL (name)
3177               && TREE_CODE ((id = TREE_OPERAND (name, 0))) == IDENTIFIER_NODE
3178               && (!current_class_type
3179                   || !lookup_member (current_class_type, id, 0, false)))
3180             {
3181               /* Do Koenig lookup if there are no class members.  */
3182               name = do_identifier (id, args);
3183             }
3184           else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
3185                    || ! really_overloaded_fn (name))
3186             name = build_expr_from_tree (name);
3187
3188           if (TREE_CODE (name) == OFFSET_REF)
3189             return build_offset_ref_call_from_tree (name, args);
3190           if (TREE_CODE (name) == COMPONENT_REF)
3191             return finish_object_call_expr (TREE_OPERAND (name, 1),
3192                                             TREE_OPERAND (name, 0),
3193                                             args);
3194           name = convert_from_reference (name);
3195           return build_call_from_tree (name, args,
3196                                        /*disallow_virtual=*/false);
3197         }
3198
3199     case COND_EXPR:
3200       return build_x_conditional_expr
3201         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3202          build_expr_from_tree (TREE_OPERAND (t, 1)),
3203          build_expr_from_tree (TREE_OPERAND (t, 2)));
3204
3205     case PSEUDO_DTOR_EXPR:
3206       return (finish_pseudo_destructor_expr
3207               (build_expr_from_tree (TREE_OPERAND (t, 0)),
3208                build_expr_from_tree (TREE_OPERAND (t, 1)),
3209                build_expr_from_tree (TREE_OPERAND (t, 2))));
3210
3211     case TREE_LIST:
3212       {
3213         tree purpose, value, chain;
3214
3215         if (t == void_list_node)
3216           return t;
3217
3218         purpose = TREE_PURPOSE (t);
3219         if (purpose)
3220           purpose = build_expr_from_tree (purpose);
3221         value = TREE_VALUE (t);
3222         if (value)
3223           value = build_expr_from_tree (value);
3224         chain = TREE_CHAIN (t);
3225         if (chain && chain != void_type_node)
3226           chain = build_expr_from_tree (chain);
3227         return tree_cons (purpose, value, chain);
3228       }
3229
3230     case COMPONENT_REF:
3231       {
3232         tree object = build_expr_from_tree (TREE_OPERAND (t, 0));
3233         tree member = TREE_OPERAND (t, 1);
3234
3235         if (!CLASS_TYPE_P (TREE_TYPE (object)))
3236           {
3237             if (TREE_CODE (member) == BIT_NOT_EXPR)
3238               return finish_pseudo_destructor_expr (object,
3239                                                     NULL_TREE,
3240                                                     TREE_TYPE (object));
3241             else if (TREE_CODE (member) == SCOPE_REF
3242                      && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
3243               return finish_pseudo_destructor_expr (object,
3244                                                     TREE_OPERAND (t, 0),
3245                                                     TREE_TYPE (object));
3246           }
3247         else if (TREE_CODE (member) == SCOPE_REF
3248                  && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
3249           {
3250             tree tmpl;
3251             tree args;
3252
3253             /* Lookup the template functions now that we know what the
3254                scope is.  */
3255             tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
3256             args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
3257             member = lookup_qualified_name (TREE_OPERAND (member, 0),
3258                                             tmpl,
3259                                             /*is_type=*/0,
3260                                             /*flags=*/0);
3261             if (BASELINK_P (member))
3262               BASELINK_FUNCTIONS (member)
3263                 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
3264                             args);
3265             else
3266               {
3267                 error ("`%D' is not a member of `%T'",
3268                        tmpl, TREE_TYPE (object));
3269                 return error_mark_node;
3270               }
3271           }
3272
3273
3274         return finish_class_member_access_expr (object, member);
3275       }
3276
3277     case THROW_EXPR:
3278       return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0)));
3279
3280     case CONSTRUCTOR:
3281       {
3282         tree r;
3283         tree elts;
3284         tree type = TREE_TYPE (t);
3285         bool purpose_p;
3286
3287         /* digest_init will do the wrong thing if we let it.  */
3288         if (type && TYPE_PTRMEMFUNC_P (type))
3289           return t;
3290
3291         r = NULL_TREE;
3292         /* We do not want to process the purpose of aggregate
3293            initializers as they are identifier nodes which will be
3294            looked up by digest_init.  */
3295         purpose_p = !(type && IS_AGGR_TYPE (type));
3296         for (elts = CONSTRUCTOR_ELTS (t); elts; elts = TREE_CHAIN (elts))
3297           {
3298             tree purpose = TREE_PURPOSE (elts);
3299             tree value = TREE_VALUE (elts);
3300
3301             if (purpose && purpose_p)
3302               purpose = build_expr_from_tree (purpose);
3303             value = build_expr_from_tree (value);
3304             r = tree_cons (purpose, value, r);
3305           }
3306
3307         r = build_constructor (NULL_TREE, nreverse (r));
3308         TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
3309
3310         if (type)
3311           return digest_init (type, r, 0);
3312         return r;
3313       }
3314
3315     case TYPEID_EXPR:
3316       if (TYPE_P (TREE_OPERAND (t, 0)))
3317         return get_typeid (TREE_OPERAND (t, 0));
3318       return build_typeid (build_expr_from_tree (TREE_OPERAND (t, 0)));
3319
3320     case PARM_DECL:
3321     case VAR_DECL:
3322       return convert_from_reference (t);
3323
3324     case VA_ARG_EXPR:
3325       return build_va_arg (build_expr_from_tree (TREE_OPERAND (t, 0)),
3326                            TREE_TYPE (t));
3327
3328     default:
3329       return t;
3330     }
3331 }
3332
3333 /* FN is an OFFSET_REF indicating the function to call in parse-tree
3334    form; it has not yet been semantically analyzed.  ARGS are the
3335    arguments to the function.  They have already been semantically
3336    analzyed.  */
3337
3338 tree
3339 build_offset_ref_call_from_tree (tree fn, tree args)
3340 {
3341   tree object_addr;
3342
3343   my_friendly_assert (TREE_CODE (fn) == OFFSET_REF, 20020725);
3344
3345   /* A qualified name corresponding to a non-static member
3346      function or a pointer-to-member is represented as an
3347      OFFSET_REF.
3348
3349      For both of these function calls, FN will be an OFFSET_REF.
3350
3351         struct A { void f(); };
3352         void A::f() { (A::f) (); }
3353
3354         struct B { void g(); };
3355         void (B::*p)();
3356         void B::g() { (this->*p)(); }  */
3357
3358   /* This code is not really correct (for example, it does not
3359      handle the case that `A::f' is overloaded), but it is
3360      historically how we have handled this situation.  */
3361   if (TREE_CODE (TREE_OPERAND (fn, 1)) == FIELD_DECL)
3362     /* This case should now be handled elsewhere.  */
3363     abort ();
3364   else
3365     {
3366       object_addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (fn, 0), 0);
3367       fn = TREE_OPERAND (fn, 1);
3368       fn = get_member_function_from_ptrfunc (&object_addr, fn);
3369       args = tree_cons (NULL_TREE, object_addr, args);
3370     }
3371   return build_function_call (fn, args);
3372 }
3373
3374 /* FN indicates the function to call.  Name resolution has been
3375    performed on FN.  ARGS are the arguments to the function.  They
3376    have already been semantically analyzed.  DISALLOW_VIRTUAL is true
3377    if the function call should be determined at compile time, even if
3378    FN is virtual.  */
3379
3380 tree
3381 build_call_from_tree (tree fn, tree args, bool disallow_virtual)
3382 {
3383   tree template_args;
3384   tree template_id;
3385   tree f;
3386
3387   /* Check to see that name lookup has already been performed.  */
3388   my_friendly_assert (TREE_CODE (fn) != OFFSET_REF, 20020725);
3389   my_friendly_assert (TREE_CODE (fn) != SCOPE_REF, 20020725);
3390
3391   /* In the future all of this should be eliminated.  Instead,
3392      name-lookup for a member function should simply return a
3393      baselink, instead of a FUNCTION_DECL, TEMPLATE_DECL, or
3394      TEMPLATE_ID_EXPR.  */
3395
3396   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3397     {
3398       template_id = fn;
3399       template_args = TREE_OPERAND (fn, 1);
3400       fn = TREE_OPERAND (fn, 0);
3401     }
3402   else
3403     {
3404       template_id = NULL_TREE;
3405       template_args = NULL_TREE;
3406     }
3407
3408   f = (TREE_CODE (fn) == OVERLOAD) ? get_first_fn (fn) : fn;
3409   /* Make sure we have a baselink (rather than simply a
3410      FUNCTION_DECL) for a member function.  */
3411   if (current_class_type
3412       && ((TREE_CODE (f) == FUNCTION_DECL
3413            && DECL_FUNCTION_MEMBER_P (f))
3414           || (DECL_FUNCTION_TEMPLATE_P (f)
3415               && DECL_FUNCTION_MEMBER_P (f))))
3416     {
3417       f = lookup_member (current_class_type, DECL_NAME (f),
3418                          /*protect=*/1, /*want_type=*/false);
3419       if (f)
3420         fn = f;
3421     }
3422
3423   if (template_id)
3424     {
3425       if (BASELINK_P (fn))
3426           BASELINK_FUNCTIONS (fn) = build_nt (TEMPLATE_ID_EXPR,
3427                                               BASELINK_FUNCTIONS (fn),
3428                                               template_args);
3429       else
3430         fn = template_id;
3431     }
3432
3433   return finish_call_expr (fn, args, disallow_virtual);
3434 }
3435
3436 /* Returns true if ROOT (a namespace, class, or function) encloses
3437    CHILD.  CHILD may be either a class type or a namespace.  */
3438
3439 bool
3440 is_ancestor (tree root, tree child)
3441 {
3442   my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
3443                        || TREE_CODE (root) == FUNCTION_DECL
3444                        || CLASS_TYPE_P (root)), 20030307);
3445   my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
3446                        || CLASS_TYPE_P (child)),
3447                       20030307);
3448
3449   /* The global namespace encloses everything.  */
3450   if (root == global_namespace)
3451     return true;
3452
3453   while (true)
3454     {
3455       /* If we've run out of scopes, stop.  */
3456       if (!child)
3457         return false;
3458       /* If we've reached the ROOT, it encloses CHILD.  */
3459       if (root == child)
3460         return true;
3461       /* Go out one level.  */
3462       if (TYPE_P (child))
3463         child = TYPE_NAME (child);
3464       child = DECL_CONTEXT (child);
3465     }
3466 }
3467
3468
3469 /* Return the namespace that is the common ancestor
3470    of two given namespaces.  */
3471
3472 tree
3473 namespace_ancestor (tree ns1, tree ns2)
3474 {
3475   timevar_push (TV_NAME_LOOKUP);
3476   if (is_ancestor (ns1, ns2))
3477     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3478   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3479                           namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3480 }
3481
3482 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3483    directive is not directly from the source. Also find the common
3484    ancestor and let our users know about the new namespace */
3485 static void
3486 add_using_namespace (tree user, tree used, bool indirect)
3487 {
3488   tree t;
3489   timevar_push (TV_NAME_LOOKUP);
3490   /* Using oneself is a no-op.  */
3491   if (user == used)
3492     {
3493       timevar_pop (TV_NAME_LOOKUP);
3494       return;
3495     }
3496   my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3497   my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3498   /* Check if we already have this.  */
3499   t = purpose_member (used, DECL_NAMESPACE_USING (user));
3500   if (t != NULL_TREE)
3501     {
3502       if (!indirect)
3503         /* Promote to direct usage.  */
3504         TREE_INDIRECT_USING (t) = 0;
3505       timevar_pop (TV_NAME_LOOKUP);
3506       return;
3507     }
3508
3509   /* Add used to the user's using list.  */
3510   DECL_NAMESPACE_USING (user)
3511     = tree_cons (used, namespace_ancestor (user, used),
3512                  DECL_NAMESPACE_USING (user));
3513
3514   TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3515
3516   /* Add user to the used's users list.  */
3517   DECL_NAMESPACE_USERS (used)
3518     = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3519
3520   /* Recursively add all namespaces used.  */
3521   for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3522     /* indirect usage */
3523     add_using_namespace (user, TREE_PURPOSE (t), 1);
3524
3525   /* Tell everyone using us about the new used namespaces.  */
3526   for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3527     add_using_namespace (TREE_PURPOSE (t), used, 1);
3528   timevar_pop (TV_NAME_LOOKUP);
3529 }
3530
3531 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3532    duplicates.  The first list becomes the tail of the result.
3533
3534    The algorithm is O(n^2).  We could get this down to O(n log n) by
3535    doing a sort on the addresses of the functions, if that becomes
3536    necessary.  */
3537
3538 static tree
3539 merge_functions (tree s1, tree s2)
3540 {
3541   for (; s2; s2 = OVL_NEXT (s2))
3542     {
3543       tree fn2 = OVL_CURRENT (s2);
3544       tree fns1;
3545
3546       for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3547         {
3548           tree fn1 = OVL_CURRENT (fns1);
3549
3550           /* If the function from S2 is already in S1, there is no
3551              need to add it again.  For `extern "C"' functions, we
3552              might have two FUNCTION_DECLs for the same function, in
3553              different namespaces; again, we only need one of them.  */
3554           if (fn1 == fn2
3555               || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3556                   && DECL_NAME (fn1) == DECL_NAME (fn2)))
3557             break;
3558         }
3559
3560       /* If we exhausted all of the functions in S1, FN2 is new.  */
3561       if (!fns1)
3562         s1 = build_overload (fn2, s1);
3563     }
3564   return s1;
3565 }
3566
3567 /* This should return an error not all definitions define functions.
3568    It is not an error if we find two functions with exactly the
3569    same signature, only if these are selected in overload resolution.
3570    old is the current set of bindings, new the freshly-found binding.
3571    XXX Do we want to give *all* candidates in case of ambiguity?
3572    XXX In what way should I treat extern declarations?
3573    XXX I don't want to repeat the entire duplicate_decls here */
3574
3575 static cxx_binding *
3576 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3577 {
3578   tree val, type;
3579   my_friendly_assert (old != NULL, 393);
3580   /* Copy the value.  */
3581   val = BINDING_VALUE (new);
3582   if (val)
3583     switch (TREE_CODE (val))
3584       {
3585       case TEMPLATE_DECL:
3586         /* If we expect types or namespaces, and not templates,
3587            or this is not a template class.  */
3588         if (LOOKUP_QUALIFIERS_ONLY (flags)
3589             && !DECL_CLASS_TEMPLATE_P (val))
3590           val = NULL_TREE;
3591         break;
3592       case TYPE_DECL:
3593         if (LOOKUP_NAMESPACES_ONLY (flags))
3594           val = NULL_TREE;
3595         break;
3596       case NAMESPACE_DECL:
3597         if (LOOKUP_TYPES_ONLY (flags))
3598           val = NULL_TREE;
3599         break;
3600       case FUNCTION_DECL:
3601         /* Ignore built-in functions that are still anticipated.  */
3602         if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3603           val = NULL_TREE;
3604         break;
3605       default:
3606         if (LOOKUP_QUALIFIERS_ONLY (flags))
3607           val = NULL_TREE;
3608       }
3609
3610   if (!BINDING_VALUE (old))
3611     BINDING_VALUE (old) = val;
3612   else if (val && val != BINDING_VALUE (old))
3613     {
3614       if (is_overloaded_fn (BINDING_VALUE (old)) && is_overloaded_fn (val))
3615         BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old), val);
3616       else
3617         {
3618           /* Some declarations are functions, some are not.  */
3619           if (flags & LOOKUP_COMPLAIN)
3620             {
3621               /* If we've already given this error for this lookup,
3622                  BINDING_VALUE (old) is error_mark_node, so let's not
3623                  repeat ourselves.  */
3624               if (BINDING_VALUE (old) != error_mark_node)
3625                 {
3626                   error ("use of `%D' is ambiguous", name);
3627                   cp_error_at ("  first declared as `%#D' here",
3628                                BINDING_VALUE (old));
3629                 }
3630               cp_error_at ("  also declared as `%#D' here", val);
3631             }
3632           BINDING_VALUE (old) = error_mark_node;
3633         }
3634     }
3635   /* ... and copy the type.  */
3636   type = BINDING_TYPE (new);
3637   if (LOOKUP_NAMESPACES_ONLY (flags))
3638     type = NULL_TREE;
3639   if (!BINDING_TYPE (old))
3640     BINDING_TYPE (old) = type;
3641   else if (type && BINDING_TYPE (old) != type)
3642     {
3643       if (flags & LOOKUP_COMPLAIN)
3644         {
3645           error ("`%D' denotes an ambiguous type",name);
3646           cp_error_at ("  first type here", BINDING_TYPE (old));
3647           cp_error_at ("  other type here", type);
3648         }
3649     }
3650   return old;
3651 }
3652
3653 /* Subroutine of unualified_namespace_lookup:
3654    Add the bindings of NAME in used namespaces to VAL.
3655    We are currently looking for names in namespace SCOPE, so we
3656    look through USINGS for using-directives of namespaces
3657    which have SCOPE as a common ancestor with the current scope.
3658    Returns false on errors.  */
3659
3660 bool
3661 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3662                         int flags, tree *spacesp)
3663 {
3664   tree iter;
3665   timevar_push (TV_NAME_LOOKUP);
3666   /* Iterate over all used namespaces in current, searching for using
3667      directives of scope.  */
3668   for (iter = usings; iter; iter = TREE_CHAIN (iter))
3669     if (TREE_VALUE (iter) == scope)
3670       {
3671         tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3672         cxx_binding *val1 =
3673           cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3674         if (spacesp)
3675           *spacesp = tree_cons (used, NULL_TREE, *spacesp);
3676         /* Resolve ambiguities.  */
3677         if (val1)
3678           val = ambiguous_decl (name, val, val1, flags);
3679       }
3680   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3681                           BINDING_VALUE (val) != error_mark_node);
3682 }
3683
3684 /* [namespace.qual]
3685    Accepts the NAME to lookup and its qualifying SCOPE.
3686    Returns the name/type pair found into the cxx_binding *RESULT,
3687    or false on error.  */
3688
3689 bool
3690 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3691                                   int flags)
3692 {
3693   /* Maintain a list of namespaces visited...  */
3694   tree seen = NULL_TREE;
3695   /* ... and a list of namespace yet to see.  */
3696   tree todo = NULL_TREE;
3697   tree usings;
3698   timevar_push (TV_NAME_LOOKUP);
3699   /* Look through namespace aliases.  */
3700   scope = ORIGINAL_NAMESPACE (scope);
3701   while (scope && result->value != error_mark_node)
3702     {
3703       cxx_binding *binding =
3704         cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3705       seen = tree_cons (scope, NULL_TREE, seen);
3706       if (binding)
3707         result = ambiguous_decl (name, result, binding, flags);
3708       if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
3709         /* Consider using directives.  */
3710         for (usings = DECL_NAMESPACE_USING (scope); usings;
3711              usings = TREE_CHAIN (usings))
3712           /* If this was a real directive, and we have not seen it.  */
3713           if (!TREE_INDIRECT_USING (usings)
3714               && !purpose_member (TREE_PURPOSE (usings), seen))
3715             todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3716       if (todo)
3717         {
3718           scope = TREE_PURPOSE (todo);
3719           todo = TREE_CHAIN (todo);
3720         }
3721       else
3722         scope = NULL_TREE; /* If there never was a todo list.  */
3723     }
3724   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3725 }
3726
3727 /* [namespace.memdef]/2 */
3728
3729 /* Set the context of a declaration to scope. Complain if we are not
3730    outside scope.  */
3731
3732 void
3733 set_decl_namespace (tree decl, tree scope, bool friendp)
3734 {
3735   tree old;
3736
3737   /* Get rid of namespace aliases.  */
3738   scope = ORIGINAL_NAMESPACE (scope);
3739
3740   /* It is ok for friends to be qualified in parallel space.  */
3741   if (!friendp && !is_ancestor (current_namespace, scope))
3742     error ("declaration of `%D' not in a namespace surrounding `%D'",
3743               decl, scope);
3744   DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3745   if (scope != current_namespace)
3746     {
3747       /* See whether this has been declared in the namespace.  */
3748       old = namespace_binding (DECL_NAME (decl), scope);
3749       if (!old)
3750         /* No old declaration at all.  */
3751         goto complain;
3752       /* A template can be explicitly specialized in any namespace.  */
3753       if (processing_explicit_instantiation)
3754         return;
3755       if (!is_overloaded_fn (decl))
3756         /* Don't compare non-function decls with decls_match here,
3757            since it can't check for the correct constness at this
3758            point. pushdecl will find those errors later.  */
3759         return;
3760       /* Since decl is a function, old should contain a function decl.  */
3761       if (!is_overloaded_fn (old))
3762         goto complain;
3763       if (processing_template_decl || processing_specialization)
3764         /* We have not yet called push_template_decl to turn a
3765            FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
3766            won't match.  But, we'll check later, when we construct the
3767            template.  */
3768         return;
3769       if (is_overloaded_fn (old))
3770         {
3771           for (; old; old = OVL_NEXT (old))
3772             if (decls_match (decl, OVL_CURRENT (old)))
3773               return;
3774         }
3775       else
3776         if (decls_match (decl, old))
3777           return;
3778     }
3779   else
3780     return;
3781  complain:
3782   error ("`%D' should have been declared inside `%D'",
3783             decl, scope);
3784 }
3785
3786 /* Compute the namespace where a declaration is defined.  */
3787
3788 static tree
3789 decl_namespace (tree decl)
3790 {
3791   timevar_push (TV_NAME_LOOKUP);
3792   if (TYPE_P (decl))
3793     decl = TYPE_STUB_DECL (decl);
3794   while (DECL_CONTEXT (decl))
3795     {
3796       decl = DECL_CONTEXT (decl);
3797       if (TREE_CODE (decl) == NAMESPACE_DECL)
3798         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
3799       if (TYPE_P (decl))
3800         decl = TYPE_STUB_DECL (decl);
3801       my_friendly_assert (DECL_P (decl), 390);
3802     }
3803
3804   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, global_namespace);
3805 }
3806
3807 /* Return the namespace where the current declaration is declared.  */
3808
3809 tree
3810 current_decl_namespace (void)
3811 {
3812   tree result;
3813   /* If we have been pushed into a different namespace, use it.  */
3814   if (decl_namespace_list)
3815     return TREE_PURPOSE (decl_namespace_list);
3816
3817   if (current_class_type)
3818     result = decl_namespace (TYPE_STUB_DECL (current_class_type));
3819   else if (current_function_decl)
3820     result = decl_namespace (current_function_decl);
3821   else
3822     result = current_namespace;
3823   return result;
3824 }
3825
3826 /* Temporarily set the namespace for the current declaration.  */
3827
3828 void
3829 push_decl_namespace (tree decl)
3830 {
3831   if (TREE_CODE (decl) != NAMESPACE_DECL)
3832     decl = decl_namespace (decl);
3833   decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3834                                    NULL_TREE, decl_namespace_list);
3835 }
3836
3837 void
3838 pop_decl_namespace (void)
3839 {
3840   decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3841 }
3842
3843 /* Enter a class or namespace scope.  */
3844
3845 void
3846 push_scope (tree t)
3847 {
3848   if (TREE_CODE (t) == NAMESPACE_DECL)
3849     push_decl_namespace (t);
3850   else if CLASS_TYPE_P (t)
3851     push_nested_class (t);
3852 }
3853
3854 /* Leave scope pushed by push_scope.  */
3855
3856 void
3857 pop_scope (tree t)
3858 {
3859   if (TREE_CODE (t) == NAMESPACE_DECL)
3860     pop_decl_namespace ();
3861   else if CLASS_TYPE_P (t)
3862     pop_nested_class ();
3863 }
3864
3865 /* [basic.lookup.koenig] */
3866 /* A nonzero return value in the functions below indicates an error.  */
3867
3868 struct arg_lookup
3869 {
3870   tree name;
3871   tree namespaces;
3872   tree classes;
3873   tree functions;
3874 };
3875
3876 static bool arg_assoc (struct arg_lookup*, tree);
3877 static bool arg_assoc_args (struct arg_lookup*, tree);
3878 static bool arg_assoc_type (struct arg_lookup*, tree);
3879 static bool add_function (struct arg_lookup *, tree);
3880 static bool arg_assoc_namespace (struct arg_lookup *, tree);
3881 static bool arg_assoc_class (struct arg_lookup *, tree);
3882 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
3883
3884 /* Add a function to the lookup structure.
3885    Returns true on error.  */
3886
3887 static bool
3888 add_function (struct arg_lookup *k, tree fn)
3889 {
3890   /* We used to check here to see if the function was already in the list,
3891      but that's O(n^2), which is just too expensive for function lookup.
3892      Now we deal with the occasional duplicate in joust.  In doing this, we
3893      assume that the number of duplicates will be small compared to the
3894      total number of functions being compared, which should usually be the
3895      case.  */
3896
3897   /* We must find only functions, or exactly one non-function.  */
3898   if (!k->functions)
3899     k->functions = fn;
3900   else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
3901     k->functions = build_overload (fn, k->functions);
3902   else
3903     {
3904       tree f1 = OVL_CURRENT (k->functions);
3905       tree f2 = fn;
3906       if (is_overloaded_fn (f1))
3907         {
3908           fn = f1; f1 = f2; f2 = fn;
3909         }
3910       cp_error_at ("`%D' is not a function,", f1);
3911       cp_error_at ("  conflict with `%D'", f2);
3912       error ("  in call to `%D'", k->name);
3913       return true;
3914     }
3915
3916   return false;
3917 }
3918
3919 /* Add functions of a namespace to the lookup structure.
3920    Returns true on error.  */
3921
3922 static bool
3923 arg_assoc_namespace (struct arg_lookup *k, tree scope)
3924 {
3925   tree value;
3926
3927   if (purpose_member (scope, k->namespaces))
3928     return 0;
3929   k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
3930
3931   value = namespace_binding (k->name, scope);
3932   if (!value)
3933     return false;
3934
3935   for (; value; value = OVL_NEXT (value))
3936     if (add_function (k, OVL_CURRENT (value)))
3937       return true;
3938
3939   return false;
3940 }
3941
3942 /* Adds everything associated with a template argument to the lookup
3943    structure.  Returns true on error.  */
3944
3945 static bool
3946 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
3947 {
3948   /* [basic.lookup.koenig]
3949
3950      If T is a template-id, its associated namespaces and classes are
3951      ... the namespaces and classes associated with the types of the
3952      template arguments provided for template type parameters
3953      (excluding template template parameters); the namespaces in which
3954      any template template arguments are defined; and the classes in
3955      which any member templates used as template template arguments
3956      are defined.  [Note: non-type template arguments do not
3957      contribute to the set of associated namespaces.  ]  */
3958
3959   /* Consider first template template arguments.  */
3960   if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3961       || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
3962     return false;
3963   else if (TREE_CODE (arg) == TEMPLATE_DECL)
3964     {
3965       tree ctx = CP_DECL_CONTEXT (arg);
3966
3967       /* It's not a member template.  */
3968       if (TREE_CODE (ctx) == NAMESPACE_DECL)
3969         return arg_assoc_namespace (k, ctx);
3970       /* Otherwise, it must be member template.  */
3971       else
3972         return arg_assoc_class (k, ctx);
3973     }
3974   /* It's not a template template argument, but it is a type template
3975      argument.  */
3976   else if (TYPE_P (arg))
3977     return arg_assoc_type (k, arg);
3978   /* It's a non-type template argument.  */
3979   else
3980     return false;
3981 }
3982
3983 /* Adds everything associated with class to the lookup structure.
3984    Returns true on error.  */
3985
3986 static bool
3987 arg_assoc_class (struct arg_lookup *k, tree type)
3988 {
3989   tree list, friends, context;
3990   int i;
3991
3992   /* Backend build structures, such as __builtin_va_list, aren't
3993      affected by all this.  */
3994   if (!CLASS_TYPE_P (type))
3995     return false;
3996
3997   if (purpose_member (type, k->classes))
3998     return false;
3999   k->classes = tree_cons (type, NULL_TREE, k->classes);
4000
4001   context = decl_namespace (TYPE_MAIN_DECL (type));
4002   if (arg_assoc_namespace (k, context))
4003     return true;
4004
4005   /* Process baseclasses.  */
4006   for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
4007     if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
4008       return true;
4009
4010   /* Process friends.  */
4011   for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4012        list = TREE_CHAIN (list))
4013     if (k->name == FRIEND_NAME (list))
4014       for (friends = FRIEND_DECLS (list); friends;
4015            friends = TREE_CHAIN (friends))
4016         /* Only interested in global functions with potentially hidden
4017            (i.e. unqualified) declarations.  */
4018         if (CP_DECL_CONTEXT (TREE_VALUE (friends)) == context)
4019           if (add_function (k, TREE_VALUE (friends)))
4020             return true;
4021
4022   /* Process template arguments.  */
4023   if (CLASSTYPE_TEMPLATE_INFO (type))
4024     {
4025       list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4026       for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4027         arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4028     }
4029
4030   return false;
4031 }
4032
4033 /* Adds everything associated with a given type.
4034    Returns 1 on error.  */
4035
4036 static bool
4037 arg_assoc_type (struct arg_lookup *k, tree type)
4038 {
4039   switch (TREE_CODE (type))
4040     {
4041     case ERROR_MARK:
4042       return false;
4043     case VOID_TYPE:
4044     case INTEGER_TYPE:
4045     case REAL_TYPE:
4046     case COMPLEX_TYPE:
4047     case VECTOR_TYPE:
4048     case CHAR_TYPE:
4049     case BOOLEAN_TYPE:
4050       return false;
4051     case RECORD_TYPE:
4052       if (TYPE_PTRMEMFUNC_P (type))
4053         return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4054       return arg_assoc_class (k, type);
4055     case POINTER_TYPE:
4056     case REFERENCE_TYPE:
4057     case ARRAY_TYPE:
4058       return arg_assoc_type (k, TREE_TYPE (type));
4059     case UNION_TYPE:
4060     case ENUMERAL_TYPE:
4061       return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
4062     case OFFSET_TYPE:
4063       /* Pointer to member: associate class type and value type.  */
4064       if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
4065         return true;
4066       return arg_assoc_type (k, TREE_TYPE (type));
4067     case METHOD_TYPE:
4068       /* The basetype is referenced in the first arg type, so just
4069          fall through.  */
4070     case FUNCTION_TYPE:
4071       /* Associate the parameter types.  */
4072       if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4073         return true;
4074       /* Associate the return type.  */
4075       return arg_assoc_type (k, TREE_TYPE (type));
4076     case TEMPLATE_TYPE_PARM:
4077     case BOUND_TEMPLATE_TEMPLATE_PARM:
4078       return false;
4079     case TYPENAME_TYPE:
4080       return false;
4081     case LANG_TYPE:
4082       if (type == unknown_type_node)
4083         return false;
4084       /* else fall through */
4085     default:
4086       abort ();
4087     }
4088   return false;
4089 }
4090
4091 /* Adds everything associated with arguments.  Returns true on error.  */
4092
4093 static bool
4094 arg_assoc_args (struct arg_lookup *k, tree args)
4095 {
4096   for (; args; args = TREE_CHAIN (args))
4097     if (arg_assoc (k, TREE_VALUE (args)))
4098       return true;
4099   return false;
4100 }
4101
4102 /* Adds everything associated with a given tree_node.  Returns 1 on error.  */
4103
4104 static bool
4105 arg_assoc (struct arg_lookup *k, tree n)
4106 {
4107   if (n == error_mark_node)
4108     return false;
4109
4110   if (TYPE_P (n))
4111     return arg_assoc_type (k, n);
4112
4113   if (! type_unknown_p (n))
4114     return arg_assoc_type (k, TREE_TYPE (n));
4115
4116   if (TREE_CODE (n) == ADDR_EXPR)
4117     n = TREE_OPERAND (n, 0);
4118   if (TREE_CODE (n) == COMPONENT_REF)
4119     n = TREE_OPERAND (n, 1);
4120   if (TREE_CODE (n) == OFFSET_REF)
4121     n = TREE_OPERAND (n, 1);
4122   while (TREE_CODE (n) == TREE_LIST)
4123     n = TREE_VALUE (n);
4124   if (TREE_CODE (n) == BASELINK)
4125     n = BASELINK_FUNCTIONS (n);
4126
4127   if (TREE_CODE (n) == FUNCTION_DECL)
4128     return arg_assoc_type (k, TREE_TYPE (n));
4129   if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4130     {
4131       /* [basic.lookup.koenig]
4132
4133          If T is a template-id, its associated namespaces and classes
4134          are the namespace in which the template is defined; for
4135          member templates, the member template's class...  */
4136       tree template = TREE_OPERAND (n, 0);
4137       tree args = TREE_OPERAND (n, 1);
4138       tree ctx;
4139       tree arg;
4140
4141       if (TREE_CODE (template) == COMPONENT_REF)
4142         template = TREE_OPERAND (template, 1);
4143
4144       /* First, the template.  There may actually be more than one if
4145          this is an overloaded function template.  But, in that case,
4146          we only need the first; all the functions will be in the same
4147          namespace.  */
4148       template = OVL_CURRENT (template);
4149
4150       ctx = CP_DECL_CONTEXT (template);
4151
4152       if (TREE_CODE (ctx) == NAMESPACE_DECL)
4153         {
4154           if (arg_assoc_namespace (k, ctx) == 1)
4155             return true;
4156         }
4157       /* It must be a member template.  */
4158       else if (arg_assoc_class (k, ctx) == 1)
4159         return true;
4160
4161       /* Now the arguments.  */
4162       for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg))
4163         if (arg_assoc_template_arg (k, TREE_VALUE (arg)) == 1)
4164           return true;
4165     }
4166   else
4167     {
4168       my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715);
4169
4170       for (; n; n = OVL_CHAIN (n))
4171         if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4172           return true;
4173     }
4174
4175   return false;
4176 }
4177
4178 /* Performs Koenig lookup depending on arguments, where fns
4179    are the functions found in normal lookup.  */
4180
4181 tree
4182 lookup_arg_dependent (tree name, tree fns, tree args)
4183 {
4184   struct arg_lookup k;
4185   tree fn = NULL_TREE;
4186
4187   timevar_push (TV_NAME_LOOKUP);
4188   k.name = name;
4189   k.functions = fns;
4190   k.classes = NULL_TREE;
4191
4192   /* Note that we've already looked at some namespaces during normal
4193      unqualified lookup, unless we found a decl in function scope.  */
4194   if (fns)
4195     fn = OVL_CURRENT (fns);
4196   if (fn && TREE_CODE (fn) == FUNCTION_DECL && DECL_LOCAL_FUNCTION_P (fn))
4197     k.namespaces = NULL_TREE;
4198   else
4199     unqualified_namespace_lookup (name, 0, &k.namespaces);
4200
4201   arg_assoc_args (&k, args);
4202   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4203 }
4204
4205 /* Process a namespace-alias declaration.  */
4206
4207 void
4208 do_namespace_alias (tree alias, tree namespace)
4209 {
4210   if (TREE_CODE (namespace) != NAMESPACE_DECL)
4211     {
4212       /* The parser did not find it, so it's not there.  */
4213       error ("unknown namespace `%D'", namespace);
4214       return;
4215     }
4216
4217   namespace = ORIGINAL_NAMESPACE (namespace);
4218
4219   /* Build the alias.  */
4220   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
4221   DECL_NAMESPACE_ALIAS (alias) = namespace;
4222   DECL_EXTERNAL (alias) = 1;
4223   pushdecl (alias);
4224 }
4225
4226 /* Check a non-member using-declaration. Return the name and scope
4227    being used, and the USING_DECL, or NULL_TREE on failure.  */
4228
4229 static tree
4230 validate_nonmember_using_decl (tree decl, tree *scope, tree *name)
4231 {
4232   *scope = global_namespace;
4233   *name = NULL_TREE;
4234
4235   if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
4236     {
4237       *name = TREE_OPERAND (decl, 0);
4238       /* 7.3.3/5
4239            A using-declaration shall not name a template-id.  */
4240       error ("a using-declaration cannot specify a template-id.  Try `using %D'", *name);
4241       return NULL_TREE;
4242     }
4243
4244   if (TREE_CODE (decl) == NAMESPACE_DECL)
4245     {
4246       error ("namespace `%D' not allowed in using-declaration", decl);
4247       return NULL_TREE;
4248     }
4249
4250   if (TREE_CODE (decl) == SCOPE_REF)
4251     {
4252       /* It's a nested name with template parameter dependent scope.
4253          This can only be using-declaration for class member.  */
4254       error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
4255       return NULL_TREE;
4256     }
4257
4258   if (is_overloaded_fn (decl))
4259     decl = get_first_fn (decl);
4260
4261   my_friendly_assert (DECL_P (decl), 20020908);
4262
4263   if (TREE_CODE (decl) == CONST_DECL)
4264     /* Enumeration constants to not have DECL_CONTEXT set.  */
4265     *scope = TYPE_CONTEXT (TREE_TYPE (decl));
4266   else
4267     *scope = DECL_CONTEXT (decl);
4268   if (!*scope)
4269     *scope = global_namespace;
4270
4271   /* [namespace.udecl]
4272        A using-declaration for a class member shall be a
4273        member-declaration.  */
4274   if (TYPE_P (*scope))
4275     {
4276       error ("`%T' is not a namespace", *scope);
4277       return NULL_TREE;
4278     }
4279   *name = DECL_NAME (decl);
4280   /* Make a USING_DECL. */
4281   return push_using_decl (*scope, *name);
4282 }
4283
4284 /* Process local and global using-declarations.  */
4285
4286 static void
4287 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
4288                          tree *newval, tree *newtype)
4289 {
4290   cxx_binding decls;
4291
4292   *newval = *newtype = NULL_TREE;
4293   cxx_binding_clear (&decls);
4294   if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
4295     /* Lookup error */
4296     return;
4297
4298   if (!decls.value && !decls.type)
4299     {
4300       error ("`%D' not declared", name);
4301       return;
4302     }
4303
4304   /* Check for using functions.  */
4305   if (decls.value && is_overloaded_fn (decls.value))
4306     {
4307       tree tmp, tmp1;
4308
4309       if (oldval && !is_overloaded_fn (oldval))
4310         {
4311           if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
4312             error ("`%D' is already declared in this scope", name);
4313           oldval = NULL_TREE;
4314         }
4315
4316       *newval = oldval;
4317       for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
4318         {
4319           tree new_fn = OVL_CURRENT (tmp);
4320
4321           /* [namespace.udecl]
4322
4323              If a function declaration in namespace scope or block
4324              scope has the same name and the same parameter types as a
4325              function introduced by a using declaration the program is
4326              ill-formed.  */
4327           for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
4328             {
4329               tree old_fn = OVL_CURRENT (tmp1);
4330
4331               if (new_fn == old_fn)
4332                 /* The function already exists in the current namespace.  */
4333                 break;
4334               else if (OVL_USED (tmp1))
4335                 continue; /* this is a using decl */
4336               else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
4337                                   TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
4338                 {
4339                   /* There was already a non-using declaration in
4340                      this scope with the same parameter types. If both
4341                      are the same extern "C" functions, that's ok.  */
4342                   if (decls_match (new_fn, old_fn))
4343                     {
4344                       /* If the OLD_FN was a builtin, there is now a
4345                          real declaration.  */
4346                       if (DECL_ANTICIPATED (old_fn))
4347                         DECL_ANTICIPATED (old_fn) = 0;
4348                       break;
4349                     }
4350                   else if (!DECL_ANTICIPATED (old_fn))
4351                     {
4352                       /* If the OLD_FN was really declared, the
4353                          declarations don't match.  */
4354                       error ("`%D' is already declared in this scope", name);
4355                       break;
4356                     }
4357
4358                   /* If the OLD_FN was not really there, just ignore
4359                      it and keep going.  */
4360                 }
4361             }
4362
4363           /* If we broke out of the loop, there's no reason to add
4364              this function to the using declarations for this
4365              scope.  */
4366           if (tmp1)
4367             continue;
4368
4369           *newval = build_overload (OVL_CURRENT (tmp), *newval);
4370           if (TREE_CODE (*newval) != OVERLOAD)
4371             *newval = ovl_cons (*newval, NULL_TREE);
4372           OVL_USED (*newval) = 1;
4373         }
4374     }
4375   else
4376     {
4377       *newval = decls.value;
4378       if (oldval && !decls_match (*newval, oldval))
4379         error ("`%D' is already declared in this scope", name);
4380     }
4381
4382   *newtype = decls.type;
4383   if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
4384     {
4385       error ("using declaration `%D' introduced ambiguous type `%T'",
4386                 name, oldtype);
4387       return;
4388     }
4389 }
4390
4391 /* Process a using-declaration not appearing in class or local scope.  */
4392
4393 void
4394 do_toplevel_using_decl (tree decl)
4395 {
4396   tree scope, name;
4397   tree oldval, oldtype, newval, newtype;
4398   cxx_binding *binding;
4399
4400   decl = validate_nonmember_using_decl (decl, &scope, &name);
4401   if (decl == NULL_TREE)
4402     return;
4403
4404   binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
4405
4406   oldval = BINDING_VALUE (binding);
4407   oldtype = BINDING_TYPE (binding);
4408
4409   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
4410
4411   /* Copy declarations found.  */
4412   if (newval)
4413     BINDING_VALUE (binding) = newval;
4414   if (newtype)
4415     BINDING_TYPE (binding) = newtype;
4416   return;
4417 }
4418
4419 /* Process a using-declaration at function scope.  */
4420
4421 void
4422 do_local_using_decl (tree decl)
4423 {
4424   tree scope, name;
4425   tree oldval, oldtype, newval, newtype;
4426
4427   decl = validate_nonmember_using_decl (decl, &scope, &name);
4428   if (decl == NULL_TREE)
4429     return;
4430
4431   if (building_stmt_tree ()
4432       && at_function_scope_p ())
4433     add_decl_stmt (decl);
4434
4435   oldval = lookup_name_current_level (name);
4436   oldtype = lookup_type_current_level (name);
4437
4438   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
4439
4440   if (newval)
4441     {
4442       if (is_overloaded_fn (newval))
4443         {
4444           tree fn, term;
4445
4446           /* We only need to push declarations for those functions
4447              that were not already bound in the current level.
4448              The old value might be NULL_TREE, it might be a single
4449              function, or an OVERLOAD.  */
4450           if (oldval && TREE_CODE (oldval) == OVERLOAD)
4451             term = OVL_FUNCTION (oldval);
4452           else
4453             term = oldval;
4454           for (fn = newval; fn && OVL_CURRENT (fn) != term;
4455                fn = OVL_NEXT (fn))
4456             push_overloaded_decl (OVL_CURRENT (fn),
4457                                   PUSH_LOCAL | PUSH_USING);
4458         }
4459       else
4460         push_local_binding (name, newval, PUSH_USING);
4461     }
4462   if (newtype)
4463     set_identifier_type_value (name, newtype);
4464 }
4465
4466 tree
4467 do_class_using_decl (tree decl)
4468 {
4469   tree name, value;
4470
4471   if (TREE_CODE (decl) != SCOPE_REF
4472       || !TREE_OPERAND (decl, 0)
4473       || !TYPE_P (TREE_OPERAND (decl, 0)))
4474     {
4475       error ("using-declaration for non-member at class scope");
4476       return NULL_TREE;
4477     }
4478   name = TREE_OPERAND (decl, 1);
4479   if (TREE_CODE (name) == BIT_NOT_EXPR)
4480     {
4481       error ("using-declaration for destructor");
4482       return NULL_TREE;
4483     }
4484   else if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
4485     {
4486       name = TREE_OPERAND (name, 0);
4487       error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'", TREE_OPERAND (decl, 0), name);
4488       return NULL_TREE;
4489     }
4490   if (TREE_CODE (name) == TYPE_DECL)
4491     {
4492       tree type = TREE_TYPE (name);
4493       if (CLASSTYPE_USE_TEMPLATE (TREE_TYPE (name)))
4494         {
4495           name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
4496           error ("a using-declaration cannot specify a template-id.");
4497           return NULL_TREE;
4498         }
4499       name = DECL_NAME (name);
4500     }
4501   else if (TREE_CODE (name) == TEMPLATE_DECL)
4502      name = DECL_NAME (name);
4503   else if (BASELINK_P (name))
4504     {
4505       tree fns;
4506
4507       fns = BASELINK_FUNCTIONS (name);
4508       if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
4509         {
4510           fns = TREE_OPERAND (fns, 0);
4511           error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'",
4512                  BASELINK_ACCESS_BINFO (name),
4513                  DECL_NAME (get_first_fn (fns)));
4514         }
4515       name = DECL_NAME (get_first_fn (fns));
4516     }
4517
4518   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
4519
4520   value = build_lang_decl (USING_DECL, name, void_type_node);
4521   DECL_INITIAL (value) = TREE_OPERAND (decl, 0);
4522   return value;
4523 }
4524
4525 /* Process a using-directive.  */
4526
4527 void
4528 do_using_directive (tree namespace)
4529 {
4530   if (building_stmt_tree ())
4531     add_stmt (build_stmt (USING_STMT, namespace));
4532
4533   /* using namespace A::B::C; */
4534   if (TREE_CODE (namespace) == SCOPE_REF)
4535       namespace = TREE_OPERAND (namespace, 1);
4536   if (TREE_CODE (namespace) == IDENTIFIER_NODE)
4537     {
4538       /* Lookup in lexer did not find a namespace.  */
4539       if (!processing_template_decl)
4540         error ("namespace `%T' undeclared", namespace);
4541       return;
4542     }
4543   if (TREE_CODE (namespace) != NAMESPACE_DECL)
4544     {
4545       if (!processing_template_decl)
4546         error ("`%T' is not a namespace", namespace);
4547       return;
4548     }
4549   namespace = ORIGINAL_NAMESPACE (namespace);
4550   if (!toplevel_bindings_p ())
4551     push_using_directive (namespace);
4552   else
4553     /* direct usage */
4554     add_using_namespace (current_namespace, namespace, 0);
4555 }
4556
4557 void
4558 check_default_args (tree x)
4559 {
4560   tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
4561   bool saw_def = false;
4562   int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
4563   for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
4564     {
4565       if (TREE_PURPOSE (arg))
4566         saw_def = true;
4567       else if (saw_def)
4568         {
4569           cp_error_at ("default argument missing for parameter %P of `%+#D'",
4570                        i, x);
4571           break;
4572         }
4573     }
4574 }
4575
4576 void
4577 mark_used (tree decl)
4578 {
4579   TREE_USED (decl) = 1;
4580   if (processing_template_decl || skip_evaluation)
4581     return;
4582
4583   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4584       && !TREE_ASM_WRITTEN (decl))
4585     /* Remember it, so we can check it was defined.  */
4586     defer_fn (decl);
4587
4588   assemble_external (decl);
4589
4590   /* Is it a synthesized method that needs to be synthesized?  */
4591   if (TREE_CODE (decl) == FUNCTION_DECL
4592       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4593       && DECL_ARTIFICIAL (decl)
4594       && !DECL_THUNK_P (decl)
4595       && ! DECL_INITIAL (decl)
4596       /* Kludge: don't synthesize for default args.  */
4597       && current_function_decl)
4598     {
4599       synthesize_method (decl);
4600       /* If we've already synthesized the method we don't need to
4601          instantiate it, so we can return right away.  */
4602       return;
4603     }
4604
4605   /* If this is a function or variable that is an instance of some
4606      template, we now know that we will need to actually do the
4607      instantiation. We check that DECL is not an explicit
4608      instantiation because that is not checked in instantiate_decl.  */
4609   if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
4610       && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
4611       && (!DECL_EXPLICIT_INSTANTIATION (decl)
4612           || (TREE_CODE (decl) == FUNCTION_DECL
4613               && DECL_INLINE (DECL_TEMPLATE_RESULT
4614                               (template_for_substitution (decl))))))
4615     {
4616       bool defer;
4617
4618       /* Normally, we put off instantiating functions in order to
4619          improve compile times.  Maintaining a stack of active
4620          functions is expensive, and the inliner knows to
4621          instantiate any functions it might need.
4622
4623          However, if instantiating this function might help us mark
4624          the current function TREE_NOTHROW, we go ahead and
4625          instantiate it now.  */
4626       defer = (!flag_exceptions
4627                || TREE_CODE (decl) != FUNCTION_DECL
4628                /* If the called function can't throw, we don't need to
4629                   generate its body to find that out.  */
4630                || TREE_NOTHROW (decl)
4631                || !cfun
4632                /* If we already know the current function can't throw,
4633                   then we don't need to work hard to prove it.  */
4634                || TREE_NOTHROW (current_function_decl)
4635                /* If we already know that the current function *can*
4636                   throw, there's no point in gathering more
4637                   information.  */
4638                || cp_function_chain->can_throw);
4639
4640       instantiate_decl (decl, defer);
4641     }
4642 }
4643
4644 /* Called when a class-head is encountered.  TAG_KIND is the class-key
4645    for the class.  SCOPE, if non-NULL, is the type or namespace
4646    indicated in the nested-name-specifier for the declaration of the
4647    class.  ID is the name of the class, if any; it may be a TYPE_DECL,
4648    or an IDENTIFIER_NODE.  ATTRIBUTES are attributes that apply to the
4649    class.
4650
4651    Return a TYPE_DECL for the class being defined.  */
4652
4653 tree
4654 handle_class_head (enum tag_types tag_kind, tree scope, tree id,
4655                    tree attributes)
4656 {
4657   tree decl = NULL_TREE;
4658   tree current = current_scope ();
4659   bool xrefd_p = false;
4660   bool new_type_p;
4661   tree context;
4662
4663   if (current == NULL_TREE)
4664     current = current_namespace;
4665
4666   if (scope)
4667     {
4668       if (TREE_CODE (id) == TYPE_DECL)
4669         /* We must bash typedefs back to the main decl of the
4670            type. Otherwise we become confused about scopes.  */
4671         decl = TYPE_MAIN_DECL (TREE_TYPE (id));
4672       else if (DECL_CLASS_TEMPLATE_P (id))
4673         decl = DECL_TEMPLATE_RESULT (id);
4674       else
4675         {
4676           if (TYPE_P (scope))
4677             {
4678               /* According to the suggested resolution of core issue
4679                  180, 'typename' is assumed after a class-key.  */
4680               decl = make_typename_type (scope, id, tf_error);
4681               if (decl != error_mark_node)
4682                 decl = TYPE_MAIN_DECL (decl);
4683               else
4684                 decl = NULL_TREE;
4685             }
4686           else if (scope == current)
4687             {
4688               /* We've been given AGGR SCOPE::ID, when we're already
4689                  inside SCOPE.  Be nice about it.  */
4690               if (pedantic)
4691                 pedwarn ("extra qualification `%T::' on member `%D' ignored",
4692                          scope, id);
4693             }
4694           else
4695             error ("`%T' does not have a class or union named `%D'",
4696                    scope, id);
4697         }
4698     }
4699
4700   if (!decl)
4701     {
4702       decl = xref_tag (tag_kind, id, attributes, false);
4703       if (decl == error_mark_node)
4704         return error_mark_node;
4705       decl = TYPE_MAIN_DECL (decl);
4706       xrefd_p = true;
4707     }
4708
4709   if (!TYPE_BINFO (TREE_TYPE (decl)))
4710     {
4711       error ("`%T' is not a class or union type", decl);
4712       return error_mark_node;
4713     }
4714
4715   /* For a definition, we want to enter the containing scope before
4716      looking up any base classes etc. Only do so, if this is different
4717      to the current scope.  */
4718   context = CP_DECL_CONTEXT (decl);
4719
4720   new_type_p = (current != context
4721                 && TREE_CODE (context) != TEMPLATE_TYPE_PARM
4722                 && TREE_CODE (context) != BOUND_TEMPLATE_TEMPLATE_PARM);
4723   if (new_type_p)
4724     push_scope (context);
4725
4726   if (!xrefd_p
4727       && PROCESSING_REAL_TEMPLATE_DECL_P ()
4728       && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
4729     decl = push_template_decl (decl);
4730
4731   return decl;
4732 }
4733
4734 #include "gt-cp-decl2.h"