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