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 body;
2471   size_t i;
2472
2473   input_location = *locus;
2474   locus->line++;
2475
2476   /* We use `I' to indicate initialization and `D' to indicate
2477      destruction.  */
2478   if (constructor_p)
2479     function_key = 'I';
2480   else
2481     function_key = 'D';
2482
2483   /* Begin the function.  */
2484   body = start_objects (function_key, priority);
2485
2486   /* Call the static storage duration function with appropriate
2487      arguments.  */
2488   if (ssdf_decls)
2489     for (i = 0; i < ssdf_decls->elements_used; ++i)
2490       {
2491         arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2492                                NULL_TREE);
2493         arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2494                                arguments);
2495         finish_expr_stmt (build_function_call (VARRAY_TREE (ssdf_decls, i),
2496                                                arguments));
2497       }
2498
2499   /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2500      calls to any functions marked with attributes indicating that
2501      they should be called at initialization- or destruction-time.  */
2502   if (priority == DEFAULT_INIT_PRIORITY)
2503     {
2504       tree fns;
2505
2506       for (fns = constructor_p ? static_ctors : static_dtors;
2507            fns;
2508            fns = TREE_CHAIN (fns))
2509         finish_expr_stmt (build_function_call (TREE_VALUE (fns), NULL_TREE));
2510     }
2511
2512   /* Close out the function.  */
2513   finish_objects (function_key, priority, body);
2514 }
2515
2516 /* Generate constructor and destructor functions for the priority
2517    indicated by N.  */
2518
2519 static int
2520 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2521 {
2522   location_t *locus = data;
2523   int priority = (int) n->key;
2524   priority_info pi = (priority_info) n->value;
2525
2526   /* Generate the functions themselves, but only if they are really
2527      needed.  */
2528   if (pi->initializations_p
2529       || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2530     generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2531   if (pi->destructions_p
2532       || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2533     generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2534
2535   /* Keep iterating.  */
2536   return 0;
2537 }
2538
2539 /* This routine is called from the last rule in yyparse ().
2540    Its job is to create all the code needed to initialize and
2541    destroy the global aggregates.  We do the destruction
2542    first, since that way we only need to reverse the decls once.  */
2543
2544 void
2545 finish_file ()
2546 {
2547   tree vars;
2548   bool reconsider;
2549   size_t i;
2550   location_t locus;
2551   unsigned ssdf_count = 0;
2552
2553   locus = input_location;
2554   at_eof = 1;
2555
2556   /* Bad parse errors.  Just forget about it.  */
2557   if (! global_bindings_p () || current_class_type || decl_namespace_list)
2558     return;
2559
2560   if (pch_file)
2561     c_common_write_pch ();
2562
2563   /* Otherwise, GDB can get confused, because in only knows
2564      about source for LINENO-1 lines.  */
2565   input_line -= 1;
2566
2567   interface_unknown = 1;
2568   interface_only = 0;
2569
2570   /* We now have to write out all the stuff we put off writing out.
2571      These include:
2572
2573        o Template specializations that we have not yet instantiated,
2574          but which are needed.
2575        o Initialization and destruction for non-local objects with
2576          static storage duration.  (Local objects with static storage
2577          duration are initialized when their scope is first entered,
2578          and are cleaned up via atexit.)
2579        o Virtual function tables.
2580
2581      All of these may cause others to be needed.  For example,
2582      instantiating one function may cause another to be needed, and
2583      generating the initializer for an object may cause templates to be
2584      instantiated, etc., etc.  */
2585
2586   timevar_push (TV_VARCONST);
2587
2588   emit_support_tinfos ();
2589
2590   do
2591     {
2592       tree t;
2593       size_t n_old, n_new;
2594
2595       reconsider = false;
2596
2597       /* If there are templates that we've put off instantiating, do
2598          them now.  */
2599       instantiate_pending_templates ();
2600
2601       /* Write out virtual tables as required.  Note that writing out
2602          the virtual table for a template class may cause the
2603          instantiation of members of that class.  If we write out
2604          vtables then we remove the class from our list so we don't
2605          have to look at it again. */
2606
2607       while (keyed_classes != NULL_TREE
2608              && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2609         {
2610           reconsider = true;
2611           keyed_classes = TREE_CHAIN (keyed_classes);
2612         }
2613
2614       t = keyed_classes;
2615       if (t != NULL_TREE)
2616         {
2617           tree next = TREE_CHAIN (t);
2618
2619           while (next)
2620             {
2621               if (maybe_emit_vtables (TREE_VALUE (next)))
2622                 {
2623                   reconsider = true;
2624                   TREE_CHAIN (t) = TREE_CHAIN (next);
2625                 }
2626               else
2627                 t = next;
2628
2629               next = TREE_CHAIN (t);
2630             }
2631         }
2632
2633       /* Write out needed type info variables.  We have to be careful
2634          looping through unemitted decls, because emit_tinfo_decl may
2635          cause other variables to be needed.  We stick new elements
2636          (and old elements that we may need to reconsider) at the end
2637          of the array, then shift them back to the beginning once we're
2638          done. */
2639
2640       n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2641       for (i = 0; i < n_old; ++i)
2642         {
2643           tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2644           if (emit_tinfo_decl (tinfo_decl))
2645             reconsider = true;
2646           else
2647             VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2648         }
2649
2650       /* The only elements we want to keep are the new ones.  Copy
2651          them to the beginning of the array, then get rid of the
2652          leftovers. */
2653       n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2654       memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2655                &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2656                n_new * sizeof (tree));
2657       memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2658               0,
2659               n_old * sizeof (tree));
2660       VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2661
2662       /* The list of objects with static storage duration is built up
2663          in reverse order.  We clear STATIC_AGGREGATES so that any new
2664          aggregates added during the initialization of these will be
2665          initialized in the correct order when we next come around the
2666          loop.  */
2667       vars = prune_vars_needing_no_initialization (&static_aggregates);
2668
2669       if (vars)
2670         {
2671           tree v;
2672
2673           /* We need to start a new initialization function each time
2674              through the loop.  That's because we need to know which
2675              vtables have been referenced, and TREE_SYMBOL_REFERENCED
2676              isn't computed until a function is finished, and written
2677              out.  That's a deficiency in the back-end.  When this is
2678              fixed, these initialization functions could all become
2679              inline, with resulting performance improvements.  */
2680           tree ssdf_body;
2681
2682           /* Set the line and file, so that it is obviously not from
2683              the source file.  */
2684           input_location = locus;
2685           ssdf_body = start_static_storage_duration_function (ssdf_count);
2686
2687           /* Make sure the back end knows about all the variables.  */
2688           write_out_vars (vars);
2689
2690           /* First generate code to do all the initializations.  */
2691           for (v = vars; v; v = TREE_CHAIN (v))
2692             do_static_initialization (TREE_VALUE (v),
2693                                       TREE_PURPOSE (v));
2694
2695           /* Then, generate code to do all the destructions.  Do these
2696              in reverse order so that the most recently constructed
2697              variable is the first destroyed.  If we're using
2698              __cxa_atexit, then we don't need to do this; functions
2699              were registered at initialization time to destroy the
2700              local statics.  */
2701           if (!flag_use_cxa_atexit)
2702             {
2703               vars = nreverse (vars);
2704               for (v = vars; v; v = TREE_CHAIN (v))
2705                 do_static_destruction (TREE_VALUE (v));
2706             }
2707           else
2708             vars = NULL_TREE;
2709
2710           /* Finish up the static storage duration function for this
2711              round.  */
2712           input_location = locus;
2713           finish_static_storage_duration_function (ssdf_body);
2714
2715           /* All those initializations and finalizations might cause
2716              us to need more inline functions, more template
2717              instantiations, etc.  */
2718           reconsider = true;
2719           ssdf_count++;
2720           locus.line++;
2721         }
2722
2723       for (i = 0; i < deferred_fns_used; ++i)
2724         {
2725           tree decl = VARRAY_TREE (deferred_fns, i);
2726
2727           /* Does it need synthesizing?  */
2728           if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2729               && TREE_USED (decl)
2730               && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2731             {
2732               /* Even though we're already at the top-level, we push
2733                  there again.  That way, when we pop back a few lines
2734                  hence, all of our state is restored.  Otherwise,
2735                  finish_function doesn't clean things up, and we end
2736                  up with CURRENT_FUNCTION_DECL set.  */
2737               push_to_top_level ();
2738               synthesize_method (decl);
2739               pop_from_top_level ();
2740               reconsider = true;
2741             }
2742
2743           /* If the function has no body, avoid calling
2744              import_export_decl.  On a system without weak symbols,
2745              calling import_export_decl will make an inline template
2746              instantiation "static", which will result in errors about
2747              the use of undefined functions if there is no body for
2748              the function.  */
2749           if (!DECL_SAVED_TREE (decl))
2750             continue;
2751
2752           import_export_decl (decl);
2753
2754           /* We lie to the back-end, pretending that some functions
2755              are not defined when they really are.  This keeps these
2756              functions from being put out unnecessarily.  But, we must
2757              stop lying when the functions are referenced, or if they
2758              are not comdat since they need to be put out now.  This
2759              is done in a separate for cycle, because if some deferred
2760              function is contained in another deferred function later
2761              in deferred_fns varray, rest_of_compilation would skip
2762              this function and we really cannot expand the same
2763              function twice.  */
2764           if (DECL_NOT_REALLY_EXTERN (decl)
2765               && DECL_INITIAL (decl)
2766               && DECL_NEEDED_P (decl))
2767             DECL_EXTERNAL (decl) = 0;
2768
2769           /* If we're going to need to write this function out, and
2770              there's already a body for it, create RTL for it now.
2771              (There might be no body if this is a method we haven't
2772              gotten around to synthesizing yet.)  */
2773           if (!DECL_EXTERNAL (decl)
2774               && DECL_NEEDED_P (decl)
2775               && DECL_SAVED_TREE (decl)
2776               && !TREE_ASM_WRITTEN (decl))
2777             {
2778               int saved_not_really_extern;
2779
2780               /* When we call finish_function in expand_body, it will
2781                  try to reset DECL_NOT_REALLY_EXTERN so we save and
2782                  restore it here.  */
2783               saved_not_really_extern = DECL_NOT_REALLY_EXTERN (decl);
2784               /* Generate RTL for this function now that we know we
2785                  need it.  */
2786               expand_body (decl);
2787               /* Undo the damage done by finish_function.  */
2788               DECL_EXTERNAL (decl) = 0;
2789               DECL_NOT_REALLY_EXTERN (decl) = saved_not_really_extern;
2790               /* If we're compiling -fsyntax-only pretend that this
2791                  function has been written out so that we don't try to
2792                  expand it again.  */
2793               if (flag_syntax_only)
2794                 TREE_ASM_WRITTEN (decl) = 1;
2795               reconsider = true;
2796             }
2797         }
2798
2799       if (deferred_fns_used
2800           && wrapup_global_declarations (&VARRAY_TREE (deferred_fns, 0),
2801                                          deferred_fns_used))
2802         reconsider = true;
2803       if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2804         reconsider = true;
2805
2806       /* Static data members are just like namespace-scope globals.  */
2807       for (i = 0; i < pending_statics_used; ++i)
2808         {
2809           tree decl = VARRAY_TREE (pending_statics, i);
2810           if (TREE_ASM_WRITTEN (decl))
2811             continue;
2812           import_export_decl (decl);
2813           if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2814             DECL_EXTERNAL (decl) = 0;
2815         }
2816       if (pending_statics
2817           && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2818                                          pending_statics_used))
2819         reconsider = true;
2820     }
2821   while (reconsider);
2822
2823   /* All used inline functions must have a definition at this point. */
2824   for (i = 0; i < deferred_fns_used; ++i)
2825     {
2826       tree decl = VARRAY_TREE (deferred_fns, i);
2827
2828       if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
2829           && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
2830                /* An explicit instantiation can be used to specify
2831                   that the body is in another unit. It will have
2832                   already verified there was a definition.  */
2833                || DECL_EXPLICIT_INSTANTIATION (decl)))
2834         {
2835           cp_warning_at ("inline function `%D' used but never defined", decl);
2836           /* This symbol is effectively an "extern" declaration now.
2837              This is not strictly necessary, but removes a duplicate
2838              warning.  */
2839           TREE_PUBLIC (decl) = 1;
2840         }
2841
2842     }
2843
2844   /* We give C linkage to static constructors and destructors.  */
2845   push_lang_context (lang_name_c);
2846
2847   /* Generate initialization and destruction functions for all
2848      priorities for which they are required.  */
2849   if (priority_info_map)
2850     splay_tree_foreach (priority_info_map,
2851                         generate_ctor_and_dtor_functions_for_priority,
2852                         /*data=*/&locus);
2853   else
2854     {
2855
2856       if (static_ctors)
2857         generate_ctor_or_dtor_function (/*constructor_p=*/true,
2858                                         DEFAULT_INIT_PRIORITY, &locus);
2859       if (static_dtors)
2860         generate_ctor_or_dtor_function (/*constructor_p=*/false,
2861                                         DEFAULT_INIT_PRIORITY, &locus);
2862     }
2863
2864   /* We're done with the splay-tree now.  */
2865   if (priority_info_map)
2866     splay_tree_delete (priority_info_map);
2867
2868   /* We're done with static constructors, so we can go back to "C++"
2869      linkage now.  */
2870   pop_lang_context ();
2871
2872   /* Now, issue warnings about static, but not defined, functions,
2873      etc., and emit debugging information.  */
2874   walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2875   if (pending_statics)
2876     check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2877                                pending_statics_used);
2878
2879   finish_repo ();
2880
2881   /* The entire file is now complete.  If requested, dump everything
2882      to a file.  */
2883   {
2884     int flags;
2885     FILE *stream = dump_begin (TDI_all, &flags);
2886
2887     if (stream)
2888       {
2889         dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2890         dump_end (TDI_all, stream);
2891       }
2892   }
2893
2894   timevar_pop (TV_VARCONST);
2895
2896   if (flag_detailed_statistics)
2897     {
2898       dump_tree_statistics ();
2899       dump_time_statistics ();
2900     }
2901   input_location = locus;
2902 }
2903
2904 /* T is the parse tree for an expression.  Return the expression after
2905    performing semantic analysis.  */
2906
2907 tree
2908 build_expr_from_tree (t)
2909      tree t;
2910 {
2911   if (t == NULL_TREE || t == error_mark_node)
2912     return t;
2913
2914   switch (TREE_CODE (t))
2915     {
2916     case IDENTIFIER_NODE:
2917       return do_identifier (t, NULL_TREE);
2918
2919     case LOOKUP_EXPR:
2920       if (LOOKUP_EXPR_GLOBAL (t))
2921         {
2922           tree token = TREE_OPERAND (t, 0);
2923           return do_scoped_id (token, IDENTIFIER_GLOBAL_VALUE (token));
2924         }
2925       else
2926         {
2927           t = do_identifier (TREE_OPERAND (t, 0), NULL_TREE);
2928           if (TREE_CODE (t) == ALIAS_DECL)
2929             t = DECL_INITIAL (t);
2930           return t;
2931         }
2932
2933     case TEMPLATE_ID_EXPR:
2934       {
2935         tree template;
2936         tree args;
2937         tree object;
2938
2939         template = build_expr_from_tree (TREE_OPERAND (t, 0));
2940         args = build_expr_from_tree (TREE_OPERAND (t, 1));
2941
2942         if (TREE_CODE (template) == COMPONENT_REF)
2943           {
2944             object = TREE_OPERAND (template, 0);
2945             template = TREE_OPERAND (template, 1);
2946           }
2947         else
2948           object = NULL_TREE;
2949
2950         template = lookup_template_function (template, args);
2951         if (object)
2952           return build (COMPONENT_REF, TREE_TYPE (template),
2953                         object, template);
2954         else
2955           return template;
2956       }
2957
2958     case INDIRECT_REF:
2959       return build_x_indirect_ref
2960         (build_expr_from_tree (TREE_OPERAND (t, 0)), "unary *");
2961
2962     case CAST_EXPR:
2963       return build_functional_cast
2964         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2965
2966     case REINTERPRET_CAST_EXPR:
2967       return build_reinterpret_cast
2968         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2969
2970     case CONST_CAST_EXPR:
2971       return build_const_cast
2972         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2973
2974     case DYNAMIC_CAST_EXPR:
2975       return build_dynamic_cast
2976         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2977
2978     case STATIC_CAST_EXPR:
2979       return build_static_cast
2980         (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
2981
2982     case PREDECREMENT_EXPR:
2983     case PREINCREMENT_EXPR:
2984     case POSTDECREMENT_EXPR:
2985     case POSTINCREMENT_EXPR:
2986     case NEGATE_EXPR:
2987     case BIT_NOT_EXPR:
2988     case ABS_EXPR:
2989     case TRUTH_NOT_EXPR:
2990     case ADDR_EXPR:
2991     case CONVERT_EXPR:      /* Unary + */
2992     case REALPART_EXPR:
2993     case IMAGPART_EXPR:
2994       if (TREE_TYPE (t))
2995         return t;
2996       return build_x_unary_op (TREE_CODE (t),
2997                                build_expr_from_tree (TREE_OPERAND (t, 0)));
2998
2999     case PLUS_EXPR:
3000     case MINUS_EXPR:
3001     case MULT_EXPR:
3002     case TRUNC_DIV_EXPR:
3003     case CEIL_DIV_EXPR:
3004     case FLOOR_DIV_EXPR:
3005     case ROUND_DIV_EXPR:
3006     case EXACT_DIV_EXPR:
3007     case BIT_AND_EXPR:
3008     case BIT_ANDTC_EXPR:
3009     case BIT_IOR_EXPR:
3010     case BIT_XOR_EXPR:
3011     case TRUNC_MOD_EXPR:
3012     case FLOOR_MOD_EXPR:
3013     case TRUTH_ANDIF_EXPR:
3014     case TRUTH_ORIF_EXPR:
3015     case TRUTH_AND_EXPR:
3016     case TRUTH_OR_EXPR:
3017     case RSHIFT_EXPR:
3018     case LSHIFT_EXPR:
3019     case RROTATE_EXPR:
3020     case LROTATE_EXPR:
3021     case EQ_EXPR:
3022     case NE_EXPR:
3023     case MAX_EXPR:
3024     case MIN_EXPR:
3025     case LE_EXPR:
3026     case GE_EXPR:
3027     case LT_EXPR:
3028     case GT_EXPR:
3029     case MEMBER_REF:
3030       return build_x_binary_op
3031         (TREE_CODE (t),
3032          build_expr_from_tree (TREE_OPERAND (t, 0)),
3033          build_expr_from_tree (TREE_OPERAND (t, 1)));
3034
3035     case DOTSTAR_EXPR:
3036       return build_m_component_ref
3037         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3038          build_expr_from_tree (TREE_OPERAND (t, 1)));
3039
3040     case SCOPE_REF:
3041       return build_offset_ref (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
3042
3043     case ARRAY_REF:
3044       if (TREE_OPERAND (t, 0) == NULL_TREE)
3045         /* new-type-id */
3046         return build_nt (ARRAY_REF, NULL_TREE,
3047                          build_expr_from_tree (TREE_OPERAND (t, 1)));
3048       return grok_array_decl (build_expr_from_tree (TREE_OPERAND (t, 0)),
3049                               build_expr_from_tree (TREE_OPERAND (t, 1)));
3050
3051     case SIZEOF_EXPR:
3052     case ALIGNOF_EXPR:
3053       {
3054         tree r = build_expr_from_tree (TREE_OPERAND (t, 0));
3055         if (!TYPE_P (r))
3056           return TREE_CODE (t) == SIZEOF_EXPR ? expr_sizeof (r) : c_alignof_expr (r);
3057         else
3058           return cxx_sizeof_or_alignof_type (r, TREE_CODE (t), true);
3059       }
3060
3061     case MODOP_EXPR:
3062       return build_x_modify_expr
3063         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3064          TREE_CODE (TREE_OPERAND (t, 1)),
3065          build_expr_from_tree (TREE_OPERAND (t, 2)));
3066
3067     case ARROW_EXPR:
3068       return build_x_arrow
3069         (build_expr_from_tree (TREE_OPERAND (t, 0)));
3070
3071     case NEW_EXPR:
3072       return build_new
3073         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3074          build_expr_from_tree (TREE_OPERAND (t, 1)),
3075          build_expr_from_tree (TREE_OPERAND (t, 2)),
3076          NEW_EXPR_USE_GLOBAL (t));
3077
3078     case DELETE_EXPR:
3079       return delete_sanity
3080         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3081          build_expr_from_tree (TREE_OPERAND (t, 1)),
3082          DELETE_EXPR_USE_VEC (t), DELETE_EXPR_USE_GLOBAL (t));
3083
3084     case COMPOUND_EXPR:
3085       if (TREE_OPERAND (t, 1) == NULL_TREE)
3086         return build_x_compound_expr
3087           (build_expr_from_tree (TREE_OPERAND (t, 0)));
3088       else
3089         abort ();
3090
3091     case METHOD_CALL_EXPR:
3092       if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3093         {
3094           tree ref = TREE_OPERAND (t, 0);
3095           tree name = TREE_OPERAND (ref, 1);
3096
3097           if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3098             name = build_nt (TEMPLATE_ID_EXPR,
3099                              TREE_OPERAND (name, 0),
3100                              build_expr_from_tree (TREE_OPERAND (name, 1)));
3101
3102           return build_scoped_method_call
3103             (build_expr_from_tree (TREE_OPERAND (t, 1)),
3104              build_expr_from_tree (TREE_OPERAND (ref, 0)),
3105              name,
3106              build_expr_from_tree (TREE_OPERAND (t, 2)));
3107         }
3108       else
3109         {
3110           tree fn = TREE_OPERAND (t, 0);
3111
3112           /* We can get a TEMPLATE_ID_EXPR here on code like:
3113
3114                x->f<2>();
3115
3116              so we must resolve that.  However, we can also get things
3117              like a BIT_NOT_EXPR here, when referring to a destructor,
3118              and things like that are not correctly resolved by
3119              build_expr_from_tree.  So, just use build_expr_from_tree
3120              when we really need it.  */
3121           if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3122             fn = lookup_template_function
3123               (TREE_OPERAND (fn, 0),
3124                build_expr_from_tree (TREE_OPERAND (fn, 1)));
3125
3126           return build_method_call
3127             (build_expr_from_tree (TREE_OPERAND (t, 1)),
3128              fn,
3129              build_expr_from_tree (TREE_OPERAND (t, 2)),
3130              NULL_TREE, LOOKUP_NORMAL);
3131         }
3132
3133     case CALL_EXPR:
3134       if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3135         {
3136           tree ref = TREE_OPERAND (t, 0);
3137           tree name = TREE_OPERAND (ref, 1);
3138           tree fn, scope, args;
3139
3140           if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3141             name = build_nt (TEMPLATE_ID_EXPR,
3142                              TREE_OPERAND (name, 0),
3143                              build_expr_from_tree (TREE_OPERAND (name, 1)));
3144
3145           scope = build_expr_from_tree (TREE_OPERAND (ref, 0));
3146           args = build_expr_from_tree (TREE_OPERAND (t, 1));
3147           fn = resolve_scoped_fn_name (scope, name);
3148
3149           return build_call_from_tree (fn, args, 1);
3150         }
3151       else
3152         {
3153           tree name = TREE_OPERAND (t, 0);
3154           tree id;
3155           tree args = build_expr_from_tree (TREE_OPERAND (t, 1));
3156           if (args != NULL_TREE && TREE_CODE (name) == LOOKUP_EXPR
3157               && !LOOKUP_EXPR_GLOBAL (name)
3158               && TREE_CODE ((id = TREE_OPERAND (name, 0))) == IDENTIFIER_NODE
3159               && (!current_class_type
3160                   || !lookup_member (current_class_type, id, 0, false)))
3161             {
3162               /* Do Koenig lookup if there are no class members.  */
3163               name = do_identifier (id, args);
3164             }
3165           else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
3166                    || ! really_overloaded_fn (name))
3167             name = build_expr_from_tree (name);
3168
3169           if (TREE_CODE (name) == OFFSET_REF)
3170             return build_offset_ref_call_from_tree (name, args);
3171           if (TREE_CODE (name) == COMPONENT_REF)
3172             return finish_object_call_expr (TREE_OPERAND (name, 1),
3173                                             TREE_OPERAND (name, 0),
3174                                             args);
3175           name = convert_from_reference (name);
3176           return build_call_from_tree (name, args,
3177                                        /*disallow_virtual=*/false);
3178         }
3179
3180     case COND_EXPR:
3181       return build_x_conditional_expr
3182         (build_expr_from_tree (TREE_OPERAND (t, 0)),
3183          build_expr_from_tree (TREE_OPERAND (t, 1)),
3184          build_expr_from_tree (TREE_OPERAND (t, 2)));
3185
3186     case PSEUDO_DTOR_EXPR:
3187       return (finish_pseudo_destructor_expr
3188               (build_expr_from_tree (TREE_OPERAND (t, 0)),
3189                build_expr_from_tree (TREE_OPERAND (t, 1)),
3190                build_expr_from_tree (TREE_OPERAND (t, 2))));
3191
3192     case TREE_LIST:
3193       {
3194         tree purpose, value, chain;
3195
3196         if (t == void_list_node)
3197           return t;
3198
3199         purpose = TREE_PURPOSE (t);
3200         if (purpose)
3201           purpose = build_expr_from_tree (purpose);
3202         value = TREE_VALUE (t);
3203         if (value)
3204           value = build_expr_from_tree (value);
3205         chain = TREE_CHAIN (t);
3206         if (chain && chain != void_type_node)
3207           chain = build_expr_from_tree (chain);
3208         return tree_cons (purpose, value, chain);
3209       }
3210
3211     case COMPONENT_REF:
3212       {
3213         tree object = build_expr_from_tree (TREE_OPERAND (t, 0));
3214         tree member = TREE_OPERAND (t, 1);
3215
3216         if (!CLASS_TYPE_P (TREE_TYPE (object)))
3217           {
3218             if (TREE_CODE (member) == BIT_NOT_EXPR)
3219               return finish_pseudo_destructor_expr (object,
3220                                                     NULL_TREE,
3221                                                     TREE_TYPE (object));
3222             else if (TREE_CODE (member) == SCOPE_REF
3223                      && (TREE_CODE (TREE_OPERAND (member, 1)) == BIT_NOT_EXPR))
3224               return finish_pseudo_destructor_expr (object,
3225                                                     TREE_OPERAND (t, 0),
3226                                                     TREE_TYPE (object));
3227           }
3228         else if (TREE_CODE (member) == SCOPE_REF
3229                  && TREE_CODE (TREE_OPERAND (member, 1)) == TEMPLATE_ID_EXPR)
3230           {
3231             tree tmpl;
3232             tree args;
3233
3234             /* Lookup the template functions now that we know what the
3235                scope is.  */
3236             tmpl = TREE_OPERAND (TREE_OPERAND (member, 1), 0);
3237             args = TREE_OPERAND (TREE_OPERAND (member, 1), 1);
3238             member = lookup_qualified_name (TREE_OPERAND (member, 0),
3239                                             tmpl,
3240                                             /*is_type=*/0,
3241                                             /*flags=*/0);
3242             if (BASELINK_P (member))
3243               BASELINK_FUNCTIONS (member)
3244                 = build_nt (TEMPLATE_ID_EXPR, BASELINK_FUNCTIONS (member),
3245                             args);
3246             else
3247               {
3248                 error ("`%D' is not a member of `%T'",
3249                        tmpl, TREE_TYPE (object));
3250                 return error_mark_node;
3251               }
3252           }
3253
3254
3255         return finish_class_member_access_expr (object, member);
3256       }
3257
3258     case THROW_EXPR:
3259       return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0)));
3260
3261     case CONSTRUCTOR:
3262       {
3263         tree r;
3264         tree elts;
3265         tree type = TREE_TYPE (t);
3266         bool purpose_p;
3267
3268         /* digest_init will do the wrong thing if we let it.  */
3269         if (type && TYPE_PTRMEMFUNC_P (type))
3270           return t;
3271
3272         r = NULL_TREE;
3273         /* We do not want to process the purpose of aggregate
3274            initializers as they are identifier nodes which will be
3275            looked up by digest_init.  */
3276         purpose_p = !(type && IS_AGGR_TYPE (type));
3277         for (elts = CONSTRUCTOR_ELTS (t); elts; elts = TREE_CHAIN (elts))
3278           {
3279             tree purpose = TREE_PURPOSE (elts);
3280             tree value = TREE_VALUE (elts);
3281
3282             if (purpose && purpose_p)
3283               purpose = build_expr_from_tree (purpose);
3284             value = build_expr_from_tree (value);
3285             r = tree_cons (purpose, value, r);
3286           }
3287
3288         r = build_constructor (NULL_TREE, nreverse (r));
3289         TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
3290
3291         if (type)
3292           return digest_init (type, r, 0);
3293         return r;
3294       }
3295
3296     case TYPEID_EXPR:
3297       if (TYPE_P (TREE_OPERAND (t, 0)))
3298         return get_typeid (TREE_OPERAND (t, 0));
3299       return build_typeid (build_expr_from_tree (TREE_OPERAND (t, 0)));
3300
3301     case PARM_DECL:
3302     case VAR_DECL:
3303       return convert_from_reference (t);
3304
3305     case VA_ARG_EXPR:
3306       return build_va_arg (build_expr_from_tree (TREE_OPERAND (t, 0)),
3307                            TREE_TYPE (t));
3308
3309     default:
3310       return t;
3311     }
3312 }
3313
3314 /* FN is an OFFSET_REF indicating the function to call in parse-tree
3315    form; it has not yet been semantically analyzed.  ARGS are the
3316    arguments to the function.  They have already been semantically
3317    analzyed.  */
3318
3319 tree
3320 build_offset_ref_call_from_tree (tree fn, tree args)
3321 {
3322   tree object_addr;
3323
3324   my_friendly_assert (TREE_CODE (fn) == OFFSET_REF, 20020725);
3325
3326   /* A qualified name corresponding to a non-static member
3327      function or a pointer-to-member is represented as an
3328      OFFSET_REF.
3329
3330      For both of these function calls, FN will be an OFFSET_REF.
3331
3332         struct A { void f(); };
3333         void A::f() { (A::f) (); }
3334
3335         struct B { void g(); };
3336         void (B::*p)();
3337         void B::g() { (this->*p)(); }  */
3338
3339   /* This code is not really correct (for example, it does not
3340      handle the case that `A::f' is overloaded), but it is
3341      historically how we have handled this situation.  */
3342   if (TREE_CODE (TREE_OPERAND (fn, 1)) == FIELD_DECL)
3343     /* This case should now be handled elsewhere.  */
3344     abort ();
3345   else
3346     {
3347       object_addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (fn, 0), 0);
3348       fn = TREE_OPERAND (fn, 1);
3349       fn = get_member_function_from_ptrfunc (&object_addr, fn);
3350       args = tree_cons (NULL_TREE, object_addr, args);
3351     }
3352   return build_function_call (fn, args);
3353 }
3354
3355 /* FN indicates the function to call.  Name resolution has been
3356    performed on FN.  ARGS are the arguments to the function.  They
3357    have already been semantically analyzed.  DISALLOW_VIRTUAL is true
3358    if the function call should be determined at compile time, even if
3359    FN is virtual.  */
3360
3361 tree
3362 build_call_from_tree (tree fn, tree args, bool disallow_virtual)
3363 {
3364   tree template_args;
3365   tree template_id;
3366   tree f;
3367
3368   /* Check to see that name lookup has already been performed.  */
3369   my_friendly_assert (TREE_CODE (fn) != OFFSET_REF, 20020725);
3370   my_friendly_assert (TREE_CODE (fn) != SCOPE_REF, 20020725);
3371
3372   /* In the future all of this should be eliminated.  Instead,
3373      name-lookup for a member function should simply return a
3374      baselink, instead of a FUNCTION_DECL, TEMPLATE_DECL, or
3375      TEMPLATE_ID_EXPR.  */
3376
3377   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3378     {
3379       template_id = fn;
3380       template_args = TREE_OPERAND (fn, 1);
3381       fn = TREE_OPERAND (fn, 0);
3382     }
3383   else
3384     {
3385       template_id = NULL_TREE;
3386       template_args = NULL_TREE;
3387     }
3388
3389   f = (TREE_CODE (fn) == OVERLOAD) ? get_first_fn (fn) : fn;
3390   /* Make sure we have a baselink (rather than simply a
3391      FUNCTION_DECL) for a member function.  */
3392   if (current_class_type
3393       && ((TREE_CODE (f) == FUNCTION_DECL
3394            && DECL_FUNCTION_MEMBER_P (f))
3395           || (DECL_FUNCTION_TEMPLATE_P (f)
3396               && DECL_FUNCTION_MEMBER_P (f))))
3397     {
3398       f = lookup_member (current_class_type, DECL_NAME (f),
3399                          /*protect=*/1, /*want_type=*/false);
3400       if (f)
3401         fn = f;
3402     }
3403
3404   if (template_id)
3405     {
3406       if (BASELINK_P (fn))
3407           BASELINK_FUNCTIONS (fn) = build_nt (TEMPLATE_ID_EXPR,
3408                                               BASELINK_FUNCTIONS (fn),
3409                                               template_args);
3410       else
3411         fn = template_id;
3412     }
3413
3414   return finish_call_expr (fn, args, disallow_virtual);
3415 }
3416
3417 /* Returns true if ROOT (a namespace, class, or function) encloses
3418    CHILD.  CHILD may be either a class type or a namespace.  */
3419
3420 bool
3421 is_ancestor (tree root, tree child)
3422 {
3423   my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
3424                        || TREE_CODE (root) == FUNCTION_DECL
3425                        || CLASS_TYPE_P (root)), 20030307);
3426   my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
3427                        || CLASS_TYPE_P (child)),
3428                       20030307);
3429
3430   /* The global namespace encloses everything.  */
3431   if (root == global_namespace)
3432     return true;
3433
3434   while (true)
3435     {
3436       /* If we've run out of scopes, stop.  */
3437       if (!child)
3438         return false;
3439       /* If we've reached the ROOT, it encloses CHILD.  */
3440       if (root == child)
3441         return true;
3442       /* Go out one level.  */
3443       if (TYPE_P (child))
3444         child = TYPE_NAME (child);
3445       child = DECL_CONTEXT (child);
3446     }
3447 }
3448
3449
3450 /* Return the namespace that is the common ancestor
3451    of two given namespaces.  */
3452
3453 tree
3454 namespace_ancestor (tree ns1, tree ns2)
3455 {
3456   timevar_push (TV_NAME_LOOKUP);
3457   if (is_ancestor (ns1, ns2))
3458     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3459   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3460                           namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3461 }
3462
3463 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3464    directive is not directly from the source. Also find the common
3465    ancestor and let our users know about the new namespace */
3466 static void
3467 add_using_namespace (tree user, tree used, bool indirect)
3468 {
3469   tree t;
3470   timevar_push (TV_NAME_LOOKUP);
3471   /* Using oneself is a no-op.  */
3472   if (user == used)
3473     {
3474       timevar_pop (TV_NAME_LOOKUP);
3475       return;
3476     }
3477   my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3478   my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3479   /* Check if we already have this.  */
3480   t = purpose_member (used, DECL_NAMESPACE_USING (user));
3481   if (t != NULL_TREE)
3482     {
3483       if (!indirect)
3484         /* Promote to direct usage.  */
3485         TREE_INDIRECT_USING (t) = 0;
3486       timevar_pop (TV_NAME_LOOKUP);
3487       return;
3488     }
3489
3490   /* Add used to the user's using list.  */
3491   DECL_NAMESPACE_USING (user)
3492     = tree_cons (used, namespace_ancestor (user, used),
3493                  DECL_NAMESPACE_USING (user));
3494
3495   TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3496
3497   /* Add user to the used's users list.  */
3498   DECL_NAMESPACE_USERS (used)
3499     = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3500
3501   /* Recursively add all namespaces used.  */
3502   for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3503     /* indirect usage */
3504     add_using_namespace (user, TREE_PURPOSE (t), 1);
3505
3506   /* Tell everyone using us about the new used namespaces.  */
3507   for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3508     add_using_namespace (TREE_PURPOSE (t), used, 1);
3509   timevar_pop (TV_NAME_LOOKUP);
3510 }
3511
3512 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3513    duplicates.  The first list becomes the tail of the result.
3514
3515    The algorithm is O(n^2).  We could get this down to O(n log n) by
3516    doing a sort on the addresses of the functions, if that becomes
3517    necessary.  */
3518
3519 static tree
3520 merge_functions (tree s1, tree s2)
3521 {
3522   for (; s2; s2 = OVL_NEXT (s2))
3523     {
3524       tree fn2 = OVL_CURRENT (s2);
3525       tree fns1;
3526
3527       for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3528         {
3529           tree fn1 = OVL_CURRENT (fns1);
3530
3531           /* If the function from S2 is already in S1, there is no
3532              need to add it again.  For `extern "C"' functions, we
3533              might have two FUNCTION_DECLs for the same function, in
3534              different namespaces; again, we only need one of them.  */
3535           if (fn1 == fn2
3536               || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3537                   && DECL_NAME (fn1) == DECL_NAME (fn2)))
3538             break;
3539         }
3540
3541       /* If we exhausted all of the functions in S1, FN2 is new.  */
3542       if (!fns1)
3543         s1 = build_overload (fn2, s1);
3544     }
3545   return s1;
3546 }
3547
3548 /* This should return an error not all definitions define functions.
3549    It is not an error if we find two functions with exactly the
3550    same signature, only if these are selected in overload resolution.
3551    old is the current set of bindings, new the freshly-found binding.
3552    XXX Do we want to give *all* candidates in case of ambiguity?
3553    XXX In what way should I treat extern declarations?
3554    XXX I don't want to repeat the entire duplicate_decls here */
3555
3556 static cxx_binding *
3557 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3558 {
3559   tree val, type;
3560   my_friendly_assert (old != NULL, 393);
3561   /* Copy the value.  */
3562   val = BINDING_VALUE (new);
3563   if (val)
3564     switch (TREE_CODE (val))
3565       {
3566       case TEMPLATE_DECL:
3567         /* If we expect types or namespaces, and not templates,
3568            or this is not a template class.  */
3569         if (LOOKUP_QUALIFIERS_ONLY (flags)
3570             && !DECL_CLASS_TEMPLATE_P (val))
3571           val = NULL_TREE;
3572         break;
3573       case TYPE_DECL:
3574         if (LOOKUP_NAMESPACES_ONLY (flags))
3575           val = NULL_TREE;
3576         break;
3577       case NAMESPACE_DECL:
3578         if (LOOKUP_TYPES_ONLY (flags))
3579           val = NULL_TREE;
3580         break;
3581       case FUNCTION_DECL:
3582         /* Ignore built-in functions that are still anticipated.  */
3583         if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3584           val = NULL_TREE;
3585         break;
3586       default:
3587         if (LOOKUP_QUALIFIERS_ONLY (flags))
3588           val = NULL_TREE;
3589       }
3590
3591   if (!BINDING_VALUE (old))
3592     BINDING_VALUE (old) = val;
3593   else if (val && val != BINDING_VALUE (old))
3594     {
3595       if (is_overloaded_fn (BINDING_VALUE (old)) && is_overloaded_fn (val))
3596         BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old), val);
3597       else
3598         {
3599           /* Some declarations are functions, some are not.  */
3600           if (flags & LOOKUP_COMPLAIN)
3601             {
3602               /* If we've already given this error for this lookup,
3603                  BINDING_VALUE (old) is error_mark_node, so let's not
3604                  repeat ourselves.  */
3605               if (BINDING_VALUE (old) != error_mark_node)
3606                 {
3607                   error ("use of `%D' is ambiguous", name);
3608                   cp_error_at ("  first declared as `%#D' here",
3609                                BINDING_VALUE (old));
3610                 }
3611               cp_error_at ("  also declared as `%#D' here", val);
3612             }
3613           BINDING_VALUE (old) = error_mark_node;
3614         }
3615     }
3616   /* ... and copy the type.  */
3617   type = BINDING_TYPE (new);
3618   if (LOOKUP_NAMESPACES_ONLY (flags))
3619     type = NULL_TREE;
3620   if (!BINDING_TYPE (old))
3621     BINDING_TYPE (old) = type;
3622   else if (type && BINDING_TYPE (old) != type)
3623     {
3624       if (flags & LOOKUP_COMPLAIN)
3625         {
3626           error ("`%D' denotes an ambiguous type",name);
3627           cp_error_at ("  first type here", BINDING_TYPE (old));
3628           cp_error_at ("  other type here", type);
3629         }
3630     }
3631   return old;
3632 }
3633
3634 /* Subroutine of unualified_namespace_lookup:
3635    Add the bindings of NAME in used namespaces to VAL.
3636    We are currently looking for names in namespace SCOPE, so we
3637    look through USINGS for using-directives of namespaces
3638    which have SCOPE as a common ancestor with the current scope.
3639    Returns false on errors.  */
3640
3641 bool
3642 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3643                         int flags, tree *spacesp)
3644 {
3645   tree iter;
3646   timevar_push (TV_NAME_LOOKUP);
3647   /* Iterate over all used namespaces in current, searching for using
3648      directives of scope.  */
3649   for (iter = usings; iter; iter = TREE_CHAIN (iter))
3650     if (TREE_VALUE (iter) == scope)
3651       {
3652         tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3653         cxx_binding *val1 =
3654           cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3655         if (spacesp)
3656           *spacesp = tree_cons (used, NULL_TREE, *spacesp);
3657         /* Resolve ambiguities.  */
3658         if (val1)
3659           val = ambiguous_decl (name, val, val1, flags);
3660       }
3661   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3662                           BINDING_VALUE (val) != error_mark_node);
3663 }
3664
3665 /* [namespace.qual]
3666    Accepts the NAME to lookup and its qualifying SCOPE.
3667    Returns the name/type pair found into the cxx_binding *RESULT,
3668    or false on error.  */
3669
3670 bool
3671 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3672                                   int flags)
3673 {
3674   /* Maintain a list of namespaces visited...  */
3675   tree seen = NULL_TREE;
3676   /* ... and a list of namespace yet to see.  */
3677   tree todo = NULL_TREE;
3678   tree usings;
3679   timevar_push (TV_NAME_LOOKUP);
3680   /* Look through namespace aliases.  */
3681   scope = ORIGINAL_NAMESPACE (scope);
3682   while (scope && result->value != error_mark_node)
3683     {
3684       cxx_binding *binding =
3685         cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3686       seen = tree_cons (scope, NULL_TREE, seen);
3687       if (binding)
3688         result = ambiguous_decl (name, result, binding, flags);
3689       if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
3690         /* Consider using directives.  */
3691         for (usings = DECL_NAMESPACE_USING (scope); usings;
3692              usings = TREE_CHAIN (usings))
3693           /* If this was a real directive, and we have not seen it.  */
3694           if (!TREE_INDIRECT_USING (usings)
3695               && !purpose_member (TREE_PURPOSE (usings), seen))
3696             todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3697       if (todo)
3698         {
3699           scope = TREE_PURPOSE (todo);
3700           todo = TREE_CHAIN (todo);
3701         }
3702       else
3703         scope = NULL_TREE; /* If there never was a todo list.  */
3704     }
3705   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3706 }
3707
3708 /* [namespace.memdef]/2 */
3709
3710 /* Set the context of a declaration to scope. Complain if we are not
3711    outside scope.  */
3712
3713 void
3714 set_decl_namespace (tree decl, tree scope, bool friendp)
3715 {
3716   tree old;
3717
3718   /* Get rid of namespace aliases.  */
3719   scope = ORIGINAL_NAMESPACE (scope);
3720
3721   /* It is ok for friends to be qualified in parallel space.  */
3722   if (!friendp && !is_ancestor (current_namespace, scope))
3723     error ("declaration of `%D' not in a namespace surrounding `%D'",
3724               decl, scope);
3725   DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3726   if (scope != current_namespace)
3727     {
3728       /* See whether this has been declared in the namespace.  */
3729       old = namespace_binding (DECL_NAME (decl), scope);
3730       if (!old)
3731         /* No old declaration at all.  */
3732         goto complain;
3733       /* A template can be explicitly specialized in any namespace.  */
3734       if (processing_explicit_instantiation)
3735         return;
3736       if (!is_overloaded_fn (decl))
3737         /* Don't compare non-function decls with decls_match here,
3738            since it can't check for the correct constness at this
3739            point. pushdecl will find those errors later.  */
3740         return;
3741       /* Since decl is a function, old should contain a function decl.  */
3742       if (!is_overloaded_fn (old))
3743         goto complain;
3744       if (processing_template_decl || processing_specialization)
3745         /* We have not yet called push_template_decl to turn a
3746            FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
3747            won't match.  But, we'll check later, when we construct the
3748            template.  */
3749         return;
3750       if (is_overloaded_fn (old))
3751         {
3752           for (; old; old = OVL_NEXT (old))
3753             if (decls_match (decl, OVL_CURRENT (old)))
3754               return;
3755         }
3756       else
3757         if (decls_match (decl, old))
3758           return;
3759     }
3760   else
3761     return;
3762  complain:
3763   error ("`%D' should have been declared inside `%D'",
3764             decl, scope);
3765 }
3766
3767 /* Compute the namespace where a declaration is defined.  */
3768
3769 static tree
3770 decl_namespace (tree decl)
3771 {
3772   timevar_push (TV_NAME_LOOKUP);
3773   if (TYPE_P (decl))
3774     decl = TYPE_STUB_DECL (decl);
3775   while (DECL_CONTEXT (decl))
3776     {
3777       decl = DECL_CONTEXT (decl);
3778       if (TREE_CODE (decl) == NAMESPACE_DECL)
3779         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
3780       if (TYPE_P (decl))
3781         decl = TYPE_STUB_DECL (decl);
3782       my_friendly_assert (DECL_P (decl), 390);
3783     }
3784
3785   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, global_namespace);
3786 }
3787
3788 /* Return the namespace where the current declaration is declared.  */
3789
3790 tree
3791 current_decl_namespace (void)
3792 {
3793   tree result;
3794   /* If we have been pushed into a different namespace, use it.  */
3795   if (decl_namespace_list)
3796     return TREE_PURPOSE (decl_namespace_list);
3797
3798   if (current_class_type)
3799     result = decl_namespace (TYPE_STUB_DECL (current_class_type));
3800   else if (current_function_decl)
3801     result = decl_namespace (current_function_decl);
3802   else
3803     result = current_namespace;
3804   return result;
3805 }
3806
3807 /* Temporarily set the namespace for the current declaration.  */
3808
3809 void
3810 push_decl_namespace (tree decl)
3811 {
3812   if (TREE_CODE (decl) != NAMESPACE_DECL)
3813     decl = decl_namespace (decl);
3814   decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3815                                    NULL_TREE, decl_namespace_list);
3816 }
3817
3818 void
3819 pop_decl_namespace (void)
3820 {
3821   decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3822 }
3823
3824 /* Enter a class or namespace scope.  */
3825
3826 void
3827 push_scope (tree t)
3828 {
3829   if (TREE_CODE (t) == NAMESPACE_DECL)
3830     push_decl_namespace (t);
3831   else if CLASS_TYPE_P (t)
3832     push_nested_class (t);
3833 }
3834
3835 /* Leave scope pushed by push_scope.  */
3836
3837 void
3838 pop_scope (tree t)
3839 {
3840   if (TREE_CODE (t) == NAMESPACE_DECL)
3841     pop_decl_namespace ();
3842   else if CLASS_TYPE_P (t)
3843     pop_nested_class ();
3844 }
3845
3846 /* [basic.lookup.koenig] */
3847 /* A nonzero return value in the functions below indicates an error.  */
3848
3849 struct arg_lookup
3850 {
3851   tree name;
3852   tree namespaces;
3853   tree classes;
3854   tree functions;
3855 };
3856
3857 static bool arg_assoc (struct arg_lookup*, tree);
3858 static bool arg_assoc_args (struct arg_lookup*, tree);
3859 static bool arg_assoc_type (struct arg_lookup*, tree);
3860 static bool add_function (struct arg_lookup *, tree);
3861 static bool arg_assoc_namespace (struct arg_lookup *, tree);
3862 static bool arg_assoc_class (struct arg_lookup *, tree);
3863 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
3864
3865 /* Add a function to the lookup structure.
3866    Returns true on error.  */
3867
3868 static bool
3869 add_function (struct arg_lookup *k, tree fn)
3870 {
3871   /* We used to check here to see if the function was already in the list,
3872      but that's O(n^2), which is just too expensive for function lookup.
3873      Now we deal with the occasional duplicate in joust.  In doing this, we
3874      assume that the number of duplicates will be small compared to the
3875      total number of functions being compared, which should usually be the
3876      case.  */
3877
3878   /* We must find only functions, or exactly one non-function.  */
3879   if (!k->functions)
3880     k->functions = fn;
3881   else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
3882     k->functions = build_overload (fn, k->functions);
3883   else
3884     {
3885       tree f1 = OVL_CURRENT (k->functions);
3886       tree f2 = fn;
3887       if (is_overloaded_fn (f1))
3888         {
3889           fn = f1; f1 = f2; f2 = fn;
3890         }
3891       cp_error_at ("`%D' is not a function,", f1);
3892       cp_error_at ("  conflict with `%D'", f2);
3893       error ("  in call to `%D'", k->name);
3894       return true;
3895     }
3896
3897   return false;
3898 }
3899
3900 /* Add functions of a namespace to the lookup structure.
3901    Returns true on error.  */
3902
3903 static bool
3904 arg_assoc_namespace (struct arg_lookup *k, tree scope)
3905 {
3906   tree value;
3907
3908   if (purpose_member (scope, k->namespaces))
3909     return 0;
3910   k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
3911
3912   value = namespace_binding (k->name, scope);
3913   if (!value)
3914     return false;
3915
3916   for (; value; value = OVL_NEXT (value))
3917     if (add_function (k, OVL_CURRENT (value)))
3918       return true;
3919
3920   return false;
3921 }
3922
3923 /* Adds everything associated with a template argument to the lookup
3924    structure.  Returns true on error.  */
3925
3926 static bool
3927 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
3928 {
3929   /* [basic.lookup.koenig]
3930
3931      If T is a template-id, its associated namespaces and classes are
3932      ... the namespaces and classes associated with the types of the
3933      template arguments provided for template type parameters
3934      (excluding template template parameters); the namespaces in which
3935      any template template arguments are defined; and the classes in
3936      which any member templates used as template template arguments
3937      are defined.  [Note: non-type template arguments do not
3938      contribute to the set of associated namespaces.  ]  */
3939
3940   /* Consider first template template arguments.  */
3941   if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
3942       || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
3943     return false;
3944   else if (TREE_CODE (arg) == TEMPLATE_DECL)
3945     {
3946       tree ctx = CP_DECL_CONTEXT (arg);
3947
3948       /* It's not a member template.  */
3949       if (TREE_CODE (ctx) == NAMESPACE_DECL)
3950         return arg_assoc_namespace (k, ctx);
3951       /* Otherwise, it must be member template.  */
3952       else
3953         return arg_assoc_class (k, ctx);
3954     }
3955   /* It's not a template template argument, but it is a type template
3956      argument.  */
3957   else if (TYPE_P (arg))
3958     return arg_assoc_type (k, arg);
3959   /* It's a non-type template argument.  */
3960   else
3961     return false;
3962 }
3963
3964 /* Adds everything associated with class to the lookup structure.
3965    Returns true on error.  */
3966
3967 static bool
3968 arg_assoc_class (struct arg_lookup *k, tree type)
3969 {
3970   tree list, friends, context;
3971   int i;
3972
3973   /* Backend build structures, such as __builtin_va_list, aren't
3974      affected by all this.  */
3975   if (!CLASS_TYPE_P (type))
3976     return false;
3977
3978   if (purpose_member (type, k->classes))
3979     return false;
3980   k->classes = tree_cons (type, NULL_TREE, k->classes);
3981
3982   context = decl_namespace (TYPE_MAIN_DECL (type));
3983   if (arg_assoc_namespace (k, context))
3984     return true;
3985
3986   /* Process baseclasses.  */
3987   for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
3988     if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
3989       return true;
3990
3991   /* Process friends.  */
3992   for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
3993        list = TREE_CHAIN (list))
3994     if (k->name == FRIEND_NAME (list))
3995       for (friends = FRIEND_DECLS (list); friends;
3996            friends = TREE_CHAIN (friends))
3997         /* Only interested in global functions with potentially hidden
3998            (i.e. unqualified) declarations.  */
3999         if (CP_DECL_CONTEXT (TREE_VALUE (friends)) == context)
4000           if (add_function (k, TREE_VALUE (friends)))
4001             return true;
4002
4003   /* Process template arguments.  */
4004   if (CLASSTYPE_TEMPLATE_INFO (type))
4005     {
4006       list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4007       for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4008         arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4009     }
4010
4011   return false;
4012 }
4013
4014 /* Adds everything associated with a given type.
4015    Returns 1 on error.  */
4016
4017 static bool
4018 arg_assoc_type (struct arg_lookup *k, tree type)
4019 {
4020   switch (TREE_CODE (type))
4021     {
4022     case ERROR_MARK:
4023       return false;
4024     case VOID_TYPE:
4025     case INTEGER_TYPE:
4026     case REAL_TYPE:
4027     case COMPLEX_TYPE:
4028     case VECTOR_TYPE:
4029     case CHAR_TYPE:
4030     case BOOLEAN_TYPE:
4031       return false;
4032     case RECORD_TYPE:
4033       if (TYPE_PTRMEMFUNC_P (type))
4034         return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4035       return arg_assoc_class (k, type);
4036     case POINTER_TYPE:
4037     case REFERENCE_TYPE:
4038     case ARRAY_TYPE:
4039       return arg_assoc_type (k, TREE_TYPE (type));
4040     case UNION_TYPE:
4041     case ENUMERAL_TYPE:
4042       return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
4043     case OFFSET_TYPE:
4044       /* Pointer to member: associate class type and value type.  */
4045       if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
4046         return true;
4047       return arg_assoc_type (k, TREE_TYPE (type));
4048     case METHOD_TYPE:
4049       /* The basetype is referenced in the first arg type, so just
4050          fall through.  */
4051     case FUNCTION_TYPE:
4052       /* Associate the parameter types.  */
4053       if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4054         return true;
4055       /* Associate the return type.  */
4056       return arg_assoc_type (k, TREE_TYPE (type));
4057     case TEMPLATE_TYPE_PARM:
4058     case BOUND_TEMPLATE_TEMPLATE_PARM:
4059       return false;
4060     case TYPENAME_TYPE:
4061       return false;
4062     case LANG_TYPE:
4063       if (type == unknown_type_node)
4064         return false;
4065       /* else fall through */
4066     default:
4067       abort ();
4068     }
4069   return false;
4070 }
4071
4072 /* Adds everything associated with arguments.  Returns true on error.  */
4073
4074 static bool
4075 arg_assoc_args (struct arg_lookup *k, tree args)
4076 {
4077   for (; args; args = TREE_CHAIN (args))
4078     if (arg_assoc (k, TREE_VALUE (args)))
4079       return true;
4080   return false;
4081 }
4082
4083 /* Adds everything associated with a given tree_node.  Returns 1 on error.  */
4084
4085 static bool
4086 arg_assoc (struct arg_lookup *k, tree n)
4087 {
4088   if (n == error_mark_node)
4089     return false;
4090
4091   if (TYPE_P (n))
4092     return arg_assoc_type (k, n);
4093
4094   if (! type_unknown_p (n))
4095     return arg_assoc_type (k, TREE_TYPE (n));
4096
4097   if (TREE_CODE (n) == ADDR_EXPR)
4098     n = TREE_OPERAND (n, 0);
4099   if (TREE_CODE (n) == COMPONENT_REF)
4100     n = TREE_OPERAND (n, 1);
4101   if (TREE_CODE (n) == OFFSET_REF)
4102     n = TREE_OPERAND (n, 1);
4103   while (TREE_CODE (n) == TREE_LIST)
4104     n = TREE_VALUE (n);
4105   if (TREE_CODE (n) == BASELINK)
4106     n = BASELINK_FUNCTIONS (n);
4107
4108   if (TREE_CODE (n) == FUNCTION_DECL)
4109     return arg_assoc_type (k, TREE_TYPE (n));
4110   if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4111     {
4112       /* [basic.lookup.koenig]
4113
4114          If T is a template-id, its associated namespaces and classes
4115          are the namespace in which the template is defined; for
4116          member templates, the member template's class...  */
4117       tree template = TREE_OPERAND (n, 0);
4118       tree args = TREE_OPERAND (n, 1);
4119       tree ctx;
4120       tree arg;
4121
4122       if (TREE_CODE (template) == COMPONENT_REF)
4123         template = TREE_OPERAND (template, 1);
4124
4125       /* First, the template.  There may actually be more than one if
4126          this is an overloaded function template.  But, in that case,
4127          we only need the first; all the functions will be in the same
4128          namespace.  */
4129       template = OVL_CURRENT (template);
4130
4131       ctx = CP_DECL_CONTEXT (template);
4132
4133       if (TREE_CODE (ctx) == NAMESPACE_DECL)
4134         {
4135           if (arg_assoc_namespace (k, ctx) == 1)
4136             return true;
4137         }
4138       /* It must be a member template.  */
4139       else if (arg_assoc_class (k, ctx) == 1)
4140         return true;
4141
4142       /* Now the arguments.  */
4143       for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg))
4144         if (arg_assoc_template_arg (k, TREE_VALUE (arg)) == 1)
4145           return true;
4146     }
4147   else
4148     {
4149       my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715);
4150
4151       for (; n; n = OVL_CHAIN (n))
4152         if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4153           return true;
4154     }
4155
4156   return false;
4157 }
4158
4159 /* Performs Koenig lookup depending on arguments, where fns
4160    are the functions found in normal lookup.  */
4161
4162 tree
4163 lookup_arg_dependent (tree name, tree fns, tree args)
4164 {
4165   struct arg_lookup k;
4166   tree fn = NULL_TREE;
4167
4168   timevar_push (TV_NAME_LOOKUP);
4169   k.name = name;
4170   k.functions = fns;
4171   k.classes = NULL_TREE;
4172
4173   /* Note that we've already looked at some namespaces during normal
4174      unqualified lookup, unless we found a decl in function scope.  */
4175   if (fns)
4176     fn = OVL_CURRENT (fns);
4177   if (fn && TREE_CODE (fn) == FUNCTION_DECL && DECL_LOCAL_FUNCTION_P (fn))
4178     k.namespaces = NULL_TREE;
4179   else
4180     unqualified_namespace_lookup (name, 0, &k.namespaces);
4181
4182   arg_assoc_args (&k, args);
4183   POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4184 }
4185
4186 /* Process a namespace-alias declaration.  */
4187
4188 void
4189 do_namespace_alias (tree alias, tree namespace)
4190 {
4191   if (TREE_CODE (namespace) != NAMESPACE_DECL)
4192     {
4193       /* The parser did not find it, so it's not there.  */
4194       error ("unknown namespace `%D'", namespace);
4195       return;
4196     }
4197
4198   namespace = ORIGINAL_NAMESPACE (namespace);
4199
4200   /* Build the alias.  */
4201   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
4202   DECL_NAMESPACE_ALIAS (alias) = namespace;
4203   DECL_EXTERNAL (alias) = 1;
4204   pushdecl (alias);
4205 }
4206
4207 /* Check a non-member using-declaration. Return the name and scope
4208    being used, and the USING_DECL, or NULL_TREE on failure.  */
4209
4210 static tree
4211 validate_nonmember_using_decl (tree decl, tree *scope, tree *name)
4212 {
4213   *scope = global_namespace;
4214   *name = NULL_TREE;
4215
4216   if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
4217     {
4218       *name = TREE_OPERAND (decl, 0);
4219       /* 7.3.3/5
4220            A using-declaration shall not name a template-id.  */
4221       error ("a using-declaration cannot specify a template-id.  Try `using %D'", *name);
4222       return NULL_TREE;
4223     }
4224
4225   if (TREE_CODE (decl) == NAMESPACE_DECL)
4226     {
4227       error ("namespace `%D' not allowed in using-declaration", decl);
4228       return NULL_TREE;
4229     }
4230
4231   if (TREE_CODE (decl) == SCOPE_REF)
4232     {
4233       /* It's a nested name with template parameter dependent scope.
4234          This can only be using-declaration for class member.  */
4235       error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
4236       return NULL_TREE;
4237     }
4238
4239   if (is_overloaded_fn (decl))
4240     decl = get_first_fn (decl);
4241
4242   my_friendly_assert (DECL_P (decl), 20020908);
4243
4244   if (TREE_CODE (decl) == CONST_DECL)
4245     /* Enumeration constants to not have DECL_CONTEXT set.  */
4246     *scope = TYPE_CONTEXT (TREE_TYPE (decl));
4247   else
4248     *scope = DECL_CONTEXT (decl);
4249   if (!*scope)
4250     *scope = global_namespace;
4251
4252   /* [namespace.udecl]
4253        A using-declaration for a class member shall be a
4254        member-declaration.  */
4255   if (TYPE_P (*scope))
4256     {
4257       error ("`%T' is not a namespace", *scope);
4258       return NULL_TREE;
4259     }
4260   *name = DECL_NAME (decl);
4261   /* Make a USING_DECL. */
4262   return push_using_decl (*scope, *name);
4263 }
4264
4265 /* Process local and global using-declarations.  */
4266
4267 static void
4268 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
4269                          tree *newval, tree *newtype)
4270 {
4271   cxx_binding decls;
4272
4273   *newval = *newtype = NULL_TREE;
4274   cxx_binding_clear (&decls);
4275   if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
4276     /* Lookup error */
4277     return;
4278
4279   if (!decls.value && !decls.type)
4280     {
4281       error ("`%D' not declared", name);
4282       return;
4283     }
4284
4285   /* Check for using functions.  */
4286   if (decls.value && is_overloaded_fn (decls.value))
4287     {
4288       tree tmp, tmp1;
4289
4290       if (oldval && !is_overloaded_fn (oldval))
4291         {
4292           if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
4293             error ("`%D' is already declared in this scope", name);
4294           oldval = NULL_TREE;
4295         }
4296
4297       *newval = oldval;
4298       for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
4299         {
4300           tree new_fn = OVL_CURRENT (tmp);
4301
4302           /* [namespace.udecl]
4303
4304              If a function declaration in namespace scope or block
4305              scope has the same name and the same parameter types as a
4306              function introduced by a using declaration the program is
4307              ill-formed.  */
4308           for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
4309             {
4310               tree old_fn = OVL_CURRENT (tmp1);
4311
4312               if (new_fn == old_fn)
4313                 /* The function already exists in the current namespace.  */
4314                 break;
4315               else if (OVL_USED (tmp1))
4316                 continue; /* this is a using decl */
4317               else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
4318                                   TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
4319                 {
4320                   /* There was already a non-using declaration in
4321                      this scope with the same parameter types. If both
4322                      are the same extern "C" functions, that's ok.  */
4323                   if (decls_match (new_fn, old_fn))
4324                     {
4325                       /* If the OLD_FN was a builtin, there is now a
4326                          real declaration.  */
4327                       if (DECL_ANTICIPATED (old_fn))
4328                         DECL_ANTICIPATED (old_fn) = 0;
4329                       break;
4330                     }
4331                   else if (!DECL_ANTICIPATED (old_fn))
4332                     {
4333                       /* If the OLD_FN was really declared, the
4334                          declarations don't match.  */
4335                       error ("`%D' is already declared in this scope", name);
4336                       break;
4337                     }
4338
4339                   /* If the OLD_FN was not really there, just ignore
4340                      it and keep going.  */
4341                 }
4342             }
4343
4344           /* If we broke out of the loop, there's no reason to add
4345              this function to the using declarations for this
4346              scope.  */
4347           if (tmp1)
4348             continue;
4349
4350           *newval = build_overload (OVL_CURRENT (tmp), *newval);
4351           if (TREE_CODE (*newval) != OVERLOAD)
4352             *newval = ovl_cons (*newval, NULL_TREE);
4353           OVL_USED (*newval) = 1;
4354         }
4355     }
4356   else
4357     {
4358       *newval = decls.value;
4359       if (oldval && !decls_match (*newval, oldval))
4360         error ("`%D' is already declared in this scope", name);
4361     }
4362
4363   *newtype = decls.type;
4364   if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
4365     {
4366       error ("using declaration `%D' introduced ambiguous type `%T'",
4367                 name, oldtype);
4368       return;
4369     }
4370 }
4371
4372 /* Process a using-declaration not appearing in class or local scope.  */
4373
4374 void
4375 do_toplevel_using_decl (tree decl)
4376 {
4377   tree scope, name;
4378   tree oldval, oldtype, newval, newtype;
4379   cxx_binding *binding;
4380
4381   decl = validate_nonmember_using_decl (decl, &scope, &name);
4382   if (decl == NULL_TREE)
4383     return;
4384
4385   binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
4386
4387   oldval = BINDING_VALUE (binding);
4388   oldtype = BINDING_TYPE (binding);
4389
4390   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
4391
4392   /* Copy declarations found.  */
4393   if (newval)
4394     BINDING_VALUE (binding) = newval;
4395   if (newtype)
4396     BINDING_TYPE (binding) = newtype;
4397   return;
4398 }
4399
4400 /* Process a using-declaration at function scope.  */
4401
4402 void
4403 do_local_using_decl (tree decl)
4404 {
4405   tree scope, name;
4406   tree oldval, oldtype, newval, newtype;
4407
4408   decl = validate_nonmember_using_decl (decl, &scope, &name);
4409   if (decl == NULL_TREE)
4410     return;
4411
4412   if (building_stmt_tree ()
4413       && at_function_scope_p ())
4414     add_decl_stmt (decl);
4415
4416   oldval = lookup_name_current_level (name);
4417   oldtype = lookup_type_current_level (name);
4418
4419   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
4420
4421   if (newval)
4422     {
4423       if (is_overloaded_fn (newval))
4424         {
4425           tree fn, term;
4426
4427           /* We only need to push declarations for those functions
4428              that were not already bound in the current level.
4429              The old value might be NULL_TREE, it might be a single
4430              function, or an OVERLOAD.  */
4431           if (oldval && TREE_CODE (oldval) == OVERLOAD)
4432             term = OVL_FUNCTION (oldval);
4433           else
4434             term = oldval;
4435           for (fn = newval; fn && OVL_CURRENT (fn) != term;
4436                fn = OVL_NEXT (fn))
4437             push_overloaded_decl (OVL_CURRENT (fn),
4438                                   PUSH_LOCAL | PUSH_USING);
4439         }
4440       else
4441         push_local_binding (name, newval, PUSH_USING);
4442     }
4443   if (newtype)
4444     set_identifier_type_value (name, newtype);
4445 }
4446
4447 tree
4448 do_class_using_decl (tree decl)
4449 {
4450   tree name, value;
4451
4452   if (TREE_CODE (decl) != SCOPE_REF
4453       || !TREE_OPERAND (decl, 0)
4454       || !TYPE_P (TREE_OPERAND (decl, 0)))
4455     {
4456       error ("using-declaration for non-member at class scope");
4457       return NULL_TREE;
4458     }
4459   name = TREE_OPERAND (decl, 1);
4460   if (TREE_CODE (name) == BIT_NOT_EXPR)
4461     {
4462       error ("using-declaration for destructor");
4463       return NULL_TREE;
4464     }
4465   else if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
4466     {
4467       name = TREE_OPERAND (name, 0);
4468       error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'", TREE_OPERAND (decl, 0), name);
4469       return NULL_TREE;
4470     }
4471   if (TREE_CODE (name) == TYPE_DECL)
4472     {
4473       tree type = TREE_TYPE (name);
4474       if (CLASSTYPE_USE_TEMPLATE (TREE_TYPE (name)))
4475         {
4476           name = DECL_NAME (CLASSTYPE_TI_TEMPLATE (type));
4477           error ("a using-declaration cannot specify a template-id.");
4478           return NULL_TREE;
4479         }
4480       name = DECL_NAME (name);
4481     }
4482   else if (TREE_CODE (name) == TEMPLATE_DECL)
4483      name = DECL_NAME (name);
4484   else if (BASELINK_P (name))
4485     {
4486       tree fns;
4487
4488       fns = BASELINK_FUNCTIONS (name);
4489       if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
4490         {
4491           fns = TREE_OPERAND (fns, 0);
4492           error ("a using-declaration cannot specify a template-id.  Try  `using %T::%D'",
4493                  BASELINK_ACCESS_BINFO (name),
4494                  DECL_NAME (get_first_fn (fns)));
4495         }
4496       name = DECL_NAME (get_first_fn (fns));
4497     }
4498
4499   my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
4500
4501   value = build_lang_decl (USING_DECL, name, void_type_node);
4502   DECL_INITIAL (value) = TREE_OPERAND (decl, 0);
4503   return value;
4504 }
4505
4506 /* Process a using-directive.  */
4507
4508 void
4509 do_using_directive (tree namespace)
4510 {
4511   if (building_stmt_tree ())
4512     add_stmt (build_stmt (USING_STMT, namespace));
4513
4514   /* using namespace A::B::C; */
4515   if (TREE_CODE (namespace) == SCOPE_REF)
4516       namespace = TREE_OPERAND (namespace, 1);
4517   if (TREE_CODE (namespace) == IDENTIFIER_NODE)
4518     {
4519       /* Lookup in lexer did not find a namespace.  */
4520       if (!processing_template_decl)
4521         error ("namespace `%T' undeclared", namespace);
4522       return;
4523     }
4524   if (TREE_CODE (namespace) != NAMESPACE_DECL)
4525     {
4526       if (!processing_template_decl)
4527         error ("`%T' is not a namespace", namespace);
4528       return;
4529     }
4530   namespace = ORIGINAL_NAMESPACE (namespace);
4531   if (!toplevel_bindings_p ())
4532     push_using_directive (namespace);
4533   else
4534     /* direct usage */
4535     add_using_namespace (current_namespace, namespace, 0);
4536 }
4537
4538 void
4539 check_default_args (tree x)
4540 {
4541   tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
4542   bool saw_def = false;
4543   int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
4544   for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
4545     {
4546       if (TREE_PURPOSE (arg))
4547         saw_def = true;
4548       else if (saw_def)
4549         {
4550           cp_error_at ("default argument missing for parameter %P of `%+#D'",
4551                        i, x);
4552           break;
4553         }
4554     }
4555 }
4556
4557 void
4558 mark_used (tree decl)
4559 {
4560   TREE_USED (decl) = 1;
4561   if (processing_template_decl || skip_evaluation)
4562     return;
4563
4564   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4565       && !TREE_ASM_WRITTEN (decl))
4566     /* Remember it, so we can check it was defined.  */
4567     defer_fn (decl);
4568
4569   assemble_external (decl);
4570
4571   /* Is it a synthesized method that needs to be synthesized?  */
4572   if (TREE_CODE (decl) == FUNCTION_DECL
4573       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4574       && DECL_ARTIFICIAL (decl)
4575       && !DECL_THUNK_P (decl)
4576       && ! DECL_INITIAL (decl)
4577       /* Kludge: don't synthesize for default args.  */
4578       && current_function_decl)
4579     {
4580       synthesize_method (decl);
4581       /* If we've already synthesized the method we don't need to
4582          instantiate it, so we can return right away.  */
4583       return;
4584     }
4585
4586   /* If this is a function or variable that is an instance of some
4587      template, we now know that we will need to actually do the
4588      instantiation. We check that DECL is not an explicit
4589      instantiation because that is not checked in instantiate_decl.  */
4590   if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
4591       && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
4592       && (!DECL_EXPLICIT_INSTANTIATION (decl)
4593           || (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))))
4594     {
4595       bool defer;
4596
4597       /* Normally, we put off instantiating functions in order to
4598          improve compile times.  Maintaining a stack of active
4599          functions is expensive, and the inliner knows to
4600          instantiate any functions it might need.
4601
4602          However, if instantiating this function might help us mark
4603          the current function TREE_NOTHROW, we go ahead and
4604          instantiate it now.  */
4605       defer = (!flag_exceptions
4606                || TREE_CODE (decl) != FUNCTION_DECL
4607                /* If the called function can't throw, we don't need to
4608                   generate its body to find that out.  */
4609                || TREE_NOTHROW (decl)
4610                || !cfun
4611                /* If we already know the current function can't throw,
4612                   then we don't need to work hard to prove it.  */
4613                || TREE_NOTHROW (current_function_decl)
4614                /* If we already know that the current function *can*
4615                   throw, there's no point in gathering more
4616                   information.  */
4617                || cp_function_chain->can_throw);
4618
4619       instantiate_decl (decl, defer);
4620     }
4621 }
4622
4623 /* Called when a class-head is encountered.  TAG_KIND is the class-key
4624    for the class.  SCOPE, if non-NULL, is the type or namespace
4625    indicated in the nested-name-specifier for the declaration of the
4626    class.  ID is the name of the class, if any; it may be a TYPE_DECL,
4627    or an IDENTIFIER_NODE.  ATTRIBUTES are attributes that apply to the
4628    class.
4629
4630    Return a TYPE_DECL for the class being defined.  */
4631
4632 tree
4633 handle_class_head (enum tag_types tag_kind, tree scope, tree id,
4634                    tree attributes)
4635 {
4636   tree decl = NULL_TREE;
4637   tree current = current_scope ();
4638   bool xrefd_p = false;
4639   bool new_type_p;
4640   tree context;
4641
4642   if (current == NULL_TREE)
4643     current = current_namespace;
4644
4645   if (scope)
4646     {
4647       if (TREE_CODE (id) == TYPE_DECL)
4648         /* We must bash typedefs back to the main decl of the
4649            type. Otherwise we become confused about scopes.  */
4650         decl = TYPE_MAIN_DECL (TREE_TYPE (id));
4651       else if (DECL_CLASS_TEMPLATE_P (id))
4652         decl = DECL_TEMPLATE_RESULT (id);
4653       else
4654         {
4655           if (TYPE_P (scope))
4656             {
4657               /* According to the suggested resolution of core issue
4658                  180, 'typename' is assumed after a class-key.  */
4659               decl = make_typename_type (scope, id, tf_error);
4660               if (decl != error_mark_node)
4661                 decl = TYPE_MAIN_DECL (decl);
4662               else
4663                 decl = NULL_TREE;
4664             }
4665           else if (scope == current)
4666             {
4667               /* We've been given AGGR SCOPE::ID, when we're already
4668                  inside SCOPE.  Be nice about it.  */
4669               if (pedantic)
4670                 pedwarn ("extra qualification `%T::' on member `%D' ignored",
4671                          scope, id);
4672             }
4673           else
4674             error ("`%T' does not have a class or union named `%D'",
4675                    scope, id);
4676         }
4677     }
4678
4679   if (!decl)
4680     {
4681       decl = xref_tag (tag_kind, id, attributes, false);
4682       if (decl == error_mark_node)
4683         return error_mark_node;
4684       decl = TYPE_MAIN_DECL (decl);
4685       xrefd_p = true;
4686     }
4687
4688   if (!TYPE_BINFO (TREE_TYPE (decl)))
4689     {
4690       error ("`%T' is not a class or union type", decl);
4691       return error_mark_node;
4692     }
4693
4694   /* For a definition, we want to enter the containing scope before
4695      looking up any base classes etc. Only do so, if this is different
4696      to the current scope.  */
4697   context = CP_DECL_CONTEXT (decl);
4698
4699   new_type_p = (current != context
4700                 && TREE_CODE (context) != TEMPLATE_TYPE_PARM
4701                 && TREE_CODE (context) != BOUND_TEMPLATE_TEMPLATE_PARM);
4702   if (new_type_p)
4703     push_scope (context);
4704
4705   if (!xrefd_p
4706       && PROCESSING_REAL_TEMPLATE_DECL_P ()
4707       && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)))
4708     decl = push_template_decl (decl);
4709
4710   return decl;
4711 }
4712
4713 #include "gt-cp-decl2.h"