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