gcc/cp/decl2.c

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