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