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