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