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