OSDN Git Service

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