gcc/cp/decl2.c

   1 /* Process declarations and variables for C++ compiler.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4    Hacked by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 /* Process declarations and symbol lookup for C++ front end.
  25    Also constructs types; the standard scalar types at initialization,
  26    and structure, union, array and enum types when they are declared.  */
  27
  28 /* ??? not all decl nodes are given the most useful possible
  29    line numbers.  For example, the CONST_DECLs for enum values.  */
  30
  31 #include "config.h"
  32 #include "system.h"
  33 #include "coretypes.h"
  34 #include "tm.h"
  35 #include "tree.h"
  36 #include "rtl.h"
  37 #include "expr.h"
  38 #include "flags.h"
  39 #include "cp-tree.h"
  40 #include "decl.h"
  41 #include "lex.h"
  42 #include "output.h"
  43 #include "except.h"
  44 #include "toplev.h"
  45 #include "timevar.h"
  46 #include "cpplib.h"
  47 #include "target.h"
  48 #include "c-common.h"
  49 #include "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 (processing_template_decl)
 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         {
1609           /* It had better be all done at compile-time.  */
1610           if (store_init_value (vtbl, DECL_INITIAL (vtbl)))
1611             abort ();
1612         }
1613
1614       if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
1615         {
1616           /* Mark the VAR_DECL node representing the vtable itself as a
1617              "gratuitous" one, thereby forcing dwarfout.c to ignore it.
1618              It is rather important that such things be ignored because
1619              any effort to actually generate DWARF for them will run
1620              into trouble when/if we encounter code like:
1621
1622                 #pragma interface
1623                 struct S { virtual void member (); };
1624
1625               because the artificial declaration of the vtable itself (as
1626               manufactured by the g++ front end) will say that the vtable
1627               is a static member of `S' but only *after* the debug output
1628               for the definition of `S' has already been output.  This causes
1629               grief because the DWARF entry for the definition of the vtable
1630               will try to refer back to an earlier *declaration* of the
1631               vtable as a static member of `S' and there won't be one.
1632               We might be able to arrange to have the "vtable static member"
1633               attached to the member list for `S' before the debug info for
1634               `S' get written (which would solve the problem) but that would
1635               require more intrusive changes to the g++ front end.  */
1636
1637           DECL_IGNORED_P (vtbl) = 1;
1638         }
1639
1640       /* Always make vtables weak.  */
1641       if (flag_weak)
1642         comdat_linkage (vtbl);
1643
1644       rest_of_decl_compilation (vtbl, NULL, 1, 1);
1645
1646       /* Because we're only doing syntax-checking, we'll never end up
1647          actually marking the variable as written.  */
1648       if (flag_syntax_only)
1649         TREE_ASM_WRITTEN (vtbl) = 1;
1650     }
1651
1652   /* Since we're writing out the vtable here, also write the debug
1653      info.  */
1654   note_debug_info_needed (ctype);
1655
1656   return true;
1657 }
1658
1659 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
1660    inline function or template instantiation at end-of-file.  */
1661
1662 void
1663 import_export_decl (tree decl)
1664 {
1665   if (DECL_INTERFACE_KNOWN (decl))
1666     return;
1667
1668   if (DECL_TEMPLATE_INSTANTIATION (decl)
1669       || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1670     {
1671       DECL_NOT_REALLY_EXTERN (decl) = 1;
1672       if ((DECL_IMPLICIT_INSTANTIATION (decl)
1673            || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
1674           && (flag_implicit_templates
1675               || (flag_implicit_inline_templates
1676                   && TREE_CODE (decl) == FUNCTION_DECL
1677                   && DECL_DECLARED_INLINE_P (decl))))
1678         {
1679           if (!TREE_PUBLIC (decl))
1680             /* Templates are allowed to have internal linkage.  See
1681                [basic.link].  */
1682             ;
1683           else
1684             comdat_linkage (decl);
1685         }
1686       else
1687         {
1688           DECL_EXTERNAL (decl) = 1;
1689           DECL_NOT_REALLY_EXTERN (decl) = 0;
1690         }
1691     }
1692   else if (DECL_FUNCTION_MEMBER_P (decl))
1693     {
1694       if (!DECL_DECLARED_INLINE_P (decl))
1695         {
1696           tree ctype = DECL_CONTEXT (decl);
1697           import_export_class (ctype);
1698           if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1699             {
1700               DECL_NOT_REALLY_EXTERN (decl)
1701                 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
1702                      || (DECL_DECLARED_INLINE_P (decl)
1703                          && ! flag_implement_inlines
1704                          && !DECL_VINDEX (decl)));
1705
1706               if (!DECL_NOT_REALLY_EXTERN (decl))
1707                 DECL_EXTERNAL (decl) = 1;
1708
1709               /* Always make artificials weak.  */
1710               if (DECL_ARTIFICIAL (decl) && flag_weak)
1711                 comdat_linkage (decl);
1712               else
1713                 maybe_make_one_only (decl);
1714             }
1715         }
1716       else
1717         comdat_linkage (decl);
1718     }
1719   else
1720     comdat_linkage (decl);
1721
1722   DECL_INTERFACE_KNOWN (decl) = 1;
1723 }
1724
1725 /* Here, we only decide whether or not the tinfo node should be
1726    emitted with the vtable.  IS_IN_LIBRARY is nonzero iff the
1727    typeinfo for TYPE should be in the runtime library.  */
1728
1729 void
1730 import_export_tinfo (tree decl, tree type, bool is_in_library)
1731 {
1732   if (DECL_INTERFACE_KNOWN (decl))
1733     return;
1734
1735   if (IS_AGGR_TYPE (type))
1736     import_export_class (type);
1737
1738   if (IS_AGGR_TYPE (type) && CLASSTYPE_INTERFACE_KNOWN (type)
1739       && TYPE_POLYMORPHIC_P (type)
1740       /* If -fno-rtti, we're not necessarily emitting this stuff with
1741          the class, so go ahead and emit it now.  This can happen when
1742          a class is used in exception handling.  */
1743       && flag_rtti)
1744     {
1745       DECL_NOT_REALLY_EXTERN (decl) = !CLASSTYPE_INTERFACE_ONLY (type);
1746       DECL_COMDAT (decl) = 0;
1747     }
1748   else
1749     {
1750       DECL_NOT_REALLY_EXTERN (decl) = 1;
1751       DECL_COMDAT (decl) = 1;
1752     }
1753
1754   /* Now override some cases.  */
1755   if (flag_weak)
1756     DECL_COMDAT (decl) = 1;
1757   else if (is_in_library)
1758     DECL_COMDAT (decl) = 0;
1759
1760   DECL_INTERFACE_KNOWN (decl) = 1;
1761 }
1762
1763 /* Return an expression that performs the destruction of DECL, which
1764    must be a VAR_DECL whose type has a non-trivial destructor, or is
1765    an array whose (innermost) elements have a non-trivial destructor.  */
1766
1767 tree
1768 build_cleanup (tree decl)
1769 {
1770   tree temp;
1771   tree type = TREE_TYPE (decl);
1772
1773   /* This function should only be called for declarations that really
1774      require cleanups.  */
1775   my_friendly_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type), 20030106);
1776
1777   /* Treat all objects with destructors as used; the destructor may do
1778      something substantive.  */
1779   mark_used (decl);
1780
1781   if (TREE_CODE (type) == ARRAY_TYPE)
1782     temp = decl;
1783   else
1784     {
1785       cxx_mark_addressable (decl);
1786       temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
1787     }
1788   temp = build_delete (TREE_TYPE (temp), temp,
1789                        sfk_complete_destructor,
1790                        LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
1791   return temp;
1792 }
1793
1794 /* Returns the initialization guard variable for the variable DECL,
1795    which has static storage duration.  */
1796
1797 tree
1798 get_guard (tree decl)
1799 {
1800   tree sname;
1801   tree guard;
1802
1803   sname = mangle_guard_variable (decl);
1804   guard = IDENTIFIER_GLOBAL_VALUE (sname);
1805   if (! guard)
1806     {
1807       tree guard_type;
1808
1809       /* We use a type that is big enough to contain a mutex as well
1810          as an integer counter.  */
1811       guard_type = long_long_integer_type_node;
1812       guard = build_decl (VAR_DECL, sname, guard_type);
1813
1814       /* The guard should have the same linkage as what it guards.  */
1815       TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
1816       TREE_STATIC (guard) = TREE_STATIC (decl);
1817       DECL_COMMON (guard) = DECL_COMMON (decl);
1818       DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
1819       if (TREE_PUBLIC (decl))
1820         DECL_WEAK (guard) = DECL_WEAK (decl);
1821
1822       DECL_ARTIFICIAL (guard) = 1;
1823       TREE_USED (guard) = 1;
1824       pushdecl_top_level_and_finish (guard, NULL_TREE);
1825     }
1826   return guard;
1827 }
1828
1829 /* Return those bits of the GUARD variable that should be set when the
1830    guarded entity is actually initialized.  */
1831
1832 static tree
1833 get_guard_bits (tree guard)
1834 {
1835   /* We only set the first byte of the guard, in order to leave room
1836      for a mutex in the high-order bits.  */
1837   guard = build1 (ADDR_EXPR,
1838                   build_pointer_type (TREE_TYPE (guard)),
1839                   guard);
1840   guard = build1 (NOP_EXPR,
1841                   build_pointer_type (char_type_node),
1842                   guard);
1843   guard = build1 (INDIRECT_REF, char_type_node, guard);
1844
1845   return guard;
1846 }
1847
1848 /* Return an expression which determines whether or not the GUARD
1849    variable has already been initialized.  */
1850
1851 tree
1852 get_guard_cond (tree guard)
1853 {
1854   tree guard_value;
1855
1856   /* Check to see if the GUARD is zero.  */
1857   guard = get_guard_bits (guard);
1858   guard_value = integer_zero_node;
1859   if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
1860     guard_value = convert (TREE_TYPE (guard), guard_value);
1861   return cp_build_binary_op (EQ_EXPR, guard, guard_value);
1862 }
1863
1864 /* Return an expression which sets the GUARD variable, indicating that
1865    the variable being guarded has been initialized.  */
1866
1867 tree
1868 set_guard (tree guard)
1869 {
1870   tree guard_init;
1871
1872   /* Set the GUARD to one.  */
1873   guard = get_guard_bits (guard);
1874   guard_init = integer_one_node;
1875   if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
1876     guard_init = convert (TREE_TYPE (guard), guard_init);
1877   return build_modify_expr (guard, NOP_EXPR, guard_init);
1878 }
1879
1880 /* Start the process of running a particular set of global constructors
1881    or destructors.  Subroutine of do_[cd]tors.  */
1882
1883 static tree
1884 start_objects (int method_type, int initp)
1885 {
1886   tree fnname;
1887   tree body;
1888   char type[10];
1889
1890   /* Make ctor or dtor function.  METHOD_TYPE may be 'I' or 'D'.  */
1891
1892   if (initp != DEFAULT_INIT_PRIORITY)
1893     {
1894       char joiner;
1895
1896 #ifdef JOINER
1897       joiner = JOINER;
1898 #else
1899       joiner = '_';
1900 #endif
1901
1902       sprintf (type, "%c%c%.5u", method_type, joiner, initp);
1903     }
1904   else
1905     sprintf (type, "%c", method_type);
1906
1907   fnname = get_file_function_name_long (type);
1908
1909   start_function (void_list_node,
1910                   make_call_declarator (fnname, void_list_node, NULL_TREE,
1911                                         NULL_TREE),
1912                   NULL_TREE, SF_DEFAULT);
1913
1914   /* It can be a static function as long as collect2 does not have
1915      to scan the object file to find its ctor/dtor routine.  */
1916   TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
1917
1918   /* Mark this declaration as used to avoid spurious warnings.  */
1919   TREE_USED (current_function_decl) = 1;
1920
1921   /* Mark this function as a global constructor or destructor.  */
1922   if (method_type == 'I')
1923     DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
1924   else
1925     DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
1926   DECL_LANG_SPECIFIC (current_function_decl)->decl_flags.u2sel = 1;
1927
1928   body = begin_compound_stmt (/*has_no_scope=*/false);
1929
1930   /* We cannot allow these functions to be elided, even if they do not
1931      have external linkage.  And, there's no point in deferring
1932      compilation of thes functions; they're all going to have to be
1933      out anyhow.  */
1934   current_function_cannot_inline
1935     = "static constructors and destructors cannot be inlined";
1936
1937   return body;
1938 }
1939
1940 /* Finish the process of running a particular set of global constructors
1941    or destructors.  Subroutine of do_[cd]tors.  */
1942
1943 static void
1944 finish_objects (int method_type, int initp, tree body)
1945 {
1946   tree fn;
1947
1948   /* Finish up.  */
1949   finish_compound_stmt (body);
1950   fn = finish_function (0);
1951   expand_or_defer_fn (fn);
1952
1953   /* When only doing semantic analysis, and no RTL generation, we
1954      can't call functions that directly emit assembly code; there is
1955      no assembly file in which to put the code.  */
1956   if (flag_syntax_only)
1957     return;
1958
1959   if (targetm.have_ctors_dtors)
1960     {
1961       rtx fnsym = XEXP (DECL_RTL (fn), 0);
1962       if (method_type == 'I')
1963         (* targetm.asm_out.constructor) (fnsym, initp);
1964       else
1965         (* targetm.asm_out.destructor) (fnsym, initp);
1966     }
1967 }
1968
1969 /* The names of the parameters to the function created to handle
1970    initializations and destructions for objects with static storage
1971    duration.  */
1972 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
1973 #define PRIORITY_IDENTIFIER "__priority"
1974
1975 /* The name of the function we create to handle initializations and
1976    destructions for objects with static storage duration.  */
1977 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
1978
1979 /* The declaration for the __INITIALIZE_P argument.  */
1980 static GTY(()) tree initialize_p_decl;
1981
1982 /* The declaration for the __PRIORITY argument.  */
1983 static GTY(()) tree priority_decl;
1984
1985 /* The declaration for the static storage duration function.  */
1986 static GTY(()) tree ssdf_decl;
1987
1988 /* All the static storage duration functions created in this
1989    translation unit.  */
1990 static GTY(()) varray_type ssdf_decls;
1991
1992 /* A map from priority levels to information about that priority
1993    level.  There may be many such levels, so efficient lookup is
1994    important.  */
1995 static splay_tree priority_info_map;
1996
1997 /* Begins the generation of the function that will handle all
1998    initialization and destruction of objects with static storage
1999    duration.  The function generated takes two parameters of type
2000    `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
2001    nonzero, it performs initializations.  Otherwise, it performs
2002    destructions.  It only performs those initializations or
2003    destructions with the indicated __PRIORITY.  The generated function
2004    returns no value.
2005
2006    It is assumed that this function will only be called once per
2007    translation unit.  */
2008
2009 static tree
2010 start_static_storage_duration_function (unsigned count)
2011 {
2012   tree parm_types;
2013   tree type;
2014   tree body;
2015   char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2016
2017   /* Create the identifier for this function.  It will be of the form
2018      SSDF_IDENTIFIER_<number>.  */
2019   sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2020
2021   /* Create the parameters.  */
2022   parm_types = void_list_node;
2023   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2024   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2025   type = build_function_type (void_type_node, parm_types);
2026
2027   /* Create the FUNCTION_DECL itself.  */
2028   ssdf_decl = build_lang_decl (FUNCTION_DECL,
2029                                get_identifier (id),
2030                                type);
2031   TREE_PUBLIC (ssdf_decl) = 0;
2032   DECL_ARTIFICIAL (ssdf_decl) = 1;
2033
2034   /* Put this function in the list of functions to be called from the
2035      static constructors and destructors.  */
2036   if (!ssdf_decls)
2037     {
2038       VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2039
2040       /* Take this opportunity to initialize the map from priority
2041          numbers to information about that priority level.  */
2042       priority_info_map = splay_tree_new (splay_tree_compare_ints,
2043                                           /*delete_key_fn=*/0,
2044                                           /*delete_value_fn=*/
2045                                           (splay_tree_delete_value_fn) &free);
2046
2047       /* We always need to generate functions for the
2048          DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
2049          priorities later, we'll be sure to find the
2050          DEFAULT_INIT_PRIORITY.  */
2051       get_priority_info (DEFAULT_INIT_PRIORITY);
2052     }
2053
2054   VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2055
2056   /* Create the argument list.  */
2057   initialize_p_decl = cp_build_parm_decl
2058     (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2059   DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2060   TREE_USED (initialize_p_decl) = 1;
2061   priority_decl = cp_build_parm_decl
2062     (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2063   DECL_CONTEXT (priority_decl) = ssdf_decl;
2064   TREE_USED (priority_decl) = 1;
2065
2066   TREE_CHAIN (initialize_p_decl) = priority_decl;
2067   DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2068
2069   /* Put the function in the global scope.  */
2070   pushdecl (ssdf_decl);
2071
2072   /* Start the function itself.  This is equivalent to declaring the
2073      function as:
2074
2075        static void __ssdf (int __initialize_p, init __priority_p);
2076
2077      It is static because we only need to call this function from the
2078      various constructor and destructor functions for this module.  */
2079   start_function (/*specs=*/NULL_TREE,
2080                   ssdf_decl,
2081                   /*attrs=*/NULL_TREE,
2082                   SF_PRE_PARSED);
2083
2084   /* Set up the scope of the outermost block in the function.  */
2085   body = begin_compound_stmt (/*has_no_scope=*/false);
2086
2087   /* This function must not be deferred because we are depending on
2088      its compilation to tell us what is TREE_SYMBOL_REFERENCED.  */
2089   current_function_cannot_inline
2090     = "static storage duration functions cannot be inlined";
2091
2092   return body;
2093 }
2094
2095 /* Finish the generation of the function which performs initialization
2096    and destruction of objects with static storage duration.  After
2097    this point, no more such objects can be created.  */
2098
2099 static void
2100 finish_static_storage_duration_function (tree body)
2101 {
2102   /* Close out the function.  */
2103   finish_compound_stmt (body);
2104   expand_or_defer_fn (finish_function (0));
2105 }
2106
2107 /* Return the information about the indicated PRIORITY level.  If no
2108    code to handle this level has yet been generated, generate the
2109    appropriate prologue.  */
2110
2111 static priority_info
2112 get_priority_info (int priority)
2113 {
2114   priority_info pi;
2115   splay_tree_node n;
2116
2117   n = splay_tree_lookup (priority_info_map,
2118                          (splay_tree_key) priority);
2119   if (!n)
2120     {
2121       /* Create a new priority information structure, and insert it
2122          into the map.  */
2123       pi = xmalloc (sizeof (struct priority_info_s));
2124       pi->initializations_p = 0;
2125       pi->destructions_p = 0;
2126       splay_tree_insert (priority_info_map,
2127                          (splay_tree_key) priority,
2128                          (splay_tree_value) pi);
2129     }
2130   else
2131     pi = (priority_info) n->value;
2132
2133   return pi;
2134 }
2135
2136 /* Set up to handle the initialization or destruction of DECL.  If
2137    INITP is nonzero, we are initializing the variable.  Otherwise, we
2138    are destroying it.  */
2139
2140 static tree
2141 start_static_initialization_or_destruction (tree decl, int initp)
2142 {
2143   tree guard_if_stmt = NULL_TREE;
2144   int priority;
2145   tree cond;
2146   tree guard;
2147   tree init_cond;
2148   priority_info pi;
2149
2150   /* Figure out the priority for this declaration.  */
2151   priority = DECL_INIT_PRIORITY (decl);
2152   if (!priority)
2153     priority = DEFAULT_INIT_PRIORITY;
2154
2155   /* Remember that we had an initialization or finalization at this
2156      priority.  */
2157   pi = get_priority_info (priority);
2158   if (initp)
2159     pi->initializations_p = 1;
2160   else
2161     pi->destructions_p = 1;
2162
2163   /* Trick the compiler into thinking we are at the file and line
2164      where DECL was declared so that error-messages make sense, and so
2165      that the debugger will show somewhat sensible file and line
2166      information.  */
2167   input_location = DECL_SOURCE_LOCATION (decl);
2168
2169   /* Because of:
2170
2171        [class.access.spec]
2172
2173        Access control for implicit calls to the constructors,
2174        the conversion functions, or the destructor called to
2175        create and destroy a static data member is performed as
2176        if these calls appeared in the scope of the member's
2177        class.
2178
2179      we pretend we are in a static member function of the class of
2180      which the DECL is a member.  */
2181   if (member_p (decl))
2182     {
2183       DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
2184       DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
2185     }
2186
2187   /* Conditionalize this initialization on being in the right priority
2188      and being initializing/finalizing appropriately.  */
2189   guard_if_stmt = begin_if_stmt ();
2190   cond = cp_build_binary_op (EQ_EXPR,
2191                              priority_decl,
2192                              build_int_2 (priority, 0));
2193   init_cond = initp ? integer_one_node : integer_zero_node;
2194   init_cond = cp_build_binary_op (EQ_EXPR,
2195                                   initialize_p_decl,
2196                                   init_cond);
2197   cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
2198
2199   /* Assume we don't need a guard.  */
2200   guard = NULL_TREE;
2201   /* We need a guard if this is an object with external linkage that
2202      might be initialized in more than one place.  (For example, a
2203      static data member of a template, when the data member requires
2204      construction.)  */
2205   if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
2206                              || DECL_ONE_ONLY (decl)
2207                              || DECL_WEAK (decl)))
2208     {
2209       tree guard_cond;
2210
2211       guard = get_guard (decl);
2212
2213       /* When using __cxa_atexit, we just check the GUARD as we would
2214          for a local static.  */
2215       if (flag_use_cxa_atexit)
2216         {
2217           /* When using __cxa_atexit, we never try to destroy
2218              anything from a static destructor.  */
2219           my_friendly_assert (initp, 20000629);
2220           guard_cond = get_guard_cond (guard);
2221         }
2222       /* If we don't have __cxa_atexit, then we will be running
2223          destructors from .fini sections, or their equivalents.  So,
2224          we need to know how many times we've tried to initialize this
2225          object.  We do initializations only if the GUARD is zero,
2226          i.e., if we are the first to initialize the variable.  We do
2227          destructions only if the GUARD is one, i.e., if we are the
2228          last to destroy the variable.  */
2229       else if (initp)
2230         guard_cond
2231           = cp_build_binary_op (EQ_EXPR,
2232                                 build_unary_op (PREINCREMENT_EXPR,
2233                                                 guard,
2234                                                 /*noconvert=*/1),
2235                                 integer_one_node);
2236       else
2237         guard_cond
2238           = cp_build_binary_op (EQ_EXPR,
2239                                 build_unary_op (PREDECREMENT_EXPR,
2240                                                 guard,
2241                                                 /*noconvert=*/1),
2242                                 integer_zero_node);
2243
2244       cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
2245     }
2246
2247   finish_if_stmt_cond (cond, guard_if_stmt);
2248
2249   /* If we're using __cxa_atexit, we have not already set the GUARD,
2250      so we must do so now.  */
2251   if (guard && initp && flag_use_cxa_atexit)
2252     finish_expr_stmt (set_guard (guard));
2253
2254   return guard_if_stmt;
2255 }
2256
2257 /* We've just finished generating code to do an initialization or
2258    finalization.  GUARD_IF_STMT is the if-statement we used to guard
2259    the initialization.  */
2260
2261 static void
2262 finish_static_initialization_or_destruction (tree guard_if_stmt)
2263 {
2264   finish_then_clause (guard_if_stmt);
2265   finish_if_stmt ();
2266
2267   /* Now that we're done with DECL we don't need to pretend to be a
2268      member of its class any longer.  */
2269   DECL_CONTEXT (current_function_decl) = NULL_TREE;
2270   DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
2271 }
2272
2273 /* Generate code to do the initialization of DECL, a VAR_DECL with
2274    static storage duration.  The initialization is INIT.  */
2275
2276 static void
2277 do_static_initialization (tree decl, tree init)
2278 {
2279   tree guard_if_stmt;
2280
2281   /* Set up for the initialization.  */
2282   guard_if_stmt
2283     = start_static_initialization_or_destruction (decl,
2284                                                   /*initp=*/1);
2285
2286   /* Perform the initialization.  */
2287   if (init)
2288     finish_expr_stmt (init);
2289
2290   /* If we're using __cxa_atexit, register a a function that calls the
2291      destructor for the object.  */
2292   if (flag_use_cxa_atexit)
2293     register_dtor_fn (decl);
2294
2295   /* Finsh up.  */
2296   finish_static_initialization_or_destruction (guard_if_stmt);
2297 }
2298
2299 /* Generate code to do the static destruction of DECL.  If DECL may be
2300    initialized more than once in different object files, GUARD is the
2301    guard variable to check.  PRIORITY is the priority for the
2302    destruction.  */
2303
2304 static void
2305 do_static_destruction (tree decl)
2306 {
2307   tree guard_if_stmt;
2308
2309   /* If we're using __cxa_atexit, then destructors are registered
2310      immediately after objects are initialized.  */
2311   my_friendly_assert (!flag_use_cxa_atexit, 20000121);
2312
2313   /* If we don't need a destructor, there's nothing to do.  */
2314   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2315     return;
2316
2317   /* Actually do the destruction.  */
2318   guard_if_stmt = start_static_initialization_or_destruction (decl,
2319                                                               /*initp=*/0);
2320   finish_expr_stmt (build_cleanup (decl));
2321   finish_static_initialization_or_destruction (guard_if_stmt);
2322 }
2323
2324 /* VARS is a list of variables with static storage duration which may
2325    need initialization and/or finalization.  Remove those variables
2326    that don't really need to be initialized or finalized, and return
2327    the resulting list.  The order in which the variables appear in
2328    VARS is in reverse order of the order in which they should actually
2329    be initialized.  The list we return is in the unreversed order;
2330    i.e., the first variable should be initialized first.  */
2331
2332 static tree
2333 prune_vars_needing_no_initialization (tree *vars)
2334 {
2335   tree *var = vars;
2336   tree result = NULL_TREE;
2337
2338   while (*var)
2339     {
2340       tree t = *var;
2341       tree decl = TREE_VALUE (t);
2342       tree init = TREE_PURPOSE (t);
2343
2344       /* Deal gracefully with error.  */
2345       if (decl == error_mark_node)
2346         {
2347           var = &TREE_CHAIN (t);
2348           continue;
2349         }
2350
2351       /* The only things that can be initialized are variables.  */
2352       my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
2353
2354       /* If this object is not defined, we don't need to do anything
2355          here.  */
2356       if (DECL_EXTERNAL (decl))
2357         {
2358           var = &TREE_CHAIN (t);
2359           continue;
2360         }
2361
2362       /* Also, if the initializer already contains errors, we can bail
2363          out now.  */
2364       if (init && TREE_CODE (init) == TREE_LIST
2365           && value_member (error_mark_node, init))
2366         {
2367           var = &TREE_CHAIN (t);
2368           continue;
2369         }
2370
2371       /* This variable is going to need initialization and/or
2372          finalization, so we add it to the list.  */
2373       *var = TREE_CHAIN (t);
2374       TREE_CHAIN (t) = result;
2375       result = t;
2376     }
2377
2378   return result;
2379 }
2380
2381 /* Make sure we have told the back end about all the variables in
2382    VARS.  */
2383
2384 static void
2385 write_out_vars (tree vars)
2386 {
2387   tree v;
2388
2389   for (v = vars; v; v = TREE_CHAIN (v))
2390     if (!var_finalized_p (TREE_VALUE (v)))
2391       rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
2392 }
2393
2394 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
2395    (otherwise) that will initialize all gobal objects with static
2396    storage duration having the indicated PRIORITY.  */
2397
2398 static void
2399 generate_ctor_or_dtor_function (bool constructor_p, int priority,
2400                                 location_t *locus)
2401 {
2402   char function_key;
2403   tree arguments;
2404   tree fndecl;
2405   tree body;
2406   size_t i;
2407
2408   input_location = *locus;
2409   locus->line++;
2410
2411   /* We use `I' to indicate initialization and `D' to indicate
2412      destruction.  */
2413   function_key = constructor_p ? 'I' : 'D';
2414
2415   /* We emit the function lazily, to avoid generating empty
2416      global constructors and destructors.  */
2417   body = NULL_TREE;
2418
2419   /* Call the static storage duration function with appropriate
2420      arguments.  */
2421   if (ssdf_decls)
2422     for (i = 0; i < ssdf_decls->elements_used; ++i)
2423       {
2424         fndecl = VARRAY_TREE (ssdf_decls, i);
2425
2426         /* Calls to pure or const functions will expand to nothing.  */
2427         if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2428           {
2429             if (! body)
2430               body = start_objects (function_key, priority);
2431
2432             arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
2433                                    NULL_TREE);
2434             arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
2435                                    arguments);
2436             finish_expr_stmt (build_function_call (fndecl, arguments));
2437           }
2438       }
2439
2440   /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
2441      calls to any functions marked with attributes indicating that
2442      they should be called at initialization- or destruction-time.  */
2443   if (priority == DEFAULT_INIT_PRIORITY)
2444     {
2445       tree fns;
2446
2447       for (fns = constructor_p ? static_ctors : static_dtors;
2448            fns;
2449            fns = TREE_CHAIN (fns))
2450         {
2451           fndecl = TREE_VALUE (fns);
2452
2453           /* Calls to pure/const functions will expand to nothing.  */
2454           if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
2455             {
2456               if (! body)
2457                 body = start_objects (function_key, priority);
2458               finish_expr_stmt (build_function_call (fndecl, NULL_TREE));
2459             }
2460         }
2461     }
2462
2463   /* Close out the function.  */
2464   if (body)
2465     finish_objects (function_key, priority, body);
2466 }
2467
2468 /* Generate constructor and destructor functions for the priority
2469    indicated by N.  */
2470
2471 static int
2472 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
2473 {
2474   location_t *locus = data;
2475   int priority = (int) n->key;
2476   priority_info pi = (priority_info) n->value;
2477
2478   /* Generate the functions themselves, but only if they are really
2479      needed.  */
2480   if (pi->initializations_p
2481       || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
2482     generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
2483   if (pi->destructions_p
2484       || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
2485     generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
2486
2487   /* Keep iterating.  */
2488   return 0;
2489 }
2490
2491 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR.  It is supposed to mark
2492    decls referenced from frontend specific constructs; it will be called
2493    only for language-specific tree nodes.
2494
2495    Here we must deal with member pointers.  */
2496
2497 tree
2498 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
2499                             tree from ATTRIBUTE_UNUSED)
2500 {
2501   tree t = *tp;
2502
2503   if (flag_unit_at_a_time)
2504     switch (TREE_CODE (t))
2505       {
2506       case PTRMEM_CST:
2507         if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
2508           cgraph_mark_needed_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
2509         break;
2510       case BASELINK:
2511         if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
2512           cgraph_mark_needed_node (cgraph_node (BASELINK_FUNCTIONS (t)));
2513         break;
2514
2515       default:
2516         break;
2517       }
2518
2519   return NULL;
2520 }
2521
2522 /* This routine is called from the last rule in yyparse ().
2523    Its job is to create all the code needed to initialize and
2524    destroy the global aggregates.  We do the destruction
2525    first, since that way we only need to reverse the decls once.  */
2526
2527 void
2528 finish_file (void)
2529 {
2530   tree vars;
2531   bool reconsider;
2532   size_t i;
2533   location_t locus;
2534   unsigned ssdf_count = 0;
2535
2536   locus = input_location;
2537   at_eof = 1;
2538
2539   /* Bad parse errors.  Just forget about it.  */
2540   if (! global_bindings_p () || current_class_type || decl_namespace_list)
2541     return;
2542
2543   if (pch_file)
2544     c_common_write_pch ();
2545
2546   /* Otherwise, GDB can get confused, because in only knows
2547      about source for LINENO-1 lines.  */
2548   input_line -= 1;
2549
2550   interface_unknown = 1;
2551   interface_only = 0;
2552
2553   /* We now have to write out all the stuff we put off writing out.
2554      These include:
2555
2556        o Template specializations that we have not yet instantiated,
2557          but which are needed.
2558        o Initialization and destruction for non-local objects with
2559          static storage duration.  (Local objects with static storage
2560          duration are initialized when their scope is first entered,
2561          and are cleaned up via atexit.)
2562        o Virtual function tables.
2563
2564      All of these may cause others to be needed.  For example,
2565      instantiating one function may cause another to be needed, and
2566      generating the initializer for an object may cause templates to be
2567      instantiated, etc., etc.  */
2568
2569   timevar_push (TV_VARCONST);
2570
2571   emit_support_tinfos ();
2572
2573   do
2574     {
2575       tree t;
2576       size_t n_old, n_new;
2577
2578       reconsider = false;
2579
2580       /* If there are templates that we've put off instantiating, do
2581          them now.  */
2582       instantiate_pending_templates ();
2583       ggc_collect ();
2584
2585       /* Write out virtual tables as required.  Note that writing out
2586          the virtual table for a template class may cause the
2587          instantiation of members of that class.  If we write out
2588          vtables then we remove the class from our list so we don't
2589          have to look at it again.  */
2590
2591       while (keyed_classes != NULL_TREE
2592              && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
2593         {
2594           reconsider = true;
2595           keyed_classes = TREE_CHAIN (keyed_classes);
2596         }
2597
2598       t = keyed_classes;
2599       if (t != NULL_TREE)
2600         {
2601           tree next = TREE_CHAIN (t);
2602
2603           while (next)
2604             {
2605               if (maybe_emit_vtables (TREE_VALUE (next)))
2606                 {
2607                   reconsider = true;
2608                   TREE_CHAIN (t) = TREE_CHAIN (next);
2609                 }
2610               else
2611                 t = next;
2612
2613               next = TREE_CHAIN (t);
2614             }
2615         }
2616
2617       /* Write out needed type info variables.  We have to be careful
2618          looping through unemitted decls, because emit_tinfo_decl may
2619          cause other variables to be needed.  We stick new elements
2620          (and old elements that we may need to reconsider) at the end
2621          of the array, then shift them back to the beginning once we're
2622          done.  */
2623
2624       n_old = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls);
2625       for (i = 0; i < n_old; ++i)
2626         {
2627           tree tinfo_decl = VARRAY_TREE (unemitted_tinfo_decls, i);
2628           if (emit_tinfo_decl (tinfo_decl))
2629             reconsider = true;
2630           else
2631             VARRAY_PUSH_TREE (unemitted_tinfo_decls, tinfo_decl);
2632         }
2633
2634       /* The only elements we want to keep are the new ones.  Copy
2635          them to the beginning of the array, then get rid of the
2636          leftovers.  */
2637       n_new = VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) - n_old;
2638       if (n_new)
2639         memmove (&VARRAY_TREE (unemitted_tinfo_decls, 0),
2640                  &VARRAY_TREE (unemitted_tinfo_decls, n_old),
2641                  n_new * sizeof (tree));
2642       memset (&VARRAY_TREE (unemitted_tinfo_decls, n_new),
2643               0, n_old * sizeof (tree));
2644       VARRAY_ACTIVE_SIZE (unemitted_tinfo_decls) = n_new;
2645
2646       /* The list of objects with static storage duration is built up
2647          in reverse order.  We clear STATIC_AGGREGATES so that any new
2648          aggregates added during the initialization of these will be
2649          initialized in the correct order when we next come around the
2650          loop.  */
2651       vars = prune_vars_needing_no_initialization (&static_aggregates);
2652
2653       if (vars)
2654         {
2655           tree v;
2656
2657           /* We need to start a new initialization function each time
2658              through the loop.  That's because we need to know which
2659              vtables have been referenced, and TREE_SYMBOL_REFERENCED
2660              isn't computed until a function is finished, and written
2661              out.  That's a deficiency in the back-end.  When this is
2662              fixed, these initialization functions could all become
2663              inline, with resulting performance improvements.  */
2664           tree ssdf_body;
2665
2666           /* Set the line and file, so that it is obviously not from
2667              the source file.  */
2668           input_location = locus;
2669           ssdf_body = start_static_storage_duration_function (ssdf_count);
2670
2671           /* Make sure the back end knows about all the variables.  */
2672           write_out_vars (vars);
2673
2674           /* First generate code to do all the initializations.  */
2675           for (v = vars; v; v = TREE_CHAIN (v))
2676             do_static_initialization (TREE_VALUE (v),
2677                                       TREE_PURPOSE (v));
2678
2679           /* Then, generate code to do all the destructions.  Do these
2680              in reverse order so that the most recently constructed
2681              variable is the first destroyed.  If we're using
2682              __cxa_atexit, then we don't need to do this; functions
2683              were registered at initialization time to destroy the
2684              local statics.  */
2685           if (!flag_use_cxa_atexit)
2686             {
2687               vars = nreverse (vars);
2688               for (v = vars; v; v = TREE_CHAIN (v))
2689                 do_static_destruction (TREE_VALUE (v));
2690             }
2691           else
2692             vars = NULL_TREE;
2693
2694           /* Finish up the static storage duration function for this
2695              round.  */
2696           input_location = locus;
2697           finish_static_storage_duration_function (ssdf_body);
2698
2699           /* All those initializations and finalizations might cause
2700              us to need more inline functions, more template
2701              instantiations, etc.  */
2702           reconsider = true;
2703           ssdf_count++;
2704           locus.line++;
2705         }
2706
2707       for (i = 0; i < deferred_fns_used; ++i)
2708         {
2709           tree decl = VARRAY_TREE (deferred_fns, i);
2710
2711           /* Does it need synthesizing?  */
2712           if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
2713               && TREE_USED (decl)
2714               && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
2715             {
2716               /* Even though we're already at the top-level, we push
2717                  there again.  That way, when we pop back a few lines
2718                  hence, all of our state is restored.  Otherwise,
2719                  finish_function doesn't clean things up, and we end
2720                  up with CURRENT_FUNCTION_DECL set.  */
2721               push_to_top_level ();
2722               synthesize_method (decl);
2723               pop_from_top_level ();
2724               reconsider = true;
2725             }
2726
2727           /* If the function has no body, avoid calling
2728              import_export_decl.  On a system without weak symbols,
2729              calling import_export_decl will make an inline template
2730              instantiation "static", which will result in errors about
2731              the use of undefined functions if there is no body for
2732              the function.  */
2733           if (!DECL_SAVED_TREE (decl))
2734             continue;
2735
2736           import_export_decl (decl);
2737
2738           /* We lie to the back-end, pretending that some functions
2739              are not defined when they really are.  This keeps these
2740              functions from being put out unnecessarily.  But, we must
2741              stop lying when the functions are referenced, or if they
2742              are not comdat since they need to be put out now.  This
2743              is done in a separate for cycle, because if some deferred
2744              function is contained in another deferred function later
2745              in deferred_fns varray, rest_of_compilation would skip
2746              this function and we really cannot expand the same
2747              function twice.  */
2748           if (DECL_NOT_REALLY_EXTERN (decl)
2749               && DECL_INITIAL (decl)
2750               && DECL_NEEDED_P (decl))
2751             DECL_EXTERNAL (decl) = 0;
2752
2753           /* If we're going to need to write this function out, and
2754              there's already a body for it, create RTL for it now.
2755              (There might be no body if this is a method we haven't
2756              gotten around to synthesizing yet.)  */
2757           if (!DECL_EXTERNAL (decl)
2758               && DECL_NEEDED_P (decl)
2759               && DECL_SAVED_TREE (decl)
2760               && !TREE_ASM_WRITTEN (decl)
2761               && (!flag_unit_at_a_time
2762                   || !cgraph_node (decl)->local.finalized))
2763             {
2764               /* We will output the function; no longer consider it in this
2765                  loop.  */
2766               DECL_DEFER_OUTPUT (decl) = 0;
2767               /* Generate RTL for this function now that we know we
2768                  need it.  */
2769               expand_or_defer_fn (decl);
2770               /* If we're compiling -fsyntax-only pretend that this
2771                  function has been written out so that we don't try to
2772                  expand it again.  */
2773               if (flag_syntax_only)
2774                 TREE_ASM_WRITTEN (decl) = 1;
2775               reconsider = true;
2776             }
2777         }
2778
2779       if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
2780         reconsider = true;
2781
2782       /* Static data members are just like namespace-scope globals.  */
2783       for (i = 0; i < pending_statics_used; ++i)
2784         {
2785           tree decl = VARRAY_TREE (pending_statics, i);
2786           if (var_finalized_p (decl))
2787             continue;
2788           import_export_decl (decl);
2789           if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
2790             DECL_EXTERNAL (decl) = 0;
2791         }
2792       if (pending_statics
2793           && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
2794                                          pending_statics_used))
2795         reconsider = true;
2796
2797       if (cgraph_assemble_pending_functions ())
2798         reconsider = true;
2799     }
2800   while (reconsider);
2801
2802   /* All used inline functions must have a definition at this point.  */
2803   for (i = 0; i < deferred_fns_used; ++i)
2804     {
2805       tree decl = VARRAY_TREE (deferred_fns, i);
2806
2807       if (TREE_USED (decl) && DECL_DECLARED_INLINE_P (decl)
2808           && !(TREE_ASM_WRITTEN (decl) || DECL_SAVED_TREE (decl)
2809                /* An explicit instantiation can be used to specify
2810                   that the body is in another unit. It will have
2811                   already verified there was a definition.  */
2812                || DECL_EXPLICIT_INSTANTIATION (decl)))
2813         {
2814           cp_warning_at ("inline function `%D' used but never defined", decl);
2815           /* This symbol is effectively an "extern" declaration now.
2816              This is not strictly necessary, but removes a duplicate
2817              warning.  */
2818           TREE_PUBLIC (decl) = 1;
2819         }
2820
2821     }
2822
2823   /* We give C linkage to static constructors and destructors.  */
2824   push_lang_context (lang_name_c);
2825
2826   /* Generate initialization and destruction functions for all
2827      priorities for which they are required.  */
2828   if (priority_info_map)
2829     splay_tree_foreach (priority_info_map,
2830                         generate_ctor_and_dtor_functions_for_priority,
2831                         /*data=*/&locus);
2832   else
2833     {
2834
2835       if (static_ctors)
2836         generate_ctor_or_dtor_function (/*constructor_p=*/true,
2837                                         DEFAULT_INIT_PRIORITY, &locus);
2838       if (static_dtors)
2839         generate_ctor_or_dtor_function (/*constructor_p=*/false,
2840                                         DEFAULT_INIT_PRIORITY, &locus);
2841     }
2842
2843   /* We're done with the splay-tree now.  */
2844   if (priority_info_map)
2845     splay_tree_delete (priority_info_map);
2846
2847   /* We're done with static constructors, so we can go back to "C++"
2848      linkage now.  */
2849   pop_lang_context ();
2850
2851   if (flag_unit_at_a_time)
2852     {
2853       cgraph_finalize_compilation_unit ();
2854       cgraph_optimize ();
2855     }
2856
2857   /* Now, issue warnings about static, but not defined, functions,
2858      etc., and emit debugging information.  */
2859   walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
2860   if (pending_statics)
2861     check_global_declarations (&VARRAY_TREE (pending_statics, 0),
2862                                pending_statics_used);
2863
2864   finish_repo ();
2865
2866   /* The entire file is now complete.  If requested, dump everything
2867      to a file.  */
2868   {
2869     int flags;
2870     FILE *stream = dump_begin (TDI_all, &flags);
2871
2872     if (stream)
2873       {
2874         dump_node (global_namespace, flags & ~TDF_SLIM, stream);
2875         dump_end (TDI_all, stream);
2876       }
2877   }
2878
2879   timevar_pop (TV_VARCONST);
2880
2881   if (flag_detailed_statistics)
2882     {
2883       dump_tree_statistics ();
2884       dump_time_statistics ();
2885     }
2886   input_location = locus;
2887 }
2888
2889 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
2890    function to call in parse-tree form; it has not yet been
2891    semantically analyzed.  ARGS are the arguments to the function.
2892    They have already been semantically analyzed.  */
2893
2894 tree
2895 build_offset_ref_call_from_tree (tree fn, tree args)
2896 {
2897   tree orig_fn;
2898   tree orig_args;
2899   tree expr;
2900   tree object;
2901
2902   orig_fn = fn;
2903   orig_args = args;
2904   object = TREE_OPERAND (fn, 0);
2905
2906   if (processing_template_decl)
2907     {
2908       my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
2909                           || TREE_CODE (fn) == MEMBER_REF,
2910                           20030708);
2911       if (type_dependent_expression_p (fn)
2912           || any_type_dependent_arguments_p (args))
2913         return build_min_nt (CALL_EXPR, fn, args);
2914
2915       /* Transform the arguments and add the implicit "this"
2916          parameter.  That must be done before the FN is transformed
2917          because we depend on the form of FN.  */
2918       args = build_non_dependent_args (args);
2919       if (TREE_CODE (fn) == DOTSTAR_EXPR)
2920         object = build_unary_op (ADDR_EXPR, object, 0);
2921       object = build_non_dependent_expr (object);
2922       args = tree_cons (NULL_TREE, object, args);
2923       /* Now that the arguments are done, transform FN.  */
2924       fn = build_non_dependent_expr (fn);
2925     }
2926
2927   /* A qualified name corresponding to a bound pointer-to-member is
2928      represented as an OFFSET_REF:
2929
2930         struct B { void g(); };
2931         void (B::*p)();
2932         void B::g() { (this->*p)(); }  */
2933   if (TREE_CODE (fn) == OFFSET_REF)
2934     {
2935       tree object_addr = build_unary_op (ADDR_EXPR, object, 0);
2936       fn = TREE_OPERAND (fn, 1);
2937       fn = get_member_function_from_ptrfunc (&object_addr, fn);
2938       args = tree_cons (NULL_TREE, object_addr, args);
2939     }
2940
2941   expr = build_function_call (fn, args);
2942   if (processing_template_decl && expr != error_mark_node)
2943     return build_min_non_dep (CALL_EXPR, expr, orig_fn, orig_args);
2944   return expr;
2945 }
2946
2947
2948 void
2949 check_default_args (tree x)
2950 {
2951   tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
2952   bool saw_def = false;
2953   int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
2954   for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
2955     {
2956       if (TREE_PURPOSE (arg))
2957         saw_def = true;
2958       else if (saw_def)
2959         {
2960           cp_error_at ("default argument missing for parameter %P of `%+#D'",
2961                        i, x);
2962           break;
2963         }
2964     }
2965 }
2966
2967 void
2968 mark_used (tree decl)
2969 {
2970   TREE_USED (decl) = 1;
2971   if (processing_template_decl || skip_evaluation)
2972     return;
2973
2974   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
2975       && !TREE_ASM_WRITTEN (decl))
2976     /* Remember it, so we can check it was defined.  */
2977     defer_fn (decl);
2978
2979   assemble_external (decl);
2980
2981   /* Is it a synthesized method that needs to be synthesized?  */
2982   if (TREE_CODE (decl) == FUNCTION_DECL
2983       && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
2984       && DECL_ARTIFICIAL (decl)
2985       && !DECL_THUNK_P (decl)
2986       && ! DECL_INITIAL (decl)
2987       /* Kludge: don't synthesize for default args.  */
2988       && current_function_decl)
2989     {
2990       synthesize_method (decl);
2991       /* If we've already synthesized the method we don't need to
2992          instantiate it, so we can return right away.  */
2993       return;
2994     }
2995
2996   /* If this is a function or variable that is an instance of some
2997      template, we now know that we will need to actually do the
2998      instantiation. We check that DECL is not an explicit
2999      instantiation because that is not checked in instantiate_decl.  */
3000   if ((DECL_NON_THUNK_FUNCTION_P (decl) || TREE_CODE (decl) == VAR_DECL)
3001       && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
3002       && (!DECL_EXPLICIT_INSTANTIATION (decl)
3003           || (TREE_CODE (decl) == FUNCTION_DECL
3004               && DECL_INLINE (DECL_TEMPLATE_RESULT
3005                               (template_for_substitution (decl))))))
3006     {
3007       bool defer;
3008
3009       /* Normally, we put off instantiating functions in order to
3010          improve compile times.  Maintaining a stack of active
3011          functions is expensive, and the inliner knows to
3012          instantiate any functions it might need.
3013
3014          However, if instantiating this function might help us mark
3015          the current function TREE_NOTHROW, we go ahead and
3016          instantiate it now.
3017
3018          This is not needed for unit-at-a-time since we reorder the functions
3019          in topological order anyway.
3020          */
3021       defer = (!flag_exceptions
3022                || flag_unit_at_a_time
3023                || !optimize
3024                || TREE_CODE (decl) != FUNCTION_DECL
3025                /* If the called function can't throw, we don't need to
3026                   generate its body to find that out.  */
3027                || TREE_NOTHROW (decl)
3028                || !cfun
3029                /* If we already know the current function can't throw,
3030                   then we don't need to work hard to prove it.  */
3031                || TREE_NOTHROW (current_function_decl)
3032                /* If we already know that the current function *can*
3033                   throw, there's no point in gathering more
3034                   information.  */
3035                || cp_function_chain->can_throw);
3036
3037       instantiate_decl (decl, defer);
3038     }
3039 }
3040
3041 #include "gt-cp-decl2.h"