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