gcc/cp/decl2.c

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