gcc/cp/decl2.c

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