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