contrib/gcc-3.4/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, 2004 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 tree build_anon_union_vars (tree);
  68 static bool acceptable_java_type (tree);
  69 static tree start_objects (int, int);
  70 static void finish_objects (int, int, tree);
  71 static tree start_static_storage_duration_function (unsigned);
  72 static void finish_static_storage_duration_function (tree);
  73 static priority_info get_priority_info (int);
  74 static void do_static_initialization (tree, tree);
  75 static void do_static_destruction (tree);
  76 static tree start_static_initialization_or_destruction (tree, int);
  77 static void finish_static_initialization_or_destruction (tree);
  78 static void generate_ctor_or_dtor_function (bool, int, location_t *);
  79 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
  80                                                           void *);
  81 static tree prune_vars_needing_no_initialization (tree *);
  82 static void write_out_vars (tree);
  83 static void import_export_class (tree);
  84 static tree get_guard_bits (tree);
  85
  86 /* A list of static class variables.  This is needed, because a
  87    static class variable can be declared inside the class without
  88    an initializer, and then initialized, statically, outside the class.  */
  89 static GTY(()) varray_type pending_statics;
  90 #define pending_statics_used \
  91   (pending_statics ? pending_statics->elements_used : 0)
  92
  93 /* A list of functions which were declared inline, but which we
  94    may need to emit outline anyway.  */
  95 static GTY(()) varray_type deferred_fns;
  96 #define deferred_fns_used \
  97   (deferred_fns ? deferred_fns->elements_used : 0)
  98
  99 /* Flag used when debugging spew.c */
 100
 101 extern int spew_debug;
 102
 103 /* Nonzero if we're done parsing and into end-of-file activities.  */
 104
 105 int at_eof;
 106
 107 /* Functions called along with real static constructors and destructors.  */
 108
 109 tree static_ctors;
 110 tree static_dtors;
 111
 112 \f
 113 /* Incorporate `const' and `volatile' qualifiers for member functions.
 114    FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
 115    QUALS is a list of qualifiers.  Returns any explicit
 116    top-level qualifiers of the method's this pointer, anything other than
 117    TYPE_UNQUALIFIED will be an extension.  */
 118
 119 int
 120 grok_method_quals (tree ctype, tree function, tree quals)
 121 {
 122   tree fntype = TREE_TYPE (function);
 123   tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
 124   int type_quals = TYPE_UNQUALIFIED;
 125   int dup_quals = TYPE_UNQUALIFIED;
 126   int this_quals = TYPE_UNQUALIFIED;
 127
 128   do
 129     {
 130       int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
 131
 132       if ((type_quals | this_quals) & tq)
 133         dup_quals |= tq;
 134       else if (tq & TYPE_QUAL_RESTRICT)
 135         this_quals |= tq;
 136       else
 137         type_quals |= tq;
 138       quals = TREE_CHAIN (quals);
 139     }
 140   while (quals);
 141
 142   if (dup_quals != TYPE_UNQUALIFIED)
 143     error ("duplicate type qualifiers in %s declaration",
 144               TREE_CODE (function) == FUNCTION_DECL
 145               ? "member function" : "type");
 146
 147   ctype = cp_build_qualified_type (ctype, type_quals);
 148   fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
 149                                        (TREE_CODE (fntype) == METHOD_TYPE
 150                                         ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
 151                                         : TYPE_ARG_TYPES (fntype)));
 152   if (raises)
 153     fntype = build_exception_variant (fntype, raises);
 154
 155   TREE_TYPE (function) = fntype;
 156   return this_quals;
 157 }
 158
 159 /* A subroutine of the parser, to handle a component list.  */
 160
 161 void
 162 grok_x_components (tree specs)
 163 {
 164   tree t;
 165
 166   specs = strip_attrs (specs);
 167
 168   check_tag_decl (specs);
 169   t = groktypename (build_tree_list (specs, NULL_TREE));
 170
 171   /* The only case where we need to do anything additional here is an
 172      anonymous union field, e.g.: `struct S { union { int i; }; };'.  */
 173   if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t))
 174     return;
 175
 176   fixup_anonymous_aggr (t);
 177   finish_member_declaration (build_decl (FIELD_DECL, NULL_TREE, t));
 178 }
 179
 180 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
 181    appropriately.  */
 182
 183 tree
 184 cp_build_parm_decl (tree name, tree type)
 185 {
 186   tree parm = build_decl (PARM_DECL, name, type);
 187   /* DECL_ARG_TYPE is only used by the back end and the back end never
 188      sees templates.  */
 189   if (!processing_template_decl)
 190     DECL_ARG_TYPE (parm) = type_passed_as (type);
 191   return parm;
 192 }
 193
 194 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
 195    indicated NAME.  */
 196
 197 tree
 198 build_artificial_parm (tree name, tree type)
 199 {
 200   tree parm = cp_build_parm_decl (name, type);
 201   DECL_ARTIFICIAL (parm) = 1;
 202   /* All our artificial parms are implicitly `const'; they cannot be
 203      assigned to.  */
 204   TREE_READONLY (parm) = 1;
 205   return parm;
 206 }
 207
 208 /* Constructors for types with virtual baseclasses need an "in-charge" flag
 209    saying whether this constructor is responsible for initialization of
 210    virtual baseclasses or not.  All destructors also need this "in-charge"
 211    flag, which additionally determines whether or not the destructor should
 212    free the memory for the object.
 213
 214    This function adds the "in-charge" flag to member function FN if
 215    appropriate.  It is called from grokclassfn and tsubst.
 216    FN must be either a constructor or destructor.
 217
 218    The in-charge flag follows the 'this' parameter, and is followed by the
 219    VTT parm (if any), then the user-written parms.  */
 220
 221 void
 222 maybe_retrofit_in_chrg (tree fn)
 223 {
 224   tree basetype, arg_types, parms, parm, fntype;
 225
 226   /* If we've already add the in-charge parameter don't do it again.  */
 227   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
 228     return;
 229
 230   /* When processing templates we can't know, in general, whether or
 231      not we're going to have virtual baseclasses.  */
 232   if (processing_template_decl)
 233     return;
 234
 235   /* We don't need an in-charge parameter for constructors that don't
 236      have virtual bases.  */
 237   if (DECL_CONSTRUCTOR_P (fn)
 238       && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
 239     return;
 240
 241   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
 242   basetype = TREE_TYPE (TREE_VALUE (arg_types));
 243   arg_types = TREE_CHAIN (arg_types);
 244
 245   parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
 246
 247   /* If this is a subobject constructor or destructor, our caller will
 248      pass us a pointer to our VTT.  */
 249   if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
 250     {
 251       parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
 252
 253       /* First add it to DECL_ARGUMENTS between 'this' and the real args...  */
 254       TREE_CHAIN (parm) = parms;
 255       parms = parm;
 256
 257       /* ...and then to TYPE_ARG_TYPES.  */
 258       arg_types = hash_tree_chain (vtt_parm_type, arg_types);
 259
 260       DECL_HAS_VTT_PARM_P (fn) = 1;
 261     }
 262
 263   /* Then add the in-charge parm (before the VTT parm).  */
 264   parm = build_artificial_parm (in_charge_identifier, integer_type_node);
 265   TREE_CHAIN (parm) = parms;
 266   parms = parm;
 267   arg_types = hash_tree_chain (integer_type_node, arg_types);
 268
 269   /* Insert our new parameter(s) into the list.  */
 270   TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
 271
 272   /* And rebuild the function type.  */
 273   fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
 274                                        arg_types);
 275   if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
 276     fntype = build_exception_variant (fntype,
 277                                       TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
 278   TREE_TYPE (fn) = fntype;
 279
 280   /* Now we've got the in-charge parameter.  */
 281   DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
 282 }
 283
 284 /* Classes overload their constituent function names automatically.
 285    When a function name is declared in a record structure,
 286    its name is changed to it overloaded name.  Since names for
 287    constructors and destructors can conflict, we place a leading
 288    '$' for destructors.
 289
 290    CNAME is the name of the class we are grokking for.
 291
 292    FUNCTION is a FUNCTION_DECL.  It was created by `grokdeclarator'.
 293
 294    FLAGS contains bits saying what's special about today's
 295    arguments.  1 == DESTRUCTOR.  2 == OPERATOR.
 296
 297    If FUNCTION is a destructor, then we must add the `auto-delete' field
 298    as a second parameter.  There is some hair associated with the fact
 299    that we must "declare" this variable in the manner consistent with the
 300    way the rest of the arguments were declared.
 301
 302    QUALS are the qualifiers for the this pointer.  */
 303
 304 void
 305 grokclassfn (tree ctype, tree function, enum overload_flags flags, tree quals)
 306 {
 307   tree fn_name = DECL_NAME (function);
 308   int this_quals = TYPE_UNQUALIFIED;
 309
 310   /* Even within an `extern "C"' block, members get C++ linkage.  See
 311      [dcl.link] for details.  */
 312   SET_DECL_LANGUAGE (function, lang_cplusplus);
 313
 314   if (fn_name == NULL_TREE)
 315     {
 316       error ("name missing for member function");
 317       fn_name = get_identifier ("<anonymous>");
 318       DECL_NAME (function) = fn_name;
 319     }
 320
 321   if (quals)
 322     this_quals = grok_method_quals (ctype, function, quals);
 323
 324   if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
 325     {
 326       /* Must add the class instance variable up front.  */
 327       /* Right now we just make this a pointer.  But later
 328          we may wish to make it special.  */
 329       tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function)));
 330       tree qual_type;
 331       tree parm;
 332
 333       /* The `this' parameter is implicitly `const'; it cannot be
 334          assigned to.  */
 335       this_quals |= TYPE_QUAL_CONST;
 336       qual_type = cp_build_qualified_type (type, this_quals);
 337       parm = build_artificial_parm (this_identifier, qual_type);
 338       c_apply_type_quals_to_decl (this_quals, parm);
 339       TREE_CHAIN (parm) = DECL_ARGUMENTS (function);
 340       DECL_ARGUMENTS (function) = parm;
 341     }
 342
 343   DECL_CONTEXT (function) = ctype;
 344
 345   if (flags == DTOR_FLAG)
 346     DECL_DESTRUCTOR_P (function) = 1;
 347
 348   if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
 349     maybe_retrofit_in_chrg (function);
 350 }
 351
 352 /* Create an ARRAY_REF, checking for the user doing things backwards
 353    along the way.  */
 354
 355 tree
 356 grok_array_decl (tree array_expr, tree index_exp)
 357 {
 358   tree type;
 359   tree expr;
 360   tree orig_array_expr = array_expr;
 361   tree orig_index_exp = index_exp;
 362
 363   if (error_operand_p (array_expr) || error_operand_p (index_exp))
 364     return error_mark_node;
 365
 366   if (processing_template_decl)
 367     {
 368       if (type_dependent_expression_p (array_expr)
 369           || type_dependent_expression_p (index_exp))
 370         return build_min_nt (ARRAY_REF, array_expr, index_exp);
 371       array_expr = build_non_dependent_expr (array_expr);
 372       index_exp = build_non_dependent_expr (index_exp);
 373     }
 374
 375   type = TREE_TYPE (array_expr);
 376   my_friendly_assert (type, 20030626);
 377   type = non_reference (type);
 378
 379   /* If they have an `operator[]', use that.  */
 380   if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
 381     expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
 382                          array_expr, index_exp, NULL_TREE,
 383                          /*overloaded_p=*/NULL);
 384   else
 385     {
 386       tree p1, p2, i1, i2;
 387
 388       /* Otherwise, create an ARRAY_REF for a pointer or array type.
 389          It is a little-known fact that, if `a' is an array and `i' is
 390          an int, you can write `i[a]', which means the same thing as
 391          `a[i]'.  */
 392       if (TREE_CODE (type) == ARRAY_TYPE)
 393         p1 = array_expr;
 394       else
 395         p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
 396
 397       if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
 398         p2 = index_exp;
 399       else
 400         p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
 401
 402       i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
 403                                        false);
 404       i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
 405                                        false);
 406
 407       if ((p1 && i2) && (i1 && p2))
 408         error ("ambiguous conversion for array subscript");
 409
 410       if (p1 && i2)
 411         array_expr = p1, index_exp = i2;
 412       else if (i1 && p2)
 413         array_expr = p2, index_exp = i1;
 414       else
 415         {
 416           error ("invalid types `%T[%T]' for array subscript",
 417                     type, TREE_TYPE (index_exp));
 418           return error_mark_node;
 419         }
 420
 421       if (array_expr == error_mark_node || index_exp == error_mark_node)
 422         error ("ambiguous conversion for array subscript");
 423
 424       expr = build_array_ref (array_expr, index_exp);
 425     }
 426   if (processing_template_decl && expr != error_mark_node)
 427     return build_min_non_dep (ARRAY_REF, expr,
 428                               orig_array_expr, orig_index_exp);
 429   return expr;
 430 }
 431
 432 /* Given the cast expression EXP, checking out its validity.   Either return
 433    an error_mark_node if there was an unavoidable error, return a cast to
 434    void for trying to delete a pointer w/ the value 0, or return the
 435    call to delete.  If DOING_VEC is true, we handle things differently
 436    for doing an array delete.
 437    Implements ARM $5.3.4.  This is called from the parser.  */
 438
 439 tree
 440 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete)
 441 {
 442   tree t, type;
 443
 444   if (exp == error_mark_node)
 445     return exp;
 446
 447   if (processing_template_decl)
 448     {
 449       t = build_min (DELETE_EXPR, void_type_node, exp, size);
 450       DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
 451       DELETE_EXPR_USE_VEC (t) = doing_vec;
 452       TREE_SIDE_EFFECTS (t) = 1;
 453       return t;
 454     }
 455
 456   exp = convert_from_reference (exp);
 457
 458   /* An array can't have been allocated by new, so complain.  */
 459   if (TREE_CODE (exp) == VAR_DECL
 460       && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
 461     warning ("deleting array `%#D'", exp);
 462
 463   t = build_expr_type_conversion (WANT_POINTER, exp, true);
 464
 465   if (t == NULL_TREE || t == error_mark_node)
 466     {
 467       error ("type `%#T' argument given to `delete', expected pointer",
 468                 TREE_TYPE (exp));
 469       return error_mark_node;
 470     }
 471
 472   type = TREE_TYPE (t);
 473
 474   /* As of Valley Forge, you can delete a pointer to const.  */
 475
 476   /* You can't delete functions.  */
 477   if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 478     {
 479       error ("cannot delete a function.  Only pointer-to-objects are valid arguments to `delete'");
 480       return error_mark_node;
 481     }
 482
 483   /* Deleting ptr to void is undefined behavior [expr.delete/3].  */
 484   if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
 485     {
 486       warning ("deleting `%T' is undefined", type);
 487       doing_vec = 0;
 488     }
 489
 490   /* Deleting a pointer with the value zero is valid and has no effect.  */
 491   if (integer_zerop (t))
 492     return build1 (NOP_EXPR, void_type_node, t);
 493
 494   if (doing_vec)
 495     return build_vec_delete (t, /*maxindex=*/NULL_TREE,
 496                              sfk_deleting_destructor,
 497                              use_global_delete);
 498   else
 499     return build_delete (type, t, sfk_deleting_destructor,
 500                          LOOKUP_NORMAL, use_global_delete);
 501 }
 502
 503 /* Report an error if the indicated template declaration is not the
 504    sort of thing that should be a member template.  */
 505
 506 void
 507 check_member_template (tree tmpl)
 508 {
 509   tree decl;
 510
 511   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
 512   decl = DECL_TEMPLATE_RESULT (tmpl);
 513
 514   if (TREE_CODE (decl) == FUNCTION_DECL
 515       || (TREE_CODE (decl) == TYPE_DECL
 516           && IS_AGGR_TYPE (TREE_TYPE (decl))))
 517     {
 518       if (current_function_decl)
 519         /* 14.5.2.2 [temp.mem]
 520
 521            A local class shall not have member templates.  */
 522         error ("invalid declaration of member template `%#D' in local class",
 523                   decl);
 524
 525       if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
 526         {
 527           /* 14.5.2.3 [temp.mem]
 528
 529              A member function template shall not be virtual.  */
 530           error
 531             ("invalid use of `virtual' in template declaration of `%#D'",
 532              decl);
 533           DECL_VIRTUAL_P (decl) = 0;
 534         }
 535
 536       /* The debug-information generating code doesn't know what to do
 537          with member templates.  */
 538       DECL_IGNORED_P (tmpl) = 1;
 539     }
 540   else
 541     error ("template declaration of `%#D'", decl);
 542 }
 543
 544 /* Return true iff TYPE is a valid Java parameter or return type.  */
 545
 546 static bool
 547 acceptable_java_type (tree type)
 548 {
 549   if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
 550     return 1;
 551   if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
 552     {
 553       type = TREE_TYPE (type);
 554       if (TREE_CODE (type) == RECORD_TYPE)
 555         {
 556           tree args;  int i;
 557           if (! TYPE_FOR_JAVA (type))
 558             return false;
 559           if (! CLASSTYPE_TEMPLATE_INFO (type))
 560             return true;
 561           args = CLASSTYPE_TI_ARGS (type);
 562           i = TREE_VEC_LENGTH (args);
 563           while (--i >= 0)
 564             {
 565               type = TREE_VEC_ELT (args, i);
 566               if (TREE_CODE (type) == POINTER_TYPE)
 567                 type = TREE_TYPE (type);
 568               if (! TYPE_FOR_JAVA (type))
 569                 return false;
 570             }
 571           return true;
 572         }
 573     }
 574   return false;
 575 }
 576
 577 /* For a METHOD in a Java class CTYPE, return true if
 578    the parameter and return types are valid Java types.
 579    Otherwise, print appropriate error messages, and return false.  */
 580
 581 bool
 582 check_java_method (tree method)
 583 {
 584   bool jerr = false;
 585   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
 586   tree ret_type = TREE_TYPE (TREE_TYPE (method));
 587
 588   if (!acceptable_java_type (ret_type))
 589     {
 590       error ("Java method '%D' has non-Java return type `%T'",
 591                 method, ret_type);
 592       jerr = true;
 593     }
 594
 595   arg_types = TREE_CHAIN (arg_types);
 596   if (DECL_HAS_IN_CHARGE_PARM_P (method))
 597     arg_types = TREE_CHAIN (arg_types);
 598   if (DECL_HAS_VTT_PARM_P (method))
 599     arg_types = TREE_CHAIN (arg_types);
 600
 601   for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
 602     {
 603       tree type = TREE_VALUE (arg_types);
 604       if (!acceptable_java_type (type))
 605         {
 606           error ("Java method '%D' has non-Java parameter type `%T'",
 607                     method, type);
 608           jerr = true;
 609         }
 610     }
 611   return !jerr;
 612 }
 613
 614 /* Sanity check: report error if this function FUNCTION is not
 615    really a member of the class (CTYPE) it is supposed to belong to.
 616    CNAME is the same here as it is for grokclassfn above.
 617    TEMPLATE_HEADER_P is true when this declaration comes with a
 618    template header.  */
 619
 620 tree
 621 check_classfn (tree ctype, tree function, bool template_header_p)
 622 {
 623   int ix;
 624   int is_template;
 625
 626   if (DECL_USE_TEMPLATE (function)
 627       && !(TREE_CODE (function) == TEMPLATE_DECL
 628            && DECL_TEMPLATE_SPECIALIZATION (function))
 629       && is_member_template (DECL_TI_TEMPLATE (function)))
 630     /* Since this is a specialization of a member template,
 631        we're not going to find the declaration in the class.
 632        For example, in:
 633
 634          struct S { template <typename T> void f(T); };
 635          template <> void S::f(int);
 636
 637        we're not going to find `S::f(int)', but there's no
 638        reason we should, either.  We let our callers know we didn't
 639        find the method, but we don't complain.  */
 640     return NULL_TREE;
 641
 642   /* OK, is this a definition of a member template?  */
 643   is_template = (TREE_CODE (function) == TEMPLATE_DECL
 644                  || template_header_p);
 645
 646   ix = lookup_fnfields_1 (complete_type (ctype),
 647                           DECL_CONSTRUCTOR_P (function) ? ctor_identifier :
 648                           DECL_DESTRUCTOR_P (function) ? dtor_identifier :
 649                           DECL_NAME (function));
 650
 651   if (ix >= 0)
 652     {
 653       tree methods = CLASSTYPE_METHOD_VEC (ctype);
 654       tree fndecls, fndecl = 0;
 655       bool is_conv_op;
 656       bool pop_p;
 657       const char *format = NULL;
 658
 659       pop_p = push_scope (ctype);
 660       for (fndecls = TREE_VEC_ELT (methods, ix);
 661            fndecls; fndecls = OVL_NEXT (fndecls))
 662         {
 663           tree p1, p2;
 664
 665           fndecl = OVL_CURRENT (fndecls);
 666           p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
 667           p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
 668
 669           /* We cannot simply call decls_match because this doesn't
 670              work for static member functions that are pretending to
 671              be methods, and because the name may have been changed by
 672              asm("new_name").  */
 673
 674            /* Get rid of the this parameter on functions that become
 675               static.  */
 676           if (DECL_STATIC_FUNCTION_P (fndecl)
 677               && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
 678             p1 = TREE_CHAIN (p1);
 679
 680           /* A member template definition only matches a member template
 681              declaration.  */
 682           if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
 683             continue;
 684
 685           if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
 686                            TREE_TYPE (TREE_TYPE (fndecl)))
 687               && compparms (p1, p2)
 688               && (DECL_TEMPLATE_SPECIALIZATION (function)
 689                   == DECL_TEMPLATE_SPECIALIZATION (fndecl))
 690               && (!DECL_TEMPLATE_SPECIALIZATION (function)
 691                   || (DECL_TI_TEMPLATE (function)
 692                       == DECL_TI_TEMPLATE (fndecl))))
 693             break;
 694         }
 695       if (pop_p)
 696         pop_scope (ctype);
 697       if (fndecls)
 698         return OVL_CURRENT (fndecls);
 699       error ("prototype for `%#D' does not match any in class `%T'",
 700              function, ctype);
 701       is_conv_op = DECL_CONV_FN_P (fndecl);
 702
 703       if (is_conv_op)
 704         ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
 705       fndecls = TREE_VEC_ELT (methods, ix);
 706       while (fndecls)
 707         {
 708           fndecl = OVL_CURRENT (fndecls);
 709           fndecls = OVL_NEXT (fndecls);
 710
 711           if (!fndecls && is_conv_op)
 712             {
 713               if (TREE_VEC_LENGTH (methods) > ix)
 714                 {
 715                   ix++;
 716                   fndecls = TREE_VEC_ELT (methods, ix);
 717                   if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
 718                     {
 719                       fndecls = NULL_TREE;
 720                       is_conv_op = false;
 721                     }
 722                 }
 723               else
 724                 is_conv_op = false;
 725             }
 726           if (format)
 727             format = "                %#D";
 728           else if (fndecls)
 729             format = "candidates are: %#D";
 730           else
 731             format = "candidate is: %#D";
 732           cp_error_at (format, fndecl);
 733         }
 734     }
 735   else if (!COMPLETE_TYPE_P (ctype))
 736     cxx_incomplete_type_error (function, ctype);
 737   else
 738     error ("no `%#D' member function declared in class `%T'",
 739            function, ctype);
 740
 741   /* If we did not find the method in the class, add it to avoid
 742      spurious errors (unless the CTYPE is not yet defined, in which
 743      case we'll only confuse ourselves when the function is declared
 744      properly within the class.  */
 745   if (COMPLETE_TYPE_P (ctype))
 746     add_method (ctype, function, /*error_p=*/1);
 747   return NULL_TREE;
 748 }
 749
 750 /* We have just processed the DECL, which is a static data member.
 751    Its initializer, if present, is INIT.  The ASMSPEC_TREE, if
 752    present, is the assembly-language name for the data member.
 753    FLAGS is as for cp_finish_decl.  */
 754
 755 void
 756 finish_static_data_member_decl (tree decl, tree init, tree asmspec_tree,
 757                                 int flags)
 758 {
 759   my_friendly_assert (TREE_PUBLIC (decl), 0);
 760
 761   DECL_CONTEXT (decl) = current_class_type;
 762
 763   /* We cannot call pushdecl here, because that would fill in the
 764      TREE_CHAIN of our decl.  Instead, we modify cp_finish_decl to do
 765      the right thing, namely, to put this decl out straight away.  */
 766   /* current_class_type can be NULL_TREE in case of error.  */
 767   if (!asmspec_tree && current_class_type)
 768     DECL_INITIAL (decl) = error_mark_node;
 769
 770   if (! processing_template_decl)
 771     {
 772       if (!pending_statics)
 773         VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
 774       VARRAY_PUSH_TREE (pending_statics, decl);
 775     }
 776
 777   if (LOCAL_CLASS_P (current_class_type))
 778     pedwarn ("local class `%#T' shall not have static data member `%#D'",
 779              current_class_type, decl);
 780
 781   /* Static consts need not be initialized in the class definition.  */
 782   if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 783     {
 784       static int explained = 0;
 785
 786       error ("initializer invalid for static member with constructor");
 787       if (!explained)
 788         {
 789           error ("(an out of class initialization is required)");
 790           explained = 1;
 791         }
 792       init = NULL_TREE;
 793     }
 794   /* Force the compiler to know when an uninitialized static const
 795      member is being used.  */
 796   if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0)
 797     TREE_USED (decl) = 1;
 798   DECL_INITIAL (decl) = init;
 799   DECL_IN_AGGR_P (decl) = 1;
 800
 801   cp_finish_decl (decl, init, asmspec_tree, flags);
 802 }
 803
 804 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
 805    of a structure component, returning a _DECL node.
 806    QUALS is a list of type qualifiers for this decl (such as for declaring
 807    const member functions).
 808
 809    This is done during the parsing of the struct declaration.
 810    The _DECL nodes are chained together and the lot of them
 811    are ultimately passed to `build_struct' to make the RECORD_TYPE node.
 812
 813    If class A defines that certain functions in class B are friends, then
 814    the way I have set things up, it is B who is interested in permission
 815    granted by A.  However, it is in A's context that these declarations
 816    are parsed.  By returning a void_type_node, class A does not attempt
 817    to incorporate the declarations of the friends within its structure.
 818
 819    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
 820    CHANGES TO CODE IN `start_method'.  */
 821
 822 tree
 823 grokfield (tree declarator, tree declspecs, tree init, tree asmspec_tree,
 824            tree attrlist)
 825 {
 826   tree value;
 827   const char *asmspec = 0;
 828   int flags = LOOKUP_ONLYCONVERTING;
 829
 830   if (declspecs == NULL_TREE
 831       && TREE_CODE (declarator) == SCOPE_REF
 832       && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
 833     {
 834       /* Access declaration */
 835       if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
 836         ;
 837       else if (TREE_COMPLEXITY (declarator) == current_class_depth)
 838         pop_nested_class ();
 839       return do_class_using_decl (declarator);
 840     }
 841
 842   if (init
 843       && TREE_CODE (init) == TREE_LIST
 844       && TREE_VALUE (init) == error_mark_node
 845       && TREE_CHAIN (init) == NULL_TREE)
 846     init = NULL_TREE;
 847
 848   value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
 849   if (! value || error_operand_p (value))
 850     /* friend or constructor went bad.  */
 851     return error_mark_node;
 852
 853   if (TREE_CODE (value) == TYPE_DECL && init)
 854     {
 855       error ("typedef `%D' is initialized (use __typeof__ instead)", value);
 856       init = NULL_TREE;
 857     }
 858
 859   /* Pass friendly classes back.  */
 860   if (value == void_type_node)
 861     return value;
 862
 863   /* Pass friend decls back.  */
 864   if ((TREE_CODE (value) == FUNCTION_DECL
 865        || TREE_CODE (value) == TEMPLATE_DECL)
 866       && DECL_CONTEXT (value) != current_class_type)
 867     return value;
 868
 869   if (DECL_NAME (value) != NULL_TREE
 870       && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
 871       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
 872     error ("member `%D' conflicts with virtual function table field name",
 873               value);
 874
 875   /* Stash away type declarations.  */
 876   if (TREE_CODE (value) == TYPE_DECL)
 877     {
 878       DECL_NONLOCAL (value) = 1;
 879       DECL_CONTEXT (value) = current_class_type;
 880
 881       if (processing_template_decl)
 882         value = push_template_decl (value);
 883
 884       return value;
 885     }
 886
 887   if (DECL_IN_AGGR_P (value))
 888     {
 889       error ("`%D' is already defined in `%T'", value,
 890                 DECL_CONTEXT (value));
 891       return void_type_node;
 892     }
 893
 894   if (asmspec_tree)
 895     asmspec = TREE_STRING_POINTER (asmspec_tree);
 896
 897   if (init)
 898     {
 899       if (TREE_CODE (value) == FUNCTION_DECL)
 900         {
 901           grok_function_init (value, init);
 902           init = NULL_TREE;
 903         }
 904       else if (pedantic && TREE_CODE (value) != VAR_DECL)
 905         /* Already complained in grokdeclarator.  */
 906         init = NULL_TREE;
 907       else
 908         {
 909           /* We allow initializers to become parameters to base
 910              initializers.  */
 911           if (TREE_CODE (init) == TREE_LIST)
 912             {
 913               if (TREE_CHAIN (init) == NULL_TREE)
 914                 init = TREE_VALUE (init);
 915               else
 916                 init = digest_init (TREE_TYPE (value), init, (tree *)0);
 917             }
 918
 919           if (!processing_template_decl)
 920             {
 921               if (TREE_CODE (init) == CONST_DECL)
 922                 init = DECL_INITIAL (init);
 923               else if (TREE_READONLY_DECL_P (init))
 924                 init = decl_constant_value (init);
 925               else if (TREE_CODE (init) == CONSTRUCTOR)
 926                 init = digest_init (TREE_TYPE (value), init, (tree *)0);
 927               if (init != error_mark_node && ! TREE_CONSTANT (init))
 928                 {
 929                   /* We can allow references to things that are effectively
 930                      static, since references are initialized with the
 931                      address.  */
 932                   if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
 933                       || (TREE_STATIC (init) == 0
 934                           && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
 935                     {
 936                       error ("field initializer is not constant");
 937                       init = error_mark_node;
 938                     }
 939                 }
 940             }
 941         }
 942     }
 943
 944   if (processing_template_decl
 945       && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
 946     {
 947       value = push_template_decl (value);
 948       if (error_operand_p (value))
 949         return error_mark_node;
 950     }
 951
 952   if (attrlist)
 953     cplus_decl_attributes (&value, attrlist, 0);
 954
 955   if (TREE_CODE (value) == VAR_DECL)
 956     {
 957       finish_static_data_member_decl (value, init, asmspec_tree,
 958                                       flags);
 959       return value;
 960     }
 961   if (TREE_CODE (value) == FIELD_DECL)
 962     {
 963       if (asmspec)
 964         error ("`asm' specifiers are not permitted on non-static data members");
 965       if (DECL_INITIAL (value) == error_mark_node)
 966         init = error_mark_node;
 967       cp_finish_decl (value, init, NULL_TREE, flags);
 968       DECL_INITIAL (value) = init;
 969       DECL_IN_AGGR_P (value) = 1;
 970       return value;
 971     }
 972   if (TREE_CODE (value) == FUNCTION_DECL)
 973     {
 974       if (asmspec)
 975         {
 976           /* This must override the asm specifier which was placed
 977              by grokclassfn.  Lay this out fresh.  */
 978           SET_DECL_RTL (value, NULL_RTX);
 979           change_decl_assembler_name (value, get_identifier (asmspec));
 980         }
 981       if (!DECL_FRIEND_P (value))
 982         grok_special_member_properties (value);
 983
 984       cp_finish_decl (value, init, asmspec_tree, flags);
 985
 986       /* Pass friends back this way.  */
 987       if (DECL_FRIEND_P (value))
 988         return void_type_node;
 989
 990       DECL_IN_AGGR_P (value) = 1;
 991       return value;
 992     }
 993   abort ();
 994   /* NOTREACHED */
 995   return NULL_TREE;
 996 }
 997
 998 /* Like `grokfield', but for bitfields.
 999    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.  */
1000
1001 tree
1002 grokbitfield (tree declarator, tree declspecs, tree width)
1003 {
1004   tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, NULL);
1005
1006   if (! value) return NULL_TREE; /* friends went bad.  */
1007
1008   /* Pass friendly classes back.  */
1009   if (TREE_CODE (value) == VOID_TYPE)
1010     return void_type_node;
1011
1012   if (TREE_CODE (value) == TYPE_DECL)
1013     {
1014       error ("cannot declare `%D' to be a bit-field type", value);
1015       return NULL_TREE;
1016     }
1017
1018   /* Usually, finish_struct_1 catches bitfields with invalid types.
1019      But, in the case of bitfields with function type, we confuse
1020      ourselves into thinking they are member functions, so we must
1021      check here.  */
1022   if (TREE_CODE (value) == FUNCTION_DECL)
1023     {
1024       error ("cannot declare bit-field `%D' with function type",
1025              DECL_NAME (value));
1026       return NULL_TREE;
1027     }
1028
1029   if (DECL_IN_AGGR_P (value))
1030     {
1031       error ("`%D' is already defined in the class %T", value,
1032                   DECL_CONTEXT (value));
1033       return void_type_node;
1034     }
1035
1036   if (TREE_STATIC (value))
1037     {
1038       error ("static member `%D' cannot be a bit-field", value);
1039       return NULL_TREE;
1040     }
1041   cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
1042
1043   if (width != error_mark_node)
1044     {
1045       constant_expression_warning (width);
1046       DECL_INITIAL (value) = width;
1047       SET_DECL_C_BIT_FIELD (value);
1048     }
1049
1050   DECL_IN_AGGR_P (value) = 1;
1051   return value;
1052 }
1053
1054 /* When a function is declared with an initializer,
1055    do the right thing.  Currently, there are two possibilities:
1056
1057    class B
1058    {
1059     public:
1060      // initialization possibility #1.
1061      virtual void f () = 0;
1062      int g ();
1063    };
1064
1065    class D1 : B
1066    {
1067     public:
1068      int d1;
1069      // error, no f ();
1070    };
1071
1072    class D2 : B
1073    {
1074     public:
1075      int d2;
1076      void f ();
1077    };
1078
1079    class D3 : B
1080    {
1081     public:
1082      int d3;
1083      // initialization possibility #2
1084      void f () = B::f;
1085    };
1086
1087 */
1088
1089 static void
1090 grok_function_init (tree decl, tree init)
1091 {
1092   /* An initializer for a function tells how this function should
1093      be inherited.  */
1094   tree type = TREE_TYPE (decl);
1095
1096   if (TREE_CODE (type) == FUNCTION_TYPE)
1097     error ("initializer specified for non-member function `%D'", decl);
1098   else if (integer_zerop (init))
1099     DECL_PURE_VIRTUAL_P (decl) = 1;
1100   else
1101     error ("invalid initializer for virtual method `%D'", decl);
1102 }
1103 \f
1104 void
1105 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1106 {
1107   if (*decl == NULL_TREE || *decl == void_type_node)
1108     return;
1109
1110   if (TREE_CODE (*decl) == TEMPLATE_DECL)
1111     decl = &DECL_TEMPLATE_RESULT (*decl);
1112
1113   decl_attributes (decl, attributes, flags);
1114
1115   if (TREE_CODE (*decl) == TYPE_DECL)
1116     SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1117 }
1118 \f
1119 /* Defer the compilation of the FN until the end of compilation.  */
1120
1121 void
1122 defer_fn (tree fn)
1123 {
1124   if (DECL_DEFERRED_FN (fn))
1125     return;
1126   DECL_DEFERRED_FN (fn) = 1;
1127   DECL_DEFER_OUTPUT (fn) = 1;
1128   if (!deferred_fns)
1129     VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
1130
1131   VARRAY_PUSH_TREE (deferred_fns, fn);
1132 }
1133
1134 /* Walks through the namespace- or function-scope anonymous union OBJECT,
1135    building appropriate ALIAS_DECLs.  Returns one of the fields for use in
1136    the mangled name.  */
1137
1138 static tree
1139 build_anon_union_vars (tree object)
1140 {
1141   tree type = TREE_TYPE (object);
1142   tree main_decl = NULL_TREE;
1143   tree field;
1144
1145   /* Rather than write the code to handle the non-union case,
1146      just give an error.  */
1147   if (TREE_CODE (type) != UNION_TYPE)
1148     error ("anonymous struct not inside named type");
1149
1150   for (field = TYPE_FIELDS (type);
1151        field != NULL_TREE;
1152        field = TREE_CHAIN (field))
1153     {
1154       tree decl;
1155       tree ref;
1156
1157       if (DECL_ARTIFICIAL (field))
1158         continue;
1159       if (TREE_CODE (field) != FIELD_DECL)
1160         {
1161           cp_pedwarn_at ("\
1162 `%#D' invalid; an anonymous union can only have non-static data members",
1163                          field);
1164           continue;
1165         }
1166
1167       if (TREE_PRIVATE (field))
1168         cp_pedwarn_at ("private member `%#D' in anonymous union", field);
1169       else if (TREE_PROTECTED (field))
1170         cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
1171
1172       if (processing_template_decl)
1173         ref = build_min_nt (COMPONENT_REF, object, DECL_NAME (field));
1174       else
1175         ref = build_class_member_access_expr (object, field, NULL_TREE,
1176                                               false);
1177
1178       if (DECL_NAME (field))
1179         {
1180           decl = build_decl (ALIAS_DECL, DECL_NAME (field), TREE_TYPE (field));
1181           DECL_INITIAL (decl) = ref;
1182           TREE_PUBLIC (decl) = 0;
1183           TREE_STATIC (decl) = 0;
1184           DECL_EXTERNAL (decl) = 1;
1185           decl = pushdecl (decl);
1186         }
1187       else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1188         decl = build_anon_union_vars (ref);
1189       else
1190         decl = 0;
1191
1192       if (main_decl == NULL_TREE)
1193         main_decl = decl;
1194     }
1195
1196   return main_decl;
1197 }
1198
1199 /* Finish off the processing of a UNION_TYPE structure.  If the union is an
1200    anonymous union, then all members must be laid out together.  PUBLIC_P
1201    is nonzero if this union is not declared static.  */
1202
1203 void
1204 finish_anon_union (tree anon_union_decl)
1205 {
1206   tree type;
1207   tree main_decl;
1208   bool public_p;
1209
1210   if (anon_union_decl == error_mark_node)
1211     return;
1212
1213   type = TREE_TYPE (anon_union_decl);
1214   public_p = TREE_PUBLIC (anon_union_decl);
1215
1216   /* The VAR_DECL's context is the same as the TYPE's context.  */
1217   DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1218
1219   if (TYPE_FIELDS (type) == NULL_TREE)
1220     return;
1221
1222   if (public_p)
1223     {
1224       error ("namespace-scope anonymous aggregates must be static");
1225       return;
1226     }
1227
1228   main_decl = build_anon_union_vars (anon_union_decl);
1229   if (main_decl == NULL_TREE)
1230     {
1231       warning ("anonymous union with no members");
1232       return;
1233     }
1234
1235   if (!processing_template_decl)
1236     {
1237       /* Use main_decl to set the mangled name.  */
1238       DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1239       mangle_decl (anon_union_decl);
1240       DECL_NAME (anon_union_decl) = NULL_TREE;
1241     }
1242
1243   pushdecl (anon_union_decl);
1244   if (building_stmt_tree ()
1245       && at_function_scope_p ())
1246     add_decl_stmt (anon_union_decl);
1247   else if (!processing_template_decl)
1248     rest_of_decl_compilation (anon_union_decl, NULL,
1249                               toplevel_bindings_p (), at_eof);
1250 }
1251 \f
1252 /* Auxiliary functions to make type signatures for
1253    `operator new' and `operator delete' correspond to
1254    what compiler will be expecting.  */
1255
1256 tree
1257 coerce_new_type (tree type)
1258 {
1259   int e = 0;
1260   tree args = TYPE_ARG_TYPES (type);
1261
1262   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1263
1264   if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1265     e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
1266
1267   if (!args || args == void_list_node
1268       || !same_type_p (TREE_VALUE (args), size_type_node))
1269     {
1270       e = 2;
1271       if (args && args != void_list_node)
1272         args = TREE_CHAIN (args);
1273       pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", size_type_node);
1274     }
1275   switch (e)
1276   {
1277     case 2:
1278       args = tree_cons (NULL_TREE, size_type_node, args);
1279       /* Fall through.  */
1280     case 1:
1281       type = build_exception_variant
1282               (build_function_type (ptr_type_node, args),
1283                TYPE_RAISES_EXCEPTIONS (type));
1284       /* Fall through.  */
1285     default:;
1286   }
1287   return type;
1288 }
1289
1290 tree
1291 coerce_delete_type (tree type)
1292 {
1293   int e = 0;
1294   tree args = TYPE_ARG_TYPES (type);
1295
1296   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
1297
1298   if (!same_type_p (TREE_TYPE (type), void_type_node))
1299     e = 1, error ("`operator delete' must return type `%T'", void_type_node);
1300
1301   if (!args || args == void_list_node
1302       || !same_type_p (TREE_VALUE (args), ptr_type_node))
1303     {
1304       e = 2;
1305       if (args && args != void_list_node)
1306         args = TREE_CHAIN (args);
1307       error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
1308     }
1309   switch (e)
1310   {
1311     case 2:
1312       args = tree_cons (NULL_TREE, ptr_type_node, args);
1313       /* Fall through.  */
1314     case 1:
1315       type = build_exception_variant
1316               (build_function_type (void_type_node, args),
1317                TYPE_RAISES_EXCEPTIONS (type));
1318       /* Fall through.  */
1319     default:;
1320   }
1321
1322   return type;
1323 }
1324 \f
1325 static void
1326 mark_vtable_entries (tree decl)
1327 {
1328   tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
1329
1330   for (; entries; entries = TREE_CHAIN (entries))
1331     {
1332       tree fnaddr = TREE_VALUE (entries);
1333       tree fn;
1334
1335       STRIP_NOPS (fnaddr);
1336
1337       if (TREE_CODE (fnaddr) != ADDR_EXPR
1338           && TREE_CODE (fnaddr) != FDESC_EXPR)
1339         /* This entry is an offset: a virtual base class offset, a
1340            virtual call offset, an RTTI offset, etc.  */
1341         continue;
1342
1343       fn = TREE_OPERAND (fnaddr, 0);
1344       TREE_ADDRESSABLE (fn) = 1;
1345       /* When we don't have vcall offsets, we output thunks whenever
1346          we output the vtables that contain them.  With vcall offsets,
1347          we know all the thunks we'll need when we emit a virtual
1348          function, so we emit the thunks there instead.  */
1349       if (DECL_THUNK_P (fn))
1350         use_thunk (fn, /*emit_p=*/0);
1351       mark_used (fn);
1352     }
1353 }
1354
1355 /* Set DECL up to have the closest approximation of "initialized common"
1356    linkage available.  */
1357
1358 void
1359 comdat_linkage (tree decl)
1360 {
1361   if (flag_weak)
1362     make_decl_one_only (decl);
1363   else if (TREE_CODE (decl) == FUNCTION_DECL
1364            || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1365     /* We can just emit function and compiler-generated variables
1366        statically; having multiple copies is (for the most part) only
1367        a waste of space.
1368
1369        There are two correctness issues, however: the address of a
1370        template instantiation with external linkage should be the
1371        same, independent of what translation unit asks for the
1372        address, and this will not hold when we emit multiple copies of
1373        the function.  However, there's little else we can do.
1374
1375        Also, by default, the typeinfo implementation assumes that
1376        there will be only one copy of the string used as the name for
1377        each type.  Therefore, if weak symbols are unavailable, the
1378        run-time library should perform a more conservative check; it
1379        should perform a string comparison, rather than an address
1380        comparison.  */
1381     TREE_PUBLIC (decl) = 0;
1382   else
1383     {
1384       /* Static data member template instantiations, however, cannot
1385          have multiple copies.  */
1386       if (DECL_INITIAL (decl) == 0
1387           || DECL_INITIAL (decl) == error_mark_node)
1388         DECL_COMMON (decl) = 1;
1389       else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1390         {
1391           DECL_COMMON (decl) = 1;
1392           DECL_INITIAL (decl) = error_mark_node;
1393         }
1394       else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1395         {
1396           /* We can't do anything useful; leave vars for explicit
1397              instantiation.  */
1398           DECL_EXTERNAL (decl) = 1;
1399           DECL_NOT_REALLY_EXTERN (decl) = 0;
1400         }
1401     }
1402
1403   if (DECL_LANG_SPECIFIC (decl))
1404     DECL_COMDAT (decl) = 1;
1405 }
1406
1407 /* For win32 we also want to put explicit instantiations in
1408    linkonce sections, so that they will be merged with implicit
1409    instantiations; otherwise we get duplicate symbol errors.  */
1410
1411 void
1412 maybe_make_one_only (tree decl)
1413 {
1414   /* We used to say that this was not necessary on targets that support weak
1415      symbols, because the implicit instantiations will defer to the explicit
1416      one.  However, that's not actually the case in SVR4; a strong definition
1417      after a weak one is an error.  Also, not making explicit
1418      instantiations one_only means that we can end up with two copies of
1419      some template instantiations.  */
1420   if (! flag_weak)
1421     return;
1422
1423   /* We can't set DECL_COMDAT on functions, or finish_file will think
1424      we can get away with not emitting them if they aren't used.  We need
1425      to for variables so that cp_finish_decl will update their linkage,
1426      because their DECL_INITIAL may not have been set properly yet.  */
1427
1428   make_decl_one_only (decl);
1429
1430   if (TREE_CODE (decl) == VAR_DECL)
1431     {
1432       DECL_COMDAT (decl) = 1;
1433       /* Mark it needed so we don't forget to emit it.  */
1434       mark_referenced (DECL_ASSEMBLER_NAME (decl));
1435     }
1436 }
1437
1438 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
1439    based on TYPE and other static flags.
1440
1441    Note that anything public is tagged TREE_PUBLIC, whether
1442    it's public in this file or in another one.  */
1443
1444 void
1445 import_export_vtable (tree decl, tree type, int final)
1446 {
1447   if (DECL_INTERFACE_KNOWN (decl))
1448     return;
1449
1450   if (TYPE_FOR_JAVA (type))
1451     {
1452       TREE_PUBLIC (decl) = 1;
1453       DECL_EXTERNAL (decl) = 1;
1454       DECL_INTERFACE_KNOWN (decl) = 1;
1455     }
1456   else if (CLASSTYPE_INTERFACE_KNOWN (type))
1457     {
1458       TREE_PUBLIC (decl) = 1;
1459       DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
1460       DECL_INTERFACE_KNOWN (decl) = 1;
1461     }
1462   else
1463     {
1464       /* We can only wait to decide if we have real non-inline virtual
1465          functions in our class, or if we come from a template.  */
1466
1467       int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
1468                    || CLASSTYPE_KEY_METHOD (type) != NULL_TREE);
1469
1470       if (final || ! found)
1471         {
1472           comdat_linkage (decl);
1473           DECL_EXTERNAL (decl) = 0;
1474         }
1475       else
1476         {
1477           TREE_PUBLIC (decl) = 1;
1478           DECL_EXTERNAL (decl) = 1;
1479         }
1480     }
1481 }
1482
1483 /* Determine whether or not we want to specifically import or export CTYPE,
1484    using various heuristics.  */
1485
1486 static void
1487 import_export_class (tree ctype)
1488 {
1489   /* -1 for imported, 1 for exported.  */
1490   int import_export = 0;
1491
1492   /* It only makes sense to call this function at EOF.  The reason is
1493      that this function looks at whether or not the first non-inline
1494      non-abstract virtual member function has been defined in this
1495      translation unit.  But, we can't possibly know that until we've
1496      seen the entire translation unit.  */
1497   my_friendly_assert (at_eof, 20000226);
1498
1499   if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1500     return;
1501
1502   /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
1503      we will have CLASSTYPE_INTERFACE_ONLY set but not
1504      CLASSTYPE_INTERFACE_KNOWN.  In that case, we don't want to use this
1505      heuristic because someone will supply a #pragma implementation
1506      elsewhere, and deducing it here would produce a conflict.  */
1507   if (CLASSTYPE_INTERFACE_ONLY (ctype))
1508     return;
1509
1510   if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1511     import_export = -1;
1512   else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1513     import_export = 1;
1514
1515   /* If we got -fno-implicit-templates, we import template classes that
1516      weren't explicitly instantiated.  */
1517   if (import_export == 0
1518       && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1519       && ! flag_implicit_templates)
1520     import_export = -1;
1521
1522   /* Base our import/export status on that of the first non-inline,
1523      non-pure virtual function, if any.  */
1524   if (import_export == 0
1525       && TYPE_POLYMORPHIC_P (ctype))
1526     {
1527       tree method = CLASSTYPE_KEY_METHOD (ctype);
1528       if (method)
1529         import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1530     }
1531
1532 #ifdef MULTIPLE_SYMBOL_SPACES
1533   if (import_export == -1)
1534     import_export = 0;
1535 #endif
1536
1537   if (import_export)
1538     {
1539       SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1540       CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1541     }
1542 }
1543
1544 /* Return true if VAR has already been provided to the back end; in that
1545    case VAR should not be modified further by the front end.  */
1546 static bool
1547 var_finalized_p (tree var)
1548 {
1549   if (flag_unit_at_a_time)
1550     return cgraph_varpool_node (var)->finalized;
1551   else
1552     return TREE_ASM_WRITTEN (var);
1553 }
1554
1555 /* If necessary, write out the vtables for the dynamic class CTYPE.
1556    Returns true if any vtables were emitted.  */
1557
1558 static bool
1559 maybe_emit_vtables (tree ctype)
1560 {
1561   tree vtbl;
1562   tree primary_vtbl;
1563   bool needed = false;
1564
1565   /* If the vtables for this class have already been emitted there is
1566      nothing more to do.  */
1567   primary_vtbl = CLASSTYPE_VTABLES (ctype);
1568   if (var_finalized_p (primary_vtbl))
1569     return false;
1570   /* Ignore dummy vtables made by get_vtable_decl.  */
1571   if (TREE_TYPE (primary_vtbl) == void_type_node)
1572     return false;
1573
1574   import_export_class (ctype);
1575
1576   /* See if any of the vtables are needed.  */
1577   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1578     {
1579       import_export_vtable (vtbl, ctype, 1);
1580       if (!DECL_EXTERNAL (vtbl) && DECL_NEEDED_P (vtbl))
1581         break;
1582     }
1583   if (!vtbl)
1584     {
1585       /* If the references to this class' vtables are optimized away,
1586          still emit the appropriate debugging information.  See
1587          dfs_debug_mark.  */
1588       if (DECL_COMDAT (primary_vtbl)
1589           && CLASSTYPE_DEBUG_REQUESTED (ctype))
1590         note_debug_info_needed (ctype);
1591       return false;
1592     }
1593   else if (TREE_PUBLIC (vtbl) && !DECL_COMDAT (vtbl))
1594     needed = true;
1595
1596
1597   /* The ABI requires that we emit all of the vtables if we emit any
1598      of them.  */
1599   for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1600     {
1601       /* Write it out.  */
1602       import_export_vtable (vtbl, ctype, 1);
1603       mark_vtable_entries (vtbl);
1604
1605       /* If we know that DECL is needed, mark it as such for the varpool.  */
1606       if (needed)
1607         cgraph_varpool_mark_needed_node (cgraph_varpool_node (vtbl));
1608
1609       if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1610         {
1611           /* It had better be all done at compile-time.  */
1612           if (store_init_value (vtbl, DECL_INITIAL (vtbl)))
1613             abort ();
1614         }
1615
1616       if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
1617         {
1618           /* Mark the VAR_DECL node representing the vtable itself as a
1619              "gratuitous" one, thereby forcing dwarfout.c to ignore it.
1620              It is rather important that such things be ignored because
1621              any effort to actually generate DWARF for them will run
1622              into trouble when/if we encounter code like:
1623
1624                 #pragma interface
1625                 struct S { virtual void member (); };
1626
1627               because the artificial declaration of the vtable itself (as
1628               manufactured by the g++ front end) will say that the vtable
1629               is a static member of `S' but only *after* the debug output
1630               for the definition of `S' has already been output.  This causes
1631               grief because the DWARF entry for the definition of the vtable
1632               will try to refer back to an earlier *declaration* of the
1633               vtable as a static member of `S' and there won't be one.
1634               We might be able to arrange to have the "vtable static member"
1635               attached to the member list for `S' before the debug info for
1636               `S' get written (which would solve the problem) but that would
1637               require more intrusive changes to the g++ front end.  */
1638
1639           DECL_IGNORED_P (vtbl) = 1;
1640         }
1641
1642       /* Always make vtables weak.  */
1643       if (flag_weak)
1644         comdat_linkage (vtbl);
1645
1646       rest_of_decl_compilation (vtbl, NULL, 1, 1);
1647
1648       /* Because we're only doing syntax-checking, we'll never end up
1649          actually marking the variable as written.  */
1650       if (flag_syntax_only)
1651         TREE_ASM_WRITTEN (vtbl) = 1;
1652     }
1653
1654   /* Since we're writing out the vtable here, also write the debug
1655      info.  */
1656   note_debug_info_needed (ctype);
1657
1658   return true;
1659 }
1660
1661 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
1662    inline function or template instantiation at end-of-file.  */
1663
1664 void
1665 import_export_decl (tree decl)
1666 {
1667   if (DECL_INTERFACE_KNOWN (decl))
1668     return;
1669
1670   if (DECL_TEMPLATE_INSTANTIATION (decl)
1671       || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1672     {
1673       DECL_NOT_REALLY_EXTERN (decl) = 1;
1674       if ((DECL_IMPLICIT_INSTANTIATION (decl)
1675            || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1676           && (flag_implicit_templates
1677               || (flag_implicit_inline_templates
1678                   && TREE_CODE (decl) == FUNCTION_DECL
1679                   && DECL_DECLARED_INLINE_P (decl))))
1680         {
1681           if (!TREE_PUBLIC (decl))
1682             /* Templates are allowed to have internal linkage.  See
1683                [basic.link].  */
1684             ;
1685           else
1686             comdat_linkage (decl);
1687         }
1688       else
1689         {
1690           DECL_EXTERNAL (decl) = 1;
1691           DECL_NOT_REALLY_EXTERN (decl) = 0;
1692         }
1693     }
1694   else if (DECL_FUNCTION_MEMBER_P (decl))
1695     {
1696       if (!DECL_DECLARED_INLINE_P (decl))
1697         {
1698           tree ctype = DECL_CONTEXT (decl);
1699           import_export_class (ctype);
1700           if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1701             {
1702               DECL_NOT_REALLY_EXTERN (decl)
1703                 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
1704                      || (DECL_DECLARED_INLINE_P (decl)
1705                          && ! flag_implement_inlines
1706                          && !DECL_VINDEX (decl)));
1707
1708               if (!DECL_NOT_REALLY_EXTERN (decl))
1709                 DECL_EXTERNAL (decl) = 1;
1710
1711               /* Always make artificials weak.  */
1712               if (DECL_ARTIFICIAL (decl) && flag_weak)
1713                 comdat_linkage (decl);
1714               else
1715                 maybe_make_one_only (decl);
1716             }
1717         }
1718       else
1719         comdat_linkage (decl);
1720     }
1721   else
1722     comdat_linkage (decl);
1723
1724   DECL_INTERFACE_KNOWN (decl) = 1;
1725 }
1726
1727 /* Here, we only decide whether or not the tinfo node should be
1728    emitted with the vtable.  IS_IN_LIBRARY is nonzero iff the
1729    typeinfo for TYPE should be in the runtime library.  */
1730
1731 void
1732 import_export_tinfo (tree decl, tree type, bool is_in_library)
1733 {
1734   if (DECL_INTERFACE_KNOWN (decl))
1735     return;
1736
1737   if (IS_AGGR_TYPE (type))
1738     import_export_class (type);
1739
1740   if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
1741       && TYPE_POLYMORPHIC_P (type)
1742       /* If -fno-rtti, we're not necessarily emitting this stuff with
1743          the class, so go ahead and emit it now.  This can happen when
1744          a class is used in exception handling.  */
1745       && flag_rtti)
1746     {
1747       DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
1748       DECL_COMDAT (decl) = 0;
1749     }
1750   else
1751     {
1752       DECL_NOT_REALLY_EXTERN (decl) = 1;
1753       DECL_COMDAT (decl) = 1;
1754     }
1755
1756   /* Now override some cases.  */
1757   if (flag_weak)
1758     DECL_COMDAT (decl) = 1;
1759   else if (is_in_library)
1760     DECL_COMDAT (decl) = 0;
1761
1762   DECL_INTERFACE_KNOWN (decl) = 1;
1763 }
1764
1765 /* Return an expression that performs the destruction of DECL, which
1766    must be a VAR_DECL whose type has a non-trivial destructor, or is
1767    an array whose (innermost) elements have a non-trivial destructor.  */
1768
1769 tree
1770 build_cleanup (tree decl)
1771 {
1772   tree temp;
1773   tree type = TREE_TYPE (decl);
1774
1775   /* This function should only be called for declarations that really
1776      require cleanups.  */
1777   my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
1778
1779   /* Treat all objects with destructors as used; the destructor may do
1780      something substantive.  */
1781   mark_used (decl);
1782
1783   if (TREE_CODE (type) == ARRAY_TYPE)
1784     temp = decl;
1785   else
1786     {
1787       cxx_mark_addressable (decl);
1788       temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
1789     }
1790   temp = build_delete (TREE_TYPE (temp), temp,
1791                        sfk_complete_destructor,
1792                        LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
1793   return temp;
1794 }
1795
1796 /* Returns the initialization guard variable for the variable DECL,
1797    which has static storage duration.  */
1798
1799 tree
1800 get_guard (tree decl)
1801 {
1802   tree sname;
1803   tree guard;
1804
1805   sname = mangle_guard_variable (decl);
1806   guard = IDENTIFIER_GLOBAL_VALUE (sname);
1807   if (! guard)
1808     {
1809       tree guard_type;
1810
1811       /* We use a type that is big enough to contain a mutex as well
1812          as an integer counter.  */
1813       guard_type = long_long_integer_type_node;
1814       guard = build_decl (VAR_DECL, sname, guard_type);
1815
1816       /* The guard should have the same linkage as what it guards.  */
1817       TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
1818       TREE_STATIC (guard) = TREE_STATIC (decl);
1819       DECL_COMMON (guard) = DECL_COMMON (decl);
1820       DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
1821       if (TREE_PUBLIC (decl))
1822         DECL_WEAK (guard) = DECL_WEAK (decl);
1823
1824       DECL_ARTIFICIAL (guard) = 1;
1825       TREE_USED (guard) = 1;
1826       pushdecl_top_level_and_finish (guard, NULL_TREE);
1827     }
1828   return guard;
1829 }
1830
1831 /* Return those bits of the GUARD variable that should be set when the
1832    guarded entity is actually initialized.  */
1833
1834 static tree
1835 get_guard_bits (tree guard)
1836 {
1837   /* We only set the first byte of the guard, in order to leave room
1838      for a mutex in the high-order bits.  */
1839   guard = build1 (ADDR_EXPR,
1840                   build_pointer_type (TREE_TYPE (guard)),
1841                   guard);
1842   guard = build1 (NOP_EXPR,
1843                   build_pointer_type (char_type_node),
1844                   guard);
1845   guard = build1 (INDIRECT_REF, char_type_node, guard);
1846
1847   return guard;
1848 }
1849
1850 /* Return an expression which determines whether or not the GUARD
1851    variable has already been initialized.  */
1852
1853 tree
1854 get_guard_cond (tree guard)
1855 {
1856   tree guard_value;
1857
1858   /* Check to see if the GUARD is zero.  */
1859   guard = get_guard_bits (guard);
1860   guard_value = integer_zero_node;
1861   if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1862     guard_value = convert (TREE_TYPE (guard), guard_value);
1863   return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1864 }
1865
1866 /* Return an expression which sets the GUARD variable, indicating that
1867    the variable being guarded has been initialized.  */
1868
1869 tree
1870 set_guard (tree guard)
1871 {
1872   tree guard_init;
1873
1874   /* Set the GUARD to one.  */
1875   guard = get_guard_bits (guard);
1876   guard_init = integer_one_node;
1877   if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1878     guard_init = convert (TREE_TYPE (guard), guard_init);
1879   return build_modify_expr (guard, NOP_EXPR, guard_init);
1880 }
1881
1882 /* Start the process of running a particular set of global constructors
1883    or destructors.  Subroutine of do_[cd]tors.  */
1884
1885 static tree
1886 start_objects (int method_type, int initp)
1887 {
1888   tree fnname;
1889   tree body;
1890   char type[10];
1891
1892   /* Make ctor or dtor function.  METHOD_TYPE may be 'I' or 'D'.  */
1893
1894   if (initp != DEFAULT_INIT_PRIORITY)
1895     {
1896       char joiner;
1897
1898 #ifdef JOINER
1899       joiner = JOINER;
1900 #else
1901       joiner = '_';
1902 #endif
1903
1904       sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1905     }
1906   else
1907     sprintf (type, "%c", method_type);
1908
1909   fnname = get_file_function_name_long (type);
1910
1911   start_function (void_list_node,
1912                   make_call_declarator (fnname, void_list_node, NULL_TREE,
1913                                         NULL_TREE),
1914                   NULL_TREE, SF_DEFAULT);
1915
1916   /* It can be a static function as long as collect2 does not have
1917      to scan the object file to find its ctor/dtor routine.  */
1918   TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1919
1920   /* Mark this declaration as used to avoid spurious warnings.  */
1921   TREE_USED (current_function_decl) = 1;
1922
1923   /* Mark this function as a global constructor or destructor.  */
1924   if (method_type == 'I')
1925     DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1926   else
1927     DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1928   DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1929
1930   body = begin_compound_stmt (/*has_no_scope=*/false);
1931
1932   /* We cannot allow these functions to be elided, even if they do not
1933      have external linkage.  And, there's no point in deferring
1934      compilation of thes functions; they're all going to have to be
1935      out anyhow.  */
1936   current_function_cannot_inline
1937     = "static constructors and destructors cannot be inlined";
1938
1939   return body;
1940 }
1941
1942 /* Finish the process of running a particular set of global constructors
1943    or destructors.  Subroutine of do_[cd]tors.  */
1944
1945 static void
1946 finish_objects (int method_type, int initp, tree body)
1947 {
1948   tree fn;
1949
1950   /* Finish up.  */
1951   finish_compound_stmt (body);
1952   fn = finish_function (0);
1953   expand_or_defer_fn (fn);
1954
1955   /* When only doing semantic analysis, and no RTL generation, we
1956      can't call functions that directly emit assembly code; there is
1957      no assembly file in which to put the code.  */
1958   if (flag_syntax_only)
1959     return;
1960
1961   if (targetm.have_ctors_dtors)
1962     {
1963       rtx fnsym = XEXP (DECL_RTL (fn), 0);
1964       if (method_type == 'I')
1965         (* targetm.asm_out.constructor) (fnsym, initp);
1966       else
1967         (* targetm.asm_out.destructor) (fnsym, initp);
1968     }
1969 }
1970
1971 /* The names of the parameters to the function created to handle
1972    initializations and destructions for objects with static storage
1973    duration.  */
1974 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
1975 #define PRIORITY_IDENTIFIER "__priority"
1976
1977 /* The name of the function we create to handle initializations and
1978    destructions for objects with static storage duration.  */
1979 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
1980
1981 /* The declaration for the __INITIALIZE_P argument.  */
1982 static GTY(()) tree initialize_p_decl;
1983
1984 /* The declaration for the __PRIORITY argument.  */
1985 static GTY(()) tree priority_decl;
1986
1987 /* The declaration for the static storage duration function.  */
1988 static GTY(()) tree ssdf_decl;
1989
1990 /* All the static storage duration functions created in this
1991    translation unit.  */
1992 static GTY(()) varray_type ssdf_decls;
1993
1994 /* A map from priority levels to information about that priority
1995    level.  There may be many such levels, so efficient lookup is
1996    important.  */
1997 static splay_tree priority_info_map;
1998
1999 /* Begins the generation of the function that will handle all
2000    initialization and destruction of objects with static storage
2001    duration.  The function generated takes two parameters of type
2002    `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
2003    nonzero, it performs initializations.  Otherwise, it performs
2004    destructions.  It only performs those initializations or
2005    destructions with the indicated __PRIORITY.  The generated function
2006    returns no value.
2007
2008    It is assumed that this function will only be called once per
2009    translation unit.  */
2010
2011 static tree
2012 start_static_storage_duration_function (unsigned count)
2013 {
2014   tree parm_types;
2015   tree type;
2016   tree body;
2017   char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2018
2019   /* Create the identifier for this function.  It will be of the form
2020      SSDF_IDENTIFIER_<number>.  */
2021   sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2022
2023   /* Create the parameters.  */
2024   parm_types = void_list_node;
2025   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2026   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2027   type = build_function_type (void_type_node, parm_types);
2028
2029   /* Create the FUNCTION_DECL itself.  */
2030   ssdf_decl = build_lang_decl (FUNCTION_DECL,
2031                                get_identifier (id),
2032                                type);
2033   TREE_PUBLIC (ssdf_decl) = 0;
2034   DECL_ARTIFICIAL (ssdf_decl) = 1;
2035
2036   /* Put this function in the list of functions to be called from the
2037      static constructors and destructors.  */
2038   if (!ssdf_decls)
2039     {
2040       VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2041
2042       /* Take this opportunity to initialize the map from priority
2043          numbers to information about that priority level.  */
2044       priority_info_map = splay_tree_new (splay_tree_compare_ints,
2045                                           /*delete_key_fn=*/0,
2046                                           /*delete_value_fn=*/
2047                                           (splay_tree_delete_value_fn) &free);
2048
2049       /* We always need to generate functions for the
2050          DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
2051          priorities later, we'll be sure to find the
2052          DEFAULT_INIT_PRIORITY.  */
2053       get_priority_info (DEFAULT_INIT_PRIORITY);
2054     }
2055
2056   VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2057
2058   /* Create the argument list.  */
2059   initialize_p_decl = cp_build_parm_decl
2060     (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2061   DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2062   TREE_USED (initialize_p_decl) = 1;
2063   priority_decl = cp_build_parm_decl
2064     (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2065   DECL_CONTEXT (priority_decl) = ssdf_decl;
2066   TREE_USED (priority_decl) = 1;
2067
2068   TREE_CHAIN (initialize_p_decl) = priority_decl;
2069   DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2070
2071   /* Put the function in the global scope.  */
2072   pushdecl (ssdf_decl);
2073
2074   /* Start the function itself.  This is equivalent to declaring the
2075      function as:
2076
2077        static void __ssdf (int __initialize_p, init __priority_p);
2078
2079      It is static because we only need to call this function from the
2080      various constructor and destructor functions for this module.  */
2081   start_function (/*specs=*/NULL_TREE,
2082                   ssdf_decl,
2083                   /*attrs=*/NULL_TREE,
2084                   SF_PRE_PARSED);
2085
2086   /* Set up the scope of the outermost block in the function.  */
2087   body = begin_compound_stmt (/*has_no_scope=*/false);
2088
2089   /* This function must not be deferred because we are depending on
2090      its compilation to tell us what is TREE_SYMBOL_REFERENCED.  */
2091   current_function_cannot_inline
2092     = "static storage duration functions cannot be inlined";
2093
2094   return body;
2095 }
2096
2097 /* Finish the generation of the function which performs initialization
2098    and destruction of objects with static storage duration.  After
2099    this point, no more such objects can be created.  */
2100
2101 static void
2102 finish_static_storage_duration_function (tree body)
2103 {
2104   /* Close out the function.  */
2105   finish_compound_stmt (body);
2106   expand_or_defer_fn (finish_function (0));
2107 }
2108
2109 /* Return the information about the indicated PRIORITY level.  If no
2110    code to handle this level has yet been generated, generate the
2111    appropriate prologue.  */
2112
2113 static priority_info
2114 get_priority_info (int priority)
2115 {
2116   priority_info pi;
2117   splay_tree_node n;
2118
2119   n = splay_tree_lookup (priority_info_map,
2120                          (splay_tree_key) priority);
2121   if (!n)
2122     {
2123       /* Create a new priority information structure, and insert it
2124          into the map.  */
2125       pi = xmalloc (sizeof (struct priority_info_s));
2126       pi->initializations_p = 0;
2127       pi->destructions_p = 0;
2128       splay_tree_insert (priority_info_map,
2129                          (splay_tree_key) priority,
2130                          (splay_tree_value) pi);
2131     }
2132   else
2133     pi = (priority_info) n->value;
2134
2135   return pi;
2136 }
2137
2138 /* Set up to handle the initialization or destruction of DECL.  If
2139    INITP is nonzero, we are initializing the variable.  Otherwise, we
2140    are destroying it.  */
2141
2142 static tree
2143 start_static_initialization_or_destruction (tree decl, int initp)
2144 {
2145   tree guard_if_stmt = NULL_TREE;
2146   int priority;
2147   tree cond;
2148   tree guard;
2149   tree init_cond;
2150   priority_info pi;
2151
2152   /* Figure out the priority for this declaration.  */
2153   priority = DECL_INIT_PRIORITY (decl);
2154   if (!priority)
2155     priority = DEFAULT_INIT_PRIORITY;
2156
2157   /* Remember that we had an initialization or finalization at this
2158      priority.  */
2159   pi = get_priority_info (priority);
2160   if (initp)
2161     pi->initializations_p = 1;
2162   else
2163     pi->destructions_p = 1;
2164
2165   /* Trick the compiler into thinking we are at the file and line
2166      where DECL was declared so that error-messages make sense, and so
2167      that the debugger will show somewhat sensible file and line
2168      information.  */
2169   input_location = DECL_SOURCE_LOCATION (decl);
2170
2171   /* Because of:
2172
2173        [class.access.spec]
2174
2175        Access control for implicit calls to the constructors,
2176        the conversion functions, or the destructor called to
2177        create and destroy a static data member is performed as
2178        if these calls appeared in the scope of the member's
2179        class.
2180
2181      we pretend we are in a static member function of the class of
2182      which the DECL is a member.  */
2183   if (member_p (decl))
2184     {
2185       DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2186       DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2187     }
2188
2189   /* Conditionalize this initialization on being in the right priority
2190      and being initializing/finalizing appropriately.  */
2191   guard_if_stmt = begin_if_stmt ();
2192   cond = cp_build_binary_op (EQ_EXPR,
2193                              priority_decl,
2194                              build_int_2 (priority, 0));
2195   init_cond = initp ? integer_one_node : integer_zero_node;
2196   init_cond = cp_build_binary_op (EQ_EXPR,
2197                                   initialize_p_decl,
2198                                   init_cond);
2199   cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2200
2201   /* Assume we don't need a guard.  */
2202   guard = NULL_TREE;
2203   /* We need a guard if this is an object with external linkage that
2204      might be initialized in more than one place.  (For example, a
2205      static data member of a template, when the data member requires
2206      construction.)  */
2207   if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2208                              || DECL_ONE_ONLY (decl)
2209                              || DECL_WEAK (decl)))
2210     {
2211       tree guard_cond;
2212
2213       guard = get_guard (decl);
2214
2215       /* When using __cxa_atexit, we just check the GUARD as we would
2216          for a local static.  */
2217       if (flag_use_cxa_atexit)
2218         {
2219           /* When using __cxa_atexit, we never try to destroy
2220              anything from a static destructor.  */
2221           my_friendly_assert (initp, 20000629);
2222           guard_cond = get_guard_cond (guard);
2223         }
2224       /* If we don't have __cxa_atexit, then we will be running
2225          destructors from .fini sections, or their equivalents.  So,
2226          we need to know how many times we've tried to initialize this
2227          object.  We do initializations only if the GUARD is zero,
2228          i.e., if we are the first to initialize the variable.  We do
2229          destructions only if the GUARD is one, i.e., if we are the
2230          last to destroy the variable.  */
2231       else if (initp)
2232         guard_cond
2233           = cp_build_binary_op (EQ_EXPR,
2234                                 build_unary_op (PREINCREMENT_EXPR,
2235                                                 guard,
2236                                                 /*noconvert=*/1),
2237                                 integer_one_node);
2238       else
2239         guard_cond
2240           = cp_build_binary_op (EQ_EXPR,
2241                                 build_unary_op (PREDECREMENT_EXPR,
2242                                                 guard,
2243                                                 /*noconvert=*/1),
2244                                 integer_zero_node);
2245
2246       cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2247     }
2248
2249   finish_if_stmt_cond (cond, guard_if_stmt);
2250
2251   /* If we're using __cxa_atexit, we have not already set the GUARD,
2252      so we must do so now.  */
2253   if (guard && initp && flag_use_cxa_atexit)
2254     finish_expr_stmt (set_guard (guard));
2255
2256   return guard_if_stmt;
2257 }
2258
2259 /* We've just finished generating code to do an initialization or
2260    finalization.  GUARD_IF_STMT is the if-statement we used to guard
2261    the initialization.  */
2262
2263 static void
2264 finish_static_initialization_or_destruction (tree guard_if_stmt)
2265 {
2266   finish_then_clause (guard_if_stmt);
2267   finish_if_stmt ();
2268
2269   /* Now that we're done with DECL we don't need to pretend to be a
2270      member of its class any longer.  */
2271   DECL_CONTEXT (current_function_decl) = NULL_TREE;
2272   DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2273 }
2274
2275 /* Generate code to do the initialization of DECL, a VAR_DECL with
2276    static storage duration.  The initialization is INIT.  */
2277
2278 static void
2279 do_static_initialization (tree decl, tree init)
2280 {
2281   tree guard_if_stmt;
2282
2283   /* Set up for the initialization.  */
2284   guard_if_stmt
2285     = start_static_initialization_or_destruction (decl,
2286                                                   /*initp=*/1);
2287
2288   /* Perform the initialization.  */
2289   if (init)
2290     finish_expr_stmt (init);
2291
2292   /* If we're using __cxa_atexit, register a a function that calls the
2293      destructor for the object.  */
2294   if (flag_use_cxa_atexit)
2295     register_dtor_fn (decl);
2296
2297   /* Finsh up.  */
2298   finish_static_initialization_or_destruction (guard_if_stmt);
2299 }
2300
2301 /* Generate code to do the static destruction of DECL.  If DECL may be
2302    initialized more than once in different object files, GUARD is the
2303    guard variable to check.  PRIORITY is the priority for the
2304    destruction.  */
2305
2306 static void
2307 do_static_destruction (tree decl)
2308 {
2309   tree guard_if_stmt;
2310
2311   /* If we're using __cxa_atexit, then destructors are registered
2312      immediately after objects are initialized.  */
2313   my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2314
2315   /* If we don't need a destructor, there's nothing to do.  */
2316   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2317     return;
2318
2319   /* Actually do the destruction.  */
2320   guard_if_stmt = start_static_initialization_or_destruction (decl,
2321                                                               /*initp=*/0);
2322   finish_expr_stmt (build_cleanup (decl));
2323   finish_static_initialization_or_destruction (guard_if_stmt);
2324 }
2325
2326 /* VARS is a list of variables with static storage duration which may
2327    need initialization and/or finalization.  Remove those variables
2328    that don't really need to be initialized or finalized, and return
2329    the resulting list.  The order in which the variables appear in
2330    VARS is in reverse order of the order in which they should actually
2331    be initialized.  The list we return is in the unreversed order;
2332    i.e., the first variable should be initialized first.  */
2333
2334 static tree
2335 prune_vars_needing_no_initialization (tree *vars)
2336 {
2337   tree *var = vars;
2338   tree result = NULL_TREE;
2339
2340   while (*var)
2341     {
2342       tree t = *var;
2343       tree decl = TREE_VALUE (t);
2344       tree init = TREE_PURPOSE (t);
2345
2346       /* Deal gracefully with error.  */
2347       if (decl == error_mark_node)
2348         {
2349           var = &TREE_CHAIN (t);
2350           continue;
2351         }
2352
2353       /* The only things that can be initialized are variables.  */
2354       my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2355
2356       /* If this object is not defined, we don't need to do anything
2357          here.  */
2358       if (DECL_EXTERNAL (decl))
2359         {
2360           var = &TREE_CHAIN (t);
2361           continue;
2362         }
2363
2364       /* Also, if the initializer already contains errors, we can bail
2365          out now.  */
2366       if (init && TREE_CODE (init) == TREE_LIST
2367           && value_member (error_mark_node, init))
2368         {
2369           var = &TREE_CHAIN (t);
2370           continue;
2371         }
2372
2373       /* This variable is going to need initialization and/or
2374          finalization, so we add it to the list.  */
2375       *var = TREE_CHAIN (t);
2376       TREE_CHAIN (t) = result;
2377       result = t;
2378     }
2379
2380   return result;
2381 }
2382
2383 /* Make sure we have told the back end about all the variables in
2384    VARS.  */
2385
2386 static void
2387 write_out_vars (tree vars)
2388 {
2389   tree v;
2390
2391   for (v = vars; v; v = TREE_CHAIN (v))
2392     if (!var_finalized_p (TREE_VALUE (v)))
2393       rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2394 }
2395
2396 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2397    (otherwise) that will initialize all gobal objects with static
2398    storage duration having the indicated PRIORITY.  */
2399
2400 static void
2401 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2402                                 location_t *locus)
2403 {
2404   char function_key;
2405   tree arguments;
2406   tree fndecl;
2407   tree body;
2408   size_t i;
2409
2410   input_location = *locus;
2411   locus->line++;
2412
2413   /* We use `I' to indicate initialization and `D' to indicate
2414      destruction.  */
2415   function_key = constructor_p ? 'I' : 'D';
2416
2417   /* We emit the function lazily, to avoid generating empty
2418      global constructors and destructors.  */
2419   body = NULL_TREE;
2420
2421   /* Call the static storage duration function with appropriate
2422      arguments.  */
2423   if (ssdf_decls)
2424     for (i = 0; i < ssdf_decls->elements_used; ++i)
2425       {
2426         fndecl = VARRAY_TREE (ssdf_decls, i);
2427
2428         /* Calls to pure or const functions will expand to nothing.  */
2429         if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2430           {
2431             if (! body)
2432               body = start_objects (function_key, priority);
2433
2434             arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2435                                    NULL_TREE);
2436             arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2437                                    arguments);
2438             finish_expr_stmt (build_function_call (fndecl, arguments));
2439           }
2440       }
2441
2442   /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2443      calls to any functions marked with attributes indicating that
2444      they should be called at initialization- or destruction-time.  */
2445   if (priority == DEFAULT_INIT_PRIORITY)
2446     {
2447       tree fns;
2448
2449       for (fns = constructor_p ? static_ctors : static_dtors;
2450            fns;
2451            fns = TREE_CHAIN (fns))
2452         {
2453           fndecl = TREE_VALUE (fns);
2454
2455           /* Calls to pure/const functions will expand to nothing.  */
2456           if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2457             {
2458               if (! body)
2459                 body = start_objects (function_key, priority);
2460               finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2461             }
2462         }
2463     }
2464
2465   /* Close out the function.  */
2466   if (body)
2467     finish_objects (function_key, priority, body);
2468 }
2469
2470 /* Generate constructor and destructor functions for the priority
2471    indicated by N.  */
2472
2473 static int
2474 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2475 {
2476   location_t *locus = data;
2477   int priority = (int) n->key;
2478   priority_info pi = (priority_info) n->value;
2479
2480   /* Generate the functions themselves, but only if they are really
2481      needed.  */
2482   if (pi->initializations_p
2483       || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2484     generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2485   if (pi->destructions_p
2486       || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2487     generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2488
2489   /* Keep iterating.  */
2490   return 0;
2491 }
2492
2493 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR.  It is supposed to mark
2494    decls referenced from frontend specific constructs; it will be called
2495    only for language-specific tree nodes.
2496
2497    Here we must deal with member pointers.  */
2498
2499 tree
2500 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2501                             tree from ATTRIBUTE_UNUSED)
2502 {
2503   tree t = *tp;
2504
2505   if (flag_unit_at_a_time)
2506     switch (TREE_CODE (t))
2507       {
2508       case PTRMEM_CST:
2509         if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2510           cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
2511         break;
2512       case BASELINK:
2513         if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
2514           cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
2515         break;
2516
2517       default:
2518         break;
2519       }
2520
2521   return NULL;
2522 }
2523
2524 /* This routine is called from the last rule in yyparse ().
2525    Its job is to create all the code needed to initialize and
2526    destroy the global aggregates.  We do the destruction
2527    first, since that way we only need to reverse the decls once.  */
2528
2529 void
2530 finish_file (void)
2531 {
2532   tree vars;
2533   bool reconsider;
2534   size_t i;
2535   location_t locus;
2536   unsigned ssdf_count = 0;
2537
2538   locus = input_location;
2539   at_eof = 1;
2540
2541   /* Bad parse errors.  Just forget about it.  */
2542   if (! global_bindings_p () || current_class_type || decl_namespace_list)
2543     return;
2544
2545   if (pch_file)
2546     c_common_write_pch ();
2547
2548   /* Otherwise, GDB can get confused, because in only knows
2549      about source for LINENO-1 lines.  */
2550   input_line -= 1;
2551
2552   interface_unknown = 1;
2553   interface_only = 0;
2554
2555   /* We now have to write out all the stuff we put off writing out.
2556      These include:
2557
2558        o Template specializations that we have not yet instantiated,
2559          but which are needed.
2560        o Initialization and destruction for non-local objects with
2561          static storage duration.  (Local objects with static storage
2562          duration are initialized when their scope is first entered,
2563          and are cleaned up via atexit.)
2564        o Virtual function tables.
2565
2566      All of these may cause others to be needed.  For example,
2567      instantiating one function may cause another to be needed, and
2568      generating the initializer for an object may cause templates to be
2569      instantiated, etc., etc.  */
2570
2571   timevar_push (TV_VARCONST);
2572
2573   emit_support_tinfos ();
2574
2575   do
2576     {
2577       tree t;
2578       size_t n_old, n_new;
2579
2580       reconsider = false;
2581
2582       /* If there are templates that we've put off instantiating, do
2583          them now.  */
2584       instantiate_pending_templates ();
2585       ggc_collect ();
2586
2587       /* Write out virtual tables as required.  Note that writing out
2588          the virtual table for a template class may cause the
2589          instantiation of members of that class.  If we write out
2590          vtables then we remove the class from our list so we don't
2591          have to look at it again.  */
2592
2593       while (keyed_classes != NULL_TREE
2594              && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2595         {
2596           reconsider = true;
2597           keyed_classes = TREE_CHAIN (keyed_classes);
2598         }
2599
2600       t = keyed_classes;
2601       if (t != NULL_TREE)
2602         {
2603           tree next = TREE_CHAIN (t);
2604
2605           while (next)
2606             {
2607               if (maybe_emit_vtables (TREE_VALUE (next)))
2608                 {
2609                   reconsider = true;
2610                   TREE_CHAIN (t) = TREE_CHAIN (next);
2611                 }
2612               else
2613                 t = next;
2614
2615               next = TREE_CHAIN (t);
2616             }
2617         }
2618
2619       /* Write out needed type info variables.  We have to be careful
2620          looping through unemitted decls, because emit_tinfo_decl may
2621          cause other variables to be needed.  We stick new elements
2622          (and old elements that we may need to reconsider) at the end
2623          of the array, then shift them back to the beginning once we're
2624          done.  */
2625
2626       n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2627       for (i = 0; i < n_old; ++i)
2628         {
2629           tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2630           if (emit_tinfo_decl (tinfo_decl))
2631             reconsider = true;
2632           else
2633             VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2634         }
2635
2636       /* The only elements we want to keep are the new ones.  Copy
2637          them to the beginning of the array, then get rid of the
2638          leftovers.  */
2639       n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2640       if (n_new)
2641         memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2642                  &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2643                  n_new * sizeof (tree));
2644       memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2645               0, n_old * sizeof (tree));
2646       VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2647
2648       /* The list of objects with static storage duration is built up
2649          in reverse order.  We clear STATIC_AGGREGATES so that any new
2650          aggregates added during the initialization of these will be
2651          initialized in the correct order when we next come around the
2652          loop.  */
2653       vars = prune_vars_needing_no_initialization (&static_aggregates);
2654
2655       if (vars)
2656         {
2657           tree v;
2658
2659           /* We need to start a new initialization function each time
2660              through the loop.  That's because we need to know which
2661              vtables have been referenced, and TREE_SYMBOL_REFERENCED
2662              isn't computed until a function is finished, and written
2663              out.  That's a deficiency in the back-end.  When this is
2664              fixed, these initialization functions could all become
2665              inline, with resulting performance improvements.  */
2666           tree ssdf_body;
2667
2668           /* Set the line and file, so that it is obviously not from
2669              the source file.  */
2670           input_location = locus;
2671           ssdf_body = start_static_storage_duration_function (ssdf_count);
2672
2673           /* Make sure the back end knows about all the variables.  */
2674           write_out_vars (vars);
2675
2676           /* First generate code to do all the initializations.  */
2677           for (v = vars; v; v = TREE_CHAIN (v))
2678             do_static_initialization (TREE_VALUE (v),
2679                                       TREE_PURPOSE (v));
2680
2681           /* Then, generate code to do all the destructions.  Do these
2682              in reverse order so that the most recently constructed
2683              variable is the first destroyed.  If we're using
2684              __cxa_atexit, then we don't need to do this; functions
2685              were registered at initialization time to destroy the
2686              local statics.  */
2687           if (!flag_use_cxa_atexit)
2688             {
2689               vars = nreverse (vars);
2690               for (v = vars; v; v = TREE_CHAIN (v))
2691                 do_static_destruction (TREE_VALUE (v));
2692             }
2693           else
2694             vars = NULL_TREE;
2695
2696           /* Finish up the static storage duration function for this
2697              round.  */
2698           input_location = locus;
2699           finish_static_storage_duration_function (ssdf_body);
2700
2701           /* All those initializations and finalizations might cause
2702              us to need more inline functions, more template
2703              instantiations, etc.  */
2704           reconsider = true;
2705           ssdf_count++;
2706           locus.line++;
2707         }
2708
2709       for (i = 0; i < deferred_fns_used; ++i)
2710         {
2711           tree decl = VARRAY_TREE (deferred_fns, i);
2712
2713           /* Does it need synthesizing?  */
2714           if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2715               && TREE_USED (decl)
2716               && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2717             {
2718               /* Even though we're already at the top-level, we push
2719                  there again.  That way, when we pop back a few lines
2720                  hence, all of our state is restored.  Otherwise,
2721                  finish_function doesn't clean things up, and we end
2722                  up with CURRENT_FUNCTION_DECL set.  */
2723               push_to_top_level ();
2724               synthesize_method (decl);
2725               pop_from_top_level ();
2726               reconsider = true;
2727             }
2728
2729           /* If the function has no body, avoid calling
2730              import_export_decl.  On a system without weak symbols,
2731              calling import_export_decl will make an inline template
2732              instantiation "static", which will result in errors about
2733              the use of undefined functions if there is no body for
2734              the function.  */
2735           if (!DECL_SAVED_TREE (decl))
2736             continue;
2737
2738           import_export_decl (decl);
2739
2740           /* We lie to the back-end, pretending that some functions
2741              are not defined when they really are.  This keeps these
2742              functions from being put out unnecessarily.  But, we must
2743              stop lying when the functions are referenced, or if they
2744              are not comdat since they need to be put out now.  This
2745              is done in a separate for cycle, because if some deferred
2746              function is contained in another deferred function later
2747              in deferred_fns varray, rest_of_compilation would skip
2748              this function and we really cannot expand the same
2749              function twice.  */
2750           if (DECL_NOT_REALLY_EXTERN (decl)
2751               && DECL_INITIAL (decl)
2752               && DECL_NEEDED_P (decl))
2753             DECL_EXTERNAL (decl) = 0;
2754
2755           /* If we're going to need to write this function out, and
2756              there's already a body for it, create RTL for it now.
2757              (There might be no body if this is a method we haven't
2758              gotten around to synthesizing yet.)  */
2759           if (!DECL_EXTERNAL (decl)
2760               && DECL_NEEDED_P (decl)
2761               && DECL_SAVED_TREE (decl)
2762               && !TREE_ASM_WRITTEN (decl)
2763               && (!flag_unit_at_a_time
2764                   || !cgraph_node (decl)->local.finalized))
2765             {
2766               /* We will output the function; no longer consider it in this
2767                  loop.  */
2768               DECL_DEFER_OUTPUT (decl) = 0;
2769               /* Generate RTL for this function now that we know we
2770                  need it.  */
2771               expand_or_defer_fn (decl);
2772               /* If we're compiling -fsyntax-only pretend that this
2773                  function has been written out so that we don't try to
2774                  expand it again.  */
2775               if (flag_syntax_only)
2776                 TREE_ASM_WRITTEN (decl) = 1;
2777               reconsider = true;
2778             }
2779         }
2780
2781       if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2782         reconsider = true;
2783
2784       /* Static data members are just like namespace-scope globals.  */
2785       for (i = 0; i < pending_statics_used; ++i)
2786         {
2787           tree decl = VARRAY_TREE (pending_statics, i);
2788           if (var_finalized_p (decl))
2789             continue;
2790           import_export_decl (decl);
2791           if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2792             DECL_EXTERNAL (decl) = 0;
2793         }
2794       if (pending_statics
2795           && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2796                                          pending_statics_used))
2797         reconsider = true;
2798
2799       if (cgraph_assemble_pending_functions ())
2800         reconsider = true;
2801     }
2802   while (reconsider);
2803
2804   /* All used inline functions must have a definition at this point.  */
2805   for (i = 0; i < deferred_fns_used; ++i)
2806     {
2807       tree decl = VARRAY_TREE (deferred_fns, i);
2808
2809       if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
2810           && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
2811                /* An explicit instantiation can be used to specify
2812                   that the body is in another unit. It will have
2813                   already verified there was a definition.  */
2814                || DECL_EXPLICIT_INSTANTIATION (decl)))
2815         {
2816           cp_warning_at ("inline function `%D' used but never defined", decl);
2817           /* This symbol is effectively an "extern" declaration now.
2818              This is not strictly necessary, but removes a duplicate
2819              warning.  */
2820           TREE_PUBLIC (decl) = 1;
2821         }
2822
2823     }
2824
2825   /* We give C linkage to static constructors and destructors.  */
2826   push_lang_context (lang_name_c);
2827
2828   /* Generate initialization and destruction functions for all
2829      priorities for which they are required.  */
2830   if (priority_info_map)
2831     splay_tree_foreach (priority_info_map,
2832                         generate_ctor_and_dtor_functions_for_priority,
2833                         /*data=*/&locus);
2834   else
2835     {
2836
2837       if (static_ctors)
2838         generate_ctor_or_dtor_function (/*constructor_p=*/true,
2839                                         DEFAULT_INIT_PRIORITY, &locus);
2840       if (static_dtors)
2841         generate_ctor_or_dtor_function (/*constructor_p=*/false,
2842                                         DEFAULT_INIT_PRIORITY, &locus);
2843     }
2844
2845   /* We're done with the splay-tree now.  */
2846   if (priority_info_map)
2847     splay_tree_delete (priority_info_map);
2848
2849   /* We're done with static constructors, so we can go back to "C++"
2850      linkage now.  */
2851   pop_lang_context ();
2852
2853   if (flag_unit_at_a_time)
2854     {
2855       cgraph_finalize_compilation_unit ();
2856       cgraph_optimize ();
2857     }
2858
2859   /* Now, issue warnings about static, but not defined, functions,
2860      etc., and emit debugging information.  */
2861   walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2862   if (pending_statics)
2863     check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2864                                pending_statics_used);
2865
2866   finish_repo ();
2867
2868   /* The entire file is now complete.  If requested, dump everything
2869      to a file.  */
2870   {
2871     int flags;
2872     FILE *stream = dump_begin (TDI_all, &flags);
2873
2874     if (stream)
2875       {
2876         dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2877         dump_end (TDI_all, stream);
2878       }
2879   }
2880
2881   timevar_pop (TV_VARCONST);
2882
2883   if (flag_detailed_statistics)
2884     {
2885       dump_tree_statistics ();
2886       dump_time_statistics ();
2887     }
2888   input_location = locus;
2889 }
2890
2891 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
2892    function to call in parse-tree form; it has not yet been
2893    semantically analyzed.  ARGS are the arguments to the function.
2894    They have already been semantically analyzed.  */
2895
2896 tree
2897 build_offset_ref_call_from_tree (tree fn, tree args)
2898 {
2899   tree orig_fn;
2900   tree orig_args;
2901   tree expr;
2902   tree object;
2903
2904   orig_fn = fn;
2905   orig_args = args;
2906   object = TREE_OPERAND (fn, 0);
2907
2908   if (processing_template_decl)
2909     {
2910       my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
2911                           || TREE_CODE (fn) == MEMBER_REF,
2912                           20030708);
2913       if (type_dependent_expression_p (fn)
2914           || any_type_dependent_arguments_p (args))
2915         return build_min_nt (CALL_EXPR, fn, args);
2916
2917       /* Transform the arguments and add the implicit "this"
2918          parameter.  That must be done before the FN is transformed
2919          because we depend on the form of FN.  */
2920       args = build_non_dependent_args (args);
2921       if (TREE_CODE (fn) == DOTSTAR_EXPR)
2922         object = build_unary_op (ADDR_EXPR, object, 0);
2923       object = build_non_dependent_expr (object);
2924       args = tree_cons (NULL_TREE, object, args);
2925       /* Now that the arguments are done, transform FN.  */
2926       fn = build_non_dependent_expr (fn);
2927     }
2928
2929   /* A qualified name corresponding to a bound pointer-to-member is
2930      represented as an OFFSET_REF:
2931
2932         struct B { void g(); };
2933         void (B::*p)();
2934         void B::g() { (this->*p)(); }  */
2935   if (TREE_CODE (fn) == OFFSET_REF)
2936     {
2937       tree object_addr = build_unary_op (ADDR_EXPR, object, 0);
2938       fn = TREE_OPERAND (fn, 1);
2939       fn = get_member_function_from_ptrfunc (&object_addr, fn);
2940       args = tree_cons (NULL_TREE, object_addr, args);
2941     }
2942
2943   expr = build_function_call (fn, args);
2944   if (processing_template_decl && expr != error_mark_node)
2945     return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args);
2946   return expr;
2947 }
2948
2949
2950 void
2951 check_default_args (tree x)
2952 {
2953   tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
2954   bool saw_def = false;
2955   int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
2956   for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
2957     {
2958       if (TREE_PURPOSE (arg))
2959         saw_def = true;
2960       else if (saw_def)
2961         {
2962           cp_error_at ("default argument missing for parameter %P of `%+#D'",
2963                        i, x);
2964           break;
2965         }
2966     }
2967 }
2968
2969 void
2970 mark_used (tree decl)
2971 {
2972   TREE_USED (decl) = 1;
2973   if (processing_template_decl || skip_evaluation)
2974     return;
2975
2976   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
2977       && !TREE_ASM_WRITTEN (decl))
2978     /* Remember it, so we can check it was defined.  */
2979     defer_fn (decl);
2980
2981   assemble_external (decl);
2982
2983   /* Is it a synthesized method that needs to be synthesized?  */
2984   if (TREE_CODE (decl) == FUNCTION_DECL
2985       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
2986       && DECL_ARTIFICIAL (decl)
2987       && !DECL_THUNK_P (decl)
2988       && ! DECL_INITIAL (decl)
2989       /* Kludge: don't synthesize for default args.  */
2990       && current_function_decl)
2991     {
2992       synthesize_method (decl);
2993       /* If we've already synthesized the method we don't need to
2994          instantiate it, so we can return right away.  */
2995       return;
2996     }
2997
2998   /* If this is a function or variable that is an instance of some
2999      template, we now know that we will need to actually do the
3000      instantiation. We check that DECL is not an explicit
3001      instantiation because that is not checked in instantiate_decl.  */
3002   if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
3003       && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3004       && (!DECL_EXPLICIT_INSTANTIATION (decl)
3005           || (TREE_CODE (decl) == FUNCTION_DECL
3006               && DECL_INLINE (DECL_TEMPLATE_RESULT
3007                               (template_for_substitution (decl))))))
3008     {
3009       bool defer;
3010
3011       /* Normally, we put off instantiating functions in order to
3012          improve compile times.  Maintaining a stack of active
3013          functions is expensive, and the inliner knows to
3014          instantiate any functions it might need.
3015
3016          However, if instantiating this function might help us mark
3017          the current function TREE_NOTHROW, we go ahead and
3018          instantiate it now.
3019
3020          This is not needed for unit-at-a-time since we reorder the functions
3021          in topological order anyway.
3022          */
3023       defer = (!flag_exceptions
3024                || flag_unit_at_a_time
3025                || !optimize
3026                || TREE_CODE (decl) != FUNCTION_DECL
3027                /* If the called function can't throw, we don't need to
3028                   generate its body to find that out.  */
3029                || TREE_NOTHROW (decl)
3030                || !cfun
3031                || !current_function_decl
3032                /* If we already know the current function can't throw,
3033                   then we don't need to work hard to prove it.  */
3034                || TREE_NOTHROW (current_function_decl)
3035                /* If we already know that the current function *can*
3036                   throw, there's no point in gathering more
3037                   information.  */
3038                || cp_function_chain->can_throw);
3039
3040       instantiate_decl (decl, defer);
3041     }
3042 }
3043
3044 #include "gt-cp-decl2.h"