gcc/cp/decl2.c

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