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