OSDN Git Service

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