gcc/cp/decl2.c

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