OSDN Git Service

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