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