OSDN Git Service

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