OSDN Git Service

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