OSDN Git Service

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