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       if (TREE_CODE (fnaddr) != ADDR_EXPR
1398           && TREE_CODE (fnaddr) != FDESC_EXPR)
1399         /* This entry is an offset: a virtual base class offset, a
1400            virtual call offset, an RTTI offset, etc.  */
1401         continue;
1402
1403       fn = TREE_OPERAND (fnaddr, 0);
1404       TREE_ADDRESSABLE (fn) = 1;
1405       /* When we don't have vcall offsets, we output thunks whenever
1406          we output the vtables that contain them.  With vcall offsets,
1407          we know all the thunks we'll need when we emit a virtual
1408          function, so we emit the thunks there instead.  */
1409       if (DECL_THUNK_P (fn))
1410         use_thunk (fn, /*emit_p=*/0);
1411       mark_used (fn);
1412     }
1413 }
1414
1415 /* Set DECL up to have the closest approximation of "initialized common"
1416    linkage available.  */
1417
1418 void
1419 comdat_linkage (tree decl)
1420 {
1421   if (flag_weak)
1422     make_decl_one_only (decl);
1423   else if (TREE_CODE (decl) == FUNCTION_DECL
1424            || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1425     /* We can just emit function and compiler-generated variables
1426        statically; having multiple copies is (for the most part) only
1427        a waste of space.
1428
1429        There are two correctness issues, however: the address of a
1430        template instantiation with external linkage should be the
1431        same, independent of what translation unit asks for the
1432        address, and this will not hold when we emit multiple copies of
1433        the function.  However, there's little else we can do.
1434
1435        Also, by default, the typeinfo implementation assumes that
1436        there will be only one copy of the string used as the name for
1437        each type.  Therefore, if weak symbols are unavailable, the
1438        run-time library should perform a more conservative check; it
1439        should perform a string comparison, rather than an address
1440        comparison.  */
1441     TREE_PUBLIC (decl) = 0;
1442   else
1443     {
1444       /* Static data member template instantiations, however, cannot
1445          have multiple copies.  */
1446       if (DECL_INITIAL (decl) == 0
1447           || DECL_INITIAL (decl) == error_mark_node)
1448         DECL_COMMON (decl) = 1;
1449       else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1450         {
1451           DECL_COMMON (decl) = 1;
1452           DECL_INITIAL (decl) = error_mark_node;
1453         }
1454       else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1455         {
1456           /* We can't do anything useful; leave vars for explicit
1457              instantiation.  */
1458           DECL_EXTERNAL (decl) = 1;
1459           DECL_NOT_REALLY_EXTERN (decl) = 0;
1460         }
1461     }
1462
1463   if (DECL_LANG_SPECIFIC (decl))
1464     DECL_COMDAT (decl) = 1;
1465 }
1466
1467 /* For win32 we also want to put explicit instantiations in
1468    linkonce sections, so that they will be merged with implicit
1469    instantiations; otherwise we get duplicate symbol errors.  */
1470
1471 void
1472 maybe_make_one_only (tree decl)
1473 {
1474   /* We used to say that this was not necessary on targets that support weak
1475      symbols, because the implicit instantiations will defer to the explicit
1476      one.  However, that's not actually the case in SVR4; a strong definition
1477      after a weak one is an error.  Also, not making explicit
1478      instantiations one_only means that we can end up with two copies of
1479      some template instantiations.  */
1480   if (! flag_weak)
1481     return;
1482
1483   /* We can't set DECL_COMDAT on functions, or finish_file will think
1484      we can get away with not emitting them if they aren't used.  We need
1485      to for variables so that cp_finish_decl will update their linkage,
1486      because their DECL_INITIAL may not have been set properly yet.  */
1487
1488   make_decl_one_only (decl);
1489
1490   if (TREE_CODE (decl) == VAR_DECL)
1491     {
1492       DECL_COMDAT (decl) = 1;
1493       /* Mark it needed so we don't forget to emit it.  */
1494       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
1495     }
1496 }
1497
1498 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
1499    based on TYPE and other static flags.
1500
1501    Note that anything public is tagged TREE_PUBLIC, whether
1502    it's public in this file or in another one.  */
1503
1504 void
1505 import_export_vtable (tree decl, tree type, int final)
1506 {
1507   if (DECL_INTERFACE_KNOWN (decl))
1508     return;
1509
1510   if (TYPE_FOR_JAVA (type))
1511     {
1512       TREE_PUBLIC (decl) = 1;
1513       DECL_EXTERNAL (decl) = 1;
1514       DECL_INTERFACE_KNOWN (decl) = 1;
1515     }
1516   else if (CLASSTYPE_INTERFACE_KNOWN (type))
1517     {
1518       TREE_PUBLIC (decl) = 1;
1519       DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
1520       DECL_INTERFACE_KNOWN (decl) = 1;
1521     }
1522   else
1523     {
1524       /* We can only wait to decide if we have real non-inline virtual
1525          functions in our class, or if we come from a template.  */
1526
1527       int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
1528                    || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);
1529
1530       if (final || ! found)
1531         {
1532           comdat_linkage (decl);
1533           DECL_EXTERNAL (decl) = 0;
1534         }
1535       else
1536         {
1537           TREE_PUBLIC (decl) = 1;
1538           DECL_EXTERNAL (decl) = 1;
1539         }
1540     }
1541 }
1542
1543 /* Determine whether or not we want to specifically import or export CTYPE,
1544    using various heuristics.  */
1545
1546 static void
1547 import_export_class (tree ctype)
1548 {
1549   /* -1 for imported, 1 for exported.  */
1550   int import_export = 0;
1551
1552   /* It only makes sense to call this function at EOF.  The reason is
1553      that this function looks at whether or not the first non-inline
1554      non-abstract virtual member function has been defined in this
1555      translation unit.  But, we can't possibly know that until we've
1556      seen the entire translation unit.  */
1557   my_friendly_assert (at_eof, 20000226);
1558
1559   if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1560     return;
1561
1562   /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
1563      we will have CLASSTYPE_INTERFACE_ONLY set but not
1564      CLASSTYPE_INTERFACE_KNOWN.  In that case, we don't want to use this
1565      heuristic because someone will supply a #pragma implementation
1566      elsewhere, and deducing it here would produce a conflict.  */
1567   if (CLASSTYPE_INTERFACE_ONLY (ctype))
1568     return;
1569
1570   if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1571     import_export = -1;
1572   else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1573     import_export = 1;
1574
1575   /* If we got -fno-implicit-templates, we import template classes that
1576      weren't explicitly instantiated.  */
1577   if (import_export == 0
1578       && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1579       && ! flag_implicit_templates)
1580     import_export = -1;
1581
1582   /* Base our import/export status on that of the first non-inline,
1583      non-pure virtual function, if any.  */
1584   if (import_export == 0
1585       && TYPE_POLYMORPHIC_P (ctype))
1586     {
1587       tree method = CLASSTYPE_KEY_METHOD (ctype);
1588       if (method)
1589         import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1590     }
1591
1592 #ifdef MULTIPLE_SYMBOL_SPACES
1593   if (import_export == -1)
1594     import_export = 0;
1595 #endif
1596
1597   if (import_export)
1598     {
1599       SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1600       CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1601     }
1602 }
1603
1604 /* We need to describe to the assembler the relationship between
1605    a vtable and the vtable of the parent class.  */
1606
1607 static void
1608 output_vtable_inherit (tree vars)
1609 {
1610   tree parent;
1611   rtx child_rtx, parent_rtx;
1612
1613   child_rtx = XEXP (DECL_RTL (vars), 0);          /* strip the mem ref  */
1614
1615   parent = binfo_for_vtable (vars);
1616
1617   if (parent == TYPE_BINFO (DECL_CONTEXT (vars)))
1618     parent_rtx = const0_rtx;
1619   else if (parent)
1620     {
1621       parent = get_vtbl_decl_for_binfo (TYPE_BINFO (BINFO_TYPE (parent)));
1622       parent_rtx = XEXP (DECL_RTL (parent), 0);  /* strip the mem ref  */
1623     }
1624   else
1625     abort ();
1626
1627   assemble_vtable_inherit (child_rtx, parent_rtx);
1628 }
1629
1630 /* If necessary, write out the vtables for the dynamic class CTYPE.
1631    Returns true if any vtables were emitted.  */
1632
1633 static bool
1634 maybe_emit_vtables (tree ctype)
1635 {
1636   tree vtbl;
1637   tree primary_vtbl;
1638
1639   /* If the vtables for this class have already been emitted there is
1640      nothing more to do.  */
1641   primary_vtbl = CLASSTYPE_VTABLES (ctype);
1642   if (TREE_ASM_WRITTEN (primary_vtbl))
1643     return false;
1644   /* Ignore dummy vtables made by get_vtable_decl.  */
1645   if (TREE_TYPE (primary_vtbl) == void_type_node)
1646     return false;
1647
1648   import_export_class (ctype);
1649   import_export_vtable (primary_vtbl, ctype, 1);
1650
1651   /* See if any of the vtables are needed.  */
1652   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1653     if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
1654       break;
1655
1656   if (!vtbl)
1657     {
1658       /* If the references to this class' vtables are optimized away,
1659          still emit the appropriate debugging information.  See
1660          dfs_debug_mark.  */
1661       if (DECL_COMDAT (primary_vtbl)
1662           && CLASSTYPE_DEBUG_REQUESTED (ctype))
1663         note_debug_info_needed (ctype);
1664       return false;
1665     }
1666
1667   /* The ABI requires that we emit all of the vtables if we emit any
1668      of them.  */
1669   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1670     {
1671       /* Write it out.  */
1672       import_export_vtable (vtbl, ctype, 1);
1673       mark_vtable_entries (vtbl);
1674       if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1675         store_init_value (vtbl, DECL_INITIAL (vtbl));
1676
1677       if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
1678         {
1679           /* Mark the VAR_DECL node representing the vtable itself as a
1680              "gratuitous" one, thereby forcing dwarfout.c to ignore it.
1681              It is rather important that such things be ignored because
1682              any effort to actually generate DWARF for them will run
1683              into trouble when/if we encounter code like:
1684
1685                 #pragma interface
1686                 struct S { virtual void member (); };
1687
1688               because the artificial declaration of the vtable itself (as
1689               manufactured by the g++ front end) will say that the vtable
1690               is a static member of `S' but only *after* the debug output
1691               for the definition of `S' has already been output.  This causes
1692               grief because the DWARF entry for the definition of the vtable
1693               will try to refer back to an earlier *declaration* of the
1694               vtable as a static member of `S' and there won't be one.
1695               We might be able to arrange to have the "vtable static member"
1696               attached to the member list for `S' before the debug info for
1697               `S' get written (which would solve the problem) but that would
1698               require more intrusive changes to the g++ front end.  */
1699
1700           DECL_IGNORED_P (vtbl) = 1;
1701         }
1702
1703       /* Always make vtables weak.  */
1704       if (flag_weak)
1705         comdat_linkage (vtbl);
1706
1707       rest_of_decl_compilation (vtbl, NULL, 1, 1);
1708
1709       if (flag_vtable_gc)
1710         output_vtable_inherit (vtbl);
1711
1712       /* Because we're only doing syntax-checking, we'll never end up
1713          actually marking the variable as written.  */
1714       if (flag_syntax_only)
1715         TREE_ASM_WRITTEN (vtbl) = 1;
1716     }
1717
1718   /* Since we're writing out the vtable here, also write the debug
1719      info.  */
1720   note_debug_info_needed (ctype);
1721
1722   return true;
1723 }
1724
1725 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
1726    inline function or template instantiation at end-of-file.  */
1727
1728 void
1729 import_export_decl (tree decl)
1730 {
1731   if (DECL_INTERFACE_KNOWN (decl))
1732     return;
1733
1734   if (DECL_TEMPLATE_INSTANTIATION (decl)
1735       || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1736     {
1737       DECL_NOT_REALLY_EXTERN (decl) = 1;
1738       if ((DECL_IMPLICIT_INSTANTIATION (decl)
1739            || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1740           && (flag_implicit_templates
1741               || (flag_implicit_inline_templates
1742                   && DECL_DECLARED_INLINE_P (decl))))
1743         {
1744           if (!TREE_PUBLIC (decl))
1745             /* Templates are allowed to have internal linkage.  See
1746                [basic.link].  */
1747             ;
1748           else
1749             comdat_linkage (decl);
1750         }
1751       else
1752         {
1753           DECL_EXTERNAL (decl) = 1;
1754           DECL_NOT_REALLY_EXTERN (decl) = 0;
1755         }
1756     }
1757   else if (DECL_FUNCTION_MEMBER_P (decl))
1758     {
1759       if (!DECL_DECLARED_INLINE_P (decl))
1760         {
1761           tree ctype = DECL_CONTEXT (decl);
1762           import_export_class (ctype);
1763           if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1764             {
1765               DECL_NOT_REALLY_EXTERN (decl)
1766                 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
1767                      || (DECL_DECLARED_INLINE_P (decl)
1768                          && ! flag_implement_inlines
1769                          && !DECL_VINDEX (decl)));
1770
1771               if (!DECL_NOT_REALLY_EXTERN (decl))
1772                 DECL_EXTERNAL (decl) = 1;
1773
1774               /* Always make artificials weak.  */
1775               if (DECL_ARTIFICIAL (decl) && flag_weak)
1776                 comdat_linkage (decl);
1777               else
1778                 maybe_make_one_only (decl);
1779             }
1780         }
1781       else
1782         comdat_linkage (decl);
1783     }
1784   else
1785     comdat_linkage (decl);
1786
1787   DECL_INTERFACE_KNOWN (decl) = 1;
1788 }
1789
1790 /* Here, we only decide whether or not the tinfo node should be
1791    emitted with the vtable.  IS_IN_LIBRARY is nonzero iff the
1792    typeinfo for TYPE should be in the runtime library.  */
1793
1794 void
1795 import_export_tinfo (tree decl, tree type, bool is_in_library)
1796 {
1797   if (DECL_INTERFACE_KNOWN (decl))
1798     return;
1799
1800   if (IS_AGGR_TYPE (type))
1801     import_export_class (type);
1802
1803   if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
1804       && TYPE_POLYMORPHIC_P (type)
1805       /* If -fno-rtti, we're not necessarily emitting this stuff with
1806          the class, so go ahead and emit it now.  This can happen when
1807          a class is used in exception handling.  */
1808       && flag_rtti)
1809     {
1810       DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
1811       DECL_COMDAT (decl) = 0;
1812     }
1813   else
1814     {
1815       DECL_NOT_REALLY_EXTERN (decl) = 1;
1816       DECL_COMDAT (decl) = 1;
1817     }
1818
1819   /* Now override some cases.  */
1820   if (flag_weak)
1821     DECL_COMDAT (decl) = 1;
1822   else if (is_in_library)
1823     DECL_COMDAT (decl) = 0;
1824
1825   DECL_INTERFACE_KNOWN (decl) = 1;
1826 }
1827
1828 /* Return an expression that performs the destruction of DECL, which
1829    must be a VAR_DECL whose type has a non-trivial destructor, or is
1830    an array whose (innermost) elements have a non-trivial destructor.  */
1831
1832 tree
1833 build_cleanup (tree decl)
1834 {
1835   tree temp;
1836   tree type = TREE_TYPE (decl);
1837
1838   /* This function should only be called for declarations that really
1839      require cleanups.  */
1840   my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
1841
1842   /* Treat all objects with destructors as used; the destructor may do
1843      something substantive.  */
1844   mark_used (decl);
1845
1846   if (TREE_CODE (type) == ARRAY_TYPE)
1847     temp = decl;
1848   else
1849     {
1850       cxx_mark_addressable (decl);
1851       temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
1852     }
1853   temp = build_delete (TREE_TYPE (temp), temp,
1854                        sfk_complete_destructor,
1855                        LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
1856   return temp;
1857 }
1858
1859 /* Returns the initialization guard variable for the variable DECL,
1860    which has static storage duration.  */
1861
1862 tree
1863 get_guard (tree decl)
1864 {
1865   tree sname;
1866   tree guard;
1867
1868   sname = mangle_guard_variable (decl);
1869   guard = IDENTIFIER_GLOBAL_VALUE (sname);
1870   if (! guard)
1871     {
1872       tree guard_type;
1873
1874       /* We use a type that is big enough to contain a mutex as well
1875          as an integer counter.  */
1876       guard_type = long_long_integer_type_node;
1877       guard = build_decl (VAR_DECL, sname, guard_type);
1878
1879       /* The guard should have the same linkage as what it guards.  */
1880       TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
1881       TREE_STATIC (guard) = TREE_STATIC (decl);
1882       DECL_COMMON (guard) = DECL_COMMON (decl);
1883       DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
1884       if (TREE_PUBLIC (decl))
1885         DECL_WEAK (guard) = DECL_WEAK (decl);
1886
1887       DECL_ARTIFICIAL (guard) = 1;
1888       TREE_USED (guard) = 1;
1889       pushdecl_top_level (guard);
1890       cp_finish_decl (guard, NULL_TREE, NULL_TREE, 0);
1891     }
1892   return guard;
1893 }
1894
1895 /* Return those bits of the GUARD variable that should be set when the
1896    guarded entity is actually initialized.  */
1897
1898 static tree
1899 get_guard_bits (tree guard)
1900 {
1901   /* We only set the first byte of the guard, in order to leave room
1902      for a mutex in the high-order bits.  */
1903   guard = build1 (ADDR_EXPR,
1904                   build_pointer_type (TREE_TYPE (guard)),
1905                   guard);
1906   guard = build1 (NOP_EXPR,
1907                   build_pointer_type (char_type_node),
1908                   guard);
1909   guard = build1 (INDIRECT_REF, char_type_node, guard);
1910
1911   return guard;
1912 }
1913
1914 /* Return an expression which determines whether or not the GUARD
1915    variable has already been initialized.  */
1916
1917 tree
1918 get_guard_cond (tree guard)
1919 {
1920   tree guard_value;
1921
1922   /* Check to see if the GUARD is zero.  */
1923   guard = get_guard_bits (guard);
1924   guard_value = integer_zero_node;
1925   if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1926     guard_value = convert (TREE_TYPE (guard), guard_value);
1927   return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1928 }
1929
1930 /* Return an expression which sets the GUARD variable, indicating that
1931    the variable being guarded has been initialized.  */
1932
1933 tree
1934 set_guard (tree guard)
1935 {
1936   tree guard_init;
1937
1938   /* Set the GUARD to one.  */
1939   guard = get_guard_bits (guard);
1940   guard_init = integer_one_node;
1941   if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1942     guard_init = convert (TREE_TYPE (guard), guard_init);
1943   return build_modify_expr (guard, NOP_EXPR, guard_init);
1944 }
1945
1946 /* Start the process of running a particular set of global constructors
1947    or destructors.  Subroutine of do_[cd]tors.  */
1948
1949 static tree
1950 start_objects (int method_type, int initp)
1951 {
1952   tree fnname;
1953   tree body;
1954   char type[10];
1955
1956   /* Make ctor or dtor function.  METHOD_TYPE may be 'I' or 'D'.  */
1957
1958   if (initp != DEFAULT_INIT_PRIORITY)
1959     {
1960       char joiner;
1961
1962 #ifdef JOINER
1963       joiner = JOINER;
1964 #else
1965       joiner = '_';
1966 #endif
1967
1968       sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1969     }
1970   else
1971     sprintf (type, "%c", method_type);
1972
1973   fnname = get_file_function_name_long (type);
1974
1975   start_function (void_list_node,
1976                   make_call_declarator (fnname, void_list_node, NULL_TREE,
1977                                         NULL_TREE),
1978                   NULL_TREE, SF_DEFAULT);
1979
1980   /* It can be a static function as long as collect2 does not have
1981      to scan the object file to find its ctor/dtor routine.  */
1982   TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1983
1984   /* Mark this declaration as used to avoid spurious warnings.  */
1985   TREE_USED (current_function_decl) = 1;
1986
1987   /* Mark this function as a global constructor or destructor.  */
1988   if (method_type == 'I')
1989     DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1990   else
1991     DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1992   DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1993
1994   body = begin_compound_stmt (/*has_no_scope=*/0);
1995
1996   /* We cannot allow these functions to be elided, even if they do not
1997      have external linkage.  And, there's no point in deferring
1998      copmilation of thes functions; they're all going to have to be
1999      out anyhow.  */
2000   current_function_cannot_inline
2001     = "static constructors and destructors cannot be inlined";
2002
2003   return body;
2004 }
2005
2006 /* Finish the process of running a particular set of global constructors
2007    or destructors.  Subroutine of do_[cd]tors.  */
2008
2009 static void
2010 finish_objects (int method_type, int initp, tree body)
2011 {
2012   tree fn;
2013
2014   /* Finish up.  */
2015   finish_compound_stmt (/*has_no_scope=*/0, body);
2016   fn = finish_function (0);
2017   expand_body (fn);
2018
2019   /* When only doing semantic analysis, and no RTL generation, we
2020      can't call functions that directly emit assembly code; there is
2021      no assembly file in which to put the code.  */
2022   if (flag_syntax_only)
2023     return;
2024
2025   if (targetm.have_ctors_dtors)
2026     {
2027       rtx fnsym = XEXP (DECL_RTL (fn), 0);
2028       if (method_type == 'I')
2029         (* targetm.asm_out.constructor) (fnsym, initp);
2030       else
2031         (* targetm.asm_out.destructor) (fnsym, initp);
2032     }
2033 }
2034
2035 /* The names of the parameters to the function created to handle
2036    initializations and destructions for objects with static storage
2037    duration.  */
2038 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2039 #define PRIORITY_IDENTIFIER "__priority"
2040
2041 /* The name of the function we create to handle initializations and
2042    destructions for objects with static storage duration.  */
2043 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2044
2045 /* The declaration for the __INITIALIZE_P argument.  */
2046 static GTY(()) tree initialize_p_decl;
2047
2048 /* The declaration for the __PRIORITY argument.  */
2049 static GTY(()) tree priority_decl;
2050
2051 /* The declaration for the static storage duration function.  */
2052 static GTY(()) tree ssdf_decl;
2053
2054 /* All the static storage duration functions created in this
2055    translation unit.  */
2056 static GTY(()) varray_type ssdf_decls;
2057
2058 /* A map from priority levels to information about that priority
2059    level.  There may be many such levels, so efficient lookup is
2060    important.  */
2061 static splay_tree priority_info_map;
2062
2063 /* Begins the generation of the function that will handle all
2064    initialization and destruction of objects with static storage
2065    duration.  The function generated takes two parameters of type
2066    `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
2067    nonzero, it performs initializations.  Otherwise, it performs
2068    destructions.  It only performs those initializations or
2069    destructions with the indicated __PRIORITY.  The generated function
2070    returns no value.
2071
2072    It is assumed that this function will only be called once per
2073    translation unit.  */
2074
2075 static tree
2076 start_static_storage_duration_function (unsigned count)
2077 {
2078   tree parm_types;
2079   tree type;
2080   tree body;
2081   char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2082
2083   /* Create the identifier for this function.  It will be of the form
2084      SSDF_IDENTIFIER_<number>.  */
2085   sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2086
2087   /* Create the parameters.  */
2088   parm_types = void_list_node;
2089   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2090   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2091   type = build_function_type (void_type_node, parm_types);
2092
2093   /* Create the FUNCTION_DECL itself.  */
2094   ssdf_decl = build_lang_decl (FUNCTION_DECL,
2095                                get_identifier (id),
2096                                type);
2097   TREE_PUBLIC (ssdf_decl) = 0;
2098   DECL_ARTIFICIAL (ssdf_decl) = 1;
2099
2100   /* Put this function in the list of functions to be called from the
2101      static constructors and destructors.  */
2102   if (!ssdf_decls)
2103     {
2104       VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2105
2106       /* Take this opportunity to initialize the map from priority
2107          numbers to information about that priority level.  */
2108       priority_info_map = splay_tree_new (splay_tree_compare_ints,
2109                                           /*delete_key_fn=*/0,
2110                                           /*delete_value_fn=*/
2111                                           (splay_tree_delete_value_fn) &free);
2112
2113       /* We always need to generate functions for the
2114          DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
2115          priorities later, we'll be sure to find the
2116          DEFAULT_INIT_PRIORITY.  */
2117       get_priority_info (DEFAULT_INIT_PRIORITY);
2118     }
2119
2120   VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2121
2122   /* Create the argument list.  */
2123   initialize_p_decl = cp_build_parm_decl
2124     (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2125   DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2126   TREE_USED (initialize_p_decl) = 1;
2127   priority_decl = cp_build_parm_decl
2128     (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2129   DECL_CONTEXT (priority_decl) = ssdf_decl;
2130   TREE_USED (priority_decl) = 1;
2131
2132   TREE_CHAIN (initialize_p_decl) = priority_decl;
2133   DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2134
2135   /* Put the function in the global scope.  */
2136   pushdecl (ssdf_decl);
2137
2138   /* Start the function itself.  This is equivalent to declarating the
2139      function as:
2140
2141        static void __ssdf (int __initialize_p, init __priority_p);
2142
2143      It is static because we only need to call this function from the
2144      various constructor and destructor functions for this module.  */
2145   start_function (/*specs=*/NULL_TREE,
2146                   ssdf_decl,
2147                   /*attrs=*/NULL_TREE,
2148                   SF_PRE_PARSED);
2149
2150   /* Set up the scope of the outermost block in the function.  */
2151   body = begin_compound_stmt (/*has_no_scope=*/0);
2152
2153   /* This function must not be deferred because we are depending on
2154      its compilation to tell us what is TREE_SYMBOL_REFERENCED.  */
2155   current_function_cannot_inline
2156     = "static storage duration functions cannot be inlined";
2157
2158   return body;
2159 }
2160
2161 /* Finish the generation of the function which performs initialization
2162    and destruction of objects with static storage duration.  After
2163    this point, no more such objects can be created.  */
2164
2165 static void
2166 finish_static_storage_duration_function (tree body)
2167 {
2168   /* Close out the function.  */
2169   finish_compound_stmt (/*has_no_scope=*/0, body);
2170   expand_body (finish_function (0));
2171 }
2172
2173 /* Return the information about the indicated PRIORITY level.  If no
2174    code to handle this level has yet been generated, generate the
2175    appropriate prologue.  */
2176
2177 static priority_info
2178 get_priority_info (int priority)
2179 {
2180   priority_info pi;
2181   splay_tree_node n;
2182
2183   n = splay_tree_lookup (priority_info_map,
2184                          (splay_tree_key) priority);
2185   if (!n)
2186     {
2187       /* Create a new priority information structure, and insert it
2188          into the map.  */
2189       pi = (priority_info) xmalloc (sizeof (struct priority_info_s));
2190       pi->initializations_p = 0;
2191       pi->destructions_p = 0;
2192       splay_tree_insert (priority_info_map,
2193                          (splay_tree_key) priority,
2194                          (splay_tree_value) pi);
2195     }
2196   else
2197     pi = (priority_info) n->value;
2198
2199   return pi;
2200 }
2201
2202 /* Set up to handle the initialization or destruction of DECL.  If
2203    INITP is nonzero, we are initializing the variable.  Otherwise, we
2204    are destroying it.  */
2205
2206 static tree
2207 start_static_initialization_or_destruction (tree decl, int initp)
2208 {
2209   tree guard_if_stmt = NULL_TREE;
2210   int priority;
2211   tree cond;
2212   tree guard;
2213   tree init_cond;
2214   priority_info pi;
2215
2216   /* Figure out the priority for this declaration.  */
2217   priority = DECL_INIT_PRIORITY (decl);
2218   if (!priority)
2219     priority = DEFAULT_INIT_PRIORITY;
2220
2221   /* Remember that we had an initialization or finalization at this
2222      priority.  */
2223   pi = get_priority_info (priority);
2224   if (initp)
2225     pi->initializations_p = 1;
2226   else
2227     pi->destructions_p = 1;
2228
2229   /* Trick the compiler into thinking we are at the file and line
2230      where DECL was declared so that error-messages make sense, and so
2231      that the debugger will show somewhat sensible file and line
2232      information.  */
2233   input_location = DECL_SOURCE_LOCATION (decl);
2234
2235   /* Because of:
2236
2237        [class.access.spec]
2238
2239        Access control for implicit calls to the constructors,
2240        the conversion functions, or the destructor called to
2241        create and destroy a static data member is performed as
2242        if these calls appeared in the scope of the member's
2243        class.
2244
2245      we pretend we are in a static member function of the class of
2246      which the DECL is a member.  */
2247   if (member_p (decl))
2248     {
2249       DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2250       DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2251     }
2252
2253   /* Conditionalize this initialization on being in the right priority
2254      and being initializing/finalizing appropriately.  */
2255   guard_if_stmt = begin_if_stmt ();
2256   cond = cp_build_binary_op (EQ_EXPR,
2257                              priority_decl,
2258                              build_int_2 (priority, 0));
2259   init_cond = initp ? integer_one_node : integer_zero_node;
2260   init_cond = cp_build_binary_op (EQ_EXPR,
2261                                   initialize_p_decl,
2262                                   init_cond);
2263   cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2264
2265   /* Assume we don't need a guard.  */
2266   guard = NULL_TREE;
2267   /* We need a guard if this is an object with external linkage that
2268      might be initialized in more than one place.  (For example, a
2269      static data member of a template, when the data member requires
2270      construction.)  */
2271   if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2272                              || DECL_ONE_ONLY (decl)
2273                              || DECL_WEAK (decl)))
2274     {
2275       tree guard_cond;
2276
2277       guard = get_guard (decl);
2278
2279       /* When using __cxa_atexit, we just check the GUARD as we would
2280          for a local static.  */
2281       if (flag_use_cxa_atexit)
2282         {
2283           /* When using __cxa_atexit, we never try to destroy
2284              anything from a static destructor.  */
2285           my_friendly_assert (initp, 20000629);
2286           guard_cond = get_guard_cond (guard);
2287         }
2288       /* If we don't have __cxa_atexit, then we will be running
2289          destructors from .fini sections, or their equivalents.  So,
2290          we need to know how many times we've tried to initialize this
2291          object.  We do initializations only if the GUARD is zero,
2292          i.e., if we are the first to initialize the variable.  We do
2293          destructions only if the GUARD is one, i.e., if we are the
2294          last to destroy the variable.  */
2295       else if (initp)
2296         guard_cond
2297           = cp_build_binary_op (EQ_EXPR,
2298                                 build_unary_op (PREINCREMENT_EXPR,
2299                                                 guard,
2300                                                 /*noconvert=*/1),
2301                                 integer_one_node);
2302       else
2303         guard_cond
2304           = cp_build_binary_op (EQ_EXPR,
2305                                 build_unary_op (PREDECREMENT_EXPR,
2306                                                 guard,
2307                                                 /*noconvert=*/1),
2308                                 integer_zero_node);
2309
2310       cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2311     }
2312
2313   finish_if_stmt_cond (cond, guard_if_stmt);
2314
2315   /* If we're using __cxa_atexit, we have not already set the GUARD,
2316      so we must do so now.  */
2317   if (guard && initp && flag_use_cxa_atexit)
2318     finish_expr_stmt (set_guard (guard));
2319
2320   return guard_if_stmt;
2321 }
2322
2323 /* We've just finished generating code to do an initialization or
2324    finalization.  GUARD_IF_STMT is the if-statement we used to guard
2325    the initialization.  */
2326
2327 static void
2328 finish_static_initialization_or_destruction (tree guard_if_stmt)
2329 {
2330   finish_then_clause (guard_if_stmt);
2331   finish_if_stmt ();
2332
2333   /* Now that we're done with DECL we don't need to pretend to be a
2334      member of its class any longer.  */
2335   DECL_CONTEXT (current_function_decl) = NULL_TREE;
2336   DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2337 }
2338
2339 /* Generate code to do the initialization of DECL, a VAR_DECL with
2340    static storage duration.  The initialization is INIT.  */
2341
2342 static void
2343 do_static_initialization (tree decl, tree init)
2344 {
2345   tree guard_if_stmt;
2346
2347   /* Set up for the initialization.  */
2348   guard_if_stmt
2349     = start_static_initialization_or_destruction (decl,
2350                                                   /*initp=*/1);
2351
2352   /* Perform the initialization.  */
2353   if (init)
2354     finish_expr_stmt (init);
2355
2356   /* If we're using __cxa_atexit, register a a function that calls the
2357      destructor for the object.  */
2358   if (flag_use_cxa_atexit)
2359     register_dtor_fn (decl);
2360
2361   /* Finsh up.  */
2362   finish_static_initialization_or_destruction (guard_if_stmt);
2363 }
2364
2365 /* Generate code to do the static destruction of DECL.  If DECL may be
2366    initialized more than once in different object files, GUARD is the
2367    guard variable to check.  PRIORITY is the priority for the
2368    destruction.  */
2369
2370 static void
2371 do_static_destruction (tree decl)
2372 {
2373   tree guard_if_stmt;
2374
2375   /* If we're using __cxa_atexit, then destructors are registered
2376      immediately after objects are initialized.  */
2377   my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2378
2379   /* If we don't need a destructor, there's nothing to do.  */
2380   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2381     return;
2382
2383   /* Actually do the destruction.  */
2384   guard_if_stmt = start_static_initialization_or_destruction (decl,
2385                                                               /*initp=*/0);
2386   finish_expr_stmt (build_cleanup (decl));
2387   finish_static_initialization_or_destruction (guard_if_stmt);
2388 }
2389
2390 /* VARS is a list of variables with static storage duration which may
2391    need initialization and/or finalization.  Remove those variables
2392    that don't really need to be initialized or finalized, and return
2393    the resulting list.  The order in which the variables appear in
2394    VARS is in reverse order of the order in which they should actually
2395    be initialized.  The list we return is in the unreversed order;
2396    i.e., the first variable should be initialized first.  */
2397
2398 static tree
2399 prune_vars_needing_no_initialization (tree *vars)
2400 {
2401   tree *var = vars;
2402   tree result = NULL_TREE;
2403
2404   while (*var)
2405     {
2406       tree t = *var;
2407       tree decl = TREE_VALUE (t);
2408       tree init = TREE_PURPOSE (t);
2409
2410       /* Deal gracefully with error.  */
2411       if (decl == error_mark_node)
2412         {
2413           var = &TREE_CHAIN (t);
2414           continue;
2415         }
2416
2417       /* The only things that can be initialized are variables.  */
2418       my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2419
2420       /* If this object is not defined, we don't need to do anything
2421          here.  */
2422       if (DECL_EXTERNAL (decl))
2423         {
2424           var = &TREE_CHAIN (t);
2425           continue;
2426         }
2427
2428       /* Also, if the initializer already contains errors, we can bail
2429          out now.  */
2430       if (init && TREE_CODE (init) == TREE_LIST
2431           && value_member (error_mark_node, init))
2432         {
2433           var = &TREE_CHAIN (t);
2434           continue;
2435         }
2436
2437       /* This variable is going to need initialization and/or
2438          finalization, so we add it to the list.  */
2439       *var = TREE_CHAIN (t);
2440       TREE_CHAIN (t) = result;
2441       result = t;
2442     }
2443
2444   return result;
2445 }
2446
2447 /* Make sure we have told the back end about all the variables in
2448    VARS.  */
2449
2450 static void
2451 write_out_vars (tree vars)
2452 {
2453   tree v;
2454
2455   for (v = vars; v; v = TREE_CHAIN (v))
2456     if (! TREE_ASM_WRITTEN (TREE_VALUE (v)))
2457       rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2458 }
2459
2460 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2461    (otherwise) that will initialize all gobal objects with static
2462    storage duration having the indicated PRIORITY.  */
2463
2464 static void
2465 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2466                                 location_t *locus)
2467 {
2468   char function_key;
2469   tree arguments;
2470   tree fndecl;
2471   tree body;
2472   size_t i;
2473
2474   input_location = *locus;
2475   locus->line++;
2476
2477   /* We use `I' to indicate initialization and `D' to indicate
2478      destruction.  */
2479   function_key = constructor_p ? 'I' : 'D';
2480
2481   /* We emit the function lazily, to avoid generating empty
2482      global constructors and destructors.  */
2483   body = NULL_TREE;
2484
2485   /* Call the static storage duration function with appropriate
2486      arguments.  */
2487   if (ssdf_decls)
2488     for (i = 0; i < ssdf_decls->elements_used; ++i)
2489       {
2490         fndecl = VARRAY_TREE (ssdf_decls, i);
2491
2492         /* Calls to pure or const functions will expand to nothing.  */
2493         if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2494           {
2495             if (! body)
2496               body = start_objects (function_key, priority);
2497
2498             arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2499                                    NULL_TREE);
2500             arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2501                                    arguments);
2502             finish_expr_stmt (build_function_call (fndecl, arguments));
2503           }
2504       }
2505
2506   /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2507      calls to any functions marked with attributes indicating that
2508      they should be called at initialization- or destruction-time.  */
2509   if (priority == DEFAULT_INIT_PRIORITY)
2510     {
2511       tree fns;
2512
2513       for (fns = constructor_p ? static_ctors : static_dtors;
2514            fns;
2515            fns = TREE_CHAIN (fns))
2516         {
2517           fndecl = TREE_VALUE (fns);
2518
2519           /* Calls to pure/const functions will expand to nothing.  */
2520           if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2521             {
2522               if (! body)
2523                 body = start_objects (function_key, priority);
2524               finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2525             }
2526         }
2527     }
2528
2529   /* Close out the function.  */
2530   if (body)
2531     finish_objects (function_key, priority, body);
2532 }
2533
2534 /* Generate constructor and destructor functions for the priority
2535    indicated by N.  */
2536
2537 static int
2538 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2539 {
2540   location_t *locus = data;
2541   int priority = (int) n->key;
2542   priority_info pi = (priority_info) n->value;
2543
2544   /* Generate the functions themselves, but only if they are really
2545      needed.  */
2546   if (pi->initializations_p
2547       || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2548     generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2549   if (pi->destructions_p
2550       || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2551     generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2552
2553   /* Keep iterating.  */
2554   return 0;
2555 }
2556
2557 /* This routine is called from the last rule in yyparse ().
2558    Its job is to create all the code needed to initialize and
2559    destroy the global aggregates.  We do the destruction
2560    first, since that way we only need to reverse the decls once.  */
2561
2562 void
2563 finish_file ()
2564 {
2565   tree vars;
2566   bool reconsider;
2567   size_t i;
2568   location_t locus;
2569   unsigned ssdf_count = 0;
2570
2571   locus = input_location;
2572   at_eof = 1;
2573
2574   /* Bad parse errors.  Just forget about it.  */
2575   if (! global_bindings_p () || current_class_type || decl_namespace_list)
2576     return;
2577
2578   if (pch_file)
2579     c_common_write_pch ();
2580
2581   /* Otherwise, GDB can get confused, because in only knows
2582      about source for LINENO-1 lines.  */
2583   input_line -= 1;
2584
2585   interface_unknown = 1;
2586   interface_only = 0;
2587
2588   /* We now have to write out all the stuff we put off writing out.
2589      These include:
2590
2591        o Template specializations that we have not yet instantiated,
2592          but which are needed.
2593        o Initialization and destruction for non-local objects with
2594          static storage duration.  (Local objects with static storage
2595          duration are initialized when their scope is first entered,
2596          and are cleaned up via atexit.)
2597        o Virtual function tables.
2598
2599      All of these may cause others to be needed.  For example,
2600      instantiating one function may cause another to be needed, and
2601      generating the initializer for an object may cause templates to be
2602      instantiated, etc., etc.  */
2603
2604   timevar_push (TV_VARCONST);
2605
2606   emit_support_tinfos ();
2607
2608   do
2609     {
2610       tree t;
2611       size_t n_old, n_new;
2612
2613       reconsider = false;
2614
2615       /* If there are templates that we've put off instantiating, do
2616          them now.  */
2617       instantiate_pending_templates ();
2618
2619       /* Write out virtual tables as required.  Note that writing out
2620          the virtual table for a template class may cause the
2621          instantiation of members of that class.  If we write out
2622          vtables then we remove the class from our list so we don't
2623          have to look at it again. */
2624
2625       while (keyed_classes != NULL_TREE
2626              && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2627         {
2628           reconsider = true;
2629           keyed_classes = TREE_CHAIN (keyed_classes);
2630         }
2631
2632       t = keyed_classes;
2633       if (t != NULL_TREE)
2634         {
2635           tree next = TREE_CHAIN (t);
2636
2637           while (next)
2638             {
2639               if (maybe_emit_vtables (TREE_VALUE (next)))
2640                 {
2641                   reconsider = true;
2642                   TREE_CHAIN (t) = TREE_CHAIN (next);
2643                 }
2644               else
2645                 t = next;
2646
2647               next = TREE_CHAIN (t);
2648             }
2649         }
2650
2651       /* Write out needed type info variables.  We have to be careful
2652          looping through unemitted decls, because emit_tinfo_decl may
2653          cause other variables to be needed.  We stick new elements
2654          (and old elements that we may need to reconsider) at the end
2655          of the array, then shift them back to the beginning once we're
2656          done. */
2657
2658       n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2659       for (i = 0; i < n_old; ++i)
2660         {
2661           tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2662           if (emit_tinfo_decl (tinfo_decl))
2663             reconsider = true;
2664           else
2665             VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2666         }
2667
2668       /* The only elements we want to keep are the new ones.  Copy
2669          them to the beginning of the array, then get rid of the
2670          leftovers. */
2671       n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2672       memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2673                &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2674                n_new * sizeof (tree));
2675       memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2676               0,
2677               n_old * sizeof (tree));
2678       VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2679
2680       /* The list of objects with static storage duration is built up
2681          in reverse order.  We clear STATIC_AGGREGATES so that any new
2682          aggregates added during the initialization of these will be
2683          initialized in the correct order when we next come around the
2684          loop.  */
2685       vars = prune_vars_needing_no_initialization (&static_aggregates);
2686
2687       if (vars)
2688         {
2689           tree v;
2690
2691           /* We need to start a new initialization function each time
2692              through the loop.  That's because we need to know which
2693              vtables have been referenced, and TREE_SYMBOL_REFERENCED
2694              isn't computed until a function is finished, and written
2695              out.  That's a deficiency in the back-end.  When this is
2696              fixed, these initialization functions could all become
2697              inline, with resulting performance improvements.  */
2698           tree ssdf_body;
2699
2700           /* Set the line and file, so that it is obviously not from
2701              the source file.  */
2702           input_location = locus;
2703           ssdf_body = start_static_storage_duration_function (ssdf_count);
2704
2705           /* Make sure the back end knows about all the variables.  */
2706           write_out_vars (vars);
2707
2708           /* First generate code to do all the initializations.  */
2709           for (v = vars; v; v = TREE_CHAIN (v))
2710             do_static_initialization (TREE_VALUE (v),
2711                                       TREE_PURPOSE (v));
2712
2713           /* Then, generate code to do all the destructions.  Do these
2714              in reverse order so that the most recently constructed
2715              variable is the first destroyed.  If we're using
2716              __cxa_atexit, then we don't need to do this; functions
2717              were registered at initialization time to destroy the
2718              local statics.  */
2719           if (!flag_use_cxa_atexit)
2720             {
2721               vars = nreverse (vars);
2722               for (v = vars; v; v = TREE_CHAIN (v))
2723                 do_static_destruction (TREE_VALUE (v));
2724             }
2725           else
2726             vars = NULL_TREE;
2727
2728           /* Finish up the static storage duration function for this
2729              round.  */
2730           input_location = locus;
2731           finish_static_storage_duration_function (ssdf_body);
2732
2733           /* All those initializations and finalizations might cause
2734              us to need more inline functions, more template
2735              instantiations, etc.  */
2736           reconsider = true;
2737           ssdf_count++;
2738           locus.line++;
2739         }
2740
2741       for (i = 0; i < deferred_fns_used; ++i)
2742         {
2743           tree decl = VARRAY_TREE (deferred_fns, i);
2744
2745           /* Does it need synthesizing?  */
2746           if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2747               && TREE_USED (decl)
2748               && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2749             {
2750               /* Even though we're already at the top-level, we push
2751                  there again.  That way, when we pop back a few lines
2752                  hence, all of our state is restored.  Otherwise,
2753                  finish_function doesn't clean things up, and we end
2754                  up with CURRENT_FUNCTION_DECL set.  */
2755               push_to_top_level ();
2756               synthesize_method (decl);
2757               pop_from_top_level ();
2758               reconsider = true;
2759             }
2760
2761           /* If the function has no body, avoid calling
2762              import_export_decl.  On a system without weak symbols,
2763              calling import_export_decl will make an inline template
2764              instantiation "static", which will result in errors about
2765              the use of undefined functions if there is no body for
2766              the function.  */
2767           if (!DECL_SAVED_TREE (decl))
2768             continue;
2769
2770           import_export_decl (decl);
2771
2772           /* We lie to the back-end, pretending that some functions
2773              are not defined when they really are.  This keeps these
2774              functions from being put out unnecessarily.  But, we must
2775              stop lying when the functions are referenced, or if they
2776              are not comdat since they need to be put out now.  This
2777              is done in a separate for cycle, because if some deferred
2778              function is contained in another deferred function later
2779              in deferred_fns varray, rest_of_compilation would skip
2780              this function and we really cannot expand the same
2781              function twice.  */
2782           if (DECL_NOT_REALLY_EXTERN (decl)
2783               && DECL_INITIAL (decl)
2784               && DECL_NEEDED_P (decl))
2785             DECL_EXTERNAL (decl) = 0;
2786
2787           /* If we're going to need to write this function out, and
2788              there's already a body for it, create RTL for it now.
2789              (There might be no body if this is a method we haven't
2790              gotten around to synthesizing yet.)  */
2791           if (!DECL_EXTERNAL (decl)
2792               && DECL_NEEDED_P (decl)
2793               && DECL_SAVED_TREE (decl)
2794               && !TREE_ASM_WRITTEN (decl))
2795             {
2796               int saved_not_really_extern;
2797
2798               /* When we call finish_function in expand_body, it will
2799                  try to reset DECL_NOT_REALLY_EXTERN so we save and
2800                  restore it here.  */
2801               saved_not_really_extern = DECL_NOT_REALLY_EXTERN (decl);
2802               /* Generate RTL for this function now that we know we
2803                  need it.  */
2804               expand_body (decl);
2805               /* Undo the damage done by finish_function.  */
2806               DECL_EXTERNAL (decl) = 0;
2807               DECL_NOT_REALLY_EXTERN (decl) = saved_not_really_extern;
2808               /* If we're compiling -fsyntax-only pretend that this
2809                  function has been written out so that we don't try to
2810                  expand it again.  */
2811               if (flag_syntax_only)
2812                 TREE_ASM_WRITTEN (decl) = 1;
2813               reconsider = true;
2814             }
2815         }
2816
2817       if (deferred_fns_used
2818           && wrapup_global_declarations (&VARRAY_TREE (deferred_fns, 0),
2819                                          deferred_fns_used))
2820         reconsider = true;
2821       if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2822         reconsider = true;
2823
2824       /* Static data members are just like namespace-scope globals.  */
2825       for (i = 0; i < pending_statics_used; ++i)
2826         {
2827           tree decl = VARRAY_TREE (pending_statics, i);
2828           if (TREE_ASM_WRITTEN (decl))
2829             continue;
2830           import_export_decl (decl);
2831           if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2832             DECL_EXTERNAL (decl) = 0;
2833         }
2834       if (pending_statics
2835           && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2836                                          pending_statics_used))
2837         reconsider = true;
2838     }
2839   while (reconsider);
2840
2841   /* All used inline functions must have a definition at this point. */
2842   for (i = 0; i < deferred_fns_used; ++i)
2843     {
2844       tree decl = VARRAY_TREE (deferred_fns, i);
2845
2846       if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
2847           && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
2848                /* An explicit instantiation can be used to specify
2849                   that the body is in another unit. It will have
2850                   already verified there was a definition.  */
2851                || DECL_EXPLICIT_INSTANTIATION (decl)))
2852         {
2853           cp_warning_at ("inline function `%D' used but never defined", decl);
2854           /* This symbol is effectively an "extern" declaration now.
2855              This is not strictly necessary, but removes a duplicate
2856              warning.  */
2857           TREE_PUBLIC (decl) = 1;
2858         }
2859
2860     }
2861
2862   /* We give C linkage to static constructors and destructors.  */
2863   push_lang_context (lang_name_c);
2864
2865   /* Generate initialization and destruction functions for all
2866      priorities for which they are required.  */
2867   if (priority_info_map)
2868     splay_tree_foreach (priority_info_map,
2869                         generate_ctor_and_dtor_functions_for_priority,
2870                         /*data=*/&locus);
2871   else
2872     {
2873
2874       if (static_ctors)
2875         generate_ctor_or_dtor_function (/*constructor_p=*/true,
2876                                         DEFAULT_INIT_PRIORITY, &locus);
2877       if (static_dtors)
2878         generate_ctor_or_dtor_function (/*constructor_p=*/false,
2879                                         DEFAULT_INIT_PRIORITY, &locus);
2880     }
2881
2882   /* We're done with the splay-tree now.  */
2883   if (priority_info_map)
2884     splay_tree_delete (priority_info_map);
2885
2886   /* We're done with static constructors, so we can go back to "C++"
2887      linkage now.  */
2888   pop_lang_context ();
2889
2890   /* Now, issue warnings about static, but not defined, functions,
2891      etc., and emit debugging information.  */
2892   walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2893   if (pending_statics)
2894     check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2895                                pending_statics_used);
2896
2897   finish_repo ();
2898
2899   /* The entire file is now complete.  If requested, dump everything
2900      to a file.  */
2901   {
2902     int flags;
2903     FILE *stream = dump_begin (TDI_all, &flags);
2904
2905     if (stream)
2906       {
2907         dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2908         dump_end (TDI_all, stream);
2909       }
2910   }
2911
2912   timevar_pop (TV_VARCONST);
2913
2914   if (flag_detailed_statistics)
2915     {
2916       dump_tree_statistics ();
2917       dump_time_statistics ();
2918     }
2919   input_location = locus;
2920 }
2921
2922 /* T is the parse tree for an expression.  Return the expression after
2923    performing semantic analysis.  */
2924
2925 tree
2926 build_expr_from_tree (t)
2927      tree t;
2928 {
2929   if (t == NULL_TREE || t == error_mark_node)
2930     return t;
2931
2932   switch (TREE_CODE (t))
2933     {
2934     case IDENTIFIER_NODE:
2935       return do_identifier (t, NULL_TREE);
2936
2937     case LOOKUP_EXPR:
2938       if (LOOKUP_EXPR_GLOBAL (t))
2939         {
2940           tree token = TREE_OPERAND (t, 0);
2941           return do_scoped_id (token, IDENTIFIER_GLOBAL_VALUE (token));
2942         }
2943       else
2944         {
2945           t = do_identifier (TREE_OPERAND (t, 0), NULL_TREE);
2946           if (TREE_CODE (t) == ALIAS_DECL)
2947             t = DECL_INITIAL (t);
2948           return t;
2949         }
2950
2951     case TEMPLATE_ID_EXPR:
2952       {
2953         tree template;
2954         tree args;
2955         tree object;
2956
2957         template = build_expr_from_tree (TREE_OPERAND (t, 0));
2958         args = build_expr_from_tree (TREE_OPERAND (t, 1));
2959
2960         if (TREE_CODE (template) == COMPONENT_REF)
2961           {
2962             object = TREE_OPERAND (template, 0);
2963             template = TREE_OPERAND (template, 1);
2964           }
2965         else
2966           object = NULL_TREE;
2967
2968         template = lookup_template_function (template, args);
2969         if (object)
2970           return build (COMPONENT_REF, TREE_TYPE (template),
2971                         object, template);
2972         else
2973           return template;
2974       }
2975
2976     case INDIRECT_REF:
2977       return build_x_indirect_ref
2978         (build_expr_from_tree (TREE_OPERAND (t, 0)), "unary *");
2979
2980     case CAST_EXPR:
2981       return build_functional_cast
2982         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2983
2984     case REINTERPRET_CAST_EXPR:
2985       return build_reinterpret_cast
2986         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2987
2988     case CONST_CAST_EXPR:
2989       return build_const_cast
2990         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2991
2992     case DYNAMIC_CAST_EXPR:
2993       return build_dynamic_cast
2994         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2995
2996     case STATIC_CAST_EXPR:
2997       return build_static_cast
2998         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2999
3000     case PREDECREMENT_EXPR:
3001     case PREINCREMENT_EXPR:
3002     case POSTDECREMENT_EXPR:
3003     case POSTINCREMENT_EXPR:
3004     case NEGATE_EXPR:
3005     case BIT_NOT_EXPR:
3006     case ABS_EXPR:
3007     case TRUTH_NOT_EXPR:
3008     case ADDR_EXPR:
3009     case CONVERT_EXPR:      /* Unary + */
3010     case REALPART_EXPR:
3011     case IMAGPART_EXPR:
3012       if (TREE_TYPE (t))
3013         return t;
3014       return build_x_unary_op (TREE_CODE (t),
3015                                build_expr_from_tree (TREE_OPERAND (t, 0)));
3016
3017     case PLUS_EXPR:
3018     case MINUS_EXPR:
3019     case MULT_EXPR:
3020     case TRUNC_DIV_EXPR:
3021     case CEIL_DIV_EXPR:
3022     case FLOOR_DIV_EXPR:
3023     case ROUND_DIV_EXPR:
3024     case EXACT_DIV_EXPR:
3025     case BIT_AND_EXPR:
3026     case BIT_ANDTC_EXPR:
3027     case BIT_IOR_EXPR:
3028     case BIT_XOR_EXPR:
3029     case TRUNC_MOD_EXPR:
3030     case FLOOR_MOD_EXPR:
3031     case TRUTH_ANDIF_EXPR:
3032     case TRUTH_ORIF_EXPR:
3033     case TRUTH_AND_EXPR:
3034     case TRUTH_OR_EXPR:
3035     case RSHIFT_EXPR:
3036     case LSHIFT_EXPR:
3037     case RROTATE_EXPR:
3038     case LROTATE_EXPR:
3039     case EQ_EXPR:
3040     case NE_EXPR:
3041     case MAX_EXPR:
3042     case MIN_EXPR:
3043     case LE_EXPR:
3044     case GE_EXPR:
3045     case LT_EXPR:
3046     case GT_EXPR:
3047     case MEMBER_REF:
3048       return build_x_binary_op
3049         (TREE_CODE (t),
3050          build_expr_from_tree (TREE_OPERAND (t, 0)),
3051          build_expr_from_tree (TREE_OPERAND (t, 1)));
3052
3053     case DOTSTAR_EXPR:
3054       return build_m_component_ref
3055         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3056          build_expr_from_tree (TREE_OPERAND (t, 1)));
3057
3058     case SCOPE_REF:
3059       return build_offset_ref (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
3060
3061     case ARRAY_REF:
3062       if (TREE_OPERAND (t, 0) == NULL_TREE)
3063         /* new-type-id */
3064         return build_nt (ARRAY_REF, NULL_TREE,
3065                          build_expr_from_tree (TREE_OPERAND (t, 1)));
3066       return grok_array_decl (build_expr_from_tree (TREE_OPERAND (t, 0)),
3067                               build_expr_from_tree (TREE_OPERAND (t, 1)));
3068
3069     case SIZEOF_EXPR:
3070     case ALIGNOF_EXPR:
3071       {
3072         tree r = build_expr_from_tree (TREE_OPERAND (t, 0));
3073         if (!TYPE_P (r))
3074           return TREE_CODE (t) == SIZEOF_EXPR ? expr_sizeof (r) : c_alignof_expr (r);
3075         else
3076           return cxx_sizeof_or_alignof_type (r, TREE_CODE (t), true);
3077       }
3078
3079     case MODOP_EXPR:
3080       return build_x_modify_expr
3081         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3082          TREE_CODE (TREE_OPERAND (t, 1)),
3083          build_expr_from_tree (TREE_OPERAND (t, 2)));
3084
3085     case ARROW_EXPR:
3086       return build_x_arrow
3087         (build_expr_from_tree (TREE_OPERAND (t, 0)));
3088
3089     case NEW_EXPR:
3090       return build_new
3091         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3092          build_expr_from_tree (TREE_OPERAND (t, 1)),
3093          build_expr_from_tree (TREE_OPERAND (t, 2)),
3094          NEW_EXPR_USE_GLOBAL (t));
3095
3096     case DELETE_EXPR:
3097       return delete_sanity
3098         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3099          build_expr_from_tree (TREE_OPERAND (t, 1)),
3100          DELETE_EXPR_USE_VEC (t), DELETE_EXPR_USE_GLOBAL (t));
3101
3102     case COMPOUND_EXPR:
3103       if (TREE_OPERAND (t, 1) == NULL_TREE)
3104         return build_x_compound_expr
3105           (build_expr_from_tree (TREE_OPERAND (t, 0)));
3106       else
3107         abort ();
3108
3109     case METHOD_CALL_EXPR:
3110       if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3111         {
3112           tree ref = TREE_OPERAND (t, 0);
3113           tree name = TREE_OPERAND (ref, 1);
3114
3115           if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3116             name = build_nt (TEMPLATE_ID_EXPR,
3117                              TREE_OPERAND (name, 0),
3118                              build_expr_from_tree (TREE_OPERAND (name, 1)));
3119
3120           return build_scoped_method_call
3121             (build_expr_from_tree (TREE_OPERAND (t, 1)),
3122              build_expr_from_tree (TREE_OPERAND (ref, 0)),
3123              name,
3124              build_expr_from_tree (TREE_OPERAND (t, 2)));
3125         }
3126       else
3127         {
3128           tree fn = TREE_OPERAND (t, 0);
3129
3130           /* We can get a TEMPLATE_ID_EXPR here on code like:
3131
3132                x->f<2>();
3133
3134              so we must resolve that.  However, we can also get things
3135              like a BIT_NOT_EXPR here, when referring to a destructor,
3136              and things like that are not correctly resolved by
3137              build_expr_from_tree.  So, just use build_expr_from_tree
3138              when we really need it.  */
3139           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3140             fn = lookup_template_function
3141               (TREE_OPERAND (fn, 0),
3142                build_expr_from_tree (TREE_OPERAND (fn, 1)));
3143
3144           return build_method_call
3145             (build_expr_from_tree (TREE_OPERAND (t, 1)),
3146              fn,
3147              build_expr_from_tree (TREE_OPERAND (t, 2)),
3148              NULL_TREE, LOOKUP_NORMAL);
3149         }
3150
3151     case CALL_EXPR:
3152       if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3153         {
3154           tree ref = TREE_OPERAND (t, 0);
3155           tree name = TREE_OPERAND (ref, 1);
3156           tree fn, scope, args;
3157
3158           if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3159             name = build_nt (TEMPLATE_ID_EXPR,
3160                              TREE_OPERAND (name, 0),
3161                              build_expr_from_tree (TREE_OPERAND (name, 1)));
3162
3163           scope = build_expr_from_tree (TREE_OPERAND (ref, 0));
3164           args = build_expr_from_tree (TREE_OPERAND (t, 1));
3165           fn = resolve_scoped_fn_name (scope, name);
3166
3167           return build_call_from_tree (fn, args, 1);
3168         }
3169       else
3170         {
3171           tree name = TREE_OPERAND (t, 0);
3172           tree id;
3173           tree args = build_expr_from_tree (TREE_OPERAND (t, 1));
3174           if (args != NULL_TREE && TREE_CODE (name) == LOOKUP_EXPR
3175               && !LOOKUP_EXPR_GLOBAL (name)
3176               && TREE_CODE ((id = TREE_OPERAND (name, 0))) == IDENTIFIER_NODE
3177               && (!current_class_type
3178                   || !lookup_member (current_class_type, id, 0, false)))
3179             {
3180               /* Do Koenig lookup if there are no class members.  */
3181               name = do_identifier (id, args);
3182             }
3183           else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
3184                    || ! really_overloaded_fn (name))
3185             name = build_expr_from_tree (name);
3186
3187           if (TREE_CODE (name) == OFFSET_REF)
3188             return build_offset_ref_call_from_tree (name, args);
3189           if (TREE_CODE (name) == COMPONENT_REF)
3190             return finish_object_call_expr (TREE_OPERAND (name, 1),
3191                                             TREE_OPERAND (name, 0),
3192                                             args);
3193           name = convert_from_reference (name);
3194           return build_call_from_tree (name, args,
3195                                        /*disallow_virtual=*/false);
3196         }
3197
3198     case COND_EXPR:
3199       return build_x_conditional_expr
3200         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3201          build_expr_from_tree (TREE_OPERAND (t, 1)),
3202          build_expr_from_tree (TREE_OPERAND (t, 2)));
3203
3204     case PSEUDO_DTOR_EXPR:
3205       return (finish_pseudo_destructor_expr
3206               (build_expr_from_tree (TREE_OPERAND (t, 0)),
3207                build_expr_from_tree (TREE_OPERAND (t, 1)),
3208                build_expr_from_tree (TREE_OPERAND (t, 2))));
3209
3210     case TREE_LIST:
3211       {
3212         tree purpose, value, chain;
3213
3214         if (t == void_list_node)
3215           return t;
3216
3217         purpose = TREE_PURPOSE (t);
3218         if (purpose)
3219           purpose = build_expr_from_tree (purpose);
3220         value = TREE_VALUE (t);
3221         if (value)
3222           value = build_expr_from_tree (value);
3223         chain = TREE_CHAIN (t);
3224         if (chain && chain != void_type_node)
3225           chain = build_expr_from_tree (chain);
3226         return tree_cons (purpose, value, chain);
3227       }
3228
3229     case COMPONENT_REF:
3230       {
3231         tree object = build_expr_from_tree (TREE_OPERAND (t, 0));
3232         tree member = TREE_OPERAND (t, 1);
3233
3234         if (!CLASS_TYPE_P (TREE_TYPE (object)))
3235           {
3236             if (TREE_CODE (member) == BIT_NOT_EXPR)
3237               return finish_pseudo_destructor_expr (object,
3238                                                     NULL_TREE,
3239                                                     TREE_TYPE (object));
3240             else if (TREE_CODE (member) == SCOPE_REF
3241                      && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
3242               return finish_pseudo_destructor_expr (object,
3243                                                     TREE_OPERAND (t, 0),
3244                                                     TREE_TYPE (object));
3245           }
3246         else if (TREE_CODE (member) == SCOPE_REF
3247                  && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
3248           {
3249             tree tmpl;
3250             tree args;
3251
3252             /* Lookup the template functions now that we know what the
3253                scope is.  */
3254             tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
3255             args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
3256             member = lookup_qualified_name (TREE_OPERAND (member, 0),
3257                                             tmpl,
3258                                             /*is_type=*/0,
3259                                             /*flags=*/0);
3260             if (BASELINK_P (member))
3261               BASELINK_FUNCTIONS (member)
3262                 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
3263                             args);
3264             else
3265               {
3266                 error ("`%D' is not a member of `%T'",
3267                        tmpl, TREE_TYPE (object));
3268                 return error_mark_node;
3269               }
3270           }
3271
3272
3273         return finish_class_member_access_expr (object, member);
3274       }
3275
3276     case THROW_EXPR:
3277       return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0)));
3278
3279     case CONSTRUCTOR:
3280       {
3281         tree r;
3282         tree elts;
3283         tree type = TREE_TYPE (t);
3284         bool purpose_p;
3285
3286         /* digest_init will do the wrong thing if we let it.  */
3287         if (type && TYPE_PTRMEMFUNC_P (type))
3288           return t;
3289
3290         r = NULL_TREE;
3291         /* We do not want to process the purpose of aggregate
3292            initializers as they are identifier nodes which will be
3293            looked up by digest_init.  */
3294         purpose_p = !(type && IS_AGGR_TYPE (type));
3295         for (elts = CONSTRUCTOR_ELTS (t); elts; elts = TREE_CHAIN (elts))
3296           {
3297             tree purpose = TREE_PURPOSE (elts);
3298             tree value = TREE_VALUE (elts);
3299
3300             if (purpose && purpose_p)
3301               purpose = build_expr_from_tree (purpose);
3302             value = build_expr_from_tree (value);
3303             r = tree_cons (purpose, value, r);
3304           }
3305
3306         r = build_constructor (NULL_TREE, nreverse (r));
3307         TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
3308
3309         if (type)
3310           return digest_init (type, r, 0);
3311         return r;
3312       }
3313
3314     case TYPEID_EXPR:
3315       if (TYPE_P (TREE_OPERAND (t, 0)))
3316         return get_typeid (TREE_OPERAND (t, 0));
3317       return build_typeid (build_expr_from_tree (TREE_OPERAND (t, 0)));
3318
3319     case PARM_DECL:
3320     case VAR_DECL:
3321       return convert_from_reference (t);
3322
3323     case VA_ARG_EXPR:
3324       return build_va_arg (build_expr_from_tree (TREE_OPERAND (t, 0)),
3325                            TREE_TYPE (t));
3326
3327     default:
3328       return t;
3329     }
3330 }
3331
3332 /* FN is an OFFSET_REF indicating the function to call in parse-tree
3333    form; it has not yet been semantically analyzed.  ARGS are the
3334    arguments to the function.  They have already been semantically
3335    analzyed.  */
3336
3337 tree
3338 build_offset_ref_call_from_tree (tree fn, tree args)
3339 {
3340   tree object_addr;
3341
3342   my_friendly_assert (TREE_CODE (fn) == OFFSET_REF, 20020725);
3343
3344   /* A qualified name corresponding to a non-static member
3345      function or a pointer-to-member is represented as an
3346      OFFSET_REF.
3347
3348      For both of these function calls, FN will be an OFFSET_REF.
3349
3350         struct A { void f(); };
3351         void A::f() { (A::f) (); }
3352
3353         struct B { void g(); };
3354         void (B::*p)();
3355         void B::g() { (this->*p)(); }  */
3356
3357   /* This code is not really correct (for example, it does not
3358      handle the case that `A::f' is overloaded), but it is
3359      historically how we have handled this situation.  */
3360   if (TREE_CODE (TREE_OPERAND (fn, 1)) == FIELD_DECL)
3361     /* This case should now be handled elsewhere.  */
3362     abort ();
3363   else
3364     {
3365       object_addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (fn, 0), 0);
3366       fn = TREE_OPERAND (fn, 1);
3367       fn = get_member_function_from_ptrfunc (&object_addr, fn);
3368       args = tree_cons (NULL_TREE, object_addr, args);
3369     }
3370   return build_function_call (fn, args);
3371 }
3372
3373 /* FN indicates the function to call.  Name resolution has been
3374    performed on FN.  ARGS are the arguments to the function.  They
3375    have already been semantically analyzed.  DISALLOW_VIRTUAL is true
3376    if the function call should be determined at compile time, even if
3377    FN is virtual.  */
3378
3379 tree
3380 build_call_from_tree (tree fn, tree args, bool disallow_virtual)
3381 {
3382   tree template_args;
3383   tree template_id;
3384   tree f;
3385
3386   /* Check to see that name lookup has already been performed.  */
3387   my_friendly_assert (TREE_CODE (fn) != OFFSET_REF, 20020725);
3388   my_friendly_assert (TREE_CODE (fn) != SCOPE_REF, 20020725);
3389
3390   /* In the future all of this should be eliminated.  Instead,
3391      name-lookup for a member function should simply return a
3392      baselink, instead of a FUNCTION_DECL, TEMPLATE_DECL, or
3393      TEMPLATE_ID_EXPR.  */
3394
3395   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3396     {
3397       template_id = fn;
3398       template_args = TREE_OPERAND (fn, 1);
3399       fn = TREE_OPERAND (fn, 0);
3400     }
3401   else
3402     {
3403       template_id = NULL_TREE;
3404       template_args = NULL_TREE;
3405     }
3406
3407   f = (TREE_CODE (fn) == OVERLOAD) ? get_first_fn (fn) : fn;
3408   /* Make sure we have a baselink (rather than simply a
3409      FUNCTION_DECL) for a member function.  */
3410   if (current_class_type
3411       && ((TREE_CODE (f) == FUNCTION_DECL
3412            && DECL_FUNCTION_MEMBER_P (f))
3413           || (DECL_FUNCTION_TEMPLATE_P (f)
3414               && DECL_FUNCTION_MEMBER_P (f))))
3415     {
3416       f = lookup_member (current_class_type, DECL_NAME (f),
3417                          /*protect=*/1, /*want_type=*/false);
3418       if (f)
3419         fn = f;
3420     }
3421
3422   if (template_id)
3423     {
3424       if (BASELINK_P (fn))
3425           BASELINK_FUNCTIONS (fn) = build_nt (TEMPLATE_ID_EXPR,
3426                                               BASELINK_FUNCTIONS (fn),
3427                                               template_args);
3428       else
3429         fn = template_id;
3430     }
3431
3432   return finish_call_expr (fn, args, disallow_virtual);
3433 }
3434
3435 /* Returns true if ROOT (a namespace, class, or function) encloses
3436    CHILD.  CHILD may be either a class type or a namespace.  */
3437
3438 bool
3439 is_ancestor (tree root, tree child)
3440 {
3441   my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
3442                        || TREE_CODE (root) == FUNCTION_DECL
3443                        || CLASS_TYPE_P (root)), 20030307);
3444   my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
3445                        || CLASS_TYPE_P (child)),
3446                       20030307);
3447
3448   /* The global namespace encloses everything.  */
3449   if (root == global_namespace)
3450     return true;
3451
3452   while (true)
3453     {
3454       /* If we've run out of scopes, stop.  */
3455       if (!child)
3456         return false;
3457       /* If we've reached the ROOT, it encloses CHILD.  */
3458       if (root == child)
3459         return true;
3460       /* Go out one level.  */
3461       if (TYPE_P (child))
3462         child = TYPE_NAME (child);
3463       child = DECL_CONTEXT (child);
3464     }
3465 }
3466
3467
3468 /* Return the namespace that is the common ancestor
3469    of two given namespaces.  */
3470
3471 tree
3472 namespace_ancestor (tree ns1, tree ns2)
3473 {
3474   timevar_push (TV_NAME_LOOKUP);
3475   if (is_ancestor (ns1, ns2))
3476     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3477   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3478                           namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3479 }
3480
3481 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3482    directive is not directly from the source. Also find the common
3483    ancestor and let our users know about the new namespace */
3484 static void
3485 add_using_namespace (tree user, tree used, bool indirect)
3486 {
3487   tree t;
3488   timevar_push (TV_NAME_LOOKUP);
3489   /* Using oneself is a no-op.  */
3490   if (user == used)
3491     {
3492       timevar_pop (TV_NAME_LOOKUP);
3493       return;
3494     }
3495   my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3496   my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3497   /* Check if we already have this.  */
3498   t = purpose_member (used, DECL_NAMESPACE_USING (user));
3499   if (t != NULL_TREE)
3500     {
3501       if (!indirect)
3502         /* Promote to direct usage.  */
3503         TREE_INDIRECT_USING (t) = 0;
3504       timevar_pop (TV_NAME_LOOKUP);
3505       return;
3506     }
3507
3508   /* Add used to the user's using list.  */
3509   DECL_NAMESPACE_USING (user)
3510     = tree_cons (used, namespace_ancestor (user, used),
3511                  DECL_NAMESPACE_USING (user));
3512
3513   TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3514
3515   /* Add user to the used's users list.  */
3516   DECL_NAMESPACE_USERS (used)
3517     = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3518
3519   /* Recursively add all namespaces used.  */
3520   for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3521     /* indirect usage */
3522     add_using_namespace (user, TREE_PURPOSE (t), 1);
3523
3524   /* Tell everyone using us about the new used namespaces.  */
3525   for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3526     add_using_namespace (TREE_PURPOSE (t), used, 1);
3527   timevar_pop (TV_NAME_LOOKUP);
3528 }
3529
3530 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3531    duplicates.  The first list becomes the tail of the result.
3532
3533    The algorithm is O(n^2).  We could get this down to O(n log n) by
3534    doing a sort on the addresses of the functions, if that becomes
3535    necessary.  */
3536
3537 static tree
3538 merge_functions (tree s1, tree s2)
3539 {
3540   for (; s2; s2 = OVL_NEXT (s2))
3541     {
3542       tree fn2 = OVL_CURRENT (s2);
3543       tree fns1;
3544
3545       for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3546         {
3547           tree fn1 = OVL_CURRENT (fns1);
3548
3549           /* If the function from S2 is already in S1, there is no
3550              need to add it again.  For `extern "C"' functions, we
3551              might have two FUNCTION_DECLs for the same function, in
3552              different namespaces; again, we only need one of them.  */
3553           if (fn1 == fn2
3554               || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3555                   && DECL_NAME (fn1) == DECL_NAME (fn2)))
3556             break;
3557         }
3558
3559       /* If we exhausted all of the functions in S1, FN2 is new.  */
3560       if (!fns1)
3561         s1 = build_overload (fn2, s1);
3562     }
3563   return s1;
3564 }
3565
3566 /* This should return an error not all definitions define functions.
3567    It is not an error if we find two functions with exactly the
3568    same signature, only if these are selected in overload resolution.
3569    old is the current set of bindings, new the freshly-found binding.
3570    XXX Do we want to give *all* candidates in case of ambiguity?
3571    XXX In what way should I treat extern declarations?
3572    XXX I don't want to repeat the entire duplicate_decls here */
3573
3574 static cxx_binding *
3575 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3576 {
3577   tree val, type;
3578   my_friendly_assert (old != NULL, 393);
3579   /* Copy the value.  */
3580   val = BINDING_VALUE (new);
3581   if (val)
3582     switch (TREE_CODE (val))
3583       {
3584       case TEMPLATE_DECL:
3585         /* If we expect types or namespaces, and not templates,
3586            or this is not a template class.  */
3587         if (LOOKUP_QUALIFIERS_ONLY (flags)
3588             && !DECL_CLASS_TEMPLATE_P (val))
3589           val = NULL_TREE;
3590         break;
3591       case TYPE_DECL:
3592         if (LOOKUP_NAMESPACES_ONLY (flags))
3593           val = NULL_TREE;
3594         break;
3595       case NAMESPACE_DECL:
3596         if (LOOKUP_TYPES_ONLY (flags))
3597           val = NULL_TREE;
3598         break;
3599       case FUNCTION_DECL:
3600         /* Ignore built-in functions that are still anticipated.  */
3601         if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3602           val = NULL_TREE;
3603         break;
3604       default:
3605         if (LOOKUP_QUALIFIERS_ONLY (flags))
3606           val = NULL_TREE;
3607       }
3608
3609   if (!BINDING_VALUE (old))
3610     BINDING_VALUE (old) = val;
3611   else if (val && val != BINDING_VALUE (old))
3612     {
3613       if (is_overloaded_fn (BINDING_VALUE (old)) && is_overloaded_fn (val))
3614         BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old), val);
3615       else
3616         {
3617           /* Some declarations are functions, some are not.  */
3618           if (flags & LOOKUP_COMPLAIN)
3619             {
3620               /* If we've already given this error for this lookup,
3621                  BINDING_VALUE (old) is error_mark_node, so let's not
3622                  repeat ourselves.  */
3623               if (BINDING_VALUE (old) != error_mark_node)
3624                 {
3625                   error ("use of `%D' is ambiguous", name);
3626                   cp_error_at ("  first declared as `%#D' here",
3627                                BINDING_VALUE (old));
3628                 }
3629               cp_error_at ("  also declared as `%#D' here", val);
3630             }
3631           BINDING_VALUE (old) = error_mark_node;
3632         }
3633     }
3634   /* ... and copy the type.  */
3635   type = BINDING_TYPE (new);
3636   if (LOOKUP_NAMESPACES_ONLY (flags))
3637     type = NULL_TREE;
3638   if (!BINDING_TYPE (old))
3639     BINDING_TYPE (old) = type;
3640   else if (type && BINDING_TYPE (old) != type)
3641     {
3642       if (flags & LOOKUP_COMPLAIN)
3643         {
3644           error ("`%D' denotes an ambiguous type",name);
3645           cp_error_at ("  first type here", BINDING_TYPE (old));
3646           cp_error_at ("  other type here", type);
3647         }
3648     }
3649   return old;
3650 }
3651
3652 /* Subroutine of unualified_namespace_lookup:
3653    Add the bindings of NAME in used namespaces to VAL.
3654    We are currently looking for names in namespace SCOPE, so we
3655    look through USINGS for using-directives of namespaces
3656    which have SCOPE as a common ancestor with the current scope.
3657    Returns false on errors.  */
3658
3659 bool
3660 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3661                         int flags, tree *spacesp)
3662 {
3663   tree iter;
3664   timevar_push (TV_NAME_LOOKUP);
3665   /* Iterate over all used namespaces in current, searching for using
3666      directives of scope.  */
3667   for (iter = usings; iter; iter = TREE_CHAIN (iter))
3668     if (TREE_VALUE (iter) == scope)
3669       {
3670         tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3671         cxx_binding *val1 =
3672           cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3673         if (spacesp)
3674           *spacesp = tree_cons (used, NULL_TREE, *spacesp);
3675         /* Resolve ambiguities.  */
3676         if (val1)
3677           val = ambiguous_decl (name, val, val1, flags);
3678       }
3679   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3680                           BINDING_VALUE (val) != error_mark_node);
3681 }
3682
3683 /* [namespace.qual]
3684    Accepts the NAME to lookup and its qualifying SCOPE.
3685    Returns the name/type pair found into the cxx_binding *RESULT,
3686    or false on error.  */
3687
3688 bool
3689 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3690                                   int flags)
3691 {
3692   /* Maintain a list of namespaces visited...  */
3693   tree seen = NULL_TREE;
3694   /* ... and a list of namespace yet to see.  */
3695   tree todo = NULL_TREE;
3696   tree usings;
3697   timevar_push (TV_NAME_LOOKUP);
3698   /* Look through namespace aliases.  */
3699   scope = ORIGINAL_NAMESPACE (scope);
3700   while (scope && result->value != error_mark_node)
3701     {
3702       cxx_binding *binding =
3703         cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3704       seen = tree_cons (scope, NULL_TREE, seen);
3705       if (binding)
3706         result = ambiguous_decl (name, result, binding, flags);
3707       if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
3708         /* Consider using directives.  */
3709         for (usings = DECL_NAMESPACE_USING (scope); usings;
3710              usings = TREE_CHAIN (usings))
3711           /* If this was a real directive, and we have not seen it.  */
3712           if (!TREE_INDIRECT_USING (usings)
3713               && !purpose_member (TREE_PURPOSE (usings), seen))
3714             todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3715       if (todo)
3716         {
3717           scope = TREE_PURPOSE (todo);
3718           todo = TREE_CHAIN (todo);
3719         }
3720       else
3721         scope = NULL_TREE; /* If there never was a todo list.  */
3722     }
3723   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3724 }
3725
3726 /* [namespace.memdef]/2 */
3727
3728 /* Set the context of a declaration to scope. Complain if we are not
3729    outside scope.  */
3730
3731 void
3732 set_decl_namespace (tree decl, tree scope, bool friendp)
3733 {
3734   tree old;
3735
3736   /* Get rid of namespace aliases.  */
3737   scope = ORIGINAL_NAMESPACE (scope);
3738
3739   /* It is ok for friends to be qualified in parallel space.  */
3740   if (!friendp && !is_ancestor (current_namespace, scope))
3741     error ("declaration of `%D' not in a namespace surrounding `%D'",
3742               decl, scope);
3743   DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3744   if (scope != current_namespace)
3745     {
3746       /* See whether this has been declared in the namespace.  */
3747       old = namespace_binding (DECL_NAME (decl), scope);
3748       if (!old)
3749         /* No old declaration at all.  */
3750         goto complain;
3751       /* A template can be explicitly specialized in any namespace.  */
3752       if (processing_explicit_instantiation)
3753         return;
3754       if (!is_overloaded_fn (decl))
3755         /* Don't compare non-function decls with decls_match here,
3756            since it can't check for the correct constness at this
3757            point. pushdecl will find those errors later.  */
3758         return;
3759       /* Since decl is a function, old should contain a function decl.  */
3760       if (!is_overloaded_fn (old))
3761         goto complain;
3762       if (processing_template_decl || processing_specialization)
3763         /* We have not yet called push_template_decl to turn a
3764            FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
3765            won't match.  But, we'll check later, when we construct the
3766            template.  */
3767         return;
3768       if (is_overloaded_fn (old))
3769         {
3770           for (; old; old = OVL_NEXT (old))
3771             if (decls_match (decl, OVL_CURRENT (old)))
3772               return;
3773         }
3774       else
3775         if (decls_match (decl, old))
3776           return;
3777     }
3778   else
3779     return;
3780  complain:
3781   error ("`%D' should have been declared inside `%D'",
3782             decl, scope);
3783 }
3784
3785 /* Compute the namespace where a declaration is defined.  */
3786
3787 static tree
3788 decl_namespace (tree decl)
3789 {
3790   timevar_push (TV_NAME_LOOKUP);
3791   if (TYPE_P (decl))
3792     decl = TYPE_STUB_DECL (decl);
3793   while (DECL_CONTEXT (decl))
3794     {
3795       decl = DECL_CONTEXT (decl);
3796       if (TREE_CODE (decl) == NAMESPACE_DECL)
3797         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
3798       if (TYPE_P (decl))
3799         decl = TYPE_STUB_DECL (decl);
3800       my_friendly_assert (DECL_P (decl), 390);
3801     }
3802
3803   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, global_namespace);
3804 }
3805
3806 /* Return the namespace where the current declaration is declared.  */
3807
3808 tree
3809 current_decl_namespace (void)
3810 {
3811   tree result;
3812   /* If we have been pushed into a different namespace, use it.  */
3813   if (decl_namespace_list)
3814     return TREE_PURPOSE (decl_namespace_list);
3815
3816   if (current_class_type)
3817     result = decl_namespace (TYPE_STUB_DECL (current_class_type));
3818   else if (current_function_decl)
3819     result = decl_namespace (current_function_decl);
3820   else
3821     result = current_namespace;
3822   return result;
3823 }
3824
3825 /* Temporarily set the namespace for the current declaration.  */
3826
3827 void
3828 push_decl_namespace (tree decl)
3829 {
3830   if (TREE_CODE (decl) != NAMESPACE_DECL)
3831     decl = decl_namespace (decl);
3832   decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3833                                    NULL_TREE, decl_namespace_list);
3834 }
3835
3836 void
3837 pop_decl_namespace (void)
3838 {
3839   decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3840 }
3841
3842 /* Enter a class or namespace scope.  */
3843
3844 void
3845 push_scope (tree t)
3846 {
3847   if (TREE_CODE (t) == NAMESPACE_DECL)
3848     push_decl_namespace (t);
3849   else if CLASS_TYPE_P (t)
3850     push_nested_class (t);
3851 }
3852
3853 /* Leave scope pushed by push_scope.  */
3854
3855 void
3856 pop_scope (tree t)
3857 {
3858   if (TREE_CODE (t) == NAMESPACE_DECL)
3859     pop_decl_namespace ();
3860   else if CLASS_TYPE_P (t)
3861     pop_nested_class ();
3862 }
3863
3864 /* [basic.lookup.koenig] */
3865 /* A nonzero return value in the functions below indicates an error.  */
3866
3867 struct arg_lookup
3868 {
3869   tree name;
3870   tree namespaces;
3871   tree classes;
3872   tree functions;
3873 };
3874
3875 static bool arg_assoc (struct arg_lookup*, tree);
3876 static bool arg_assoc_args (struct arg_lookup*, tree);
3877 static bool arg_assoc_type (struct arg_lookup*, tree);
3878 static bool add_function (struct arg_lookup *, tree);
3879 static bool arg_assoc_namespace (struct arg_lookup *, tree);
3880 static bool arg_assoc_class (struct arg_lookup *, tree);
3881 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
3882
3883 /* Add a function to the lookup structure.
3884    Returns true on error.  */
3885
3886 static bool
3887 add_function (struct arg_lookup *k, tree fn)
3888 {
3889   /* We used to check here to see if the function was already in the list,
3890      but that's O(n^2), which is just too expensive for function lookup.
3891      Now we deal with the occasional duplicate in joust.  In doing this, we
3892      assume that the number of duplicates will be small compared to the
3893      total number of functions being compared, which should usually be the
3894      case.  */
3895
3896   /* We must find only functions, or exactly one non-function.  */
3897   if (!k->functions)
3898     k->functions = fn;
3899   else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
3900     k->functions = build_overload (fn, k->functions);
3901   else
3902     {
3903       tree f1 = OVL_CURRENT (k->functions);
3904       tree f2 = fn;
3905       if (is_overloaded_fn (f1))
3906         {
3907           fn = f1; f1 = f2; f2 = fn;
3908         }
3909       cp_error_at ("`%D' is not a function,", f1);
3910       cp_error_at ("  conflict with `%D'", f2);
3911       error ("  in call to `%D'", k->name);
3912       return true;
3913     }
3914
3915   return false;
3916 }
3917
3918 /* Add functions of a namespace to the lookup structure.
3919    Returns true on error.  */
3920
3921 static bool
3922 arg_assoc_namespace (struct arg_lookup *k, tree scope)
3923 {
3924   tree value;
3925
3926   if (purpose_member (scope, k->namespaces))
3927     return 0;
3928   k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
3929
3930   value = namespace_binding (k->name, scope);
3931   if (!value)
3932     return false;
3933
3934   for (; value; value = OVL_NEXT (value))
3935     if (add_function (k, OVL_CURRENT (value)))
3936       return true;
3937
3938   return false;
3939 }
3940
3941 /* Adds everything associated with a template argument to the lookup
3942    structure.  Returns true on error.  */
3943
3944 static bool
3945 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
3946 {
3947   /* [basic.lookup.koenig]
3948
3949      If T is a template-id, its associated namespaces and classes are
3950      ... the namespaces and classes associated with the types of the
3951      template arguments provided for template type parameters
3952      (excluding template template parameters); the namespaces in which
3953      any template template arguments are defined; and the classes in
3954      which any member templates used as template template arguments
3955      are defined.  [Note: non-type template arguments do not
3956      contribute to the set of associated namespaces.  ]  */
3957
3958   /* Consider first template template arguments.  */
3959   if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3960       || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
3961     return false;
3962   else if (TREE_CODE (arg) == TEMPLATE_DECL)
3963     {
3964       tree ctx = CP_DECL_CONTEXT (arg);
3965
3966       /* It's not a member template.  */
3967       if (TREE_CODE (ctx) == NAMESPACE_DECL)
3968         return arg_assoc_namespace (k, ctx);
3969       /* Otherwise, it must be member template.  */
3970       else
3971         return arg_assoc_class (k, ctx);
3972     }
3973   /* It's not a template template argument, but it is a type template
3974      argument.  */
3975   else if (TYPE_P (arg))
3976     return arg_assoc_type (k, arg);
3977   /* It's a non-type template argument.  */
3978   else
3979     return false;
3980 }
3981
3982 /* Adds everything associated with class to the lookup structure.
3983    Returns true on error.  */
3984
3985 static bool
3986 arg_assoc_class (struct arg_lookup *k, tree type)
3987 {
3988   tree list, friends, context;
3989   int i;
3990
3991   /* Backend build structures, such as __builtin_va_list, aren't
3992      affected by all this.  */
3993   if (!CLASS_TYPE_P (type))
3994     return false;
3995
3996   if (purpose_member (type, k->classes))
3997     return false;
3998   k->classes = tree_cons (type, NULL_TREE, k->classes);
3999
4000   context = decl_namespace (TYPE_MAIN_DECL (type));
4001   if (arg_assoc_namespace (k, context))
4002     return true;
4003
4004   /* Process baseclasses.  */
4005   for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
4006     if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
4007       return true;
4008
4009   /* Process friends.  */
4010   for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4011        list = TREE_CHAIN (list))
4012     if (k->name == FRIEND_NAME (list))
4013       for (friends = FRIEND_DECLS (list); friends;
4014            friends = TREE_CHAIN (friends))
4015         /* Only interested in global functions with potentially hidden
4016            (i.e. unqualified) declarations.  */
4017         if (CP_DECL_CONTEXT (TREE_VALUE (friends)) == context)
4018           if (add_function (k, TREE_VALUE (friends)))
4019             return true;
4020
4021   /* Process template arguments.  */
4022   if (CLASSTYPE_TEMPLATE_INFO (type))
4023     {
4024       list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4025       for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4026         arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4027     }
4028
4029   return false;
4030 }
4031
4032 /* Adds everything associated with a given type.
4033    Returns 1 on error.  */
4034
4035 static bool
4036 arg_assoc_type (struct arg_lookup *k, tree type)
4037 {
4038   switch (TREE_CODE (type))
4039     {
4040     case ERROR_MARK:
4041       return false;
4042     case VOID_TYPE:
4043     case INTEGER_TYPE:
4044     case REAL_TYPE:
4045     case COMPLEX_TYPE:
4046     case VECTOR_TYPE:
4047     case CHAR_TYPE:
4048     case BOOLEAN_TYPE:
4049       return false;
4050     case RECORD_TYPE:
4051       if (TYPE_PTRMEMFUNC_P (type))
4052         return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4053       return arg_assoc_class (k, type);
4054     case POINTER_TYPE:
4055     case REFERENCE_TYPE:
4056     case ARRAY_TYPE:
4057       return arg_assoc_type (k, TREE_TYPE (type));
4058     case UNION_TYPE:
4059     case ENUMERAL_TYPE:
4060       return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
4061     case OFFSET_TYPE:
4062       /* Pointer to member: associate class type and value type.  */
4063       if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
4064         return true;
4065       return arg_assoc_type (k, TREE_TYPE (type));
4066     case METHOD_TYPE:
4067       /* The basetype is referenced in the first arg type, so just
4068          fall through.  */
4069     case FUNCTION_TYPE:
4070       /* Associate the parameter types.  */
4071       if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4072         return true;
4073       /* Associate the return type.  */
4074       return arg_assoc_type (k, TREE_TYPE (type));
4075     case TEMPLATE_TYPE_PARM:
4076     case BOUND_TEMPLATE_TEMPLATE_PARM:
4077       return false;
4078     case TYPENAME_TYPE:
4079       return false;
4080     case LANG_TYPE:
4081       if (type == unknown_type_node)
4082         return false;
4083       /* else fall through */
4084     default:
4085       abort ();
4086     }
4087   return false;
4088 }
4089
4090 /* Adds everything associated with arguments.  Returns true on error.  */
4091
4092 static bool
4093 arg_assoc_args (struct arg_lookup *k, tree args)
4094 {
4095   for (; args; args = TREE_CHAIN (args))
4096     if (arg_assoc (k, TREE_VALUE (args)))
4097       return true;
4098   return false;
4099 }
4100
4101 /* Adds everything associated with a given tree_node.  Returns 1 on error.  */
4102
4103 static bool
4104 arg_assoc (struct arg_lookup *k, tree n)
4105 {
4106   if (n == error_mark_node)
4107     return false;
4108
4109   if (TYPE_P (n))
4110     return arg_assoc_type (k, n);
4111
4112   if (! type_unknown_p (n))
4113     return arg_assoc_type (k, TREE_TYPE (n));
4114
4115   if (TREE_CODE (n) == ADDR_EXPR)
4116     n = TREE_OPERAND (n, 0);
4117   if (TREE_CODE (n) == COMPONENT_REF)
4118     n = TREE_OPERAND (n, 1);
4119   if (TREE_CODE (n) == OFFSET_REF)
4120     n = TREE_OPERAND (n, 1);
4121   while (TREE_CODE (n) == TREE_LIST)
4122     n = TREE_VALUE (n);
4123   if (TREE_CODE (n) == BASELINK)
4124     n = BASELINK_FUNCTIONS (n);
4125
4126   if (TREE_CODE (n) == FUNCTION_DECL)
4127     return arg_assoc_type (k, TREE_TYPE (n));
4128   if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4129     {
4130       /* [basic.lookup.koenig]
4131
4132          If T is a template-id, its associated namespaces and classes
4133          are the namespace in which the template is defined; for
4134          member templates, the member template's class...  */
4135       tree template = TREE_OPERAND (n, 0);
4136       tree args = TREE_OPERAND (n, 1);
4137       tree ctx;
4138       tree arg;
4139
4140       if (TREE_CODE (template) == COMPONENT_REF)
4141         template = TREE_OPERAND (template, 1);
4142
4143       /* First, the template.  There may actually be more than one if
4144          this is an overloaded function template.  But, in that case,
4145          we only need the first; all the functions will be in the same
4146          namespace.  */
4147       template = OVL_CURRENT (template);
4148
4149       ctx = CP_DECL_CONTEXT (template);
4150
4151       if (TREE_CODE (ctx) == NAMESPACE_DECL)
4152         {
4153           if (arg_assoc_namespace (k, ctx) == 1)
4154             return true;
4155         }
4156       /* It must be a member template.  */
4157       else if (arg_assoc_class (k, ctx) == 1)
4158         return true;
4159
4160       /* Now the arguments.  */
4161       for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg))
4162         if (arg_assoc_template_arg (k, TREE_VALUE (arg)) == 1)
4163           return true;
4164     }
4165   else
4166     {
4167       my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715);
4168
4169       for (; n; n = OVL_CHAIN (n))
4170         if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4171           return true;
4172     }
4173
4174   return false;
4175 }
4176
4177 /* Performs Koenig lookup depending on arguments, where fns
4178    are the functions found in normal lookup.  */
4179
4180 tree
4181 lookup_arg_dependent (tree name, tree fns, tree args)
4182 {
4183   struct arg_lookup k;
4184   tree fn = NULL_TREE;
4185
4186   timevar_push (TV_NAME_LOOKUP);
4187   k.name = name;
4188   k.functions = fns;
4189   k.classes = NULL_TREE;
4190
4191   /* Note that we've already looked at some namespaces during normal
4192      unqualified lookup, unless we found a decl in function scope.  */
4193   if (fns)
4194     fn = OVL_CURRENT (fns);
4195   if (fn && TREE_CODE (fn) == FUNCTION_DECL && DECL_LOCAL_FUNCTION_P (fn))
4196     k.namespaces = NULL_TREE;
4197   else
4198     unqualified_namespace_lookup (name, 0, &k.namespaces);
4199
4200   arg_assoc_args (&k, args);
4201   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4202 }
4203
4204 /* Process a namespace-alias declaration.  */
4205
4206 void
4207 do_namespace_alias (tree alias, tree namespace)
4208 {
4209   if (TREE_CODE (namespace) != NAMESPACE_DECL)
4210     {
4211       /* The parser did not find it, so it's not there.  */
4212       error ("unknown namespace `%D'", namespace);
4213       return;
4214     }
4215
4216   namespace = ORIGINAL_NAMESPACE (namespace);
4217
4218   /* Build the alias.  */
4219   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
4220   DECL_NAMESPACE_ALIAS (alias) = namespace;
4221   DECL_EXTERNAL (alias) = 1;
4222   pushdecl (alias);
4223 }
4224
4225 /* Check a non-member using-declaration. Return the name and scope
4226    being used, and the USING_DECL, or NULL_TREE on failure.  */
4227
4228 static tree
4229 validate_nonmember_using_decl (tree decl, tree *scope, tree *name)
4230 {
4231   *scope = global_namespace;
4232   *name = NULL_TREE;
4233
4234   if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
4235     {
4236       *name = TREE_OPERAND (decl, 0);
4237       /* 7.3.3/5
4238            A using-declaration shall not name a template-id.  */
4239       error ("a using-declaration cannot specify a template-id.  Try `using %D'", *name);
4240       return NULL_TREE;
4241     }
4242
4243   if (TREE_CODE (decl) == NAMESPACE_DECL)
4244     {
4245       error ("namespace `%D' not allowed in using-declaration", decl);
4246       return NULL_TREE;
4247     }
4248
4249   if (TREE_CODE (decl) == SCOPE_REF)
4250     {
4251       /* It's a nested name with template parameter dependent scope.
4252          This can only be using-declaration for class member.  */
4253       error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
4254       return NULL_TREE;
4255     }
4256
4257   if (is_overloaded_fn (decl))
4258     decl = get_first_fn (decl);
4259
4260   my_friendly_assert (DECL_P (decl), 20020908);
4261
4262   if (TREE_CODE (decl) == CONST_DECL)
4263     /* Enumeration constants to not have DECL_CONTEXT set.  */
4264     *scope = TYPE_CONTEXT (TREE_TYPE (decl));
4265   else
4266     *scope = DECL_CONTEXT (decl);
4267   if (!*scope)
4268     *scope = global_namespace;
4269
4270   /* [namespace.udecl]
4271        A using-declaration for a class member shall be a
4272        member-declaration.  */
4273   if (TYPE_P (*scope))
4274     {
4275       error ("`%T' is not a namespace", *scope);
4276       return NULL_TREE;
4277     }
4278   *name = DECL_NAME (decl);
4279   /* Make a USING_DECL. */
4280   return push_using_decl (*scope, *name);
4281 }
4282
4283 /* Process local and global using-declarations.  */
4284
4285 static void
4286 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
4287                          tree *newval, tree *newtype)
4288 {
4289   cxx_binding decls;
4290
4291   *newval = *newtype = NULL_TREE;
4292   cxx_binding_clear (&decls);
4293   if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
4294     /* Lookup error */
4295     return;
4296
4297   if (!decls.value && !decls.type)
4298     {
4299       error ("`%D' not declared", name);
4300       return;
4301     }
4302
4303   /* Check for using functions.  */
4304   if (decls.value && is_overloaded_fn (decls.value))
4305     {
4306       tree tmp, tmp1;
4307
4308       if (oldval && !is_overloaded_fn (oldval))
4309         {
4310           if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
4311             error ("`%D' is already declared in this scope", name);
4312           oldval = NULL_TREE;
4313         }
4314
4315       *newval = oldval;
4316       for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
4317         {
4318           tree new_fn = OVL_CURRENT (tmp);
4319
4320           /* [namespace.udecl]
4321
4322              If a function declaration in namespace scope or block
4323              scope has the same name and the same parameter types as a
4324              function introduced by a using declaration the program is
4325              ill-formed.  */
4326           for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
4327             {
4328               tree old_fn = OVL_CURRENT (tmp1);
4329
4330               if (new_fn == old_fn)
4331                 /* The function already exists in the current namespace.  */
4332                 break;
4333               else if (OVL_USED (tmp1))
4334                 continue; /* this is a using decl */
4335               else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
4336                                   TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
4337                 {
4338                   /* There was already a non-using declaration in
4339                      this scope with the same parameter types. If both
4340                      are the same extern "C" functions, that's ok.  */
4341                   if (decls_match (new_fn, old_fn))
4342                     {
4343                       /* If the OLD_FN was a builtin, there is now a
4344                          real declaration.  */
4345                       if (DECL_ANTICIPATED (old_fn))
4346                         DECL_ANTICIPATED (old_fn) = 0;
4347                       break;
4348                     }
4349                   else if (!DECL_ANTICIPATED (old_fn))
4350                     {
4351                       /* If the OLD_FN was really declared, the
4352                          declarations don't match.  */
4353                       error ("`%D' is already declared in this scope", name);
4354                       break;
4355                     }
4356
4357                   /* If the OLD_FN was not really there, just ignore
4358                      it and keep going.  */
4359                 }
4360             }
4361
4362           /* If we broke out of the loop, there's no reason to add
4363              this function to the using declarations for this
4364              scope.  */
4365           if (tmp1)
4366             continue;
4367
4368           *newval = build_overload (OVL_CURRENT (tmp), *newval);
4369           if (TREE_CODE (*newval) != OVERLOAD)
4370             *newval = ovl_cons (*newval, NULL_TREE);
4371           OVL_USED (*newval) = 1;
4372         }
4373     }
4374   else
4375     {
4376       *newval = decls.value;
4377       if (oldval && !decls_match (*newval, oldval))
4378         error ("`%D' is already declared in this scope", name);
4379     }
4380
4381   *newtype = decls.type;
4382   if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
4383     {
4384       error ("using declaration `%D' introduced ambiguous type `%T'",
4385                 name, oldtype);
4386       return;
4387     }
4388 }
4389
4390 /* Process a using-declaration not appearing in class or local scope.  */
4391
4392 void
4393 do_toplevel_using_decl (tree decl)
4394 {
4395   tree scope, name;
4396   tree oldval, oldtype, newval, newtype;
4397   cxx_binding *binding;
4398
4399   decl = validate_nonmember_using_decl (decl, &scope, &name);
4400   if (decl == NULL_TREE)
4401     return;
4402
4403   binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
4404
4405   oldval = BINDING_VALUE (binding);
4406   oldtype = BINDING_TYPE (binding);
4407
4408   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
4409
4410   /* Copy declarations found.  */
4411   if (newval)
4412     BINDING_VALUE (binding) = newval;
4413   if (newtype)
4414     BINDING_TYPE (binding) = newtype;
4415   return;
4416 }
4417
4418 /* Process a using-declaration at function scope.  */
4419
4420 void
4421 do_local_using_decl (tree decl)
4422 {
4423   tree scope, name;
4424   tree oldval, oldtype, newval, newtype;
4425
4426   decl = validate_nonmember_using_decl (decl, &scope, &name);
4427   if (decl == NULL_TREE)
4428     return;
4429
4430   if (building_stmt_tree ()
4431       && at_function_scope_p ())
4432     add_decl_stmt (decl);
4433
4434   oldval = lookup_name_current_level (name);
4435   oldtype = lookup_type_current_level (name);
4436
4437   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
4438
4439   if (newval)
4440     {
4441       if (is_overloaded_fn (newval))
4442         {
4443           tree fn, term;
4444
4445           /* We only need to push declarations for those functions
4446              that were not already bound in the current level.
4447              The old value might be NULL_TREE, it might be a single
4448              function, or an OVERLOAD.  */
4449           if (oldval && TREE_CODE (oldval) == OVERLOAD)
4450             term = OVL_FUNCTION (oldval);
4451           else
4452             term = oldval;
4453           for (fn = newval; fn && OVL_CURRENT (fn) != term;
4454                fn = OVL_NEXT (fn))
4455             push_overloaded_decl (OVL_CURRENT (fn),
4456                                   PUSH_LOCAL | PUSH_USING);
4457         }
4458       else
4459         push_local_binding (name, newval, PUSH_USING);
4460     }
4461   if (newtype)
4462     set_identifier_type_value (name, newtype);
4463 }
4464
4465 tree
4466 do_class_using_decl (tree decl)
4467 {
4468   tree name, value;
4469
4470   if (TREE_CODE (decl) != SCOPE_REF
4471       || !TREE_OPERAND (decl, 0)
4472       || !TYPE_P (TREE_OPERAND (decl, 0)))
4473     {
4474       error ("using-declaration for non-member at class scope");
4475       return NULL_TREE;
4476     }
4477   name = TREE_OPERAND (decl, 1);
4478   if (TREE_CODE (name) == BIT_NOT_EXPR)
4479     {
4480       error ("using-declaration for destructor");
4481       return NULL_TREE;
4482     }
4483   else if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
4484     {
4485       name = TREE_OPERAND (name, 0);
4486       error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'", TREE_OPERAND (decl, 0), name);
4487       return NULL_TREE;
4488     }
4489   if (TREE_CODE (name) == TYPE_DECL)
4490     {
4491       tree type = TREE_TYPE (name);
4492       if (CLASSTYPE_USE_TEMPLATE (TREE_TYPE (name)))
4493         {
4494           name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
4495           error ("a using-declaration cannot specify a template-id.");
4496           return NULL_TREE;
4497         }
4498       name = DECL_NAME (name);
4499     }
4500   else if (TREE_CODE (name) == TEMPLATE_DECL)
4501      name = DECL_NAME (name);
4502   else if (BASELINK_P (name))
4503     {
4504       tree fns;
4505
4506       fns = BASELINK_FUNCTIONS (name);
4507       if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
4508         {
4509           fns = TREE_OPERAND (fns, 0);
4510           error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'",
4511                  BASELINK_ACCESS_BINFO (name),
4512                  DECL_NAME (get_first_fn (fns)));
4513         }
4514       name = DECL_NAME (get_first_fn (fns));
4515     }
4516
4517   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
4518
4519   value = build_lang_decl (USING_DECL, name, void_type_node);
4520   DECL_INITIAL (value) = TREE_OPERAND (decl, 0);
4521   return value;
4522 }
4523
4524 /* Process a using-directive.  */
4525
4526 void
4527 do_using_directive (tree namespace)
4528 {
4529   if (building_stmt_tree ())
4530     add_stmt (build_stmt (USING_STMT, namespace));
4531
4532   /* using namespace A::B::C; */
4533   if (TREE_CODE (namespace) == SCOPE_REF)
4534       namespace = TREE_OPERAND (namespace, 1);
4535   if (TREE_CODE (namespace) == IDENTIFIER_NODE)
4536     {
4537       /* Lookup in lexer did not find a namespace.  */
4538       if (!processing_template_decl)
4539         error ("namespace `%T' undeclared", namespace);
4540       return;
4541     }
4542   if (TREE_CODE (namespace) != NAMESPACE_DECL)
4543     {
4544       if (!processing_template_decl)
4545         error ("`%T' is not a namespace", namespace);
4546       return;
4547     }
4548   namespace = ORIGINAL_NAMESPACE (namespace);
4549   if (!toplevel_bindings_p ())
4550     push_using_directive (namespace);
4551   else
4552     /* direct usage */
4553     add_using_namespace (current_namespace, namespace, 0);
4554 }
4555
4556 void
4557 check_default_args (tree x)
4558 {
4559   tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
4560   bool saw_def = false;
4561   int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
4562   for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
4563     {
4564       if (TREE_PURPOSE (arg))
4565         saw_def = true;
4566       else if (saw_def)
4567         {
4568           cp_error_at ("default argument missing for parameter %P of `%+#D'",
4569                        i, x);
4570           break;
4571         }
4572     }
4573 }
4574
4575 void
4576 mark_used (tree decl)
4577 {
4578   TREE_USED (decl) = 1;
4579   if (processing_template_decl || skip_evaluation)
4580     return;
4581
4582   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4583       && !TREE_ASM_WRITTEN (decl))
4584     /* Remember it, so we can check it was defined.  */
4585     defer_fn (decl);
4586
4587   assemble_external (decl);
4588
4589   /* Is it a synthesized method that needs to be synthesized?  */
4590   if (TREE_CODE (decl) == FUNCTION_DECL
4591       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4592       && DECL_ARTIFICIAL (decl)
4593       && !DECL_THUNK_P (decl)
4594       && ! DECL_INITIAL (decl)
4595       /* Kludge: don't synthesize for default args.  */
4596       && current_function_decl)
4597     {
4598       synthesize_method (decl);
4599       /* If we've already synthesized the method we don't need to
4600          instantiate it, so we can return right away.  */
4601       return;
4602     }
4603
4604   /* If this is a function or variable that is an instance of some
4605      template, we now know that we will need to actually do the
4606      instantiation. We check that DECL is not an explicit
4607      instantiation because that is not checked in instantiate_decl.  */
4608   if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
4609       && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
4610       && (!DECL_EXPLICIT_INSTANTIATION (decl)
4611           || (TREE_CODE (decl) == FUNCTION_DECL
4612               && DECL_INLINE (DECL_TEMPLATE_RESULT
4613                               (template_for_substitution (decl))))))
4614     {
4615       bool defer;
4616
4617       /* Normally, we put off instantiating functions in order to
4618          improve compile times.  Maintaining a stack of active
4619          functions is expensive, and the inliner knows to
4620          instantiate any functions it might need.
4621
4622          However, if instantiating this function might help us mark
4623          the current function TREE_NOTHROW, we go ahead and
4624          instantiate it now.  */
4625       defer = (!flag_exceptions
4626                || TREE_CODE (decl) != FUNCTION_DECL
4627                /* If the called function can't throw, we don't need to
4628                   generate its body to find that out.  */
4629                || TREE_NOTHROW (decl)
4630                || !cfun
4631                /* If we already know the current function can't throw,
4632                   then we don't need to work hard to prove it.  */
4633                || TREE_NOTHROW (current_function_decl)
4634                /* If we already know that the current function *can*
4635                   throw, there's no point in gathering more
4636                   information.  */
4637                || cp_function_chain->can_throw);
4638
4639       instantiate_decl (decl, defer);
4640     }
4641 }
4642
4643 /* Called when a class-head is encountered.  TAG_KIND is the class-key
4644    for the class.  SCOPE, if non-NULL, is the type or namespace
4645    indicated in the nested-name-specifier for the declaration of the
4646    class.  ID is the name of the class, if any; it may be a TYPE_DECL,
4647    or an IDENTIFIER_NODE.  ATTRIBUTES are attributes that apply to the
4648    class.
4649
4650    Return a TYPE_DECL for the class being defined.  */
4651
4652 tree
4653 handle_class_head (enum tag_types tag_kind, tree scope, tree id,
4654                    tree attributes)
4655 {
4656   tree decl = NULL_TREE;
4657   tree current = current_scope ();
4658   bool xrefd_p = false;
4659   bool new_type_p;
4660   tree context;
4661
4662   if (current == NULL_TREE)
4663     current = current_namespace;
4664
4665   if (scope)
4666     {
4667       if (TREE_CODE (id) == TYPE_DECL)
4668         /* We must bash typedefs back to the main decl of the
4669            type. Otherwise we become confused about scopes.  */
4670         decl = TYPE_MAIN_DECL (TREE_TYPE (id));
4671       else if (DECL_CLASS_TEMPLATE_P (id))
4672         decl = DECL_TEMPLATE_RESULT (id);
4673       else
4674         {
4675           if (TYPE_P (scope))
4676             {
4677               /* According to the suggested resolution of core issue
4678                  180, 'typename' is assumed after a class-key.  */
4679               decl = make_typename_type (scope, id, tf_error);
4680               if (decl != error_mark_node)
4681                 decl = TYPE_MAIN_DECL (decl);
4682               else
4683                 decl = NULL_TREE;
4684             }
4685           else if (scope == current)
4686             {
4687               /* We've been given AGGR SCOPE::ID, when we're already
4688                  inside SCOPE.  Be nice about it.  */
4689               if (pedantic)
4690                 pedwarn ("extra qualification `%T::' on member `%D' ignored",
4691                          scope, id);
4692             }
4693           else
4694             error ("`%T' does not have a class or union named `%D'",
4695                    scope, id);
4696         }
4697     }
4698
4699   if (!decl)
4700     {
4701       decl = xref_tag (tag_kind, id, attributes, false);
4702       if (decl == error_mark_node)
4703         return error_mark_node;
4704       decl = TYPE_MAIN_DECL (decl);
4705       xrefd_p = true;
4706     }
4707
4708   if (!TYPE_BINFO (TREE_TYPE (decl)))
4709     {
4710       error ("`%T' is not a class or union type", decl);
4711       return error_mark_node;
4712     }
4713
4714   /* For a definition, we want to enter the containing scope before
4715      looking up any base classes etc. Only do so, if this is different
4716      to the current scope.  */
4717   context = CP_DECL_CONTEXT (decl);
4718
4719   new_type_p = (current != context
4720                 && TREE_CODE (context) != TEMPLATE_TYPE_PARM
4721                 && TREE_CODE (context) != BOUND_TEMPLATE_TEMPLATE_PARM);
4722   if (new_type_p)
4723     push_scope (context);
4724
4725   if (!xrefd_p
4726       && PROCESSING_REAL_TEMPLATE_DECL_P ()
4727       && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
4728     decl = push_template_decl (decl);
4729
4730   return decl;
4731 }
4732
4733 #include "gt-cp-decl2.h"