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