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