OSDN Git Service

* toplev.c (wrapup_global_declarations): Clarify variable handling.
[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 Free Software Foundation, Inc.
4    Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GNU CC.
7
8 GNU CC 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 GNU CC 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 GNU CC; 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 "tree.h"
34 #include "rtl.h"
35 #include "expr.h"
36 #include "flags.h"
37 #include "cp-tree.h"
38 #include "decl.h"
39 #include "lex.h"
40 #include "output.h"
41 #include "except.h"
42 #include "toplev.h"
43 #include "ggc.h"
44 #include "timevar.h"
45 #include "cpplib.h"
46 #include "target.h"
47 extern cpp_reader *parse_in;
48
49 /* This structure contains information about the initializations
50    and/or destructions required for a particular priority level.  */
51 typedef struct priority_info_s {
52   /* Non-zero if there have been any initializations at this priority
53      throughout the translation unit.  */
54   int initializations_p;
55   /* Non-zero if there have been any destructions at this priority
56      throughout the translation unit.  */
57   int destructions_p;
58 } *priority_info;
59
60 static void mark_vtable_entries PARAMS ((tree));
61 static void grok_function_init PARAMS ((tree, tree));
62 static int finish_vtable_vardecl PARAMS ((tree *, void *));
63 static int prune_vtable_vardecl PARAMS ((tree *, void *));
64 static int is_namespace_ancestor PARAMS ((tree, tree));
65 static void add_using_namespace PARAMS ((tree, tree, int));
66 static tree ambiguous_decl PARAMS ((tree, tree, tree,int));
67 static tree build_anon_union_vars PARAMS ((tree, tree*, int, int));
68 static int acceptable_java_type PARAMS ((tree));
69 static void output_vtable_inherit PARAMS ((tree));
70 static tree start_objects PARAMS ((int, int));
71 static void finish_objects PARAMS ((int, int, tree));
72 static tree merge_functions PARAMS ((tree, tree));
73 static tree decl_namespace PARAMS ((tree));
74 static tree validate_nonmember_using_decl PARAMS ((tree, tree *, tree *));
75 static void do_nonmember_using_decl PARAMS ((tree, tree, tree, tree,
76                                            tree *, tree *));
77 static tree start_static_storage_duration_function PARAMS ((void));
78 static void finish_static_storage_duration_function PARAMS ((tree));
79 static priority_info get_priority_info PARAMS ((int));
80 static void do_static_initialization PARAMS ((tree, tree));
81 static void do_static_destruction PARAMS ((tree));
82 static tree start_static_initialization_or_destruction PARAMS ((tree, int));
83 static void finish_static_initialization_or_destruction PARAMS ((tree));
84 static void generate_ctor_or_dtor_function PARAMS ((int, int));
85 static int generate_ctor_and_dtor_functions_for_priority
86                                   PARAMS ((splay_tree_node, void *));
87 static tree prune_vars_needing_no_initialization PARAMS ((tree));
88 static void write_out_vars PARAMS ((tree));
89 static void import_export_class PARAMS ((tree));
90 static tree key_method PARAMS ((tree));
91 static int compare_options PARAMS ((const PTR, const PTR));
92 static tree get_guard_bits PARAMS ((tree));
93
94 /* A list of static class variables.  This is needed, because a
95    static class variable can be declared inside the class without
96    an initializer, and then initialized, statically, outside the class.  */
97 static varray_type pending_statics;
98 #define pending_statics_used \
99   (pending_statics ? pending_statics->elements_used : 0)
100
101 /* A list of functions which were declared inline, but which we
102    may need to emit outline anyway.  */
103 static varray_type deferred_fns;
104 #define deferred_fns_used \
105   (deferred_fns ? deferred_fns->elements_used : 0)
106
107 /* Flag used when debugging spew.c */
108
109 extern int spew_debug;
110
111 /* Nonzero if we're done parsing and into end-of-file activities.  */
112
113 int at_eof;
114
115 /* Functions called along with real static constructors and destructors.  */
116
117 tree static_ctors;
118 tree static_dtors;
119
120 /* The :: namespace. */
121
122 tree global_namespace;
123 \f
124 /* C (and C++) language-specific option variables.  */
125
126 /* Nonzero means don't recognize the keyword `asm'.  */
127
128 int flag_no_asm;
129
130 /* Nonzero means don't recognize any extension keywords.  */
131
132 int flag_no_gnu_keywords;
133
134 /* Nonzero means to treat bitfields as unsigned unless they say `signed'.  */
135
136 int flag_signed_bitfields = 1;
137
138 /* Nonzero means enable obscure standard features and disable GNU
139    extensions that might cause standard-compliant code to be
140    miscompiled.  */
141
142 int flag_ansi;
143
144 /* Nonzero means do emit exported implementations of functions even if
145    they can be inlined.  */
146
147 int flag_implement_inlines = 1;
148
149 /* Nonzero means do emit exported implementations of templates, instead of
150    multiple static copies in each file that needs a definition.  */
151
152 int flag_external_templates;
153
154 /* Nonzero means that the decision to emit or not emit the implementation of a
155    template depends on where the template is instantiated, rather than where
156    it is defined.  */
157
158 int flag_alt_external_templates;
159
160 /* Nonzero means that implicit instantiations will be emitted if needed.  */
161
162 int flag_implicit_templates = 1;
163
164 /* Nonzero means that implicit instantiations of inline templates will be
165    emitted if needed, even if instantiations of non-inline templates
166    aren't.  */
167
168 int flag_implicit_inline_templates = 1;
169
170 /* Nonzero means warn about implicit declarations.  */
171
172 int warn_implicit = 1;
173
174 /* Nonzero means warn about usage of long long when `-pedantic'.  */
175
176 int warn_long_long = 1;
177
178 /* Nonzero means warn when all ctors or dtors are private, and the class
179    has no friends.  */
180
181 int warn_ctor_dtor_privacy = 1;
182
183 /* Nonzero means generate separate instantiation control files and juggle
184    them at link time.  */
185
186 int flag_use_repository;
187
188 /* Nonzero if we want to issue diagnostics that the standard says are not
189    required.  */
190
191 int flag_optional_diags = 1;
192
193 /* Nonzero means give string constants the type `const char *', as mandated
194    by the standard.  */
195
196 int flag_const_strings = 1;
197
198 /* Nonzero means warn about deprecated conversion from string constant to
199    `char *'.  */
200
201 int warn_write_strings;
202
203 /* Nonzero means warn about pointer casts that can drop a type qualifier
204    from the pointer target type.  */
205
206 int warn_cast_qual;
207
208 /* Nonzero means warn about sizeof(function) or addition/subtraction
209    of function pointers.  */
210
211 int warn_pointer_arith = 1;
212
213 /* Nonzero means warn for any function def without prototype decl.  */
214
215 int warn_missing_prototypes;
216
217 /* Nonzero means warn about multiple (redundant) decls for the same single
218    variable or function.  */
219
220 int warn_redundant_decls;
221
222 /* Warn if initializer is not completely bracketed.  */
223
224 int warn_missing_braces;
225
226 /* Warn about comparison of signed and unsigned values.  */
227
228 int warn_sign_compare;
229
230 /* Warn about testing equality of floating point numbers. */
231
232 int warn_float_equal = 0;
233
234 /* Warn about functions which might be candidates for format attributes.  */
235
236 int warn_missing_format_attribute;
237
238 /* Warn about a subscript that has type char.  */
239
240 int warn_char_subscripts;
241
242 /* Warn if a type conversion is done that might have confusing results.  */
243
244 int warn_conversion;
245
246 /* Warn if adding () is suggested.  */
247
248 int warn_parentheses;
249
250 /* Non-zero means warn in function declared in derived class has the
251    same name as a virtual in the base class, but fails to match the
252    type signature of any virtual function in the base class.  */
253
254 int warn_overloaded_virtual;
255
256 /* Non-zero means warn when declaring a class that has a non virtual
257    destructor, when it really ought to have a virtual one.  */
258
259 int warn_nonvdtor;
260
261 /* Non-zero means warn when the compiler will reorder code.  */
262
263 int warn_reorder;
264
265 /* Non-zero means warn when synthesis behavior differs from Cfront's.  */
266
267 int warn_synth;
268
269 /* Non-zero means warn when we convert a pointer to member function
270    into a pointer to (void or function).  */
271
272 int warn_pmf2ptr = 1;
273
274 /* Nonzero means warn about violation of some Effective C++ style rules.  */
275
276 int warn_ecpp;
277
278 /* Nonzero means warn where overload resolution chooses a promotion from
279    unsigned to signed over a conversion to an unsigned of the same size.  */
280
281 int warn_sign_promo;
282
283 /* Nonzero means warn when an old-style cast is used.  */
284
285 int warn_old_style_cast;
286
287 /* Warn about #pragma directives that are not recognised.  */      
288
289 int warn_unknown_pragmas; /* Tri state variable.  */  
290
291 /* Nonzero means warn about use of multicharacter literals.  */
292
293 int warn_multichar = 1;
294
295 /* Nonzero means warn when non-templatized friend functions are
296    declared within a template */
297
298 int warn_nontemplate_friend = 1;
299
300 /* Nonzero means complain about deprecated features.  */
301
302 int warn_deprecated = 1;
303
304 /* Nonzero means `$' can be in an identifier.  */
305
306 #ifndef DOLLARS_IN_IDENTIFIERS
307 #define DOLLARS_IN_IDENTIFIERS 1
308 #endif
309 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
310
311 /* Nonzero means allow Microsoft extensions without a pedwarn.  */
312
313 int flag_ms_extensions;
314
315 /* C++ specific flags.  */   
316
317 /* Nonzero means we should attempt to elide constructors when possible.  */
318
319 int flag_elide_constructors = 1;
320
321 /* Nonzero means that member functions defined in class scope are
322    inline by default.  */
323
324 int flag_default_inline = 1;
325
326 /* Controls whether compiler generates 'type descriptor' that give
327    run-time type information.  */
328
329 int flag_rtti = 1;
330
331 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
332    objects.  */
333
334 int flag_huge_objects;
335
336 /* Nonzero if we want to conserve space in the .o files.  We do this
337    by putting uninitialized data and runtime initialized data into
338    .common instead of .data at the expense of not flagging multiple
339    definitions.  */
340
341 int flag_conserve_space;
342
343 /* Nonzero if we want to obey access control semantics.  */
344
345 int flag_access_control = 1;
346
347 /* Nonzero if we want to understand the operator names, i.e. 'bitand'.  */
348
349 int flag_operator_names = 1;
350
351 /* Nonzero if we want to check the return value of new and avoid calling
352    constructors if it is a null pointer.  */
353
354 int flag_check_new;
355
356 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
357    initialization variables.
358    0: Old rules, set by -fno-for-scope.
359    2: New ISO rules, set by -ffor-scope.
360    1: Try to implement new ISO rules, but with backup compatibility
361    (and warnings).  This is the default, for now.  */
362
363 int flag_new_for_scope = 1;
364
365 /* Nonzero if we want to emit defined symbols with common-like linkage as
366    weak symbols where possible, in order to conform to C++ semantics.
367    Otherwise, emit them as local symbols.  */
368
369 int flag_weak = 1;
370
371 /* Nonzero to use __cxa_atexit, rather than atexit, to register
372    destructors for local statics and global objects.  */
373
374 int flag_use_cxa_atexit;
375
376 /* Maximum template instantiation depth.  This limit is rather
377    arbitrary, but it exists to limit the time it takes to notice
378    infinite template instantiations.  */
379
380 int max_tinst_depth = 500;
381
382 /* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc.  */
383
384 int flag_vtable_gc;
385
386 /* Nonzero means make the default pedwarns warnings instead of errors.
387    The value of this flag is ignored if -pedantic is specified.  */
388
389 int flag_permissive;
390
391 /* Nonzero means to implement standard semantics for exception
392    specifications, calling unexpected if an exception is thrown that
393    doesn't match the specification.  Zero means to treat them as
394    assertions and optimize accordingly, but not check them.  */
395
396 int flag_enforce_eh_specs = 1;
397
398 /* Table of language-dependent -f options.
399    STRING is the option name.  VARIABLE is the address of the variable.
400    ON_VALUE is the value to store in VARIABLE
401     if `-fSTRING' is seen as an option.
402    (If `-fno-STRING' is seen as an option, the opposite value is stored.)  */
403
404 static const struct { const char *const string; int *const variable; const int on_value;}
405 lang_f_options[] =
406 {
407   /* C/C++ options.  */
408   {"signed-char", &flag_signed_char, 1},
409   {"unsigned-char", &flag_signed_char, 0},
410   {"signed-bitfields", &flag_signed_bitfields, 1},
411   {"unsigned-bitfields", &flag_signed_bitfields, 0},
412   {"short-enums", &flag_short_enums, 1},
413   {"short-double", &flag_short_double, 1},
414   {"short-wchar", &flag_short_wchar, 1},
415   {"asm", &flag_no_asm, 0},
416   {"builtin", &flag_no_builtin, 0},
417
418   /* C++-only options.  */
419   {"access-control", &flag_access_control, 1},
420   {"check-new", &flag_check_new, 1},
421   {"conserve-space", &flag_conserve_space, 1},
422   {"const-strings", &flag_const_strings, 1},
423   {"default-inline", &flag_default_inline, 1},
424   {"dollars-in-identifiers", &dollars_in_ident, 1},
425   {"elide-constructors", &flag_elide_constructors, 1},
426   {"enforce-eh-specs", &flag_enforce_eh_specs, 1},
427   {"external-templates", &flag_external_templates, 1},
428   {"for-scope", &flag_new_for_scope, 2},
429   {"gnu-keywords", &flag_no_gnu_keywords, 0},
430   {"handle-exceptions", &flag_exceptions, 1},
431   {"implement-inlines", &flag_implement_inlines, 1},
432   {"implicit-inline-templates", &flag_implicit_inline_templates, 1},
433   {"implicit-templates", &flag_implicit_templates, 1},
434   {"ms-extensions", &flag_ms_extensions, 1},
435   {"nonansi-builtins", &flag_no_nonansi_builtin, 0},
436   {"operator-names", &flag_operator_names, 1},
437   {"optional-diags", &flag_optional_diags, 1},
438   {"permissive", &flag_permissive, 1},
439   {"repo", &flag_use_repository, 1},
440   {"rtti", &flag_rtti, 1},
441   {"stats", &flag_detailed_statistics, 1},
442   {"vtable-gc", &flag_vtable_gc, 1},
443   {"use-cxa-atexit", &flag_use_cxa_atexit, 1},
444   {"weak", &flag_weak, 1}
445 };
446
447 /* The list of `-f' options that we no longer support.  The `-f'
448    prefix is not given in this table.  The `-fno-' variants are not
449    listed here.  This table must be kept in alphabetical order.  */
450 static const char * const unsupported_options[] = {
451   "all-virtual",
452   "cond-mismatch",
453   "enum-int-equiv",
454   "guiding-decls",
455   "honor-std",
456   "huge-objects",
457   "labels-ok",
458   "new-abi",
459   "nonnull-objects",
460   "squangle",
461   "strict-prototype",
462   "this-is-variable",
463   "vtable-thunks",
464   "xref"
465 };
466
467 /* Compare two option strings, pointed two by P1 and P2, for use with
468    bsearch.  */
469
470 static int
471 compare_options (p1, p2)
472      const PTR p1;
473      const PTR p2;
474 {
475   return strcmp (*((const char *const *) p1), *((const char *const *) p2));
476 }
477
478 /* Decode the string P as a language-specific option.
479    Return the number of strings consumed for a valid option.
480    Otherwise return 0.  Should not complain if it does not
481    recognise the option.  */
482
483 int   
484 cxx_decode_option (argc, argv)
485      int argc;
486      char **argv;
487 {
488   int strings_processed;
489   const char *p = argv[0];
490
491   strings_processed = cpp_handle_option (parse_in, argc, argv, 0);
492
493   if (p[0] == '-' && p[1] == 'f')
494     {
495       /* Some kind of -f option.
496          P's value is the option sans `-f'.
497          Search for it in the table of options.  */
498       const char *option_value = NULL;
499       const char *positive_option;
500       size_t j;
501
502       p += 2;
503       /* Try special -f options.  */
504
505       /* See if this is one of the options no longer supported.  We
506          used to support these options, so we continue to accept them,
507          with a warning.  */
508       if (strncmp (p, "no-", strlen ("no-")) == 0)
509         positive_option = p + strlen ("no-");
510       else
511         positive_option = p;
512
513       /* If the option is present, issue a warning.  Indicate to our
514          caller that the option was processed successfully.  */
515       if (bsearch (&positive_option, 
516                    unsupported_options, 
517                    ARRAY_SIZE (unsupported_options),
518                    sizeof (unsupported_options[0]),
519                    compare_options))
520         {
521           warning ("-f%s is no longer supported", p);
522           return 1;
523         }
524
525       if (!strcmp (p, "handle-exceptions")
526           || !strcmp (p, "no-handle-exceptions"))
527         warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)");
528       else if (! strcmp (p, "alt-external-templates"))
529         {
530           flag_external_templates = 1;
531           flag_alt_external_templates = 1;
532           cp_deprecated ("-falt-external-templates");
533         }
534       else if (! strcmp (p, "no-alt-external-templates"))
535         flag_alt_external_templates = 0;
536       else if (!strcmp (p, "repo"))
537         {
538           flag_use_repository = 1;
539           flag_implicit_templates = 0;
540         }
541       else if (!strcmp (p, "external-templates"))
542         {
543           flag_external_templates = 1;
544           cp_deprecated ("-fexternal-templates");
545         }
546       else if ((option_value
547                 = skip_leading_substring (p, "template-depth-")))
548         max_tinst_depth
549           = read_integral_parameter (option_value, p - 2, max_tinst_depth);
550       else if ((option_value
551                 = skip_leading_substring (p, "name-mangling-version-")))
552         {
553           warning ("-fname-mangling-version is no longer supported");
554           return 1;
555         }
556       else if (dump_switch_p (p))
557         ;
558       else 
559         {
560           int found = 0;
561
562           for (j = 0; !found && j < ARRAY_SIZE (lang_f_options); j++)
563             {
564               if (!strcmp (p, lang_f_options[j].string))
565                 {
566                   *lang_f_options[j].variable = lang_f_options[j].on_value;
567                   /* A goto here would be cleaner,
568                      but breaks the VAX pcc.  */
569                   found = 1;
570                 }
571               else if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
572                        && ! strcmp (p+3, lang_f_options[j].string))
573                 {
574                   *lang_f_options[j].variable = ! lang_f_options[j].on_value;
575                   found = 1;
576                 }
577             }
578
579           return found;
580         }
581     }
582   else if (p[0] == '-' && p[1] == 'W')
583     {
584       int setting = 1;
585
586       /* The -W options control the warning behavior of the compiler.  */
587       p += 2;
588
589       if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
590         setting = 0, p += 3;
591
592       if (!strcmp (p, "implicit"))
593         warn_implicit = setting;
594       else if (!strcmp (p, "long-long"))
595         warn_long_long = setting;
596       else if (!strcmp (p, "return-type"))
597         warn_return_type = setting;
598       else if (!strcmp (p, "ctor-dtor-privacy"))
599         warn_ctor_dtor_privacy = setting;
600       else if (!strcmp (p, "write-strings"))
601         warn_write_strings = setting;
602       else if (!strcmp (p, "cast-qual"))
603         warn_cast_qual = setting;
604       else if (!strcmp (p, "char-subscripts"))
605         warn_char_subscripts = setting;
606       else if (!strcmp (p, "pointer-arith"))
607         warn_pointer_arith = setting;
608       else if (!strcmp (p, "missing-prototypes"))
609         warn_missing_prototypes = setting;
610       else if (!strcmp (p, "strict-prototypes"))
611         {
612           if (setting == 0)
613             warning ("-Wno-strict-prototypes is not supported in C++");
614         }
615       else if (!strcmp (p, "redundant-decls"))
616         warn_redundant_decls = setting;
617       else if (!strcmp (p, "missing-braces"))
618         warn_missing_braces = setting;
619       else if (!strcmp (p, "sign-compare"))
620         warn_sign_compare = setting;
621       else if (!strcmp (p, "float-equal"))
622         warn_float_equal = setting;
623       else if (!strcmp (p, "format"))
624         set_Wformat (setting);
625       else if (!strcmp (p, "format=2"))
626         set_Wformat (2);
627       else if (!strcmp (p, "format-y2k"))
628         warn_format_y2k = setting;
629       else if (!strcmp (p, "format-extra-args"))
630         warn_format_extra_args = setting;
631       else if (!strcmp (p, "format-nonliteral"))
632         warn_format_nonliteral = setting;
633       else if (!strcmp (p, "format-security"))
634         warn_format_security = setting;
635       else if (!strcmp (p, "missing-format-attribute"))
636         warn_missing_format_attribute = setting;
637       else if (!strcmp (p, "conversion"))
638         warn_conversion = setting;
639       else if (!strcmp (p, "parentheses"))
640         warn_parentheses = setting;
641       else if (!strcmp (p, "non-virtual-dtor"))
642         warn_nonvdtor = setting;
643       else if (!strcmp (p, "reorder"))
644         warn_reorder = setting;
645       else if (!strcmp (p, "synth"))
646         warn_synth = setting;
647       else if (!strcmp (p, "pmf-conversions"))
648         warn_pmf2ptr = setting;
649       else if (!strcmp (p, "effc++"))
650         warn_ecpp = setting;
651       else if (!strcmp (p, "sign-promo"))
652         warn_sign_promo = setting;
653       else if (!strcmp (p, "old-style-cast"))
654         warn_old_style_cast = setting;
655       else if (!strcmp (p, "overloaded-virtual"))
656         warn_overloaded_virtual = setting;
657       else if (!strcmp (p, "multichar"))
658         warn_multichar = setting;
659       else if (!strcmp (p, "unknown-pragmas"))
660         /* Set to greater than 1, so that even unknown pragmas in
661            system headers will be warned about.  */  
662         warn_unknown_pragmas = setting * 2;
663       else if (!strcmp (p, "non-template-friend"))
664         warn_nontemplate_friend = setting;
665       else if (!strcmp (p, "deprecated"))
666         warn_deprecated = setting;
667       else if (!strcmp (p, "comment"))
668         ;                       /* cpp handles this one.  */
669       else if (!strcmp (p, "comments"))
670         ;                       /* cpp handles this one.  */
671       else if (!strcmp (p, "trigraphs"))
672         ;                       /* cpp handles this one.  */
673       else if (!strcmp (p, "import"))
674         ;                       /* cpp handles this one.  */
675       else if (!strcmp (p, "all"))
676         {
677           warn_return_type = setting;
678           set_Wunused (setting);
679           warn_implicit = setting;
680           warn_switch = setting;
681           set_Wformat (setting);
682           warn_parentheses = setting;
683           warn_missing_braces = setting;
684           warn_sign_compare = setting;
685           warn_multichar = setting;
686           /* We save the value of warn_uninitialized, since if they put
687              -Wuninitialized on the command line, we need to generate a
688              warning about not using it without also specifying -O.  */
689           if (warn_uninitialized != 1)
690             warn_uninitialized = (setting ? 2 : 0);
691           /* Only warn about unknown pragmas that are not in system
692              headers.  */                                        
693           warn_unknown_pragmas = 1;       
694
695           /* C++-specific warnings.  */
696           warn_ctor_dtor_privacy = setting;
697           warn_nonvdtor = setting;
698           warn_reorder = setting;
699           warn_nontemplate_friend = setting;           
700         }
701       else return strings_processed;
702     }
703   else if (!strcmp (p, "-ansi"))
704     flag_no_nonansi_builtin = 1, flag_ansi = 1,
705     flag_noniso_default_format_attributes = 0, flag_no_gnu_keywords = 1;
706 #ifdef SPEW_DEBUG
707   /* Undocumented, only ever used when you're invoking cc1plus by hand, since
708      it's probably safe to assume no sane person would ever want to use this
709      under normal circumstances.  */
710   else if (!strcmp (p, "-spew-debug"))
711     spew_debug = 1;
712 #endif
713   else
714     return strings_processed;
715
716   return 1;
717 }
718 \f
719 /* Incorporate `const' and `volatile' qualifiers for member functions.
720    FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
721    QUALS is a list of qualifiers.  Returns any explicit
722    top-level qualifiers of the method's this pointer, anything other than
723    TYPE_UNQUALIFIED will be an extension.  */
724
725 int
726 grok_method_quals (ctype, function, quals)
727      tree ctype, function, quals;
728 {
729   tree fntype = TREE_TYPE (function);
730   tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
731   int type_quals = TYPE_UNQUALIFIED;
732   int dup_quals = TYPE_UNQUALIFIED;
733   int this_quals = TYPE_UNQUALIFIED;
734
735   do
736     {
737       int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
738       
739       if ((type_quals | this_quals) & tq)
740         dup_quals |= tq;
741       else if (tq & TYPE_QUAL_RESTRICT)
742         this_quals |= tq;
743       else
744         type_quals |= tq;
745       quals = TREE_CHAIN (quals);
746     } 
747   while (quals);
748
749   if (dup_quals != TYPE_UNQUALIFIED)
750     error ("duplicate type qualifiers in %s declaration",
751               TREE_CODE (function) == FUNCTION_DECL 
752               ? "member function" : "type");
753
754   ctype = cp_build_qualified_type (ctype, type_quals);
755   fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype),
756                                     (TREE_CODE (fntype) == METHOD_TYPE
757                                      ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
758                                      : TYPE_ARG_TYPES (fntype)));
759   if (raises)
760     fntype = build_exception_variant (fntype, raises);
761
762   TREE_TYPE (function) = fntype;
763   return this_quals;
764 }
765
766 /* Warn when -fexternal-templates is used and #pragma
767    interface/implementation is not used all the times it should be,
768    inform the user.  */
769
770 void
771 warn_if_unknown_interface (decl)
772      tree decl;
773 {
774   static int already_warned = 0;
775   if (already_warned++)
776     return;
777
778   if (flag_alt_external_templates)
779     {
780       tree til = tinst_for_decl ();
781       int sl = lineno;
782       const char *sf = input_filename;
783
784       if (til)
785         {
786           lineno = TINST_LINE (til);
787           input_filename = TINST_FILE (til);
788         }
789       warning ("template `%#D' instantiated in file without #pragma interface",
790                   decl);
791       lineno = sl;
792       input_filename = sf;
793     }
794   else
795     cp_warning_at ("template `%#D' defined in file without #pragma interface",
796                    decl);
797 }
798
799 /* A subroutine of the parser, to handle a component list.  */
800
801 void
802 grok_x_components (specs)
803      tree specs;
804 {
805   tree t;
806
807   specs = strip_attrs (specs);
808
809   check_tag_decl (specs);
810   t = groktypename (build_tree_list (specs, NULL_TREE)); 
811
812   /* The only case where we need to do anything additional here is an
813      anonymous union field, e.g.: `struct S { union { int i; }; };'.  */
814   if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t))
815     return;
816
817   fixup_anonymous_aggr (t);
818   finish_member_declaration (build_decl (FIELD_DECL, NULL_TREE, t)); 
819 }
820
821 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
822    indicated NAME.  */
823
824 tree
825 build_artificial_parm (name, type)
826      tree name;
827      tree type;
828 {
829   tree parm;
830
831   parm = build_decl (PARM_DECL, name, type);
832   DECL_ARTIFICIAL (parm) = 1;
833   /* All our artificial parms are implicitly `const'; they cannot be
834      assigned to.  */
835   TREE_READONLY (parm) = 1;
836   DECL_ARG_TYPE (parm) = type;
837   return parm;
838 }
839
840 /* Constructors for types with virtual baseclasses need an "in-charge" flag
841    saying whether this constructor is responsible for initialization of
842    virtual baseclasses or not.  All destructors also need this "in-charge"
843    flag, which additionally determines whether or not the destructor should
844    free the memory for the object.
845
846    This function adds the "in-charge" flag to member function FN if
847    appropriate.  It is called from grokclassfn and tsubst.
848    FN must be either a constructor or destructor.
849
850    The in-charge flag follows the 'this' parameter, and is followed by the
851    VTT parm (if any), then the user-written parms.  */
852
853 void
854 maybe_retrofit_in_chrg (fn)
855      tree fn;
856 {
857   tree basetype, arg_types, parms, parm, fntype;
858
859   /* If we've already add the in-charge parameter don't do it again.  */
860   if (DECL_HAS_IN_CHARGE_PARM_P (fn))
861     return;
862
863   /* When processing templates we can't know, in general, whether or
864      not we're going to have virtual baseclasses.  */
865   if (uses_template_parms (fn))
866     return;
867
868   /* We don't need an in-charge parameter for constructors that don't
869      have virtual bases.  */
870   if (DECL_CONSTRUCTOR_P (fn)
871       && !TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
872     return;
873
874   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
875   basetype = TREE_TYPE (TREE_VALUE (arg_types));
876   arg_types = TREE_CHAIN (arg_types);
877
878   parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
879
880   /* If this is a subobject constructor or destructor, our caller will
881      pass us a pointer to our VTT.  */
882   if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (fn)))
883     {
884       parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
885
886       /* First add it to DECL_ARGUMENTS between 'this' and the real args...  */
887       TREE_CHAIN (parm) = parms;
888       parms = parm;
889
890       /* ...and then to TYPE_ARG_TYPES.  */
891       arg_types = hash_tree_chain (vtt_parm_type, arg_types);
892
893       DECL_HAS_VTT_PARM_P (fn) = 1;
894     }
895
896   /* Then add the in-charge parm (before the VTT parm).  */
897   parm = build_artificial_parm (in_charge_identifier, integer_type_node);
898   TREE_CHAIN (parm) = parms;
899   parms = parm;
900   arg_types = hash_tree_chain (integer_type_node, arg_types);
901
902   /* Insert our new parameter(s) into the list.  */
903   TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
904
905   /* And rebuild the function type.  */
906   fntype = build_cplus_method_type (basetype, TREE_TYPE (TREE_TYPE (fn)),
907                                     arg_types);
908   if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
909     fntype = build_exception_variant (fntype,
910                                       TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
911   TREE_TYPE (fn) = fntype;
912
913   /* Now we've got the in-charge parameter.  */
914   DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
915 }
916
917 /* Classes overload their constituent function names automatically.
918    When a function name is declared in a record structure,
919    its name is changed to it overloaded name.  Since names for
920    constructors and destructors can conflict, we place a leading
921    '$' for destructors.
922
923    CNAME is the name of the class we are grokking for.
924
925    FUNCTION is a FUNCTION_DECL.  It was created by `grokdeclarator'.
926
927    FLAGS contains bits saying what's special about today's
928    arguments.  1 == DESTRUCTOR.  2 == OPERATOR.
929
930    If FUNCTION is a destructor, then we must add the `auto-delete' field
931    as a second parameter.  There is some hair associated with the fact
932    that we must "declare" this variable in the manner consistent with the
933    way the rest of the arguments were declared.
934
935    QUALS are the qualifiers for the this pointer.  */
936
937 void
938 grokclassfn (ctype, function, flags, quals)
939      tree ctype, function;
940      enum overload_flags flags;
941      tree quals;
942 {
943   tree fn_name = DECL_NAME (function);
944   int this_quals = TYPE_UNQUALIFIED;
945
946   /* Even within an `extern "C"' block, members get C++ linkage.  See
947      [dcl.link] for details.  */
948   SET_DECL_LANGUAGE (function, lang_cplusplus);
949
950   if (fn_name == NULL_TREE)
951     {
952       error ("name missing for member function");
953       fn_name = get_identifier ("<anonymous>");
954       DECL_NAME (function) = fn_name;
955     }
956
957   if (quals)
958     this_quals = grok_method_quals (ctype, function, quals);
959
960   if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
961     {
962       /* Must add the class instance variable up front.  */
963       /* Right now we just make this a pointer.  But later
964          we may wish to make it special.  */
965       tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (function)));
966       tree qual_type;
967       tree parm;
968
969       /* The `this' parameter is implicitly `const'; it cannot be
970          assigned to.  */
971       this_quals |= TYPE_QUAL_CONST;
972       qual_type = cp_build_qualified_type (type, this_quals);
973       parm = build_artificial_parm (this_identifier, qual_type);
974       c_apply_type_quals_to_decl (this_quals, parm);
975       TREE_CHAIN (parm) = last_function_parms;
976       last_function_parms = parm;
977     }
978
979   DECL_ARGUMENTS (function) = last_function_parms;
980   DECL_CONTEXT (function) = ctype;
981
982   if (flags == DTOR_FLAG)
983     DECL_DESTRUCTOR_P (function) = 1;
984
985   if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
986     maybe_retrofit_in_chrg (function);
987
988   if (flags == DTOR_FLAG)
989     {
990       DECL_DESTRUCTOR_P (function) = 1;
991       TYPE_HAS_DESTRUCTOR (ctype) = 1;
992     }
993 }
994
995 /* Create an ARRAY_REF, checking for the user doing things backwards
996    along the way.  */
997
998 tree
999 grok_array_decl (array_expr, index_exp)
1000      tree array_expr, index_exp;
1001 {
1002   tree type = TREE_TYPE (array_expr);
1003   tree p1, p2, i1, i2;
1004
1005   if (type == error_mark_node || index_exp == error_mark_node)
1006     return error_mark_node;
1007   if (processing_template_decl)
1008     return build_min (ARRAY_REF, type ? TREE_TYPE (type) : NULL_TREE,
1009                       array_expr, index_exp);
1010
1011   if (type == NULL_TREE)
1012     {
1013       /* Something has gone very wrong.  Assume we are mistakenly reducing
1014          an expression instead of a declaration.  */
1015       error ("parser may be lost: is there a '{' missing somewhere?");
1016       return NULL_TREE;
1017     }
1018
1019   if (TREE_CODE (type) == OFFSET_TYPE
1020       || TREE_CODE (type) == REFERENCE_TYPE)
1021     type = TREE_TYPE (type);
1022
1023   /* If they have an `operator[]', use that.  */
1024   if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
1025     return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
1026                            array_expr, index_exp, NULL_TREE);
1027
1028   /* Otherwise, create an ARRAY_REF for a pointer or array type.  It
1029      is a little-known fact that, if `a' is an array and `i' is an
1030      int, you can write `i[a]', which means the same thing as `a[i]'.  */
1031
1032   if (TREE_CODE (type) == ARRAY_TYPE)
1033     p1 = array_expr;
1034   else
1035     p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0);
1036
1037   if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
1038     p2 = index_exp;
1039   else
1040     p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0);
1041
1042   i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0);
1043   i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0);
1044
1045   if ((p1 && i2) && (i1 && p2))
1046     error ("ambiguous conversion for array subscript");
1047
1048   if (p1 && i2)
1049     array_expr = p1, index_exp = i2;
1050   else if (i1 && p2)
1051     array_expr = p2, index_exp = i1;
1052   else
1053     {
1054       error ("invalid types `%T[%T]' for array subscript",
1055                 type, TREE_TYPE (index_exp));
1056       return error_mark_node;
1057     }
1058
1059   if (array_expr == error_mark_node || index_exp == error_mark_node)
1060     error ("ambiguous conversion for array subscript");
1061
1062   return build_array_ref (array_expr, index_exp);
1063 }
1064
1065 /* Given the cast expression EXP, checking out its validity.   Either return
1066    an error_mark_node if there was an unavoidable error, return a cast to
1067    void for trying to delete a pointer w/ the value 0, or return the
1068    call to delete.  If DOING_VEC is 1, we handle things differently
1069    for doing an array delete.  If DOING_VEC is 2, they gave us the
1070    array size as an argument to delete.
1071    Implements ARM $5.3.4.  This is called from the parser.  */
1072
1073 tree
1074 delete_sanity (exp, size, doing_vec, use_global_delete)
1075      tree exp, size;
1076      int doing_vec, use_global_delete;
1077 {
1078   tree t, type;
1079   /* For a regular vector delete (aka, no size argument) we will pass
1080      this down as a NULL_TREE into build_vec_delete.  */
1081   tree maxindex = NULL_TREE;
1082
1083   if (exp == error_mark_node)
1084     return exp;
1085
1086   if (processing_template_decl)
1087     {
1088       t = build_min (DELETE_EXPR, void_type_node, exp, size);
1089       DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
1090       DELETE_EXPR_USE_VEC (t) = doing_vec;
1091       return t;
1092     }
1093
1094   if (TREE_CODE (exp) == OFFSET_REF)
1095     exp = resolve_offset_ref (exp);
1096   exp = convert_from_reference (exp);
1097   t = stabilize_reference (exp);
1098   t = build_expr_type_conversion (WANT_POINTER, t, 1);
1099
1100   if (t == NULL_TREE || t == error_mark_node)
1101     {
1102       error ("type `%#T' argument given to `delete', expected pointer",
1103                 TREE_TYPE (exp));
1104       return error_mark_node;
1105     }
1106
1107   if (doing_vec == 2)
1108     {
1109       maxindex = cp_build_binary_op (MINUS_EXPR, size, integer_one_node);
1110       pedwarn ("anachronistic use of array size in vector delete");
1111     }
1112
1113   type = TREE_TYPE (t);
1114
1115   /* As of Valley Forge, you can delete a pointer to const.  */
1116
1117   /* You can't delete functions.  */
1118   if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
1119     {
1120       error ("cannot delete a function.  Only pointer-to-objects are valid arguments to `delete'");
1121       return error_mark_node;
1122     }
1123
1124   /* Deleting ptr to void is undefined behaviour [expr.delete/3].  */
1125   if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
1126     {
1127       warning ("deleting `%T' is undefined", type);
1128       doing_vec = 0;
1129     }
1130
1131   /* An array can't have been allocated by new, so complain.  */
1132   if (TREE_CODE (t) == ADDR_EXPR
1133       && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
1134       && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE)
1135     warning ("deleting array `%#D'", TREE_OPERAND (t, 0));
1136
1137   /* Deleting a pointer with the value zero is valid and has no effect.  */
1138   if (integer_zerop (t))
1139     return build1 (NOP_EXPR, void_type_node, t);
1140
1141   if (doing_vec)
1142     return build_vec_delete (t, maxindex, sfk_deleting_destructor,
1143                              use_global_delete);
1144   else
1145     {
1146       if (IS_AGGR_TYPE (TREE_TYPE (type))
1147           && TYPE_GETS_REG_DELETE (TREE_TYPE (type)))
1148         {
1149           /* Only do access checking here; we'll be calling op delete
1150              from the destructor.  */
1151           tree tmp = build_op_delete_call (DELETE_EXPR, t, size_zero_node,
1152                                            LOOKUP_NORMAL, NULL_TREE);
1153           if (tmp == error_mark_node)
1154             return error_mark_node;
1155         }
1156
1157       return build_delete (type, t, sfk_deleting_destructor,
1158                            LOOKUP_NORMAL, use_global_delete);
1159     }
1160 }
1161
1162 /* Report an error if the indicated template declaration is not the
1163    sort of thing that should be a member template.  */
1164
1165 void
1166 check_member_template (tmpl)
1167      tree tmpl;
1168 {
1169   tree decl;
1170
1171   my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
1172   decl = DECL_TEMPLATE_RESULT (tmpl);
1173
1174   if (TREE_CODE (decl) == FUNCTION_DECL
1175       || (TREE_CODE (decl) == TYPE_DECL
1176           && IS_AGGR_TYPE (TREE_TYPE (decl))))
1177     {
1178       if (current_function_decl)
1179         /* 14.5.2.2 [temp.mem]
1180            
1181            A local class shall not have member templates. */
1182         error ("invalid declaration of member template `%#D' in local class",
1183                   decl);
1184       
1185       if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
1186         {
1187           /* 14.5.2.3 [temp.mem]
1188
1189              A member function template shall not be virtual.  */
1190           error 
1191             ("invalid use of `virtual' in template declaration of `%#D'",
1192              decl);
1193           DECL_VIRTUAL_P (decl) = 0;
1194         }
1195
1196       /* The debug-information generating code doesn't know what to do
1197          with member templates.  */ 
1198       DECL_IGNORED_P (tmpl) = 1;
1199     } 
1200   else
1201     error ("template declaration of `%#D'", decl);
1202 }
1203
1204 /* Return true iff TYPE is a valid Java parameter or return type. */
1205
1206 static int
1207 acceptable_java_type (type)
1208      tree type;
1209 {
1210   if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
1211     return 1;
1212   if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
1213     {
1214       type = TREE_TYPE (type);
1215       if (TREE_CODE (type) == RECORD_TYPE)
1216         {
1217           tree args;  int i;
1218           if (! TYPE_FOR_JAVA (type))
1219             return 0;
1220           if (! CLASSTYPE_TEMPLATE_INFO (type))
1221             return 1;
1222           args = CLASSTYPE_TI_ARGS (type);
1223           i = TREE_VEC_LENGTH (args);
1224           while (--i >= 0)
1225             {
1226               type = TREE_VEC_ELT (args, i);
1227               if (TREE_CODE (type) == POINTER_TYPE)
1228                 type = TREE_TYPE (type);
1229               if (! TYPE_FOR_JAVA (type))
1230                 return 0;
1231             }
1232           return 1;
1233         }
1234     }
1235   return 0;
1236 }
1237
1238 /* For a METHOD in a Java class CTYPE, return 1 if
1239    the parameter and return types are valid Java types.
1240    Otherwise, print appropriate error messages, and return 0.  */
1241
1242 int
1243 check_java_method (method)
1244      tree method;
1245 {
1246   int jerr = 0;
1247   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
1248   tree ret_type = TREE_TYPE (TREE_TYPE (method));
1249   if (! acceptable_java_type (ret_type))
1250     {
1251       error ("Java method '%D' has non-Java return type `%T'",
1252                 method, ret_type);
1253       jerr++;
1254     }
1255   for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
1256     {
1257       tree type = TREE_VALUE (arg_types);
1258       if (! acceptable_java_type (type))
1259         {
1260           error ("Java method '%D' has non-Java parameter type `%T'",
1261                     method, type);
1262           jerr++;
1263         }
1264     }
1265   return jerr ? 0 : 1;
1266 }
1267
1268 /* Sanity check: report error if this function FUNCTION is not
1269    really a member of the class (CTYPE) it is supposed to belong to.
1270    CNAME is the same here as it is for grokclassfn above.  */
1271
1272 tree
1273 check_classfn (ctype, function)
1274      tree ctype, function;
1275 {
1276   tree fn_name = DECL_NAME (function);
1277   tree fndecl, fndecls;
1278   tree method_vec = CLASSTYPE_METHOD_VEC (complete_type (ctype));
1279   tree *methods = 0;
1280   tree *end = 0;
1281   
1282   if (DECL_USE_TEMPLATE (function)
1283       && !(TREE_CODE (function) == TEMPLATE_DECL
1284            && DECL_TEMPLATE_SPECIALIZATION (function))
1285       && is_member_template (DECL_TI_TEMPLATE (function)))
1286     /* Since this is a specialization of a member template,
1287        we're not going to find the declaration in the class.
1288        For example, in:
1289        
1290          struct S { template <typename T> void f(T); };
1291          template <> void S::f(int);
1292        
1293        we're not going to find `S::f(int)', but there's no
1294        reason we should, either.  We let our callers know we didn't
1295        find the method, but we don't complain.  */
1296     return NULL_TREE;
1297       
1298   if (method_vec != 0)
1299     {
1300       methods = &TREE_VEC_ELT (method_vec, 0);
1301       end = TREE_VEC_END (method_vec);
1302
1303       /* First suss out ctors and dtors.  */
1304       if (*methods && fn_name == DECL_NAME (OVL_CURRENT (*methods))
1305           && DECL_CONSTRUCTOR_P (function))
1306         goto got_it;
1307       if (*++methods && fn_name == DECL_NAME (OVL_CURRENT (*methods))
1308           && DECL_DESTRUCTOR_P (function))
1309         goto got_it;
1310
1311       while (++methods != end && *methods)
1312         {
1313           fndecl = *methods;
1314           if (fn_name == DECL_NAME (OVL_CURRENT (*methods)))
1315             {
1316             got_it:
1317               for (fndecls = *methods; fndecls != NULL_TREE;
1318                    fndecls = OVL_NEXT (fndecls))
1319                 {
1320                   fndecl = OVL_CURRENT (fndecls);
1321
1322                   /* We cannot simply call decls_match because this
1323                      doesn't work for static member functions that are 
1324                      pretending to be methods, and because the name
1325                      may have been changed by asm("new_name").  */ 
1326                   if (DECL_NAME (function) == DECL_NAME (fndecl))
1327                     {
1328                       tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
1329                       tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1330
1331                       /* Get rid of the this parameter on functions that become
1332                          static.  */
1333                       if (DECL_STATIC_FUNCTION_P (fndecl)
1334                           && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
1335                         p1 = TREE_CHAIN (p1);
1336
1337                       if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
1338                                        TREE_TYPE (TREE_TYPE (fndecl)))
1339                           && compparms (p1, p2)
1340                           && (DECL_TEMPLATE_SPECIALIZATION (function)
1341                               == DECL_TEMPLATE_SPECIALIZATION (fndecl))
1342                           && (!DECL_TEMPLATE_SPECIALIZATION (function)
1343                               || (DECL_TI_TEMPLATE (function) 
1344                                   == DECL_TI_TEMPLATE (fndecl))))
1345                         return fndecl;
1346                     }
1347                 }
1348               break;            /* loser */
1349             }
1350         }
1351     }
1352
1353   if (methods != end && *methods)
1354     {
1355       tree fndecl = *methods;
1356       error ("prototype for `%#D' does not match any in class `%T'",
1357                 function, ctype);
1358       cp_error_at ("candidate%s: %+#D", OVL_NEXT (fndecl) ? "s are" : " is",
1359                    OVL_CURRENT (fndecl));
1360       while (fndecl = OVL_NEXT (fndecl), fndecl)
1361         cp_error_at ("                %#D", OVL_CURRENT(fndecl));
1362     }
1363   else
1364     {
1365       methods = 0;
1366       if (!COMPLETE_TYPE_P (ctype))
1367         incomplete_type_error (function, ctype);
1368       else
1369         error ("no `%#D' member function declared in class `%T'",
1370                   function, ctype);
1371     }
1372
1373   /* If we did not find the method in the class, add it to avoid
1374      spurious errors (unless the CTYPE is not yet defined, in which
1375      case we'll only confuse ourselves when the function is declared
1376      properly within the class.  */
1377   if (COMPLETE_TYPE_P (ctype))
1378     add_method (ctype, function, /*error_p=*/1);
1379   return NULL_TREE;
1380 }
1381
1382 /* We have just processed the DECL, which is a static data member.
1383    Its initializer, if present, is INIT.  The ASMSPEC_TREE, if
1384    present, is the assembly-language name for the data member.
1385    FLAGS is as for cp_finish_decl.  */
1386
1387 void
1388 finish_static_data_member_decl (decl, init, asmspec_tree, flags)
1389      tree decl;
1390      tree init;
1391      tree asmspec_tree;
1392      int flags;
1393 {
1394   my_friendly_assert (TREE_PUBLIC (decl), 0);
1395
1396   DECL_CONTEXT (decl) = current_class_type;
1397
1398   /* We cannot call pushdecl here, because that would fill in the
1399      TREE_CHAIN of our decl.  Instead, we modify cp_finish_decl to do
1400      the right thing, namely, to put this decl out straight away.  */
1401   /* current_class_type can be NULL_TREE in case of error.  */
1402   if (!asmspec_tree && current_class_type)
1403     DECL_INITIAL (decl) = error_mark_node;
1404
1405   if (! processing_template_decl)
1406     {
1407       if (!pending_statics)
1408         VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
1409       VARRAY_PUSH_TREE (pending_statics, decl);
1410     }
1411
1412   if (LOCAL_CLASS_P (current_class_type))
1413     pedwarn ("local class `%#T' shall not have static data member `%#D'",
1414              current_class_type, decl);
1415
1416   /* Static consts need not be initialized in the class definition.  */
1417   if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
1418     {
1419       static int explained = 0;
1420           
1421       error ("initializer invalid for static member with constructor");
1422       if (!explained)
1423         {
1424           error ("(an out of class initialization is required)");
1425           explained = 1;
1426         }
1427       init = NULL_TREE;
1428     }
1429   /* Force the compiler to know when an uninitialized static const
1430      member is being used.  */
1431   if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0)
1432     TREE_USED (decl) = 1;
1433   DECL_INITIAL (decl) = init;
1434   DECL_IN_AGGR_P (decl) = 1;
1435
1436   cp_finish_decl (decl, init, asmspec_tree, flags);
1437 }
1438
1439 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
1440    of a structure component, returning a _DECL node.
1441    QUALS is a list of type qualifiers for this decl (such as for declaring
1442    const member functions).
1443
1444    This is done during the parsing of the struct declaration.
1445    The _DECL nodes are chained together and the lot of them
1446    are ultimately passed to `build_struct' to make the RECORD_TYPE node.
1447
1448    If class A defines that certain functions in class B are friends, then
1449    the way I have set things up, it is B who is interested in permission
1450    granted by A.  However, it is in A's context that these declarations
1451    are parsed.  By returning a void_type_node, class A does not attempt
1452    to incorporate the declarations of the friends within its structure.
1453
1454    DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
1455    CHANGES TO CODE IN `start_method'.  */
1456
1457 tree
1458 grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
1459      tree declarator, declspecs, init, asmspec_tree, attrlist;
1460 {
1461   tree value;
1462   const char *asmspec = 0;
1463   int flags = LOOKUP_ONLYCONVERTING;
1464
1465   /* Convert () initializers to = initializers.  */
1466   if (init == NULL_TREE && declarator != NULL_TREE
1467       && TREE_CODE (declarator) == CALL_EXPR
1468       && TREE_OPERAND (declarator, 0)
1469       && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE
1470           || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF)
1471       && parmlist_is_exprlist (CALL_DECLARATOR_PARMS (declarator)))
1472     {
1473       /* It's invalid to try to initialize a data member using a
1474          functional notation, e.g.:
1475          
1476             struct S {
1477               static int i (3);
1478             };
1479             
1480          Explain that to the user.  */
1481       static int explained;
1482
1483       error ("invalid data member initialization");
1484       if (!explained)
1485         {
1486           error ("(use `=' to initialize static data members)");
1487           explained = 1;
1488         }
1489
1490       declarator = TREE_OPERAND (declarator, 0);
1491       flags = 0;
1492     }
1493
1494   if (declspecs == NULL_TREE
1495       && TREE_CODE (declarator) == SCOPE_REF
1496       && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
1497     {
1498       /* Access declaration */
1499       if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
1500         ;
1501       else if (TREE_COMPLEXITY (declarator) == current_class_depth)
1502         pop_nested_class ();
1503       return do_class_using_decl (declarator);
1504     }
1505
1506   if (init
1507       && TREE_CODE (init) == TREE_LIST
1508       && TREE_VALUE (init) == error_mark_node
1509       && TREE_CHAIN (init) == NULL_TREE)
1510     init = NULL_TREE;
1511
1512   value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
1513   if (! value || value == error_mark_node)
1514     /* friend or constructor went bad.  */
1515     return value;
1516   if (TREE_TYPE (value) == error_mark_node)
1517     return error_mark_node;  
1518
1519   /* Pass friendly classes back.  */
1520   if (TREE_CODE (value) == VOID_TYPE)
1521     return void_type_node;
1522
1523   if (DECL_NAME (value) != NULL_TREE
1524       && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
1525       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
1526     error ("member `%D' conflicts with virtual function table field name",
1527               value);
1528
1529   /* Stash away type declarations.  */
1530   if (TREE_CODE (value) == TYPE_DECL)
1531     {
1532       DECL_NONLOCAL (value) = 1;
1533       DECL_CONTEXT (value) = current_class_type;
1534
1535       if (CLASS_TYPE_P (TREE_TYPE (value)))
1536         CLASSTYPE_GOT_SEMICOLON (TREE_TYPE (value)) = 1;
1537       
1538       if (processing_template_decl)
1539         value = push_template_decl (value);
1540
1541       return value;
1542     }
1543
1544   if (DECL_IN_AGGR_P (value))
1545     {
1546       error ("`%D' is already defined in `%T'", value,
1547                 DECL_CONTEXT (value));
1548       return void_type_node;
1549     }
1550
1551   if (asmspec_tree)
1552     asmspec = TREE_STRING_POINTER (asmspec_tree);
1553
1554   if (init)
1555     {
1556       if (TREE_CODE (value) == FUNCTION_DECL)
1557         {
1558           grok_function_init (value, init);
1559           init = NULL_TREE;
1560         }
1561       else if (pedantic && TREE_CODE (value) != VAR_DECL)
1562         /* Already complained in grokdeclarator.  */
1563         init = NULL_TREE;
1564       else
1565         {
1566           /* We allow initializers to become parameters to base
1567              initializers.  */
1568           if (TREE_CODE (init) == TREE_LIST)
1569             {
1570               if (TREE_CHAIN (init) == NULL_TREE)
1571                 init = TREE_VALUE (init);
1572               else
1573                 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1574             }
1575           
1576           if (TREE_CODE (init) == CONST_DECL)
1577             init = DECL_INITIAL (init);
1578           else if (TREE_READONLY_DECL_P (init))
1579             init = decl_constant_value (init);
1580           else if (TREE_CODE (init) == CONSTRUCTOR)
1581             init = digest_init (TREE_TYPE (value), init, (tree *)0);
1582           if (init == error_mark_node)
1583             /* We must make this look different than `error_mark_node'
1584                because `decl_const_value' would mis-interpret it
1585                as only meaning that this VAR_DECL is defined.  */
1586             init = build1 (NOP_EXPR, TREE_TYPE (value), init);
1587           else if (processing_template_decl)
1588             ;
1589           else if (! TREE_CONSTANT (init))
1590             {
1591               /* We can allow references to things that are effectively
1592                  static, since references are initialized with the address.  */
1593               if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
1594                   || (TREE_STATIC (init) == 0
1595                       && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
1596                 {
1597                   error ("field initializer is not constant");
1598                   init = error_mark_node;
1599                 }
1600             }
1601         }
1602     }
1603
1604   if (processing_template_decl && ! current_function_decl
1605       && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
1606     value = push_template_decl (value);
1607
1608   if (attrlist)
1609     cplus_decl_attributes (&value, attrlist, 0);
1610
1611   if (TREE_CODE (value) == VAR_DECL)
1612     {
1613       finish_static_data_member_decl (value, init, asmspec_tree, 
1614                                       flags);
1615       return value;
1616     }
1617   if (TREE_CODE (value) == FIELD_DECL)
1618     {
1619       if (asmspec)
1620         error ("`asm' specifiers are not permitted on non-static data members");
1621       if (DECL_INITIAL (value) == error_mark_node)
1622         init = error_mark_node;
1623       cp_finish_decl (value, init, NULL_TREE, flags);
1624       DECL_INITIAL (value) = init;
1625       DECL_IN_AGGR_P (value) = 1;
1626       return value;
1627     }
1628   if (TREE_CODE (value) == FUNCTION_DECL)
1629     {
1630       if (asmspec)
1631         {
1632           /* This must override the asm specifier which was placed
1633              by grokclassfn.  Lay this out fresh.  */
1634           SET_DECL_RTL (value, NULL_RTX);
1635           SET_DECL_ASSEMBLER_NAME (value, get_identifier (asmspec));
1636         }
1637       if (!DECL_FRIEND_P (value))
1638         grok_special_member_properties (value);
1639       
1640       cp_finish_decl (value, init, asmspec_tree, flags);
1641
1642       /* Pass friends back this way.  */
1643       if (DECL_FRIEND_P (value))
1644         return void_type_node;
1645
1646       DECL_IN_AGGR_P (value) = 1;
1647       return value;
1648     }
1649   abort ();
1650   /* NOTREACHED */
1651   return NULL_TREE;
1652 }
1653
1654 /* Like `grokfield', but for bitfields.
1655    WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.  */
1656
1657 tree
1658 grokbitfield (declarator, declspecs, width)
1659      tree declarator, declspecs, width;
1660 {
1661   register tree value = grokdeclarator (declarator, declspecs, BITFIELD,
1662                                         0, NULL);
1663
1664   if (! value) return NULL_TREE; /* friends went bad.  */
1665
1666   /* Pass friendly classes back.  */
1667   if (TREE_CODE (value) == VOID_TYPE)
1668     return void_type_node;
1669
1670   if (TREE_CODE (value) == TYPE_DECL)
1671     {
1672       error ("cannot declare `%D' to be a bit-field type", value);
1673       return NULL_TREE;
1674     }
1675
1676   /* Usually, finish_struct_1 catches bitfields with invalid types.
1677      But, in the case of bitfields with function type, we confuse
1678      ourselves into thinking they are member functions, so we must
1679      check here.  */
1680   if (TREE_CODE (value) == FUNCTION_DECL)
1681     {
1682       error ("cannot declare bit-field `%D' with function type",
1683              DECL_NAME (value));
1684       return NULL_TREE;
1685     }
1686
1687   if (DECL_IN_AGGR_P (value))
1688     {
1689       error ("`%D' is already defined in the class %T", value,
1690                   DECL_CONTEXT (value));
1691       return void_type_node;
1692     }
1693
1694   if (TREE_STATIC (value))
1695     {
1696       error ("static member `%D' cannot be a bit-field", value);
1697       return NULL_TREE;
1698     }
1699   cp_finish_decl (value, NULL_TREE, NULL_TREE, 0);
1700
1701   if (width != error_mark_node)
1702     {
1703       constant_expression_warning (width);
1704       DECL_INITIAL (value) = width;
1705       SET_DECL_C_BIT_FIELD (value);
1706     }
1707
1708   DECL_IN_AGGR_P (value) = 1;
1709   return value;
1710 }
1711
1712 tree
1713 grokoptypename (declspecs, declarator)
1714      tree declspecs, declarator;
1715 {
1716   tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, NULL);
1717   return mangle_conv_op_name_for_type (t);
1718 }
1719
1720 /* When a function is declared with an initializer,
1721    do the right thing.  Currently, there are two possibilities:
1722
1723    class B
1724    {
1725     public:
1726      // initialization possibility #1.
1727      virtual void f () = 0;
1728      int g ();
1729    };
1730    
1731    class D1 : B
1732    {
1733     public:
1734      int d1;
1735      // error, no f ();
1736    };
1737    
1738    class D2 : B
1739    {
1740     public:
1741      int d2;
1742      void f ();
1743    };
1744    
1745    class D3 : B
1746    {
1747     public:
1748      int d3;
1749      // initialization possibility #2
1750      void f () = B::f;
1751    };
1752
1753 */
1754
1755 static void
1756 grok_function_init (decl, init)
1757      tree decl;
1758      tree init;
1759 {
1760   /* An initializer for a function tells how this function should
1761      be inherited.  */
1762   tree type = TREE_TYPE (decl);
1763
1764   if (TREE_CODE (type) == FUNCTION_TYPE)
1765     error ("initializer specified for non-member function `%D'", decl);
1766   else if (integer_zerop (init))
1767     DECL_PURE_VIRTUAL_P (decl) = 1;
1768   else
1769     error ("invalid initializer for virtual method `%D'", decl);
1770 }
1771 \f
1772 void
1773 cplus_decl_attributes (decl, attributes, flags)
1774      tree *decl, attributes;
1775      int flags;
1776 {
1777   if (*decl == NULL_TREE || *decl == void_type_node)
1778     return;
1779
1780   if (TREE_CODE (*decl) == TEMPLATE_DECL)
1781     decl = &DECL_TEMPLATE_RESULT (*decl);
1782
1783   decl_attributes (decl, attributes, flags);
1784
1785   if (TREE_CODE (*decl) == TYPE_DECL)
1786     SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1787 }
1788 \f
1789 /* CONSTRUCTOR_NAME:
1790    Return the name for the constructor (or destructor) for the
1791    specified class.  Argument can be RECORD_TYPE, TYPE_DECL, or
1792    IDENTIFIER_NODE.  When given a template, this routine doesn't
1793    lose the specialization.  */
1794
1795 tree
1796 constructor_name_full (thing)
1797      tree thing;
1798 {
1799   if (TREE_CODE (thing) == TEMPLATE_TYPE_PARM
1800       || TREE_CODE (thing) == BOUND_TEMPLATE_TEMPLATE_PARM
1801       || TREE_CODE (thing) == TYPENAME_TYPE)
1802     thing = TYPE_NAME (thing);
1803   else if (IS_AGGR_TYPE_CODE (TREE_CODE (thing)))
1804     {
1805       if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing))
1806         thing = DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (thing), 0)));
1807       else
1808         thing = TYPE_NAME (thing);
1809     }
1810   if (TREE_CODE (thing) == TYPE_DECL
1811       || (TREE_CODE (thing) == TEMPLATE_DECL
1812           && TREE_CODE (DECL_TEMPLATE_RESULT (thing)) == TYPE_DECL))
1813     thing = DECL_NAME (thing);
1814   my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197);
1815   return thing;
1816 }
1817
1818 /* CONSTRUCTOR_NAME:
1819    Return the name for the constructor (or destructor) for the
1820    specified class.  Argument can be RECORD_TYPE, TYPE_DECL, or
1821    IDENTIFIER_NODE.  When given a template, return the plain
1822    unspecialized name.  */
1823
1824 tree
1825 constructor_name (thing)
1826      tree thing;
1827 {
1828   tree t;
1829   thing = constructor_name_full (thing);
1830   t = IDENTIFIER_TEMPLATE (thing);
1831   if (!t)
1832     return thing;
1833   return t;
1834 }
1835 \f
1836 /* Defer the compilation of the FN until the end of compilation.  */
1837
1838 void
1839 defer_fn (fn)
1840      tree fn;
1841 {
1842   if (DECL_DEFERRED_FN (fn))
1843     return;
1844   DECL_DEFERRED_FN (fn) = 1;
1845   if (!deferred_fns)
1846     VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
1847
1848   VARRAY_PUSH_TREE (deferred_fns, fn);
1849 }
1850
1851 /* Hunts through the global anonymous union ANON_DECL, building
1852    appropriate VAR_DECLs.  Stores cleanups on the list of ELEMS, and
1853    returns a VAR_DECL whose size is the same as the size of the
1854    ANON_DECL, if one is available.
1855
1856    FIXME: we should really handle anonymous unions by binding the names
1857    of the members to COMPONENT_REFs rather than this kludge.  */
1858
1859 static tree 
1860 build_anon_union_vars (anon_decl, elems, static_p, external_p)
1861      tree anon_decl;
1862      tree* elems;
1863      int static_p;
1864      int external_p;
1865 {
1866   tree type = TREE_TYPE (anon_decl);
1867   tree main_decl = NULL_TREE;
1868   tree field;
1869
1870   /* Rather than write the code to handle the non-union case,
1871      just give an error.  */
1872   if (TREE_CODE (type) != UNION_TYPE)
1873     error ("anonymous struct not inside named type");
1874
1875   for (field = TYPE_FIELDS (type); 
1876        field != NULL_TREE; 
1877        field = TREE_CHAIN (field))
1878     {
1879       tree decl;
1880
1881       if (DECL_ARTIFICIAL (field))
1882         continue;
1883       if (TREE_CODE (field) != FIELD_DECL)
1884         {
1885           cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
1886                          field);
1887           continue;
1888         }
1889
1890       if (TREE_PRIVATE (field))
1891         cp_pedwarn_at ("private member `%#D' in anonymous union", field);
1892       else if (TREE_PROTECTED (field))
1893         cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
1894
1895       if (DECL_NAME (field) == NULL_TREE
1896           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1897         {
1898           decl = build_anon_union_vars (field, elems, static_p, external_p);
1899           if (!decl)
1900             continue;
1901         }
1902       else if (DECL_NAME (field) == NULL_TREE)
1903         continue;
1904       else
1905         {
1906           decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
1907           /* tell `pushdecl' that this is not tentative.  */
1908           DECL_INITIAL (decl) = error_mark_node;
1909           TREE_PUBLIC (decl) = 0;
1910           TREE_STATIC (decl) = static_p;
1911           DECL_EXTERNAL (decl) = external_p;
1912           decl = pushdecl (decl);
1913           DECL_INITIAL (decl) = NULL_TREE;
1914         }
1915
1916       /* Only write out one anon union element--choose the largest
1917          one.  We used to try to find one the same size as the union,
1918          but that fails if the ABI forces us to align the union more
1919          strictly.  */
1920       if (main_decl == NULL_TREE
1921           || tree_int_cst_lt (DECL_SIZE (main_decl), DECL_SIZE (decl)))
1922         {
1923           if (main_decl)
1924             TREE_ASM_WRITTEN (main_decl) = 1;
1925           main_decl = decl;
1926         }
1927       else 
1928         /* ??? This causes there to be no debug info written out
1929            about this decl.  */
1930         TREE_ASM_WRITTEN (decl) = 1;
1931       
1932       if (DECL_NAME (field) == NULL_TREE
1933           && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1934         /* The remainder of the processing was already done in the
1935            recursive call.  */
1936         continue;
1937
1938       /* If there's a cleanup to do, it belongs in the
1939          TREE_PURPOSE of the following TREE_LIST.  */
1940       *elems = tree_cons (NULL_TREE, decl, *elems);
1941       TREE_TYPE (*elems) = type;
1942     }
1943   
1944   return main_decl;
1945 }
1946
1947 /* Finish off the processing of a UNION_TYPE structure.  If the union is an
1948    anonymous union, then all members must be laid out together.  PUBLIC_P
1949    is nonzero if this union is not declared static.  */
1950
1951 void
1952 finish_anon_union (anon_union_decl)
1953      tree anon_union_decl;
1954 {
1955   tree type = TREE_TYPE (anon_union_decl);
1956   tree main_decl;
1957   int public_p = TREE_PUBLIC (anon_union_decl);
1958   int static_p = TREE_STATIC (anon_union_decl);
1959   int external_p = DECL_EXTERNAL (anon_union_decl);
1960
1961   /* The VAR_DECL's context is the same as the TYPE's context. */
1962   DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1963   
1964   if (TYPE_FIELDS (type) == NULL_TREE)
1965     return;
1966
1967   if (public_p)
1968     {
1969       error ("namespace-scope anonymous aggregates must be static");
1970       return;
1971     }
1972
1973   main_decl = build_anon_union_vars (anon_union_decl,
1974                                      &DECL_ANON_UNION_ELEMS (anon_union_decl),
1975                                      static_p, external_p);
1976
1977   if (main_decl == NULL_TREE)
1978     {
1979       warning ("anonymous aggregate with no members");
1980       return;
1981     }
1982
1983   if (static_p)
1984     {
1985       make_decl_rtl (main_decl, 0);
1986       COPY_DECL_RTL (main_decl, anon_union_decl);
1987       expand_anon_union_decl (anon_union_decl, 
1988                               NULL_TREE,
1989                               DECL_ANON_UNION_ELEMS (anon_union_decl));
1990     }
1991   else
1992     add_decl_stmt (anon_union_decl);
1993 }
1994
1995 /* Finish processing a builtin type TYPE.  It's name is NAME,
1996    its fields are in the array FIELDS.  LEN is the number of elements
1997    in FIELDS minus one, or put another way, it is the maximum subscript
1998    used in FIELDS.
1999
2000    It is given the same alignment as ALIGN_TYPE.  */
2001
2002 void
2003 finish_builtin_type (type, name, fields, len, align_type)
2004      tree type;
2005      const char *name;
2006      tree fields[];
2007      int len;
2008      tree align_type;
2009 {
2010   register int i;
2011
2012   TYPE_FIELDS (type) = fields[0];
2013   for (i = 0; i < len; i++)
2014     {
2015       layout_type (TREE_TYPE (fields[i]));
2016       DECL_FIELD_CONTEXT (fields[i]) = type;
2017       TREE_CHAIN (fields[i]) = fields[i+1];
2018     }
2019   DECL_FIELD_CONTEXT (fields[i]) = type;
2020   TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
2021   TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type);
2022   layout_type (type);
2023 #if 0 /* not yet, should get fixed properly later */
2024   TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
2025 #else
2026   TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
2027 #endif
2028   TYPE_STUB_DECL (type) = TYPE_NAME (type);
2029   layout_decl (TYPE_NAME (type), 0);
2030 }
2031 \f
2032 /* Auxiliary functions to make type signatures for
2033    `operator new' and `operator delete' correspond to
2034    what compiler will be expecting.  */
2035
2036 tree
2037 coerce_new_type (type)
2038      tree type;
2039 {
2040   int e = 0;
2041   tree args = TYPE_ARG_TYPES (type);
2042
2043   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
2044   
2045   if (!same_type_p (TREE_TYPE (type), ptr_type_node))
2046     e = 1, error ("`operator new' must return type `%T'", ptr_type_node);
2047
2048   if (!args || args == void_list_node
2049       || !same_type_p (TREE_VALUE (args), c_size_type_node))
2050     {
2051       e = 2;
2052       if (args && args != void_list_node)
2053         args = TREE_CHAIN (args);
2054       pedwarn ("`operator new' takes type `size_t' (`%T') as first parameter", c_size_type_node);
2055     }
2056   switch (e)
2057   {
2058     case 2:
2059       args = tree_cons (NULL_TREE, c_size_type_node, args);
2060       /* FALLTHROUGH */
2061     case 1:
2062       type = build_exception_variant
2063               (build_function_type (ptr_type_node, args),
2064                TYPE_RAISES_EXCEPTIONS (type));
2065       /* FALLTHROUGH */
2066     default:;
2067   }
2068   return type;
2069 }
2070
2071 tree
2072 coerce_delete_type (type)
2073      tree type;
2074 {
2075   int e = 0;
2076   tree args = TYPE_ARG_TYPES (type);
2077   
2078   my_friendly_assert (TREE_CODE (type) == FUNCTION_TYPE, 20001107);
2079
2080   if (!same_type_p (TREE_TYPE (type), void_type_node))
2081     e = 1, error ("`operator delete' must return type `%T'", void_type_node);
2082
2083   if (!args || args == void_list_node
2084       || !same_type_p (TREE_VALUE (args), ptr_type_node))
2085     {
2086       e = 2;
2087       if (args && args != void_list_node)
2088         args = TREE_CHAIN (args);
2089       error ("`operator delete' takes type `%T' as first parameter", ptr_type_node);
2090     }
2091   switch (e)
2092   {
2093     case 2:
2094       args = tree_cons (NULL_TREE, ptr_type_node, args);
2095       /* FALLTHROUGH */
2096     case 1:
2097       type = build_exception_variant
2098               (build_function_type (void_type_node, args),
2099                TYPE_RAISES_EXCEPTIONS (type));
2100       /* FALLTHROUGH */
2101     default:;
2102   }
2103
2104   return type;
2105 }
2106 \f
2107 static void
2108 mark_vtable_entries (decl)
2109      tree decl;
2110 {
2111   tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
2112
2113   for (; entries; entries = TREE_CHAIN (entries))
2114     {
2115       tree fnaddr = TREE_VALUE (entries);
2116       tree fn;
2117       
2118       if (TREE_CODE (fnaddr) != ADDR_EXPR
2119           && TREE_CODE (fnaddr) != FDESC_EXPR)
2120         /* This entry is an offset: a virtual base class offset, a
2121            virtual call offset, an RTTI offset, etc.  */
2122         continue;
2123
2124       fn = TREE_OPERAND (fnaddr, 0);
2125       TREE_ADDRESSABLE (fn) = 1;
2126       /* When we don't have vcall offsets, we output thunks whenever
2127          we output the vtables that contain them.  With vcall offsets,
2128          we know all the thunks we'll need when we emit a virtual
2129          function, so we emit the thunks there instead.  */
2130       if (DECL_THUNK_P (fn)) 
2131         use_thunk (fn, /*emit_p=*/0);
2132       mark_used (fn);
2133     }
2134 }
2135
2136 /* Set DECL up to have the closest approximation of "initialized common"
2137    linkage available.  */
2138
2139 void
2140 comdat_linkage (decl)
2141      tree decl;
2142 {
2143   if (flag_weak)
2144     make_decl_one_only (decl);
2145   else if (TREE_CODE (decl) == FUNCTION_DECL 
2146            || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
2147     /* We can just emit function and compiler-generated variables
2148        statically; having multiple copies is (for the most part) only
2149        a waste of space.  
2150
2151        There are two correctness issues, however: the address of a
2152        template instantiation with external linkage should be the
2153        same, independent of what translation unit asks for the
2154        address, and this will not hold when we emit multiple copies of
2155        the function.  However, there's little else we can do.  
2156
2157        Also, by default, the typeinfo implementation assumes that
2158        there will be only one copy of the string used as the name for
2159        each type.  Therefore, if weak symbols are unavailable, the
2160        run-time library should perform a more conservative check; it
2161        should perform a string comparison, rather than an address
2162        comparison.  */
2163     TREE_PUBLIC (decl) = 0;
2164   else
2165     {
2166       /* Static data member template instantiations, however, cannot
2167          have multiple copies.  */
2168       if (DECL_INITIAL (decl) == 0
2169           || DECL_INITIAL (decl) == error_mark_node)
2170         DECL_COMMON (decl) = 1;
2171       else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
2172         {
2173           DECL_COMMON (decl) = 1;
2174           DECL_INITIAL (decl) = error_mark_node;
2175         }
2176       else
2177         {
2178           /* We can't do anything useful; leave vars for explicit
2179              instantiation.  */
2180           DECL_EXTERNAL (decl) = 1;
2181           DECL_NOT_REALLY_EXTERN (decl) = 0;
2182         }
2183     }
2184
2185   if (DECL_LANG_SPECIFIC (decl))
2186     DECL_COMDAT (decl) = 1;
2187 }
2188
2189 /* For win32 we also want to put explicit instantiations in
2190    linkonce sections, so that they will be merged with implicit
2191    instantiations; otherwise we get duplicate symbol errors.  */
2192
2193 void
2194 maybe_make_one_only (decl)
2195      tree decl;
2196 {
2197   /* We used to say that this was not necessary on targets that support weak
2198      symbols, because the implicit instantiations will defer to the explicit
2199      one.  However, that's not actually the case in SVR4; a strong definition
2200      after a weak one is an error.  Also, not making explicit
2201      instantiations one_only means that we can end up with two copies of
2202      some template instantiations. */
2203   if (! flag_weak)
2204     return;
2205
2206   /* We can't set DECL_COMDAT on functions, or finish_file will think
2207      we can get away with not emitting them if they aren't used.  We need
2208      to for variables so that cp_finish_decl will update their linkage,
2209      because their DECL_INITIAL may not have been set properly yet.  */
2210
2211   make_decl_one_only (decl);
2212
2213   if (TREE_CODE (decl) == VAR_DECL)
2214     {
2215       DECL_COMDAT (decl) = 1;
2216       /* Mark it needed so we don't forget to emit it.  */
2217       TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
2218     }
2219 }
2220
2221 /* Returns the virtual function with which the vtable for TYPE is
2222    emitted, or NULL_TREE if that heuristic is not applicable to TYPE.  */
2223
2224 static tree
2225 key_method (type)
2226      tree type;
2227 {
2228   tree method;
2229
2230   if (TYPE_FOR_JAVA (type)
2231       || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
2232       || CLASSTYPE_INTERFACE_KNOWN (type))
2233     return NULL_TREE;
2234
2235   for (method = TYPE_METHODS (type); method != NULL_TREE;
2236        method = TREE_CHAIN (method))
2237     if (DECL_VINDEX (method) != NULL_TREE
2238         && ! DECL_DECLARED_INLINE_P (method)
2239         && (! DECL_PURE_VIRTUAL_P (method)
2240 #if 0
2241             /* This would be nice, but we didn't think of it in time.  */
2242             || DECL_DESTRUCTOR_P (method)
2243 #endif
2244             ))
2245       return method;
2246
2247   return NULL_TREE;
2248 }
2249
2250 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
2251    based on TYPE and other static flags.
2252
2253    Note that anything public is tagged TREE_PUBLIC, whether
2254    it's public in this file or in another one.  */
2255
2256 void
2257 import_export_vtable (decl, type, final)
2258      tree decl, type;
2259      int final;
2260 {
2261   if (DECL_INTERFACE_KNOWN (decl))
2262     return;
2263
2264   if (TYPE_FOR_JAVA (type))
2265     {
2266       TREE_PUBLIC (decl) = 1;
2267       DECL_EXTERNAL (decl) = 1;
2268       DECL_INTERFACE_KNOWN (decl) = 1;
2269     }
2270   else if (CLASSTYPE_INTERFACE_KNOWN (type))
2271     {
2272       TREE_PUBLIC (decl) = 1;
2273       DECL_EXTERNAL (decl) = CLASSTYPE_INTERFACE_ONLY (type);
2274       DECL_INTERFACE_KNOWN (decl) = 1;
2275     }
2276   else
2277     {
2278       /* We can only wait to decide if we have real non-inline virtual
2279          functions in our class, or if we come from a template.  */
2280
2281       int found = (CLASSTYPE_TEMPLATE_INSTANTIATION (type)
2282                    || key_method (type));
2283
2284       if (final || ! found)
2285         {
2286           comdat_linkage (decl);
2287           DECL_EXTERNAL (decl) = 0;
2288         }
2289       else
2290         {
2291           TREE_PUBLIC (decl) = 1;
2292           DECL_EXTERNAL (decl) = 1;
2293         }
2294     }
2295 }
2296
2297 /* Determine whether or not we want to specifically import or export CTYPE,
2298    using various heuristics.  */
2299
2300 static void
2301 import_export_class (ctype)
2302      tree ctype;
2303 {
2304   /* -1 for imported, 1 for exported.  */
2305   int import_export = 0;
2306
2307   /* It only makes sense to call this function at EOF.  The reason is
2308      that this function looks at whether or not the first non-inline
2309      non-abstract virtual member function has been defined in this
2310      translation unit.  But, we can't possibly know that until we've
2311      seen the entire translation unit.  */
2312   my_friendly_assert (at_eof, 20000226);
2313
2314   if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2315     return;
2316
2317   /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
2318      we will have CLASSTYPE_INTERFACE_ONLY set but not
2319      CLASSTYPE_INTERFACE_KNOWN.  In that case, we don't want to use this
2320      heuristic because someone will supply a #pragma implementation
2321      elsewhere, and deducing it here would produce a conflict.  */
2322   if (CLASSTYPE_INTERFACE_ONLY (ctype))
2323     return;
2324
2325   if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
2326     import_export = -1;
2327   else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
2328     import_export = 1;
2329
2330   /* If we got -fno-implicit-templates, we import template classes that
2331      weren't explicitly instantiated.  */
2332   if (import_export == 0
2333       && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
2334       && ! flag_implicit_templates)
2335     import_export = -1;
2336
2337   /* Base our import/export status on that of the first non-inline,
2338      non-pure virtual function, if any.  */
2339   if (import_export == 0
2340       && TYPE_POLYMORPHIC_P (ctype))
2341     {
2342       tree method = key_method (ctype);
2343       if (method)
2344         import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
2345     }
2346
2347 #ifdef MULTIPLE_SYMBOL_SPACES
2348   if (import_export == -1)
2349     import_export = 0;
2350 #endif
2351
2352   if (import_export)
2353     {
2354       SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
2355       CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
2356     }
2357 }
2358     
2359 /* We need to describe to the assembler the relationship between
2360    a vtable and the vtable of the parent class.  */
2361
2362 static void
2363 output_vtable_inherit (vars)
2364      tree vars;
2365 {
2366   tree parent;
2367   rtx child_rtx, parent_rtx;
2368
2369   child_rtx = XEXP (DECL_RTL (vars), 0);          /* strip the mem ref  */
2370
2371   parent = binfo_for_vtable (vars);
2372
2373   if (parent == TYPE_BINFO (DECL_CONTEXT (vars)))
2374     parent_rtx = const0_rtx;
2375   else if (parent)
2376     {
2377       parent = get_vtbl_decl_for_binfo (TYPE_BINFO (BINFO_TYPE (parent)));
2378       parent_rtx = XEXP (DECL_RTL (parent), 0);  /* strip the mem ref  */
2379     }
2380   else
2381     abort ();
2382
2383   assemble_vtable_inherit (child_rtx, parent_rtx);
2384 }
2385
2386 static int
2387 finish_vtable_vardecl (t, data)
2388      tree *t;
2389      void *data ATTRIBUTE_UNUSED;
2390 {
2391   tree vars = *t;
2392   tree ctype = DECL_CONTEXT (vars);
2393   import_export_class (ctype);
2394   import_export_vtable (vars, ctype, 1);
2395
2396   if (! DECL_EXTERNAL (vars)
2397       && DECL_NEEDED_P (vars)
2398       && ! TREE_ASM_WRITTEN (vars))
2399     {
2400       if (TREE_TYPE (vars) == void_type_node)
2401         /* It is a dummy vtable made by get_vtable_decl. Ignore it.  */
2402         return 0;
2403       
2404       /* Write it out.  */
2405       mark_vtable_entries (vars);
2406       if (TREE_TYPE (DECL_INITIAL (vars)) == 0)
2407         store_init_value (vars, DECL_INITIAL (vars));
2408
2409       if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
2410         {
2411           /* Mark the VAR_DECL node representing the vtable itself as a
2412              "gratuitous" one, thereby forcing dwarfout.c to ignore it.
2413              It is rather important that such things be ignored because
2414              any effort to actually generate DWARF for them will run
2415              into trouble when/if we encounter code like:
2416
2417                 #pragma interface
2418                 struct S { virtual void member (); };
2419
2420               because the artificial declaration of the vtable itself (as
2421               manufactured by the g++ front end) will say that the vtable
2422               is a static member of `S' but only *after* the debug output
2423               for the definition of `S' has already been output.  This causes
2424               grief because the DWARF entry for the definition of the vtable
2425               will try to refer back to an earlier *declaration* of the
2426               vtable as a static member of `S' and there won't be one.
2427               We might be able to arrange to have the "vtable static member"
2428               attached to the member list for `S' before the debug info for
2429               `S' get written (which would solve the problem) but that would
2430               require more intrusive changes to the g++ front end.  */
2431
2432           DECL_IGNORED_P (vars) = 1;
2433         }
2434
2435       /* Always make vtables weak.  */
2436       if (flag_weak)
2437         comdat_linkage (vars);
2438
2439       rest_of_decl_compilation (vars, NULL, 1, 1);
2440
2441       if (flag_vtable_gc)
2442         output_vtable_inherit (vars);
2443
2444       /* Because we're only doing syntax-checking, we'll never end up
2445          actually marking the variable as written.  */
2446       if (flag_syntax_only)
2447         TREE_ASM_WRITTEN (vars) = 1;
2448
2449       /* Since we're writing out the vtable here, also write the debug 
2450          info.  */
2451       note_debug_info_needed (ctype);
2452
2453       return 1;
2454     }
2455
2456   /* If the references to this class' vtables were optimized away, still
2457      emit the appropriate debugging information.  See dfs_debug_mark.  */
2458   if (DECL_COMDAT (vars)
2459       && CLASSTYPE_DEBUG_REQUESTED (ctype))
2460     note_debug_info_needed (ctype);
2461
2462   return 0;
2463 }
2464
2465 static int
2466 prune_vtable_vardecl (t, data)
2467      tree *t;
2468      void *data ATTRIBUTE_UNUSED;
2469 {
2470   *t = TREE_CHAIN (*t);
2471   return 1;
2472 }
2473
2474 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
2475    inline function or template instantiation at end-of-file.  */
2476
2477 void
2478 import_export_decl (decl)
2479      tree decl;
2480 {
2481   if (DECL_INTERFACE_KNOWN (decl))
2482     return;
2483
2484   if (DECL_TEMPLATE_INSTANTIATION (decl)
2485       || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2486     {
2487       DECL_NOT_REALLY_EXTERN (decl) = 1;
2488       if ((DECL_IMPLICIT_INSTANTIATION (decl)
2489            || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2490           && (flag_implicit_templates
2491               || (flag_implicit_inline_templates 
2492                   && DECL_DECLARED_INLINE_P (decl))))
2493         {
2494           if (!TREE_PUBLIC (decl))
2495             /* Templates are allowed to have internal linkage.  See 
2496                [basic.link].  */
2497             ;
2498           else
2499             comdat_linkage (decl);
2500         }
2501       else
2502         DECL_NOT_REALLY_EXTERN (decl) = 0;
2503     }
2504   else if (DECL_FUNCTION_MEMBER_P (decl))
2505     {
2506       if (!DECL_DECLARED_INLINE_P (decl))
2507         {
2508           tree ctype = DECL_CONTEXT (decl);
2509           import_export_class (ctype);
2510           if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2511             {
2512               DECL_NOT_REALLY_EXTERN (decl)
2513                 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2514                      || (DECL_DECLARED_INLINE_P (decl) 
2515                          && ! flag_implement_inlines
2516                          && !DECL_VINDEX (decl)));
2517
2518               /* Always make artificials weak.  */
2519               if (DECL_ARTIFICIAL (decl) && flag_weak)
2520                 comdat_linkage (decl);
2521               else
2522                 maybe_make_one_only (decl);
2523             }
2524         }
2525       else
2526         comdat_linkage (decl);
2527     }
2528   else if (tinfo_decl_p (decl, 0))
2529     {
2530       tree ctype = TREE_TYPE (DECL_NAME (decl));
2531
2532       if (IS_AGGR_TYPE (ctype))
2533         import_export_class (ctype);
2534
2535       if (IS_AGGR_TYPE (ctype) && CLASSTYPE_INTERFACE_KNOWN (ctype)
2536           && TYPE_POLYMORPHIC_P (ctype)
2537           /* If -fno-rtti, we're not necessarily emitting this stuff with
2538              the class, so go ahead and emit it now.  This can happen
2539              when a class is used in exception handling.  */
2540           && flag_rtti
2541           /* If the type is a cv-qualified variant of a type, then we
2542              must emit the tinfo function in this translation unit
2543              since it will not be emitted when the vtable for the type
2544              is output (which is when the unqualified version is
2545              generated).  */
2546           && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype)))
2547         {
2548           DECL_NOT_REALLY_EXTERN (decl)
2549             = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2550                  || (DECL_DECLARED_INLINE_P (decl) 
2551                      && ! flag_implement_inlines
2552                      && !DECL_VINDEX (decl)));
2553
2554           /* Always make artificials weak.  */
2555           if (flag_weak)
2556             comdat_linkage (decl);
2557         }
2558       else if (TYPE_BUILT_IN (ctype) 
2559                && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype)))
2560         DECL_NOT_REALLY_EXTERN (decl) = 0;
2561       else
2562         comdat_linkage (decl);
2563     } 
2564   else
2565     comdat_linkage (decl);
2566
2567   DECL_INTERFACE_KNOWN (decl) = 1;
2568 }
2569
2570 tree
2571 build_cleanup (decl)
2572      tree decl;
2573 {
2574   tree temp;
2575   tree type = TREE_TYPE (decl);
2576
2577   if (TREE_CODE (type) == ARRAY_TYPE)
2578     temp = decl;
2579   else
2580     {
2581       mark_addressable (decl);
2582       temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
2583     }
2584   temp = build_delete (TREE_TYPE (temp), temp,
2585                        sfk_complete_destructor,
2586                        LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
2587   return temp;
2588 }
2589
2590 /* Returns the initialization guard variable for the variable DECL,
2591    which has static storage duration.  */
2592
2593 tree
2594 get_guard (decl)
2595      tree decl;
2596 {
2597   tree sname;
2598   tree guard;
2599
2600   sname = mangle_guard_variable (decl);
2601   guard = IDENTIFIER_GLOBAL_VALUE (sname);
2602   if (! guard)
2603     {
2604       tree guard_type;
2605
2606       /* We use a type that is big enough to contain a mutex as well
2607          as an integer counter.  */
2608       guard_type = long_long_integer_type_node;
2609       guard = build_decl (VAR_DECL, sname, guard_type);
2610       
2611       /* The guard should have the same linkage as what it guards. */
2612       TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
2613       TREE_STATIC (guard) = TREE_STATIC (decl);
2614       DECL_COMMON (guard) = DECL_COMMON (decl);
2615       DECL_ONE_ONLY (guard) = DECL_ONE_ONLY (decl);
2616       if (TREE_PUBLIC (decl))
2617         DECL_WEAK (guard) = DECL_WEAK (decl);
2618       
2619       DECL_ARTIFICIAL (guard) = 1;
2620       TREE_USED (guard) = 1;
2621       pushdecl_top_level (guard);
2622       cp_finish_decl (guard, NULL_TREE, NULL_TREE, 0);
2623     }
2624   return guard;
2625 }
2626
2627 /* Return those bits of the GUARD variable that should be set when the
2628    guarded entity is actually initialized.  */
2629
2630 static tree
2631 get_guard_bits (guard)
2632      tree guard;
2633 {
2634   /* We only set the first byte of the guard, in order to leave room
2635      for a mutex in the high-order bits.  */
2636   guard = build1 (ADDR_EXPR, 
2637                   build_pointer_type (TREE_TYPE (guard)),
2638                   guard);
2639   guard = build1 (NOP_EXPR, 
2640                   build_pointer_type (char_type_node), 
2641                   guard);
2642   guard = build1 (INDIRECT_REF, char_type_node, guard);
2643
2644   return guard;
2645 }
2646
2647 /* Return an expression which determines whether or not the GUARD
2648    variable has already been initialized.  */
2649
2650 tree
2651 get_guard_cond (guard)
2652      tree guard;
2653 {
2654   tree guard_value;
2655
2656   /* Check to see if the GUARD is zero.  */
2657   guard = get_guard_bits (guard);
2658   guard_value = integer_zero_node;
2659   if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2660     guard_value = convert (TREE_TYPE (guard), guard_value);
2661   return cp_build_binary_op (EQ_EXPR, guard, guard_value);
2662 }
2663
2664 /* Return an expression which sets the GUARD variable, indicating that
2665    the variable being guarded has been initialized.  */
2666
2667 tree
2668 set_guard (guard)
2669      tree guard;
2670 {
2671   tree guard_init;
2672
2673   /* Set the GUARD to one.  */
2674   guard = get_guard_bits (guard);
2675   guard_init = integer_one_node;
2676   if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
2677     guard_init = convert (TREE_TYPE (guard), guard_init);
2678   return build_modify_expr (guard, NOP_EXPR, guard_init);
2679 }
2680
2681 /* Start the process of running a particular set of global constructors
2682    or destructors.  Subroutine of do_[cd]tors.  */
2683
2684 static tree
2685 start_objects (method_type, initp)
2686      int method_type, initp;
2687 {
2688   tree fnname;
2689   tree body;
2690   char type[10];
2691
2692   /* Make ctor or dtor function.  METHOD_TYPE may be 'I' or 'D'.  */
2693
2694   if (initp != DEFAULT_INIT_PRIORITY)
2695     {
2696       char joiner;
2697
2698 #ifdef JOINER
2699       joiner = JOINER;
2700 #else
2701       joiner = '_';
2702 #endif
2703
2704       sprintf (type, "%c%c%.5u", method_type, joiner, initp);
2705     }
2706   else
2707     sprintf (type, "%c", method_type);
2708
2709   fnname = get_file_function_name_long (type);
2710
2711   start_function (void_list_node,
2712                   make_call_declarator (fnname, void_list_node, NULL_TREE,
2713                                         NULL_TREE),
2714                   NULL_TREE, SF_DEFAULT);
2715
2716   /* It can be a static function as long as collect2 does not have
2717      to scan the object file to find its ctor/dtor routine.  */
2718   TREE_PUBLIC (current_function_decl) = ! targetm.have_ctors_dtors;
2719
2720   /* Mark this declaration as used to avoid spurious warnings.  */
2721   TREE_USED (current_function_decl) = 1;
2722
2723   /* Mark this function as a global constructor or destructor.  */
2724   if (method_type == 'I')
2725     DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
2726   else
2727     DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
2728   GLOBAL_INIT_PRIORITY (current_function_decl) = initp;
2729
2730   body = begin_compound_stmt (/*has_no_scope=*/0);
2731
2732   /* We cannot allow these functions to be elided, even if they do not
2733      have external linkage.  And, there's no point in deferring
2734      copmilation of thes functions; they're all going to have to be
2735      out anyhow.  */
2736   current_function_cannot_inline
2737     = "static constructors and destructors cannot be inlined";
2738
2739   return body;
2740 }
2741
2742 /* Finish the process of running a particular set of global constructors
2743    or destructors.  Subroutine of do_[cd]tors.  */
2744
2745 static void
2746 finish_objects (method_type, initp, body)
2747      int method_type, initp;
2748      tree body;
2749 {
2750   tree fn;
2751
2752   /* Finish up.  */
2753   finish_compound_stmt (/*has_no_scope=*/0, body);
2754   fn = finish_function (0);
2755   expand_body (fn);
2756
2757   /* When only doing semantic analysis, and no RTL generation, we
2758      can't call functions that directly emit assembly code; there is
2759      no assembly file in which to put the code.  */
2760   if (flag_syntax_only)
2761     return;
2762
2763   if (targetm.have_ctors_dtors)
2764     {
2765       rtx fnsym = XEXP (DECL_RTL (fn), 0);
2766       if (method_type == 'I')
2767         (* targetm.asm_out.constructor) (fnsym, initp);
2768       else
2769         (* targetm.asm_out.destructor) (fnsym, initp);
2770     }
2771 }
2772
2773 /* The names of the parameters to the function created to handle
2774    initializations and destructions for objects with static storage
2775    duration.  */
2776 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2777 #define PRIORITY_IDENTIFIER "__priority"
2778
2779 /* The name of the function we create to handle initializations and
2780    destructions for objects with static storage duration.  */
2781 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2782
2783 /* The declaration for the __INITIALIZE_P argument.  */
2784 static tree initialize_p_decl;
2785
2786 /* The declaration for the __PRIORITY argument.  */
2787 static tree priority_decl;
2788
2789 /* The declaration for the static storage duration function.  */
2790 static tree ssdf_decl;
2791
2792 /* All the static storage duration functions created in this
2793    translation unit.  */
2794 static varray_type ssdf_decls;
2795
2796 /* A map from priority levels to information about that priority
2797    level.  There may be many such levels, so efficient lookup is
2798    important.  */
2799 static splay_tree priority_info_map;
2800
2801 /* Begins the generation of the function that will handle all
2802    initialization and destruction of objects with static storage
2803    duration.  The function generated takes two parameters of type
2804    `int': __INITIALIZE_P and __PRIORITY.  If __INITIALIZE_P is
2805    non-zero, it performs initializations.  Otherwise, it performs
2806    destructions.  It only performs those initializations or
2807    destructions with the indicated __PRIORITY.  The generated function
2808    returns no value.  
2809
2810    It is assumed that this function will only be called once per
2811    translation unit.  */
2812
2813 static tree
2814 start_static_storage_duration_function ()
2815 {
2816   static unsigned ssdf_number;
2817
2818   tree parm_types;
2819   tree type;
2820   tree body;
2821   char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2822
2823   /* Create the identifier for this function.  It will be of the form
2824      SSDF_IDENTIFIER_<number>.  */
2825   sprintf (id, "%s_%u", SSDF_IDENTIFIER, ssdf_number++);
2826   if (ssdf_number == 0)
2827     {
2828       /* Overflow occurred.  That means there are at least 4 billion
2829          initialization functions.  */
2830       sorry ("too many initialization functions required");
2831       abort ();
2832     }
2833
2834   /* Create the parameters.  */
2835   parm_types = void_list_node;
2836   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2837   parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2838   type = build_function_type (void_type_node, parm_types);
2839
2840   /* Create the FUNCTION_DECL itself.  */
2841   ssdf_decl = build_lang_decl (FUNCTION_DECL, 
2842                                get_identifier (id),
2843                                type);
2844   TREE_PUBLIC (ssdf_decl) = 0;
2845   DECL_ARTIFICIAL (ssdf_decl) = 1;
2846
2847   /* Put this function in the list of functions to be called from the
2848      static constructors and destructors.  */
2849   if (!ssdf_decls)
2850     {
2851       VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2852
2853       /* Take this opportunity to initialize the map from priority
2854          numbers to information about that priority level. */
2855       priority_info_map = splay_tree_new (splay_tree_compare_ints,
2856                                           /*delete_key_fn=*/0,
2857                                           /*delete_value_fn=*/
2858                                           (splay_tree_delete_value_fn) &free);
2859
2860       /* We always need to generate functions for the
2861          DEFAULT_INIT_PRIORITY so enter it now.  That way when we walk
2862          priorities later, we'll be sure to find the
2863          DEFAULT_INIT_PRIORITY.  */
2864       get_priority_info (DEFAULT_INIT_PRIORITY);
2865     }
2866
2867   VARRAY_PUSH_TREE (ssdf_decls, ssdf_decl);
2868
2869   /* Create the argument list.  */
2870   initialize_p_decl = build_decl (PARM_DECL,
2871                                   get_identifier (INITIALIZE_P_IDENTIFIER),
2872                                   integer_type_node);
2873   DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2874   DECL_ARG_TYPE (initialize_p_decl) = integer_type_node;
2875   TREE_USED (initialize_p_decl) = 1;
2876   priority_decl = build_decl (PARM_DECL, get_identifier (PRIORITY_IDENTIFIER),
2877                               integer_type_node);
2878   DECL_CONTEXT (priority_decl) = ssdf_decl;
2879   DECL_ARG_TYPE (priority_decl) = integer_type_node;
2880   TREE_USED (priority_decl) = 1;
2881
2882   TREE_CHAIN (initialize_p_decl) = priority_decl;
2883   DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2884
2885   /* Put the function in the global scope.  */
2886   pushdecl (ssdf_decl);
2887
2888   /* Start the function itself.  This is equivalent to declarating the
2889      function as:
2890
2891        static void __ssdf (int __initialize_p, init __priority_p);
2892        
2893      It is static because we only need to call this function from the
2894      various constructor and destructor functions for this module.  */
2895   start_function (/*specs=*/NULL_TREE, 
2896                   ssdf_decl,
2897                   /*attrs=*/NULL_TREE,
2898                   SF_PRE_PARSED);
2899
2900   /* Set up the scope of the outermost block in the function.  */
2901   body = begin_compound_stmt (/*has_no_scope=*/0);
2902
2903   /* This function must not be deferred because we are depending on
2904      its compilation to tell us what is TREE_SYMBOL_REFERENCED.  */
2905   current_function_cannot_inline 
2906     = "static storage duration functions cannot be inlined";
2907
2908   return body;
2909 }
2910
2911 /* Finish the generation of the function which performs initialization
2912    and destruction of objects with static storage duration.  After
2913    this point, no more such objects can be created.  */
2914
2915 static void
2916 finish_static_storage_duration_function (body)
2917      tree body;
2918 {
2919   /* Close out the function.  */
2920   finish_compound_stmt (/*has_no_scope=*/0, body);
2921   expand_body (finish_function (0));
2922 }
2923
2924 /* Return the information about the indicated PRIORITY level.  If no
2925    code to handle this level has yet been generated, generate the
2926    appropriate prologue.  */
2927
2928 static priority_info
2929 get_priority_info (priority)
2930      int priority;
2931 {
2932   priority_info pi;
2933   splay_tree_node n;
2934
2935   n = splay_tree_lookup (priority_info_map, 
2936                          (splay_tree_key) priority);
2937   if (!n)
2938     {
2939       /* Create a new priority information structure, and insert it
2940          into the map.  */
2941       pi = (priority_info) xmalloc (sizeof (struct priority_info_s));
2942       pi->initializations_p = 0;
2943       pi->destructions_p = 0;
2944       splay_tree_insert (priority_info_map,
2945                          (splay_tree_key) priority,
2946                          (splay_tree_value) pi);
2947     }
2948   else
2949     pi = (priority_info) n->value;
2950
2951   return pi;
2952 }
2953
2954 /* Set up to handle the initialization or destruction of DECL.  If
2955    INITP is non-zero, we are initializing the variable.  Otherwise, we
2956    are destroying it.  */
2957
2958 static tree
2959 start_static_initialization_or_destruction (decl, initp)
2960      tree decl;
2961      int initp;
2962 {
2963   tree guard_if_stmt = NULL_TREE;
2964   int priority;
2965   tree cond;
2966   tree guard;
2967   tree init_cond;
2968   priority_info pi;
2969
2970   /* Figure out the priority for this declaration.  */
2971   priority = DECL_INIT_PRIORITY (decl);
2972   if (!priority)
2973     priority = DEFAULT_INIT_PRIORITY;
2974
2975   /* Remember that we had an initialization or finalization at this
2976      priority.  */
2977   pi = get_priority_info (priority);
2978   if (initp)
2979     pi->initializations_p = 1;
2980   else
2981     pi->destructions_p = 1;
2982
2983   /* Trick the compiler into thinking we are at the file and line
2984      where DECL was declared so that error-messages make sense, and so
2985      that the debugger will show somewhat sensible file and line
2986      information.  */
2987   input_filename = DECL_SOURCE_FILE (decl);
2988   lineno = DECL_SOURCE_LINE (decl);
2989
2990   /* Because of:
2991
2992        [class.access.spec]
2993
2994        Access control for implicit calls to the constructors,
2995        the conversion functions, or the destructor called to
2996        create and destroy a static data member is performed as
2997        if these calls appeared in the scope of the member's
2998        class.  
2999
3000      we pretend we are in a static member function of the class of
3001      which the DECL is a member.  */
3002   if (member_p (decl))
3003     {
3004       DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3005       DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3006     }
3007   
3008   /* Conditionalize this initialization on being in the right priority
3009      and being initializing/finalizing appropriately.  */
3010   guard_if_stmt = begin_if_stmt ();
3011   cond = cp_build_binary_op (EQ_EXPR,
3012                              priority_decl,
3013                              build_int_2 (priority, 0));
3014   init_cond = initp ? integer_one_node : integer_zero_node;
3015   init_cond = cp_build_binary_op (EQ_EXPR,
3016                                   initialize_p_decl,
3017                                   init_cond);
3018   cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
3019
3020   /* Assume we don't need a guard.  */
3021   guard = NULL_TREE;
3022   /* We need a guard if this is an object with external linkage that
3023      might be initialized in more than one place.  (For example, a
3024      static data member of a template, when the data member requires
3025      construction.)  */
3026   if (TREE_PUBLIC (decl) && (DECL_COMMON (decl) 
3027                              || DECL_ONE_ONLY (decl)
3028                              || DECL_WEAK (decl)))
3029     {
3030       tree guard_cond;
3031
3032       guard = get_guard (decl);
3033
3034       /* When using __cxa_atexit, we just check the GUARD as we would
3035          for a local static.  */
3036       if (flag_use_cxa_atexit)
3037         {
3038           /* When using __cxa_atexit, we never try to destroy
3039              anything from a static destructor.  */
3040           my_friendly_assert (initp, 20000629);
3041           guard_cond = get_guard_cond (guard);
3042         }
3043       /* If we don't have __cxa_atexit, then we will be running
3044          destructors from .fini sections, or their equivalents.  So,
3045          we need to know how many times we've tried to initialize this
3046          object.  We do initializations only if the GUARD is zero,
3047          i.e., if we are the first to initialize the variable.  We do
3048          destructions only if the GUARD is one, i.e., if we are the
3049          last to destroy the variable.  */
3050       else if (initp)
3051         guard_cond 
3052           = cp_build_binary_op (EQ_EXPR,
3053                                 build_unary_op (PREINCREMENT_EXPR,
3054                                                 guard,
3055                                                 /*noconvert=*/1),
3056                                 integer_one_node);
3057       else
3058         guard_cond 
3059           = cp_build_binary_op (EQ_EXPR,
3060                                 build_unary_op (PREDECREMENT_EXPR,
3061                                                 guard,
3062                                                 /*noconvert=*/1),
3063                                 integer_zero_node);
3064
3065       cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, guard_cond);
3066     }
3067
3068   finish_if_stmt_cond (cond, guard_if_stmt);
3069
3070   /* If we're using __cxa_atexit, we have not already set the GUARD,
3071      so we must do so now.  */
3072   if (guard && initp && flag_use_cxa_atexit)
3073     finish_expr_stmt (set_guard (guard));
3074
3075   return guard_if_stmt;
3076 }
3077
3078 /* We've just finished generating code to do an initialization or
3079    finalization.  GUARD_IF_STMT is the if-statement we used to guard
3080    the initialization.  */
3081
3082 static void
3083 finish_static_initialization_or_destruction (guard_if_stmt)
3084      tree guard_if_stmt;
3085 {
3086   finish_then_clause (guard_if_stmt);
3087   finish_if_stmt ();
3088
3089   /* Now that we're done with DECL we don't need to pretend to be a
3090      member of its class any longer.  */
3091   DECL_CONTEXT (current_function_decl) = NULL_TREE;
3092   DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3093 }
3094
3095 /* Generate code to do the static initialization of DECL.  The
3096    initialization is INIT.  If DECL may be initialized more than once
3097    in different object files, GUARD is the guard variable to 
3098    check.  PRIORITY is the priority for the initialization.  */
3099
3100 static void
3101 do_static_initialization (decl, init)
3102      tree decl;
3103      tree init;
3104 {
3105   tree expr;
3106   tree guard_if_stmt;
3107
3108   /* Set up for the initialization.  */
3109   guard_if_stmt
3110     = start_static_initialization_or_destruction (decl,
3111                                                   /*initp=*/1);
3112   
3113   /* Do the initialization itself.  */
3114   if (IS_AGGR_TYPE (TREE_TYPE (decl))
3115       || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
3116     expr = build_aggr_init (decl, init, 0);
3117   else
3118     {
3119       expr = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
3120       TREE_SIDE_EFFECTS (expr) = 1;
3121     }
3122   finish_expr_stmt (expr);
3123
3124   /* If we're using __cxa_atexit, register a a function that calls the
3125      destructor for the object.  */
3126   if (flag_use_cxa_atexit)
3127     register_dtor_fn (decl);
3128
3129   /* Finsh up.  */
3130   finish_static_initialization_or_destruction (guard_if_stmt);
3131 }
3132
3133 /* Generate code to do the static destruction of DECL.  If DECL may be
3134    initialized more than once in different object files, GUARD is the
3135    guard variable to check.  PRIORITY is the priority for the
3136    destruction.  */
3137
3138 static void
3139 do_static_destruction (decl)
3140      tree decl;
3141 {
3142   tree guard_if_stmt;
3143
3144   /* If we're using __cxa_atexit, then destructors are registered
3145      immediately after objects are initialized.  */
3146   my_friendly_assert (!flag_use_cxa_atexit, 20000121);
3147
3148   /* If we don't need a destructor, there's nothing to do.  */
3149   if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3150     return;
3151
3152   /* Actually do the destruction.  */
3153   guard_if_stmt = start_static_initialization_or_destruction (decl,
3154                                                                /*initp=*/0);
3155   finish_expr_stmt (build_cleanup (decl));
3156   finish_static_initialization_or_destruction (guard_if_stmt);
3157 }
3158
3159 /* VARS is a list of variables with static storage duration which may
3160    need initialization and/or finalization.  Remove those variables
3161    that don't really need to be initialized or finalized, and return
3162    the resulting list.  The order in which the variables appear in
3163    VARS is in reverse order of the order in which they should actually
3164    be initialized.  The list we return is in the unreversed order;
3165    i.e., the first variable should be initialized first.  */
3166
3167 static tree
3168 prune_vars_needing_no_initialization (vars)
3169      tree vars;
3170 {
3171   tree var;
3172   tree result;
3173
3174   for (var = vars, result = NULL_TREE;
3175        var;
3176        var = TREE_CHAIN (var))
3177     {
3178       tree decl = TREE_VALUE (var);
3179       tree init = TREE_PURPOSE (var);
3180
3181       /* Deal gracefully with error.  */
3182       if (decl == error_mark_node)
3183         continue;
3184
3185       /* The only things that can be initialized are variables.  */
3186       my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
3187
3188       /* If this object is not defined, we don't need to do anything
3189          here.  */
3190       if (DECL_EXTERNAL (decl))
3191         continue;
3192
3193       /* Also, if the initializer already contains errors, we can bail
3194          out now.  */
3195       if (init && TREE_CODE (init) == TREE_LIST 
3196           && value_member (error_mark_node, init))
3197         continue;
3198
3199       /* This variable is going to need initialization and/or
3200          finalization, so we add it to the list.  */
3201       result = tree_cons (init, decl, result);
3202     }
3203
3204   return result;
3205 }
3206
3207 /* Make sure we have told the back end about all the variables in
3208    VARS.  */
3209
3210 static void
3211 write_out_vars (vars)
3212      tree vars;
3213 {
3214   tree v;
3215
3216   for (v = vars; v; v = TREE_CHAIN (v))
3217     if (! TREE_ASM_WRITTEN (TREE_VALUE (v)))
3218       rest_of_decl_compilation (TREE_VALUE (v), 0, 1, 1);
3219 }
3220
3221 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3222    (otherwise) that will initialize all gobal objects with static
3223    storage duration having the indicated PRIORITY.  */
3224
3225 static void
3226 generate_ctor_or_dtor_function (constructor_p, priority)
3227      int constructor_p;
3228      int priority;
3229 {
3230   char function_key;
3231   tree arguments;
3232   tree body;
3233   size_t i;
3234
3235   /* We use `I' to indicate initialization and `D' to indicate
3236      destruction.  */
3237   if (constructor_p)
3238     function_key = 'I';
3239   else
3240     function_key = 'D';
3241
3242   /* Begin the function.  */
3243   body = start_objects (function_key, priority);
3244
3245   /* Call the static storage duration function with appropriate
3246      arguments.  */
3247   for (i = 0; i < ssdf_decls->elements_used; ++i) 
3248     {
3249       arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0), 
3250                              NULL_TREE);
3251       arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
3252                              arguments);
3253       finish_expr_stmt (build_function_call (VARRAY_TREE (ssdf_decls, i),
3254                                              arguments));
3255     }
3256
3257   /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
3258      calls to any functions marked with attributes indicating that
3259      they should be called at initialization- or destruction-time.  */
3260   if (priority == DEFAULT_INIT_PRIORITY)
3261     {
3262       tree fns;
3263       
3264       for (fns = constructor_p ? static_ctors : static_dtors; 
3265            fns;
3266            fns = TREE_CHAIN (fns))
3267         finish_expr_stmt (build_function_call (TREE_VALUE (fns), NULL_TREE));
3268     }
3269
3270   /* Close out the function.  */
3271   finish_objects (function_key, priority, body);
3272 }
3273
3274 /* Generate constructor and destructor functions for the priority
3275    indicated by N.  */
3276
3277 static int
3278 generate_ctor_and_dtor_functions_for_priority (n, data)
3279      splay_tree_node n;
3280      void *data ATTRIBUTE_UNUSED;
3281 {
3282   int priority = (int) n->key;
3283   priority_info pi = (priority_info) n->value;
3284
3285   /* Generate the functions themselves, but only if they are really
3286      needed.  */
3287   if (pi->initializations_p
3288       || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
3289     generate_ctor_or_dtor_function (/*constructor_p=*/1,
3290                                     priority);
3291   if (pi->destructions_p
3292       || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
3293     generate_ctor_or_dtor_function (/*constructor_p=*/0,
3294                                     priority);
3295
3296   /* Keep iterating.  */
3297   return 0;
3298 }
3299
3300 /* This routine is called from the last rule in yyparse ().
3301    Its job is to create all the code needed to initialize and
3302    destroy the global aggregates.  We do the destruction
3303    first, since that way we only need to reverse the decls once.  */
3304
3305 void
3306 finish_file ()
3307 {
3308   tree vars;
3309   int reconsider;
3310   size_t i;
3311
3312   at_eof = 1;
3313
3314   /* Bad parse errors.  Just forget about it.  */
3315   if (! global_bindings_p () || current_class_type || decl_namespace_list)
3316     return;
3317
3318   /* Otherwise, GDB can get confused, because in only knows
3319      about source for LINENO-1 lines.  */
3320   lineno -= 1;
3321
3322   interface_unknown = 1;
3323   interface_only = 0;
3324
3325   /* We now have to write out all the stuff we put off writing out.
3326      These include:
3327
3328        o Template specializations that we have not yet instantiated,
3329          but which are needed.
3330        o Initialization and destruction for non-local objects with
3331          static storage duration.  (Local objects with static storage
3332          duration are initialized when their scope is first entered,
3333          and are cleaned up via atexit.)
3334        o Virtual function tables.  
3335
3336      All of these may cause others to be needed.  For example,
3337      instantiating one function may cause another to be needed, and
3338      generating the intiailzer for an object may cause templates to be
3339      instantiated, etc., etc.  */
3340
3341   timevar_push (TV_VARCONST);
3342
3343   emit_support_tinfos ();
3344   
3345   do 
3346     {
3347       reconsider = 0;
3348
3349       /* If there are templates that we've put off instantiating, do
3350          them now.  */
3351       instantiate_pending_templates ();
3352
3353       /* Write out virtual tables as required.  Note that writing out
3354          the virtual table for a template class may cause the
3355          instantiation of members of that class.  */
3356       if (walk_globals (vtable_decl_p,
3357                         finish_vtable_vardecl,
3358                         /*data=*/0))
3359         reconsider = 1;
3360       
3361       /* Write out needed type info variables. Writing out one variable
3362          might cause others to be needed.  */
3363       if (walk_globals (tinfo_decl_p, emit_tinfo_decl, /*data=*/0))
3364         reconsider = 1;
3365
3366       /* The list of objects with static storage duration is built up
3367          in reverse order.  We clear STATIC_AGGREGATES so that any new
3368          aggregates added during the initialization of these will be
3369          initialized in the correct order when we next come around the
3370          loop.  */
3371       vars = prune_vars_needing_no_initialization (static_aggregates);
3372       static_aggregates = NULL_TREE;
3373
3374       if (vars)
3375         {
3376           tree v;
3377
3378           /* We need to start a new initialization function each time
3379              through the loop.  That's because we need to know which
3380              vtables have been referenced, and TREE_SYMBOL_REFERENCED
3381              isn't computed until a function is finished, and written
3382              out.  That's a deficiency in the back-end.  When this is
3383              fixed, these initialization functions could all become
3384              inline, with resulting performance improvements.  */
3385           tree ssdf_body = start_static_storage_duration_function ();
3386
3387           /* Make sure the back end knows about all the variables.  */
3388           write_out_vars (vars);
3389
3390           /* First generate code to do all the initializations.  */
3391           for (v = vars; v; v = TREE_CHAIN (v))
3392             do_static_initialization (TREE_VALUE (v),
3393                                       TREE_PURPOSE (v));
3394
3395           /* Then, generate code to do all the destructions.  Do these
3396              in reverse order so that the most recently constructed
3397              variable is the first destroyed.  If we're using
3398              __cxa_atexit, then we don't need to do this; functions
3399              were registered at initialization time to destroy the
3400              local statics.  */
3401           if (!flag_use_cxa_atexit)
3402             {
3403               vars = nreverse (vars);
3404               for (v = vars; v; v = TREE_CHAIN (v))
3405                 do_static_destruction (TREE_VALUE (v));
3406             }
3407           else
3408             vars = NULL_TREE;
3409
3410           /* Finish up the static storage duration function for this
3411              round.  */
3412           finish_static_storage_duration_function (ssdf_body);
3413
3414           /* All those initializations and finalizations might cause
3415              us to need more inline functions, more template
3416              instantiations, etc.  */
3417           reconsider = 1;
3418         }
3419       
3420       /* Go through the various inline functions, and see if any need
3421          synthesizing.  */
3422       for (i = 0; i < deferred_fns_used; ++i)
3423         {
3424           tree decl = VARRAY_TREE (deferred_fns, i);
3425           import_export_decl (decl);
3426           if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
3427               && TREE_USED (decl)
3428               && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
3429             {
3430               /* Even though we're already at the top-level, we push
3431                  there again.  That way, when we pop back a few lines
3432                  hence, all of our state is restored.  Otherwise,
3433                  finish_function doesn't clean things up, and we end
3434                  up with CURRENT_FUNCTION_DECL set.  */
3435               push_to_top_level ();
3436               synthesize_method (decl);
3437               pop_from_top_level ();
3438               reconsider = 1;
3439             }
3440         }
3441
3442       /* We lie to the back-end, pretending that some functions are
3443          not defined when they really are.  This keeps these functions
3444          from being put out unnecessarily.  But, we must stop lying
3445          when the functions are referenced, or if they are not comdat
3446          since they need to be put out now.  */
3447       for (i = 0; i < deferred_fns_used; ++i)
3448         {
3449           tree decl = VARRAY_TREE (deferred_fns, i);
3450       
3451           if (DECL_NOT_REALLY_EXTERN (decl)
3452               && DECL_INITIAL (decl)
3453               && DECL_NEEDED_P (decl))
3454             DECL_EXTERNAL (decl) = 0;
3455
3456           /* If we're going to need to write this function out, and
3457              there's already a body for it, create RTL for it now.
3458              (There might be no body if this is a method we haven't
3459              gotten around to synthesizing yet.)  */
3460           if (!DECL_EXTERNAL (decl)
3461               && DECL_NEEDED_P (decl)
3462               && DECL_SAVED_TREE (decl)
3463               && !TREE_ASM_WRITTEN (decl))
3464             {
3465               int saved_not_really_extern;
3466
3467               /* When we call finish_function in expand_body, it will
3468                  try to reset DECL_NOT_REALLY_EXTERN so we save and
3469                  restore it here.  */
3470               saved_not_really_extern = DECL_NOT_REALLY_EXTERN (decl);
3471               /* Generate RTL for this function now that we know we
3472                  need it.  */
3473               expand_body (decl);
3474               /* Undo the damage done by finish_function.  */
3475               DECL_EXTERNAL (decl) = 0;
3476               DECL_NOT_REALLY_EXTERN (decl) = saved_not_really_extern;
3477               /* If we're compiling -fsyntax-only pretend that this
3478                  function has been written out so that we don't try to
3479                  expand it again.  */
3480               if (flag_syntax_only)
3481                 TREE_ASM_WRITTEN (decl) = 1;
3482               reconsider = 1;
3483             }
3484         }
3485
3486       if (deferred_fns_used
3487           && wrapup_global_declarations (&VARRAY_TREE (deferred_fns, 0),
3488                                          deferred_fns_used))
3489         reconsider = 1;
3490       if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3491         reconsider = 1;
3492
3493       /* Static data members are just like namespace-scope globals.  */
3494       for (i = 0; i < pending_statics_used; ++i) 
3495         {
3496           tree decl = VARRAY_TREE (pending_statics, i);
3497           if (TREE_ASM_WRITTEN (decl))
3498             continue;
3499           import_export_decl (decl);
3500           if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
3501             DECL_EXTERNAL (decl) = 0;
3502         }
3503       if (pending_statics
3504           && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
3505                                          pending_statics_used))
3506         reconsider = 1;
3507     } 
3508   while (reconsider);
3509
3510   /* We give C linkage to static constructors and destructors.  */
3511   push_lang_context (lang_name_c);
3512
3513   /* Generate initialization and destruction functions for all
3514      priorities for which they are required.  */
3515   if (priority_info_map)
3516     splay_tree_foreach (priority_info_map, 
3517                         generate_ctor_and_dtor_functions_for_priority,
3518                         /*data=*/0);
3519
3520   /* We're done with the splay-tree now.  */
3521   if (priority_info_map)
3522     splay_tree_delete (priority_info_map);
3523
3524   /* We're done with static constructors, so we can go back to "C++"
3525      linkage now.  */
3526   pop_lang_context ();
3527
3528   /* Now delete from the chain of variables all virtual function tables.
3529      We output them all ourselves, because each will be treated
3530      specially.  We don't do this if we're just doing semantic
3531      analysis, and not code-generation.  */
3532   if (!flag_syntax_only)
3533     walk_globals (vtable_decl_p, prune_vtable_vardecl, /*data=*/0);
3534
3535   /* Now, issue warnings about static, but not defined, functions,
3536      etc., and emit debugging information.  */
3537   walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
3538   if (pending_statics)
3539     check_global_declarations (&VARRAY_TREE (pending_statics, 0),
3540                                pending_statics_used);
3541
3542   finish_repo ();
3543
3544   /* The entire file is now complete.  If requested, dump everything
3545      to a file.   */
3546   {
3547     int flags;
3548     FILE *stream = dump_begin (TDI_all, &flags);
3549
3550     if (stream)
3551       {
3552         dump_node (global_namespace, flags & ~TDF_SLIM, stream);
3553         dump_end (TDI_all, stream);
3554       }
3555   }
3556   
3557   timevar_pop (TV_VARCONST);
3558
3559   if (flag_detailed_statistics)
3560     {
3561       dump_tree_statistics ();
3562       dump_time_statistics ();
3563     }
3564 }
3565
3566 /* This is something of the form 'A()()()()()+1' that has turned out to be an
3567    expr.  Since it was parsed like a type, we need to wade through and fix
3568    that.  Unfortunately, since operator() is left-associative, we can't use
3569    tail recursion.  In the above example, TYPE is `A', and DECL is
3570    `()()()()()'.
3571
3572    Maybe this shouldn't be recursive, but how often will it actually be
3573    used?  (jason) */
3574
3575 tree
3576 reparse_absdcl_as_expr (type, decl)
3577      tree type, decl;
3578 {
3579   /* do build_functional_cast (type, NULL_TREE) at bottom */
3580   if (TREE_OPERAND (decl, 0) == NULL_TREE)
3581     return build_functional_cast (type, NULL_TREE);
3582
3583   /* recurse */
3584   decl = reparse_absdcl_as_expr (type, TREE_OPERAND (decl, 0));
3585