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