gcc/cp/decl2.c

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