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