gcc/cp/decl2.c

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