]> gcc.gnu.org Git - gcc.git/blame_incremental - gcc/cp/decl2.c
c-parse.in (compstmt_primary_start): New, broken out of first part of compstmt handli...
[gcc.git] / gcc / cp / decl2.c
... / ...
CommitLineData
1/* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-98, 1999 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5This file is part of GNU CC.
6
7GNU CC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GNU CC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GNU CC; see the file COPYING. If not, write to
19the Free Software Foundation, 59 Temple Place - Suite 330,
20Boston, MA 02111-1307, USA. */
21
22
23/* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
26
27/* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
29
30#include "config.h"
31#include "system.h"
32#include "tree.h"
33#include "rtl.h"
34#include "flags.h"
35#include "cp-tree.h"
36#include "decl.h"
37#include "lex.h"
38#include "output.h"
39#include "except.h"
40#include "function.h"
41#include "expr.h"
42#include "defaults.h"
43#include "toplev.h"
44#include "dwarf2out.h"
45#include "dwarfout.h"
46#include "splay-tree.h"
47#include "varray.h"
48
49#if USE_CPPLIB
50#include "cpplib.h"
51extern cpp_reader parse_in;
52#endif
53
54/* This structure contains information about the initializations
55 and/or destructions required for a particular priority level. */
56typedef struct priority_info_s {
57 /* A label indicating where we should generate the next
58 initialization with this priority. */
59 rtx initialization_sequence;
60 /* A label indicating where we should generate the next destruction
61 with this priority. */
62 rtx destruction_sequence;
63 /* Non-zero if there have been any initializations at this priority
64 throughout the translation unit. */
65 int initializations_p;
66 /* Non-zero if there have been any destructions at this priority
67 throughout the translation unit. */
68 int destructions_p;
69} *priority_info;
70
71static tree get_sentry PROTO((tree));
72static void mark_vtable_entries PROTO((tree));
73static void grok_function_init PROTO((tree, tree));
74static int finish_vtable_vardecl PROTO((tree *, void *));
75static int prune_vtable_vardecl PROTO((tree *, void *));
76static int is_namespace_ancestor PROTO((tree, tree));
77static void add_using_namespace PROTO((tree, tree, int));
78static tree ambiguous_decl PROTO((tree, tree, tree,int));
79static tree build_anon_union_vars PROTO((tree, tree*, int, int));
80static int acceptable_java_type PROTO((tree));
81static void output_vtable_inherit PROTO((tree));
82static void start_objects PROTO((int, int));
83static void finish_objects PROTO((int, int));
84static tree merge_functions PROTO((tree, tree));
85static tree decl_namespace PROTO((tree));
86static tree validate_nonmember_using_decl PROTO((tree, tree *, tree *));
87static void do_nonmember_using_decl PROTO((tree, tree, tree, tree,
88 tree *, tree *));
89static void start_static_storage_duration_function PROTO((void));
90static int generate_inits_for_priority PROTO((splay_tree_node, void *));
91static void finish_static_storage_duration_function PROTO((void));
92static priority_info get_priority_info PROTO((int));
93static void do_static_initialization PROTO((tree, tree, tree, int));
94static void do_static_destruction PROTO((tree, tree, int));
95static void do_static_initialization_and_destruction PROTO((tree, tree));
96static void generate_ctor_or_dtor_function PROTO((int, int));
97static int generate_ctor_and_dtor_functions_for_priority
98 PROTO((splay_tree_node, void *));
99extern int current_class_depth;
100
101/* A list of virtual function tables we must make sure to write out. */
102tree pending_vtables;
103
104/* A list of static class variables. This is needed, because a
105 static class variable can be declared inside the class without
106 an initializer, and then initialized, staticly, outside the class. */
107static varray_type pending_statics;
108static size_t pending_statics_used;
109
110/* A list of functions which were declared inline, but which we
111 may need to emit outline anyway. */
112static varray_type saved_inlines;
113static size_t saved_inlines_used;
114
115/* Used to help generate temporary names which are unique within
116 a function. Reset to 0 by start_function. */
117
118int temp_name_counter;
119
120/* Same, but not reset. Local temp variables and global temp variables
121 can have the same name. */
122static int global_temp_name_counter;
123
124/* Flag used when debugging spew.c */
125
126extern int spew_debug;
127
128/* Nonzero if we're done parsing and into end-of-file activities. */
129
130int at_eof;
131
132/* Functions called along with real static constructors and destructors. */
133
134tree static_ctors, static_dtors;
135
136/* The current open namespace, and ::. */
137
138tree current_namespace;
139tree global_namespace;
140
141/* The stack for namespaces of current declarations. */
142
143static tree decl_namespace_list;
144
145\f
146/* C (and C++) language-specific option variables. */
147
148/* Nonzero means allow type mismatches in conditional expressions;
149 just make their values `void'. */
150
151int flag_cond_mismatch;
152
153/* Nonzero means give `double' the same size as `float'. */
154
155int flag_short_double;
156
157/* Nonzero means don't recognize the keyword `asm'. */
158
159int flag_no_asm;
160
161/* Nonzero means don't recognize any extension keywords. */
162
163int flag_no_gnu_keywords;
164
165/* Nonzero means don't recognize the non-ANSI builtin functions. */
166
167int flag_no_builtin;
168
169/* Nonzero means don't recognize the non-ANSI builtin functions.
170 -ansi sets this. */
171
172int flag_no_nonansi_builtin;
173
174/* Nonzero means do some things the same way PCC does. Only provided so
175 the compiler will link. */
176
177int flag_traditional;
178
179/* Nonzero means to treat bitfields as unsigned unless they say `signed'. */
180
181int flag_signed_bitfields = 1;
182
183/* Nonzero means enable obscure ANSI features and disable GNU extensions
184 that might cause ANSI-compliant code to be miscompiled. */
185
186int flag_ansi;
187
188/* Nonzero means do emit exported implementations of functions even if
189 they can be inlined. */
190
191int flag_implement_inlines = 1;
192
193/* Nonzero means do emit exported implementations of templates, instead of
194 multiple static copies in each file that needs a definition. */
195
196int flag_external_templates;
197
198/* Nonzero means that the decision to emit or not emit the implementation of a
199 template depends on where the template is instantiated, rather than where
200 it is defined. */
201
202int flag_alt_external_templates;
203
204/* Nonzero means that implicit instantiations will be emitted if needed. */
205
206int flag_implicit_templates = 1;
207
208/* Nonzero means that implicit instantiations of inline templates will be
209 emitted if needed, even if instantiations of non-inline templates
210 aren't. */
211
212int flag_implicit_inline_templates = 1;
213
214/* Nonzero means warn about implicit declarations. */
215
216int warn_implicit = 1;
217
218/* Nonzero means warn about usage of long long when `-pedantic'. */
219
220int warn_long_long = 1;
221
222/* Nonzero means warn when all ctors or dtors are private, and the class
223 has no friends. */
224
225int warn_ctor_dtor_privacy = 1;
226
227/* True if we want to implement vtables using "thunks".
228 The default is off. */
229
230#ifndef DEFAULT_VTABLE_THUNKS
231#define DEFAULT_VTABLE_THUNKS 0
232#endif
233int flag_vtable_thunks = DEFAULT_VTABLE_THUNKS;
234
235/* Nonzero means generate separate instantiation control files and juggle
236 them at link time. */
237
238int flag_use_repository;
239
240/* Nonzero if we want to issue diagnostics that the standard says are not
241 required. */
242
243int flag_optional_diags = 1;
244
245/* Nonzero means give string constants the type `const char *', as mandated
246 by the standard. */
247
248int flag_const_strings = 1;
249
250/* If non-NULL, dump the tree structure for the entire translation
251 unit to this file. */
252
253char *flag_dump_translation_unit = 0;
254
255/* Nonzero means warn about deprecated conversion from string constant to
256 `char *'. */
257
258int warn_write_strings;
259
260/* Nonzero means warn about pointer casts that can drop a type qualifier
261 from the pointer target type. */
262
263int warn_cast_qual;
264
265/* Nonzero means warn about sizeof(function) or addition/subtraction
266 of function pointers. */
267
268int warn_pointer_arith = 1;
269
270/* Nonzero means warn for any function def without prototype decl. */
271
272int warn_missing_prototypes;
273
274/* Nonzero means warn about multiple (redundant) decls for the same single
275 variable or function. */
276
277int warn_redundant_decls;
278
279/* Warn if initializer is not completely bracketed. */
280
281int warn_missing_braces;
282
283/* Warn about comparison of signed and unsigned values. */
284
285int warn_sign_compare;
286
287/* Warn about *printf or *scanf format/argument anomalies. */
288
289int warn_format;
290
291/* Warn about a subscript that has type char. */
292
293int warn_char_subscripts;
294
295/* Warn if a type conversion is done that might have confusing results. */
296
297int warn_conversion;
298
299/* Warn if adding () is suggested. */
300
301int warn_parentheses;
302
303/* Non-zero means warn in function declared in derived class has the
304 same name as a virtual in the base class, but fails to match the
305 type signature of any virtual function in the base class. */
306int warn_overloaded_virtual;
307
308/* Non-zero means warn when declaring a class that has a non virtual
309 destructor, when it really ought to have a virtual one. */
310int warn_nonvdtor;
311
312/* Non-zero means warn when a function is declared extern and later inline. */
313int warn_extern_inline;
314
315/* Non-zero means warn when the compiler will reorder code. */
316int warn_reorder;
317
318/* Non-zero means warn when synthesis behavior differs from Cfront's. */
319int warn_synth;
320
321/* Non-zero means warn when we convert a pointer to member function
322 into a pointer to (void or function). */
323int warn_pmf2ptr = 1;
324
325/* Nonzero means warn about violation of some Effective C++ style rules. */
326
327int warn_ecpp;
328
329/* Nonzero means warn where overload resolution chooses a promotion from
330 unsigned to signed over a conversion to an unsigned of the same size. */
331
332int warn_sign_promo;
333
334/* Nonzero means warn when an old-style cast is used. */
335
336int warn_old_style_cast;
337
338/* Warn about #pragma directives that are not recognised. */
339
340int warn_unknown_pragmas; /* Tri state variable. */
341
342/* Nonzero means warn about use of multicharacter literals. */
343
344int warn_multichar = 1;
345
346/* Nonzero means warn when non-templatized friend functions are
347 declared within a template */
348
349int warn_nontemplate_friend = 1;
350
351/* Nonzero means complain about deprecated features. */
352
353int warn_deprecated = 1;
354
355/* Nonzero means `$' can be in an identifier. */
356
357#ifndef DOLLARS_IN_IDENTIFIERS
358#define DOLLARS_IN_IDENTIFIERS 1
359#endif
360int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
361
362/* Nonzero for -fno-strict-prototype switch: do not consider empty
363 argument prototype to mean function takes no arguments. */
364
365int flag_strict_prototype = 2;
366int strict_prototype = 1;
367int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus = 1;
368
369/* Nonzero means that labels can be used as first-class objects */
370
371int flag_labels_ok;
372
373/* Nonzero means allow Microsoft extensions without a pedwarn. */
374
375int flag_ms_extensions;
376
377/* Non-zero means to collect statistics which might be expensive
378 and to print them when we are done. */
379int flag_detailed_statistics;
380
381/* C++ specific flags. */
382/* Zero means that `this' is a *const. This gives nice behavior in the
383 2.0 world. 1 gives 1.2-compatible behavior. 2 gives Spring behavior.
384 -2 means we're constructing an object and it has fixed type. */
385
386int flag_this_is_variable;
387
388/* Nonzero means we should attempt to elide constructors when possible. */
389
390int flag_elide_constructors = 1;
391
392/* Nonzero means that member functions defined in class scope are
393 inline by default. */
394
395int flag_default_inline = 1;
396
397/* Controls whether compiler generates 'type descriptor' that give
398 run-time type information. */
399int flag_rtti = 1;
400
401/* Nonzero if we wish to output cross-referencing information
402 for the GNU class browser. */
403extern int flag_gnu_xref;
404
405/* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
406 objects. */
407
408int flag_huge_objects;
409
410/* Nonzero if we want to conserve space in the .o files. We do this
411 by putting uninitialized data and runtime initialized data into
412 .common instead of .data at the expense of not flagging multiple
413 definitions. */
414
415int flag_conserve_space;
416
417/* Nonzero if we want to obey access control semantics. */
418
419int flag_access_control = 1;
420
421/* Nonzero if we want to understand the operator names, i.e. 'bitand'. */
422
423int flag_operator_names;
424
425/* Nonzero if we want to check the return value of new and avoid calling
426 constructors if it is a null pointer. */
427
428int flag_check_new;
429
430/* Nonzero if we want the new ANSI rules for pushing a new scope for `for'
431 initialization variables.
432 0: Old rules, set by -fno-for-scope.
433 2: New ANSI rules, set by -ffor-scope.
434 1: Try to implement new ANSI rules, but with backup compatibility
435 (and warnings). This is the default, for now. */
436
437int flag_new_for_scope = 1;
438
439/* Nonzero if we want to emit defined symbols with common-like linkage as
440 weak symbols where possible, in order to conform to C++ semantics.
441 Otherwise, emit them as local symbols. */
442
443int flag_weak = 1;
444
445/* Nonzero to enable experimental ABI changes. */
446
447int flag_new_abi;
448
449/* Nonzero to not ignore namespace std. */
450
451int flag_honor_std;
452
453/* Maximum template instantiation depth. Must be at least 17 for ANSI
454 compliance. */
455
456int max_tinst_depth = 17;
457
458/* The name-mangling scheme to use. Must be 1 or greater to support
459 template functions with identical types, but different template
460 arguments. */
461int name_mangling_version = 2;
462
463/* Nonzero means that guiding declarations are allowed. */
464int flag_guiding_decls;
465
466/* Nonzero if squashed mangling is to be performed.
467 This uses the B and K codes to reference previously seen class types
468 and class qualifiers. */
469int flag_do_squangling;
470
471/* Nonzero means output .vtable_{entry,inherit} for use in doing vtable gc. */
472
473int flag_vtable_gc;
474
475/* Nonzero means make the default pedwarns warnings instead of errors.
476 The value of this flag is ignored if -pedantic is specified. */
477
478int flag_permissive;
479
480/* If this variable is defined to a non-NULL value, it will be called
481 after the file has been completely parsed. */
482
483void (*back_end_hook) PROTO((tree));
484
485/* Table of language-dependent -f options.
486 STRING is the option name. VARIABLE is the address of the variable.
487 ON_VALUE is the value to store in VARIABLE
488 if `-fSTRING' is seen as an option.
489 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
490
491static struct { const char *string; int *variable; int on_value;}
492lang_f_options[] =
493{
494 /* C/C++ options. */
495 {"signed-char", &flag_signed_char, 1},
496 {"unsigned-char", &flag_signed_char, 0},
497 {"signed-bitfields", &flag_signed_bitfields, 1},
498 {"unsigned-bitfields", &flag_signed_bitfields, 0},
499 {"short-enums", &flag_short_enums, 1},
500 {"short-double", &flag_short_double, 1},
501 {"cond-mismatch", &flag_cond_mismatch, 1},
502 {"asm", &flag_no_asm, 0},
503 {"builtin", &flag_no_builtin, 0},
504
505 /* C++-only options. */
506 {"access-control", &flag_access_control, 1},
507 {"check-new", &flag_check_new, 1},
508 {"conserve-space", &flag_conserve_space, 1},
509 {"const-strings", &flag_const_strings, 1},
510 {"default-inline", &flag_default_inline, 1},
511 {"dollars-in-identifiers", &dollars_in_ident, 1},
512 {"elide-constructors", &flag_elide_constructors, 1},
513 {"external-templates", &flag_external_templates, 1},
514 {"for-scope", &flag_new_for_scope, 2},
515 {"gnu-keywords", &flag_no_gnu_keywords, 0},
516 {"handle-exceptions", &flag_exceptions, 1},
517 {"honor-std", &flag_honor_std, 1},
518 {"huge-objects", &flag_huge_objects, 1},
519 {"implement-inlines", &flag_implement_inlines, 1},
520 {"implicit-inline-templates", &flag_implicit_inline_templates, 1},
521 {"implicit-templates", &flag_implicit_templates, 1},
522 {"labels-ok", &flag_labels_ok, 1},
523 {"ms-extensions", &flag_ms_extensions, 1},
524 {"nonansi-builtins", &flag_no_nonansi_builtin, 0},
525 {"operator-names", &flag_operator_names, 1},
526 {"optional-diags", &flag_optional_diags, 1},
527 {"permissive", &flag_permissive, 1},
528 {"repo", &flag_use_repository, 1},
529 {"rtti", &flag_rtti, 1},
530 {"squangle", &flag_do_squangling, 1},
531 {"stats", &flag_detailed_statistics, 1},
532 {"strict-prototype", &flag_strict_prototype, 1},
533 {"this-is-variable", &flag_this_is_variable, 1},
534 {"vtable-gc", &flag_vtable_gc, 1},
535 {"vtable-thunks", &flag_vtable_thunks, 1},
536 {"weak", &flag_weak, 1},
537 {"xref", &flag_gnu_xref, 1}
538};
539
540/* Decode the string P as a language-specific option.
541 Return the number of strings consumed for a valid option.
542 Otherwise return 0. */
543
544int
545lang_decode_option (argc, argv)
546 int argc
547#if !USE_CPPLIB
548 ATTRIBUTE_UNUSED
549#endif
550 ;
551 char **argv;
552
553{
554 int strings_processed;
555 char *p = argv[0];
556#if USE_CPPLIB
557 strings_processed = cpp_handle_option (&parse_in, argc, argv);
558#else
559 strings_processed = 0;
560#endif /* ! USE_CPPLIB */
561
562 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
563 /* ignore */;
564 else if (p[0] == '-' && p[1] == 'f')
565 {
566 /* Some kind of -f option.
567 P's value is the option sans `-f'.
568 Search for it in the table of options. */
569 int found = 0;
570 size_t j;
571
572 p += 2;
573 /* Try special -f options. */
574
575 if (!strcmp (p, "handle-exceptions")
576 || !strcmp (p, "no-handle-exceptions"))
577 warning ("-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)");
578
579 if (!strcmp (p, "memoize-lookups")
580 || !strcmp (p, "no-memoize-lookups")
581 || !strcmp (p, "save-memoized")
582 || !strcmp (p, "no-save-memoized")
583 || !strcmp (p, "no-all-virtual")
584 || !strcmp (p, "no-enum-int-equiv")
585 || !strcmp (p, "nonnull-objects")
586 || !strcmp (p, "ansi-overloading"))
587 {
588 /* ignore */
589 found = 1;
590 }
591 else if (!strcmp (p, "all-virtual")
592 || !strcmp (p, "enum-int-equiv")
593 || !strcmp (p, "no-nonnull-objects")
594 || !strcmp (p, "no-ansi-overloading"))
595 {
596 warning ("-f%s is no longer supported", p);
597 found = 1;
598 }
599 else if (! strcmp (p, "alt-external-templates"))
600 {
601 flag_external_templates = 1;
602 flag_alt_external_templates = 1;
603 found = 1;
604 cp_deprecated ("-falt-external-templates");
605 }
606 else if (! strcmp (p, "no-alt-external-templates"))
607 {
608 flag_alt_external_templates = 0;
609 found = 1;
610 }
611 else if (!strcmp (p, "repo"))
612 {
613 flag_use_repository = 1;
614 flag_implicit_templates = 0;
615 found = 1;
616 }
617 else if (!strcmp (p, "guiding-decls"))
618 {
619 flag_guiding_decls = 1;
620 name_mangling_version = 0;
621 found = 1;
622 }
623 else if (!strcmp (p, "no-guiding-decls"))
624 {
625 flag_guiding_decls = 0;
626 found = 1;
627 }
628 else if (!strcmp (p, "this-is-variable"))
629 {
630 flag_this_is_variable = 1;
631 found = 1;
632 cp_deprecated ("-fthis-is-variable");
633 }
634 else if (!strcmp (p, "external-templates"))
635 {
636 flag_external_templates = 1;
637 found = 1;
638 cp_deprecated ("-fexternal-templates");
639 }
640 else if (!strcmp (p, "new-abi"))
641 {
642 flag_new_abi = 1;
643 flag_do_squangling = 1;
644 flag_honor_std = 1;
645 flag_vtable_thunks = 1;
646 }
647 else if (!strcmp (p, "no-new-abi"))
648 {
649 flag_new_abi = 0;
650 flag_do_squangling = 0;
651 flag_honor_std = 0;
652 }
653 else if (!strncmp (p, "template-depth-", 15))
654 {
655 max_tinst_depth =
656 read_integral_parameter (p + 15, p - 2, max_tinst_depth);
657 }
658 else if (!strncmp (p, "name-mangling-version-", 22))
659 {
660 name_mangling_version =
661 read_integral_parameter (p + 22, p - 2, name_mangling_version);
662 }
663 else if (!strncmp (p, "dump-translation-unit-", 22))
664 {
665 if (p[22] == '\0')
666 error ("no file specified with -fdump-translation-unit");
667 else
668 flag_dump_translation_unit = p + 22;
669 }
670 else for (j = 0;
671 !found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]);
672 j++)
673 {
674 if (!strcmp (p, lang_f_options[j].string))
675 {
676 *lang_f_options[j].variable = lang_f_options[j].on_value;
677 /* A goto here would be cleaner,
678 but breaks the vax pcc. */
679 found = 1;
680 }
681 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
682 && ! strcmp (p+3, lang_f_options[j].string))
683 {
684 *lang_f_options[j].variable = ! lang_f_options[j].on_value;
685 found = 1;
686 }
687 }
688 return found;
689 }
690 else if (p[0] == '-' && p[1] == 'W')
691 {
692 int setting = 1;
693
694 /* The -W options control the warning behavior of the compiler. */
695 p += 2;
696
697 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
698 setting = 0, p += 3;
699
700 if (!strcmp (p, "implicit"))
701 warn_implicit = setting;
702 else if (!strcmp (p, "long-long"))
703 warn_long_long = setting;
704 else if (!strcmp (p, "return-type"))
705 warn_return_type = setting;
706 else if (!strcmp (p, "ctor-dtor-privacy"))
707 warn_ctor_dtor_privacy = setting;
708 else if (!strcmp (p, "write-strings"))
709 warn_write_strings = setting;
710 else if (!strcmp (p, "cast-qual"))
711 warn_cast_qual = setting;
712 else if (!strcmp (p, "char-subscripts"))
713 warn_char_subscripts = setting;
714 else if (!strcmp (p, "pointer-arith"))
715 warn_pointer_arith = setting;
716 else if (!strcmp (p, "missing-prototypes"))
717 warn_missing_prototypes = setting;
718 else if (!strcmp (p, "redundant-decls"))
719 warn_redundant_decls = setting;
720 else if (!strcmp (p, "missing-braces"))
721 warn_missing_braces = setting;
722 else if (!strcmp (p, "sign-compare"))
723 warn_sign_compare = setting;
724 else if (!strcmp (p, "format"))
725 warn_format = setting;
726 else if (!strcmp (p, "conversion"))
727 warn_conversion = setting;
728 else if (!strcmp (p, "parentheses"))
729 warn_parentheses = setting;
730 else if (!strcmp (p, "non-virtual-dtor"))
731 warn_nonvdtor = setting;
732 else if (!strcmp (p, "extern-inline"))
733 warn_extern_inline = setting;
734 else if (!strcmp (p, "reorder"))
735 warn_reorder = setting;
736 else if (!strcmp (p, "synth"))
737 warn_synth = setting;
738 else if (!strcmp (p, "pmf-conversions"))
739 warn_pmf2ptr = setting;
740 else if (!strcmp (p, "effc++"))
741 warn_ecpp = setting;
742 else if (!strcmp (p, "sign-promo"))
743 warn_sign_promo = setting;
744 else if (!strcmp (p, "old-style-cast"))
745 warn_old_style_cast = setting;
746 else if (!strcmp (p, "overloaded-virtual"))
747 warn_overloaded_virtual = setting;
748 else if (!strcmp (p, "multichar"))
749 warn_multichar = setting;
750 else if (!strcmp (p, "unknown-pragmas"))
751 /* Set to greater than 1, so that even unknown pragmas in
752 system headers will be warned about. */
753 warn_unknown_pragmas = setting * 2;
754 else if (!strcmp (p, "non-template-friend"))
755 warn_nontemplate_friend = setting;
756 else if (!strcmp (p, "deprecated"))
757 warn_deprecated = setting;
758 else if (!strcmp (p, "comment"))
759 ; /* cpp handles this one. */
760 else if (!strcmp (p, "comments"))
761 ; /* cpp handles this one. */
762 else if (!strcmp (p, "trigraphs"))
763 ; /* cpp handles this one. */
764 else if (!strcmp (p, "import"))
765 ; /* cpp handles this one. */
766 else if (!strcmp (p, "all"))
767 {
768 warn_return_type = setting;
769 warn_unused = setting;
770 warn_implicit = setting;
771 warn_switch = setting;
772 warn_format = setting;
773 warn_parentheses = setting;
774 warn_missing_braces = setting;
775 warn_sign_compare = setting;
776 warn_multichar = setting;
777 /* We save the value of warn_uninitialized, since if they put
778 -Wuninitialized on the command line, we need to generate a
779 warning about not using it without also specifying -O. */
780 if (warn_uninitialized != 1)
781 warn_uninitialized = (setting ? 2 : 0);
782 /* Only warn about unknown pragmas that are not in system
783 headers. */
784 warn_unknown_pragmas = 1;
785
786 /* C++-specific warnings. */
787 warn_ctor_dtor_privacy = setting;
788 warn_nonvdtor = setting;
789 warn_reorder = setting;
790 warn_nontemplate_friend = setting;
791 }
792 else return strings_processed;
793 }
794 else if (!strcmp (p, "-ansi"))
795 flag_no_nonansi_builtin = 1, flag_ansi = 1,
796 flag_no_gnu_keywords = 1, flag_operator_names = 1;
797#ifdef SPEW_DEBUG
798 /* Undocumented, only ever used when you're invoking cc1plus by hand, since
799 it's probably safe to assume no sane person would ever want to use this
800 under normal circumstances. */
801 else if (!strcmp (p, "-spew-debug"))
802 spew_debug = 1;
803#endif
804 else
805 return strings_processed;
806
807 return 1;
808}
809\f
810/* Incorporate `const' and `volatile' qualifiers for member functions.
811 FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
812 QUALS is a list of qualifiers. */
813
814tree
815grok_method_quals (ctype, function, quals)
816 tree ctype, function, quals;
817{
818 tree fntype = TREE_TYPE (function);
819 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
820 int type_quals = TYPE_UNQUALIFIED;
821 int dup_quals = TYPE_UNQUALIFIED;
822
823 do
824 {
825 int tq = cp_type_qual_from_rid (TREE_VALUE (quals));
826
827 if (type_quals & tq)
828 dup_quals |= tq;
829 else
830 type_quals |= tq;
831 quals = TREE_CHAIN (quals);
832 }
833 while (quals);
834
835 if (dup_quals != TYPE_UNQUALIFIED)
836 cp_error ("duplicate type qualifiers in %s declaration",
837 TREE_CODE (function) == FUNCTION_DECL
838 ? "member function" : "type");
839
840 ctype = cp_build_qualified_type (ctype, type_quals);
841 fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype),
842 (TREE_CODE (fntype) == METHOD_TYPE
843 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
844 : TYPE_ARG_TYPES (fntype)));
845 if (raises)
846 fntype = build_exception_variant (fntype, raises);
847
848 TREE_TYPE (function) = fntype;
849 return ctype;
850}
851
852/* Warn when -fexternal-templates is used and #pragma
853 interface/implementation is not used all the times it should be,
854 inform the user. */
855
856void
857warn_if_unknown_interface (decl)
858 tree decl;
859{
860 static int already_warned = 0;
861 if (already_warned++)
862 return;
863
864 if (flag_alt_external_templates)
865 {
866 struct tinst_level *til = tinst_for_decl ();
867 int sl = lineno;
868 char *sf = input_filename;
869
870 if (til)
871 {
872 lineno = til->line;
873 input_filename = til->file;
874 }
875 cp_warning ("template `%#D' instantiated in file without #pragma interface",
876 decl);
877 lineno = sl;
878 input_filename = sf;
879 }
880 else
881 cp_warning_at ("template `%#D' defined in file without #pragma interface",
882 decl);
883}
884
885/* A subroutine of the parser, to handle a component list. */
886
887void
888grok_x_components (specs)
889 tree specs;
890{
891 struct pending_inline **p;
892 tree t;
893
894 specs = strip_attrs (specs);
895
896 check_tag_decl (specs);
897 t = groktypename (build_decl_list (specs, NULL_TREE));
898
899 /* The only case where we need to do anything additional here is an
900 anonymous union field, e.g.: `struct S { union { int i; }; };'. */
901 if (t == NULL_TREE || !ANON_AGGR_TYPE_P (t))
902 return;
903
904 fixup_anonymous_aggr (t);
905 finish_member_declaration (build_lang_decl (FIELD_DECL, NULL_TREE, t));
906
907 /* Ignore any inline function definitions in the anonymous union
908 since an anonymous union may not have function members. */
909 p = &pending_inlines;
910 for (; *p; *p = (*p)->next)
911 if (DECL_CONTEXT ((*p)->fndecl) != t)
912 break;
913}
914
915/* Constructors for types with virtual baseclasses need an "in-charge" flag
916 saying whether this constructor is responsible for initialization of
917 virtual baseclasses or not. All destructors also need this "in-charge"
918 flag, which additionally determines whether or not the destructor should
919 free the memory for the object.
920
921 This function adds the "in-charge" flag to member function FN if
922 appropriate. It is called from grokclassfn and tsubst.
923 FN must be either a constructor or destructor. */
924
925void
926maybe_retrofit_in_chrg (fn)
927 tree fn;
928{
929 tree basetype, arg_types, parms, parm, fntype;
930
931 if (DECL_CONSTRUCTOR_P (fn)
932 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CLASS_CONTEXT (fn))
933 && ! DECL_CONSTRUCTOR_FOR_VBASE_P (fn))
934 /* OK */;
935 else if (! DECL_CONSTRUCTOR_P (fn)
936 && TREE_CHAIN (DECL_ARGUMENTS (fn)) == NULL_TREE)
937 /* OK */;
938 else
939 return;
940
941 if (DECL_CONSTRUCTOR_P (fn))
942 DECL_CONSTRUCTOR_FOR_VBASE_P (fn) = 1;
943
944 /* First add it to DECL_ARGUMENTS... */
945 parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
946 /* Mark the artificial `__in_chrg' parameter as "artificial". */
947 SET_DECL_ARTIFICIAL (parm);
948 DECL_ARG_TYPE (parm) = integer_type_node;
949 TREE_READONLY (parm) = 1;
950 parms = DECL_ARGUMENTS (fn);
951 TREE_CHAIN (parm) = TREE_CHAIN (parms);
952 TREE_CHAIN (parms) = parm;
953
954 /* ...and then to TYPE_ARG_TYPES. */
955 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
956 basetype = TREE_TYPE (TREE_VALUE (arg_types));
957 arg_types = hash_tree_chain (integer_type_node, TREE_CHAIN (arg_types));
958 fntype = build_cplus_method_type (basetype, TREE_TYPE (TREE_TYPE (fn)),
959 arg_types);
960 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
961 fntype = build_exception_variant (fntype,
962 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
963 TREE_TYPE (fn) = fntype;
964}
965
966/* Classes overload their constituent function names automatically.
967 When a function name is declared in a record structure,
968 its name is changed to it overloaded name. Since names for
969 constructors and destructors can conflict, we place a leading
970 '$' for destructors.
971
972 CNAME is the name of the class we are grokking for.
973
974 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
975
976 FLAGS contains bits saying what's special about today's
977 arguments. 1 == DESTRUCTOR. 2 == OPERATOR.
978
979 If FUNCTION is a destructor, then we must add the `auto-delete' field
980 as a second parameter. There is some hair associated with the fact
981 that we must "declare" this variable in the manner consistent with the
982 way the rest of the arguments were declared.
983
984 QUALS are the qualifiers for the this pointer. */
985
986void
987grokclassfn (ctype, function, flags, quals)
988 tree ctype, function;
989 enum overload_flags flags;
990 tree quals;
991{
992 tree fn_name = DECL_NAME (function);
993 tree arg_types;
994 tree parm;
995 tree qualtype;
996
997 if (fn_name == NULL_TREE)
998 {
999 error ("name missing for member function");
1000 fn_name = get_identifier ("<anonymous>");
1001 DECL_NAME (function) = fn_name;
1002 }
1003
1004 if (quals)
1005 qualtype = grok_method_quals (ctype, function, quals);
1006 else
1007 qualtype = ctype;
1008
1009 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
1010 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
1011 {
1012 /* Must add the class instance variable up front. */
1013 /* Right now we just make this a pointer. But later
1014 we may wish to make it special. */
1015 tree type = TREE_VALUE (arg_types);
1016 int constp = 1;
1017
1018 if ((flag_this_is_variable > 0)
1019 && (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)))
1020 constp = 0;
1021
1022 parm = build_decl (PARM_DECL, this_identifier, type);
1023 /* Mark the artificial `this' parameter as "artificial". */
1024 SET_DECL_ARTIFICIAL (parm);
1025 DECL_ARG_TYPE (parm) = type;
1026 /* We can make this a register, so long as we don't
1027 accidentally complain if someone tries to take its address. */
1028 DECL_REGISTER (parm) = 1;
1029 if (constp)
1030 TREE_READONLY (parm) = 1;
1031 TREE_CHAIN (parm) = last_function_parms;
1032 last_function_parms = parm;
1033 }
1034
1035 DECL_ARGUMENTS (function) = last_function_parms;
1036 /* First approximations. */
1037 DECL_CONTEXT (function) = ctype;
1038 DECL_CLASS_CONTEXT (function) = ctype;
1039
1040 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
1041 {
1042 maybe_retrofit_in_chrg (function);
1043 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
1044 }
1045
1046 if (flags == DTOR_FLAG)
1047 {
1048 DECL_ASSEMBLER_NAME (function) = build_destructor_name (ctype);
1049 TYPE_HAS_DESTRUCTOR (ctype) = 1;
1050 }
1051 else
1052 set_mangled_name_for_decl (function);
1053}
1054
1055/* Work on the expr used by alignof (this is only called by the parser). */
1056
1057tree
1058grok_alignof (expr)
1059 tree expr;
1060{
1061 tree best, t;
1062 int bestalign;
1063
1064 if (processing_template_decl)
1065 return build_min (ALIGNOF_EXPR, sizetype, expr);
1066
1067 if (TREE_CODE (expr) == COMPONENT_REF
1068 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
1069 error ("`__alignof__' applied to a bit-field");
1070
1071 if (TREE_CODE (expr) == INDIRECT_REF)
1072 {
1073 best = t = TREE_OPERAND (expr, 0);
1074 bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1075
1076 while (TREE_CODE (t) == NOP_EXPR
1077 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
1078 {
1079 int thisalign;
1080 t = TREE_OPERAND (t, 0);
1081 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1082 if (thisalign > bestalign)
1083 best = t, bestalign = thisalign;
1084 }
1085 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
1086 }
1087 else
1088 {
1089 /* ANSI says arrays and fns are converted inside comma.
1090 But we can't convert them in build_compound_expr
1091 because that would break commas in lvalues.
1092 So do the conversion here if operand was a comma. */
1093 if (TREE_CODE (expr) == COMPOUND_EXPR
1094 && (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1095 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE))
1096 expr = default_conversion (expr);
1097 return c_alignof (TREE_TYPE (expr));
1098 }
1099}
1100
1101/* Create an ARRAY_REF, checking for the user doing things backwards
1102 along the way. */
1103
1104tree
1105grok_array_decl (array_expr, index_exp)
1106 tree array_expr, index_exp;
1107{
1108 tree type = TREE_TYPE (array_expr);
1109 tree p1, p2, i1, i2;
1110
1111 if (type == error_mark_node || index_exp == error_mark_node)
1112 return error_mark_node;
1113 if (processing_template_decl)
1114 return build_min (ARRAY_REF, type ? TREE_TYPE (type) : NULL_TREE,
1115 array_expr, index_exp);
1116
1117 if (type == NULL_TREE)
1118 {
1119 /* Something has gone very wrong. Assume we are mistakenly reducing
1120 an expression instead of a declaration. */
1121 error ("parser may be lost: is there a '{' missing somewhere?");
1122 return NULL_TREE;
1123 }
1124
1125 if (TREE_CODE (type) == OFFSET_TYPE
1126 || TREE_CODE (type) == REFERENCE_TYPE)
1127 type = TREE_TYPE (type);
1128
1129 /* If they have an `operator[]', use that. */
1130 if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
1131 return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
1132 array_expr, index_exp, NULL_TREE);
1133
1134 /* Otherwise, create an ARRAY_REF for a pointer or array type. It
1135 is a little-known fact that, if `a' is an array and `i' is an
1136 int, you can write `i[a]', which means the same thing as `a[i]'. */
1137
1138 if (TREE_CODE (type) == ARRAY_TYPE)
1139 p1 = array_expr;
1140 else
1141 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0);
1142
1143 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
1144 p2 = index_exp;
1145 else
1146 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0);
1147
1148 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0);
1149 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0);
1150
1151 if ((p1 && i2) && (i1 && p2))
1152 error ("ambiguous conversion for array subscript");
1153
1154 if (p1 && i2)
1155 array_expr = p1, index_exp = i2;
1156 else if (i1 && p2)
1157 array_expr = p2, index_exp = i1;
1158 else
1159 {
1160 cp_error ("invalid types `%T[%T]' for array subscript",
1161 type, TREE_TYPE (index_exp));
1162 return error_mark_node;
1163 }
1164
1165 if (array_expr == error_mark_node || index_exp == error_mark_node)
1166 error ("ambiguous conversion for array subscript");
1167
1168 return build_array_ref (array_expr, index_exp);
1169}
1170
1171/* Given the cast expression EXP, checking out its validity. Either return
1172 an error_mark_node if there was an unavoidable error, return a cast to
1173 void for trying to delete a pointer w/ the value 0, or return the
1174 call to delete. If DOING_VEC is 1, we handle things differently
1175 for doing an array delete. If DOING_VEC is 2, they gave us the
1176 array size as an argument to delete.
1177 Implements ARM $5.3.4. This is called from the parser. */
1178
1179tree
1180delete_sanity (exp, size, doing_vec, use_global_delete)
1181 tree exp, size;
1182 int doing_vec, use_global_delete;
1183{
1184 tree t, type;
1185 /* For a regular vector delete (aka, no size argument) we will pass
1186 this down as a NULL_TREE into build_vec_delete. */
1187 tree maxindex = NULL_TREE;
1188
1189 if (exp == error_mark_node)
1190 return exp;
1191
1192 if (processing_template_decl)
1193 {
1194 t = build_min (DELETE_EXPR, void_type_node, exp, size);
1195 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
1196 DELETE_EXPR_USE_VEC (t) = doing_vec;
1197 return t;
1198 }
1199
1200 if (TREE_CODE (exp) == OFFSET_REF)
1201 exp = resolve_offset_ref (exp);
1202 exp = convert_from_reference (exp);
1203 t = stabilize_reference (exp);
1204 t = build_expr_type_conversion (WANT_POINTER, t, 1);
1205
1206 if (t == NULL_TREE || t == error_mark_node)
1207 {
1208 cp_error ("type `%#T' argument given to `delete', expected pointer",
1209 TREE_TYPE (exp));
1210 return error_mark_node;
1211 }
1212
1213 if (doing_vec == 2)
1214 {
1215 maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node);
1216 pedwarn ("anachronistic use of array size in vector delete");
1217 }
1218
1219 type = TREE_TYPE (t);
1220
1221 /* As of Valley Forge, you can delete a pointer to const. */
1222
1223 /* You can't delete functions. */
1224 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
1225 {
1226 error ("cannot delete a function");
1227 return error_mark_node;
1228 }
1229
1230 /* Deleting ptr to void is undefined behaviour [expr.delete/3]. */
1231 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
1232 cp_warning ("`%T' is not a pointer-to-object type", type);
1233
1234 /* An array can't have been allocated by new, so complain. */
1235 if (TREE_CODE (t) == ADDR_EXPR
1236 && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
1237 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE)
1238 cp_warning ("deleting array `%#D'", TREE_OPERAND (t, 0));
1239
1240 /* Deleting a pointer with the value zero is valid and has no effect. */
1241 if (integer_zerop (t))
1242 return build1 (NOP_EXPR, void_type_node, t);
1243
1244 if (doing_vec)
1245 return build_vec_delete (t, maxindex, integer_one_node,
1246 integer_zero_node, use_global_delete);
1247 else
1248 {
1249 if (IS_AGGR_TYPE (TREE_TYPE (type))
1250 && TYPE_GETS_REG_DELETE (TREE_TYPE (type)))
1251 {
1252 /* Only do access checking here; we'll be calling op delete
1253 from the destructor. */
1254 tree tmp = build_op_delete_call (DELETE_EXPR, t, size_zero_node,
1255 LOOKUP_NORMAL, NULL_TREE);
1256 if (tmp == error_mark_node)
1257 return error_mark_node;
1258 }
1259
1260 return build_delete (type, t, integer_three_node,
1261 LOOKUP_NORMAL, use_global_delete);
1262 }
1263}
1264
1265/* Report an error if the indicated template declaration is not the
1266 sort of thing that should be a member template. */
1267
1268void
1269check_member_template (tmpl)
1270 tree tmpl;
1271{
1272 tree decl;
1273
1274 my_friendly_assert (TREE_CODE (tmpl) == TEMPLATE_DECL, 0);
1275 decl = DECL_TEMPLATE_RESULT (tmpl);
1276
1277 if (TREE_CODE (decl) == FUNCTION_DECL
1278 || (TREE_CODE (decl) == TYPE_DECL
1279 && IS_AGGR_TYPE (TREE_TYPE (decl))))
1280 {
1281 if (current_function_decl)
1282 /* 14.5.2.2 [temp.mem]
1283
1284 A local class shall not have member templates. */
1285 cp_error ("declaration of member template `%#D' in local class",
1286 decl);
1287
1288 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
1289 {
1290 /* 14.5.2.3 [temp.mem]
1291
1292 A member function template shall not be virtual. */
1293 cp_error
1294 ("invalid use of `virtual' in template declaration of `%#D'",
1295 decl);
1296 DECL_VIRTUAL_P (decl) = 0;
1297 }
1298
1299 /* The debug-information generating code doesn't know what to do
1300 with member templates. */
1301 DECL_IGNORED_P (tmpl) = 1;
1302 }
1303 else
1304 cp_error ("template declaration of `%#D'", decl);
1305}
1306
1307/* Return true iff TYPE is a valid Java parameter or return type. */
1308
1309static int
1310acceptable_java_type (type)
1311 tree type;
1312{
1313 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
1314 return 1;
1315 if (TREE_CODE (type) == POINTER_TYPE)
1316 {
1317 type = TREE_TYPE (type);
1318 if (TREE_CODE (type) == RECORD_TYPE)
1319 {
1320 tree args; int i;
1321 if (! TYPE_FOR_JAVA (type))
1322 return 0;
1323 if (! CLASSTYPE_TEMPLATE_INFO (type))
1324 return 1;
1325 args = CLASSTYPE_TI_ARGS (type);
1326 i = TREE_VEC_LENGTH (args);
1327 while (--i >= 0)
1328 {
1329 type = TREE_VEC_ELT (args, i);
1330 if (TREE_CODE (type) == POINTER_TYPE)
1331 type = TREE_TYPE (type);
1332 if (! TYPE_FOR_JAVA (type))
1333 return 0;
1334 }
1335 return 1;
1336 }
1337 }
1338 return 0;
1339}
1340
1341/* For a METHOD in a Java class CTYPE, return 1 if
1342 the parameter and return types are valid Java types.
1343 Otherwise, print appropriate error messages, and return 0. */
1344
1345int
1346check_java_method (method)
1347 tree method;
1348{
1349 int jerr = 0;
1350 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
1351 tree ret_type = TREE_TYPE (TREE_TYPE (method));
1352 if (! acceptable_java_type (ret_type))
1353 {
1354 cp_error ("Java method '%D' has non-Java return type `%T'",
1355 method, ret_type);
1356 jerr++;
1357 }
1358 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
1359 {
1360 tree type = TREE_VALUE (arg_types);
1361 if (! acceptable_java_type (type))
1362 {
1363 cp_error ("Java method '%D' has non-Java parameter type `%T'",
1364 method, type);
1365 jerr++;
1366 }
1367 }
1368 return jerr ? 0 : 1;
1369}
1370
1371/* Sanity check: report error if this function FUNCTION is not
1372 really a member of the class (CTYPE) it is supposed to belong to.
1373 CNAME is the same here as it is for grokclassfn above. */
1374
1375tree
1376check_classfn (ctype, function)
1377 tree ctype, function;
1378{
1379 tree fn_name = DECL_NAME (function);
1380 tree fndecl, fndecls;
1381 tree method_vec = CLASSTYPE_METHOD_VEC (complete_type (ctype));
1382 tree *methods = 0;
1383 tree *end = 0;
1384
1385 if (DECL_USE_TEMPLATE (function)
1386 && is_member_template (DECL_TI_TEMPLATE (function)))
1387 /* Since this is a specialization of a member template,
1388 we're not going to find the declaration in the class.
1389 For example, in:
1390
1391 struct S { template <typename T> void f(T); };
1392 template <> void S::f(int);
1393
1394 we're not going to find `S::f(int)', but there's no
1395 reason we should, either. We let our callers know we didn't
1396 find the method, but we don't complain. */
1397 return NULL_TREE;
1398
1399 if (method_vec != 0)
1400 {
1401 methods = &TREE_VEC_ELT (method_vec, 0);
1402 end = TREE_VEC_END (method_vec);
1403
1404 /* First suss out ctors and dtors. */
1405 if (*methods && fn_name == DECL_NAME (OVL_CURRENT (*methods))
1406 && DECL_CONSTRUCTOR_P (function))
1407 goto got_it;
1408 if (*++methods && fn_name == DECL_NAME (OVL_CURRENT (*methods))
1409 && DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function)))
1410 goto got_it;
1411
1412 while (++methods != end && *methods)
1413 {
1414 fndecl = *methods;
1415 if (fn_name == DECL_NAME (OVL_CURRENT (*methods)))
1416 {
1417 got_it:
1418 for (fndecls = *methods; fndecls != NULL_TREE;
1419 fndecls = OVL_NEXT (fndecls))
1420 {
1421 fndecl = OVL_CURRENT (fndecls);
1422 /* The DECL_ASSEMBLER_NAME for a TEMPLATE_DECL, or
1423 for a for member function of a template class, is
1424 not mangled, so the check below does not work
1425 correctly in that case. Since mangled destructor
1426 names do not include the type of the arguments,
1427 we can't use this short-cut for them, either.
1428 (It's not legal to declare arguments for a
1429 destructor, but some people try.) */
1430 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function))
1431 && (DECL_ASSEMBLER_NAME (function)
1432 != DECL_NAME (function))
1433 && (DECL_ASSEMBLER_NAME (fndecl)
1434 != DECL_NAME (fndecl))
1435 && (DECL_ASSEMBLER_NAME (function)
1436 == DECL_ASSEMBLER_NAME (fndecl)))
1437 return fndecl;
1438
1439 /* We cannot simply call decls_match because this
1440 doesn't work for static member functions that are
1441 pretending to be methods, and because the name
1442 may have been changed by asm("new_name"). */
1443 if (DECL_NAME (function) == DECL_NAME (fndecl))
1444 {
1445 tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
1446 tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1447
1448 /* Get rid of the this parameter on functions that become
1449 static. */
1450 if (DECL_STATIC_FUNCTION_P (fndecl)
1451 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
1452 p1 = TREE_CHAIN (p1);
1453
1454 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
1455 TREE_TYPE (TREE_TYPE (fndecl)))
1456 && compparms (p1, p2)
1457 && (DECL_TEMPLATE_SPECIALIZATION (function)
1458 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
1459 && (!DECL_TEMPLATE_SPECIALIZATION (function)
1460 || (DECL_TI_TEMPLATE (function)
1461 == DECL_TI_TEMPLATE (fndecl))))
1462 return fndecl;
1463 }
1464 }
1465 break; /* loser */
1466 }
1467 }
1468 }
1469
1470 if (methods != end && *methods)
1471 {
1472 tree fndecl = *methods;
1473 cp_error ("prototype for `%#D' does not match any in class `%T'",
1474 function, ctype);
1475 cp_error_at ("candidate%s: %+#D", OVL_NEXT (fndecl) ? "s are" : " is",
1476 OVL_CURRENT (fndecl));
1477 while (fndecl = OVL_NEXT (fndecl), fndecl)
1478 cp_error_at (" %#D", OVL_CURRENT(fndecl));
1479 }
1480 else
1481 {
1482 methods = 0;
1483 if (TYPE_SIZE (ctype) == 0)
1484 incomplete_type_error (function, ctype);
1485 else
1486 cp_error ("no `%#D' member function declared in class `%T'",
1487 function, ctype);
1488 }
1489
1490 /* If we did not find the method in the class, add it to avoid
1491 spurious errors (unless the CTYPE is not yet defined, in which
1492 case we'll only confuse ourselves when the function is declared
1493 properly within the class. */
1494 if (TYPE_SIZE (ctype))
1495 add_method (ctype, methods, function);
1496 return NULL_TREE;
1497}
1498
1499/* We have just processed the DECL, which is a static data member.
1500 Its initializer, if present, is INIT. The ASMSPEC_TREE, if
1501 present, is the assembly-language name for the data member.
1502 NEED_POP and FLAGS are as for cp_finish_decl. */
1503
1504void
1505finish_static_data_member_decl (decl, init, asmspec_tree, need_pop, flags)
1506 tree decl;
1507 tree init;
1508 tree asmspec_tree;
1509 int need_pop;
1510 int flags;
1511{
1512 const char *asmspec = 0;
1513
1514 if (asmspec_tree)
1515 asmspec = TREE_STRING_POINTER (asmspec_tree);
1516
1517 my_friendly_assert (TREE_PUBLIC (decl), 0);
1518
1519 /* We cannot call pushdecl here, because that would fill in the
1520 decl of our TREE_CHAIN. Instead, we modify cp_finish_decl to do
1521 the right thing, namely, to put this decl out straight away. */
1522 /* current_class_type can be NULL_TREE in case of error. */
1523 if (!asmspec && current_class_type)
1524 {
1525 DECL_INITIAL (decl) = error_mark_node;
1526 DECL_ASSEMBLER_NAME (decl)
1527 = build_static_name (current_class_type, DECL_NAME (decl));
1528 }
1529 if (! processing_template_decl)
1530 {
1531 if (!pending_statics)
1532 VARRAY_TREE_INIT (pending_statics, 32, "pending_statics");
1533
1534 if (pending_statics_used == pending_statics->num_elements)
1535 VARRAY_GROW (pending_statics,
1536 2 * pending_statics->num_elements);
1537 VARRAY_TREE (pending_statics, pending_statics_used) = decl;
1538 ++pending_statics_used;
1539 }
1540
1541 /* Static consts need not be initialized in the class definition. */
1542 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
1543 {
1544 static int explanation = 0;
1545
1546 error ("initializer invalid for static member with constructor");
1547 if (explanation++ == 0)
1548 error ("(you really want to initialize it separately)");
1549 init = 0;
1550 }
1551 /* Force the compiler to know when an uninitialized static const
1552 member is being used. */
1553 if (CP_TYPE_CONST_P (TREE_TYPE (decl)) && init == 0)
1554 TREE_USED (decl) = 1;
1555 DECL_INITIAL (decl) = init;
1556 DECL_IN_AGGR_P (decl) = 1;
1557 DECL_CONTEXT (decl) = current_class_type;
1558 DECL_CLASS_CONTEXT (decl) = current_class_type;
1559
1560 cp_finish_decl (decl, init, asmspec_tree, need_pop, flags);
1561}
1562
1563/* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
1564 of a structure component, returning a FIELD_DECL node.
1565 QUALS is a list of type qualifiers for this decl (such as for declaring
1566 const member functions).
1567
1568 This is done during the parsing of the struct declaration.
1569 The FIELD_DECL nodes are chained together and the lot of them
1570 are ultimately passed to `build_struct' to make the RECORD_TYPE node.
1571
1572 C++:
1573
1574 If class A defines that certain functions in class B are friends, then
1575 the way I have set things up, it is B who is interested in permission
1576 granted by A. However, it is in A's context that these declarations
1577 are parsed. By returning a void_type_node, class A does not attempt
1578 to incorporate the declarations of the friends within its structure.
1579
1580 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
1581 CHANGES TO CODE IN `start_method'. */
1582
1583tree
1584grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
1585 tree declarator, declspecs, init, asmspec_tree, attrlist;
1586{
1587 register tree value;
1588 const char *asmspec = 0;
1589 int flags = LOOKUP_ONLYCONVERTING;
1590
1591 /* Convert () initializers to = initializers. */
1592 if (init == NULL_TREE && declarator != NULL_TREE
1593 && TREE_CODE (declarator) == CALL_EXPR
1594 && TREE_OPERAND (declarator, 0)
1595 && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE
1596 || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF)
1597 && parmlist_is_exprlist (CALL_DECLARATOR_PARMS (declarator)))
1598 {
1599 init = TREE_OPERAND (declarator, 1);
1600 declarator = TREE_OPERAND (declarator, 0);
1601 flags = 0;
1602 }
1603
1604 if (declspecs == NULL_TREE
1605 && TREE_CODE (declarator) == SCOPE_REF
1606 && TREE_CODE (TREE_OPERAND (declarator, 1)) == IDENTIFIER_NODE)
1607 {
1608 /* Access declaration */
1609 if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
1610 ;
1611 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
1612 pop_nested_class ();
1613 return do_class_using_decl (declarator);
1614 }
1615
1616 if (init
1617 && TREE_CODE (init) == TREE_LIST
1618 && TREE_VALUE (init) == error_mark_node
1619 && TREE_CHAIN (init) == NULL_TREE)
1620 init = NULL_TREE;
1621
1622 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, attrlist);
1623 if (! value || value == error_mark_node)
1624 /* friend or constructor went bad. */
1625 return value;
1626
1627 /* Pass friendly classes back. */
1628 if (TREE_CODE (value) == VOID_TYPE)
1629 return void_type_node;
1630
1631 if (DECL_NAME (value) != NULL_TREE
1632 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
1633 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
1634 cp_error ("member `%D' conflicts with virtual function table field name",
1635 value);
1636
1637 /* Stash away type declarations. */
1638 if (TREE_CODE (value) == TYPE_DECL)
1639 {
1640 DECL_NONLOCAL (value) = 1;
1641 DECL_CONTEXT (value) = current_class_type;
1642 DECL_CLASS_CONTEXT (value) = current_class_type;
1643
1644 /* Now that we've updated the context, we need to remangle the
1645 name for this TYPE_DECL. */
1646 DECL_ASSEMBLER_NAME (value) = DECL_NAME (value);
1647 if (!uses_template_parms (value))
1648 DECL_ASSEMBLER_NAME (value) =
1649 get_identifier (build_overload_name (TREE_TYPE (value), 1, 1));
1650
1651 if (processing_template_decl)
1652 value = push_template_decl (value);
1653
1654 return value;
1655 }
1656
1657 if (DECL_IN_AGGR_P (value))
1658 {
1659 cp_error ("`%D' is already defined in `%T'", value,
1660 DECL_CONTEXT (value));
1661 return void_type_node;
1662 }
1663
1664 if (asmspec_tree)
1665 asmspec = TREE_STRING_POINTER (asmspec_tree);
1666
1667 if (init)
1668 {
1669 if (TREE_CODE (value) == FUNCTION_DECL)
1670 {
1671 grok_function_init (value, init);
1672 init = NULL_TREE;
1673 }
1674 else if (pedantic && TREE_CODE (value) != VAR_DECL)
1675 /* Already complained in grokdeclarator. */
1676 init = NULL_TREE;
1677 else
1678 {
1679 /* We allow initializers to become parameters to base
1680 initializers. */
1681 if (TREE_CODE (init) == TREE_LIST)
1682 {
1683 if (TREE_CHAIN (init) == NULL_TREE)
1684 init = TREE_VALUE (init);
1685 else
1686 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1687 }
1688
1689 if (TREE_CODE (init) == CONST_DECL)
1690 init = DECL_INITIAL (init);
1691 else if (TREE_READONLY_DECL_P (init))
1692 init = decl_constant_value (init);
1693 else if (TREE_CODE (init) == CONSTRUCTOR)
1694 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1695 my_friendly_assert (TREE_PERMANENT (init), 192);
1696 if (init == error_mark_node)
1697 /* We must make this look different than `error_mark_node'
1698 because `decl_const_value' would mis-interpret it
1699 as only meaning that this VAR_DECL is defined. */
1700 init = build1 (NOP_EXPR, TREE_TYPE (value), init);
1701 else if (processing_template_decl)
1702 ;
1703 else if (! TREE_CONSTANT (init))
1704 {
1705 /* We can allow references to things that are effectively
1706 static, since references are initialized with the address. */
1707 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
1708 || (TREE_STATIC (init) == 0
1709 && (TREE_CODE_CLASS (TREE_CODE (init)) != 'd'
1710 || DECL_EXTERNAL (init) == 0)))
1711 {
1712 error ("field initializer is not constant");
1713 init = error_mark_node;
1714 }
1715 }
1716 }
1717 }
1718
1719 /* The corresponding pop_obstacks is in cp_finish_decl. */
1720 push_obstacks_nochange ();
1721
1722 if (processing_template_decl && ! current_function_decl
1723 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
1724 value = push_template_decl (value);
1725
1726 if (attrlist)
1727 cplus_decl_attributes (value, TREE_PURPOSE (attrlist),
1728 TREE_VALUE (attrlist));
1729
1730 if (TREE_CODE (value) == VAR_DECL)
1731 {
1732 finish_static_data_member_decl (value, init, asmspec_tree,
1733 /*need_pop=*/1, flags);
1734 return value;
1735 }
1736 if (TREE_CODE (value) == FIELD_DECL)
1737 {
1738 if (asmspec)
1739 {
1740 /* This must override the asm specifier which was placed
1741 by grokclassfn. Lay this out fresh. */
1742 DECL_RTL (value) = NULL_RTX;
1743 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
1744 }
1745 if (DECL_INITIAL (value) == error_mark_node)
1746 init = error_mark_node;
1747 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1748 DECL_INITIAL (value) = init;
1749 DECL_IN_AGGR_P (value) = 1;
1750 return value;
1751 }
1752 if (TREE_CODE (value) == FUNCTION_DECL)
1753 {
1754 if (asmspec)
1755 {
1756 /* This must override the asm specifier which was placed
1757 by grokclassfn. Lay this out fresh. */
1758 DECL_RTL (value) = NULL_RTX;
1759 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
1760 }
1761 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1762
1763 /* Pass friends back this way. */
1764 if (DECL_FRIEND_P (value))
1765 return void_type_node;
1766
1767 DECL_IN_AGGR_P (value) = 1;
1768 return value;
1769 }
1770 my_friendly_abort (21);
1771 /* NOTREACHED */
1772 return NULL_TREE;
1773}
1774
1775/* Like `grokfield', but for bitfields.
1776 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1777
1778tree
1779grokbitfield (declarator, declspecs, width)
1780 tree declarator, declspecs, width;
1781{
1782 register tree value = grokdeclarator (declarator, declspecs, BITFIELD,
1783 0, NULL_TREE);
1784
1785 if (! value) return NULL_TREE; /* friends went bad. */
1786
1787 /* Pass friendly classes back. */
1788 if (TREE_CODE (value) == VOID_TYPE)
1789 return void_type_node;
1790
1791 if (TREE_CODE (value) == TYPE_DECL)
1792 {
1793 cp_error ("cannot declare `%D' to be a bitfield type", value);
1794 return NULL_TREE;
1795 }
1796
1797 /* Usually, finish_struct_1 catches bitifields with invalid types.
1798 But, in the case of bitfields with function type, we confuse
1799 ourselves into thinking they are member functions, so we must
1800 check here. */
1801 if (TREE_CODE (value) == FUNCTION_DECL)
1802 {
1803 cp_error ("cannot declare bitfield `%D' with funcion type",
1804 DECL_NAME (value));
1805 return NULL_TREE;
1806 }
1807
1808 if (DECL_IN_AGGR_P (value))
1809 {
1810 cp_error ("`%D' is already defined in the class %T", value,
1811 DECL_CONTEXT (value));
1812 return void_type_node;
1813 }
1814
1815 GNU_xref_member (current_class_name, value);
1816
1817 if (TREE_STATIC (value))
1818 {
1819 cp_error ("static member `%D' cannot be a bitfield", value);
1820 return NULL_TREE;
1821 }
1822 cp_finish_decl (value, NULL_TREE, NULL_TREE, 0, 0);
1823
1824 if (width != error_mark_node)
1825 {
1826 constant_expression_warning (width);
1827 DECL_INITIAL (value) = width;
1828 SET_DECL_C_BIT_FIELD (value);
1829 }
1830
1831 DECL_IN_AGGR_P (value) = 1;
1832 return value;
1833}
1834
1835tree
1836grokoptypename (declspecs, declarator)
1837 tree declspecs, declarator;
1838{
1839 tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0, NULL_TREE);
1840 return build_typename_overload (t);
1841}
1842
1843/* When a function is declared with an initializer,
1844 do the right thing. Currently, there are two possibilities:
1845
1846 class B
1847 {
1848 public:
1849 // initialization possibility #1.
1850 virtual void f () = 0;
1851 int g ();
1852 };
1853
1854 class D1 : B
1855 {
1856 public:
1857 int d1;
1858 // error, no f ();
1859 };
1860
1861 class D2 : B
1862 {
1863 public:
1864 int d2;
1865 void f ();
1866 };
1867
1868 class D3 : B
1869 {
1870 public:
1871 int d3;
1872 // initialization possibility #2
1873 void f () = B::f;
1874 };
1875
1876*/
1877
1878int
1879copy_assignment_arg_p (parmtype, virtualp)
1880 tree parmtype;
1881 int virtualp ATTRIBUTE_UNUSED;
1882{
1883 if (current_class_type == NULL_TREE)
1884 return 0;
1885
1886 if (TREE_CODE (parmtype) == REFERENCE_TYPE)
1887 parmtype = TREE_TYPE (parmtype);
1888
1889 if ((TYPE_MAIN_VARIANT (parmtype) == current_class_type)
1890#if 0
1891 /* Non-standard hack to support old Booch components. */
1892 || (! virtualp && DERIVED_FROM_P (parmtype, current_class_type))
1893#endif
1894 )
1895 return 1;
1896
1897 return 0;
1898}
1899
1900static void
1901grok_function_init (decl, init)
1902 tree decl;
1903 tree init;
1904{
1905 /* An initializer for a function tells how this function should
1906 be inherited. */
1907 tree type = TREE_TYPE (decl);
1908
1909 if (TREE_CODE (type) == FUNCTION_TYPE)
1910 cp_error ("initializer specified for non-member function `%D'", decl);
1911#if 0
1912 /* We'll check for this in finish_struct_1. */
1913 else if (DECL_VINDEX (decl) == NULL_TREE)
1914 cp_error ("initializer specified for non-virtual method `%D'", decl);
1915#endif
1916 else if (integer_zerop (init))
1917 {
1918#if 0
1919 /* Mark this function as being "defined". */
1920 DECL_INITIAL (decl) = error_mark_node;
1921 /* pure virtual destructors must be defined. */
1922 /* pure virtual needs to be defined (as abort) only when put in
1923 vtbl. For wellformed call, it should be itself. pr4737 */
1924 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)))
1925 {
1926 extern tree abort_fndecl;
1927 /* Give this node rtl from `abort'. */
1928 DECL_RTL (decl) = DECL_RTL (abort_fndecl);
1929 }
1930#endif
1931 DECL_ABSTRACT_VIRTUAL_P (decl) = 1;
1932 if (DECL_NAME (decl) == ansi_opname [(int) MODIFY_EXPR])
1933 {
1934 tree parmtype
1935 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))));
1936
1937 if (copy_assignment_arg_p (parmtype, 1))
1938 TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
1939 }
1940 }
1941 else
1942 cp_error ("invalid initializer for virtual method `%D'", decl);
1943}
1944\f
1945void
1946cplus_decl_attributes (decl, attributes, prefix_attributes)
1947 tree decl, attributes, prefix_attributes;
1948{
1949 if (decl == NULL_TREE || decl == void_type_node)
1950 return;
1951
1952 if (TREE_CODE (decl) == TEMPLATE_DECL)
1953 decl = DECL_TEMPLATE_RESULT (decl);
1954
1955 decl_attributes (decl, attributes, prefix_attributes);
1956
1957 if (TREE_CODE (decl) == TYPE_DECL)
1958 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (decl), TREE_TYPE (decl));
1959}
1960\f
1961/* CONSTRUCTOR_NAME:
1962 Return the name for the constructor (or destructor) for the
1963 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
1964 IDENTIFIER_NODE. When given a template, this routine doesn't
1965 lose the specialization. */
1966
1967tree
1968constructor_name_full (thing)
1969 tree thing;
1970{
1971 if (TREE_CODE (thing) == TEMPLATE_TYPE_PARM
1972 || TREE_CODE (thing) == TEMPLATE_TEMPLATE_PARM
1973 || TREE_CODE (thing) == TYPENAME_TYPE)
1974 thing = TYPE_NAME (thing);
1975 else if (IS_AGGR_TYPE_CODE (TREE_CODE (thing)))
1976 {
1977 if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing))
1978 thing = DECL_NAME (OVL_CURRENT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (thing), 0)));
1979 else
1980 thing = TYPE_NAME (thing);
1981 }
1982 if (TREE_CODE (thing) == TYPE_DECL
1983 || (TREE_CODE (thing) == TEMPLATE_DECL
1984 && TREE_CODE (DECL_TEMPLATE_RESULT (thing)) == TYPE_DECL))
1985 thing = DECL_NAME (thing);
1986 my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197);
1987 return thing;
1988}
1989
1990/* CONSTRUCTOR_NAME:
1991 Return the name for the constructor (or destructor) for the
1992 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
1993 IDENTIFIER_NODE. When given a template, return the plain
1994 unspecialized name. */
1995
1996tree
1997constructor_name (thing)
1998 tree thing;
1999{
2000 tree t;
2001 thing = constructor_name_full (thing);
2002 t = IDENTIFIER_TEMPLATE (thing);
2003 if (!t)
2004 return thing;
2005 return t;
2006}
2007\f
2008/* Record the existence of an addressable inline function. */
2009
2010void
2011mark_inline_for_output (decl)
2012 tree decl;
2013{
2014 decl = DECL_MAIN_VARIANT (decl);
2015 if (DECL_SAVED_INLINE (decl))
2016 return;
2017 my_friendly_assert (TREE_PERMANENT (decl), 363);
2018 DECL_SAVED_INLINE (decl) = 1;
2019 if (!saved_inlines)
2020 VARRAY_TREE_INIT (saved_inlines, 32, "saved_inlines");
2021
2022 if (saved_inlines_used == saved_inlines->num_elements)
2023 VARRAY_GROW (saved_inlines,
2024 2 * saved_inlines->num_elements);
2025 VARRAY_TREE (saved_inlines, saved_inlines_used) = decl;
2026 ++saved_inlines_used;
2027}
2028
2029void
2030clear_temp_name ()
2031{
2032 temp_name_counter = 0;
2033}
2034
2035/* Hand off a unique name which can be used for variable we don't really
2036 want to know about anyway, for example, the anonymous variables which
2037 are needed to make references work. Declare this thing so we can use it.
2038 The variable created will be of type TYPE.
2039
2040 STATICP is nonzero if this variable should be static. */
2041
2042tree
2043get_temp_name (type, staticp)
2044 tree type;
2045 int staticp;
2046{
2047 char buf[sizeof (AUTO_TEMP_FORMAT) + 20];
2048 tree decl;
2049 int toplev = toplevel_bindings_p ();
2050
2051 push_obstacks_nochange ();
2052 if (toplev || staticp)
2053 {
2054 end_temporary_allocation ();
2055 sprintf (buf, AUTO_TEMP_FORMAT, global_temp_name_counter++);
2056 decl = pushdecl_top_level (build_decl (VAR_DECL, get_identifier (buf), type));
2057 }
2058 else
2059 {
2060 sprintf (buf, AUTO_TEMP_FORMAT, temp_name_counter++);
2061 decl = pushdecl (build_decl (VAR_DECL, get_identifier (buf), type));
2062 }
2063 TREE_USED (decl) = 1;
2064 TREE_STATIC (decl) = staticp;
2065 DECL_ARTIFICIAL (decl) = 1;
2066
2067 /* If this is a local variable, then lay out its rtl now.
2068 Otherwise, callers of this function are responsible for dealing
2069 with this variable's rtl. */
2070 if (! toplev)
2071 {
2072 expand_decl (decl);
2073 my_friendly_assert (DECL_INITIAL (decl) == NULL_TREE,
2074 19990826);
2075 }
2076 pop_obstacks ();
2077
2078 return decl;
2079}
2080
2081/* Hunts through the global anonymous union ANON_DECL, building
2082 appropriate VAR_DECLs. Stores cleanups on the list of ELEMS, and
2083 returns a VAR_DECL whose size is the same as the size of the
2084 ANON_DECL, if one is available. */
2085
2086static tree
2087build_anon_union_vars (anon_decl, elems, static_p, external_p)
2088 tree anon_decl;
2089 tree* elems;
2090 int static_p;
2091 int external_p;
2092{
2093 tree type = TREE_TYPE (anon_decl);
2094 tree main_decl = NULL_TREE;
2095 tree field;
2096
2097 /* Rather than write the code to handle the non-union case,
2098 just give an error. */
2099 if (TREE_CODE (type) != UNION_TYPE)
2100 error ("anonymous struct not inside named type");
2101
2102 for (field = TYPE_FIELDS (type);
2103 field != NULL_TREE;
2104 field = TREE_CHAIN (field))
2105 {
2106 tree decl;
2107
2108 if (DECL_ARTIFICIAL (field))
2109 continue;
2110 if (TREE_CODE (field) != FIELD_DECL)
2111 {
2112 cp_pedwarn_at ("`%#D' invalid; an anonymous union can only have non-static data members",
2113 field);
2114 continue;
2115 }
2116
2117 if (TREE_PRIVATE (field))
2118 cp_pedwarn_at ("private member `%#D' in anonymous union", field);
2119 else if (TREE_PROTECTED (field))
2120 cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
2121
2122 if (DECL_NAME (field) == NULL_TREE
2123 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2124 {
2125 decl = build_anon_union_vars (field, elems, static_p, external_p);
2126 if (!decl)
2127 continue;
2128 }
2129 else if (DECL_NAME (field) == NULL_TREE)
2130 continue;
2131 else
2132 {
2133 decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
2134 /* tell `pushdecl' that this is not tentative. */
2135 DECL_INITIAL (decl) = error_mark_node;
2136 TREE_PUBLIC (decl) = 0;
2137 TREE_STATIC (decl) = static_p;
2138 DECL_EXTERNAL (decl) = external_p;
2139 decl = pushdecl (decl);
2140 DECL_INITIAL (decl) = NULL_TREE;
2141 }
2142
2143 /* Only write out one anon union element--choose the one that
2144 can hold them all. */
2145 if (main_decl == NULL_TREE
2146 && simple_cst_equal (DECL_SIZE (decl),
2147 DECL_SIZE (anon_decl)) == 1)
2148 main_decl = decl;
2149 else
2150 /* ??? This causes there to be no debug info written out
2151 about this decl. */
2152 TREE_ASM_WRITTEN (decl) = 1;
2153
2154 if (DECL_NAME (field) == NULL_TREE
2155 && ANON_AGGR_TYPE_P (TREE_TYPE (field)))
2156 /* The remainder of the processing was already done in the
2157 recursive call. */
2158 continue;
2159
2160 /* If there's a cleanup to do, it belongs in the
2161 TREE_PURPOSE of the following TREE_LIST. */
2162 *elems = scratch_tree_cons (NULL_TREE, decl, *elems);
2163 TREE_TYPE (*elems) = type;
2164 }
2165
2166 return main_decl;
2167}
2168
2169/* Finish off the processing of a UNION_TYPE structure.
2170 If there are static members, then all members are
2171 static, and must be laid out together. If the
2172 union is an anonymous union, we arrange for that
2173 as well. PUBLIC_P is nonzero if this union is
2174 not declared static. */
2175
2176void
2177finish_anon_union (anon_union_decl)
2178 tree anon_union_decl;
2179{
2180 tree type = TREE_TYPE (anon_union_decl);
2181 tree elems = NULL_TREE;
2182 tree main_decl;
2183 int public_p = TREE_PUBLIC (anon_union_decl);
2184 int static_p = TREE_STATIC (anon_union_decl);
2185 int external_p = DECL_EXTERNAL (anon_union_decl);
2186
2187 if (TYPE_FIELDS (type) == NULL_TREE)
2188 return;
2189
2190 if (public_p)
2191 {
2192 error ("global anonymous unions must be declared static");
2193 return;
2194 }
2195
2196 main_decl = build_anon_union_vars (anon_union_decl, &elems,
2197 static_p, external_p);
2198
2199 if (main_decl == NULL_TREE)
2200 {
2201 warning ("anonymous union with no members");
2202 return;
2203 }
2204
2205 if (static_p)
2206 {
2207 make_decl_rtl (main_decl, 0, toplevel_bindings_p ());
2208 DECL_RTL (anon_union_decl) = DECL_RTL (main_decl);
2209 }
2210
2211 /* The following call assumes that there are never any cleanups
2212 for anonymous unions--a reasonable assumption. */
2213 expand_anon_union_decl (anon_union_decl, NULL_TREE, elems);
2214}
2215
2216/* Finish processing a builtin type TYPE. It's name is NAME,
2217 its fields are in the array FIELDS. LEN is the number of elements
2218 in FIELDS minus one, or put another way, it is the maximum subscript
2219 used in FIELDS.
2220
2221 It is given the same alignment as ALIGN_TYPE. */
2222
2223void
2224finish_builtin_type (type, name, fields, len, align_type)
2225 tree type;
2226 const char *name;
2227 tree fields[];
2228 int len;
2229 tree align_type;
2230{
2231 register int i;
2232
2233 TYPE_FIELDS (type) = fields[0];
2234 for (i = 0; i < len; i++)
2235 {
2236 layout_type (TREE_TYPE (fields[i]));
2237 DECL_FIELD_CONTEXT (fields[i]) = type;
2238 TREE_CHAIN (fields[i]) = fields[i+1];
2239 }
2240 DECL_FIELD_CONTEXT (fields[i]) = type;
2241 DECL_CLASS_CONTEXT (fields[i]) = type;
2242 TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
2243 layout_type (type);
2244#if 0 /* not yet, should get fixed properly later */
2245 TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
2246#else
2247 TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
2248#endif
2249 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2250 layout_decl (TYPE_NAME (type), 0);
2251}
2252\f
2253/* Auxiliary functions to make type signatures for
2254 `operator new' and `operator delete' correspond to
2255 what compiler will be expecting. */
2256
2257tree
2258coerce_new_type (type)
2259 tree type;
2260{
2261 int e1 = 0, e2 = 0;
2262
2263 if (TREE_CODE (type) == METHOD_TYPE)
2264 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type)));
2265 if (! same_type_p (TREE_TYPE (type), ptr_type_node))
2266 e1 = 1, error ("`operator new' must return type `void *'");
2267
2268 /* Technically the type must be `size_t', but we may not know
2269 what that is. */
2270 if (TYPE_ARG_TYPES (type) == NULL_TREE)
2271 e1 = 1, error ("`operator new' takes type `size_t' parameter");
2272 else if (! same_type_p (TREE_VALUE (TYPE_ARG_TYPES (type)), sizetype))
2273 e2 = 1, error ("`operator new' takes type `size_t' as first parameter");
2274 if (e2)
2275 type = build_function_type (ptr_type_node, tree_cons (NULL_TREE, sizetype, TREE_CHAIN (TYPE_ARG_TYPES (type))));
2276 else if (e1)
2277 type = build_function_type (ptr_type_node, TYPE_ARG_TYPES (type));
2278 return type;
2279}
2280
2281tree
2282coerce_delete_type (type)
2283 tree type;
2284{
2285 int e1 = 0, e2 = 0;
2286#if 0
2287 e3 = 0;
2288#endif
2289 tree arg_types = TYPE_ARG_TYPES (type);
2290
2291 if (TREE_CODE (type) == METHOD_TYPE)
2292 {
2293 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (arg_types));
2294 arg_types = TREE_CHAIN (arg_types);
2295 }
2296
2297 if (TREE_TYPE (type) != void_type_node)
2298 e1 = 1, error ("`operator delete' must return type `void'");
2299
2300 if (arg_types == NULL_TREE
2301 || ! same_type_p (TREE_VALUE (arg_types), ptr_type_node))
2302 e2 = 1, error ("`operator delete' takes type `void *' as first parameter");
2303
2304#if 0
2305 if (arg_types
2306 && TREE_CHAIN (arg_types)
2307 && TREE_CHAIN (arg_types) != void_list_node)
2308 {
2309 /* Again, technically this argument must be `size_t', but again
2310 we may not know what that is. */
2311 tree t2 = TREE_VALUE (TREE_CHAIN (arg_types));
2312 if (! same_type_p (t2, sizetype))
2313 e3 = 1, error ("second argument to `operator delete' must be of type `size_t'");
2314 else if (TREE_CHAIN (TREE_CHAIN (arg_types)) != void_list_node)
2315 {
2316 e3 = 1;
2317 if (TREE_CHAIN (TREE_CHAIN (arg_types)))
2318 error ("too many arguments in declaration of `operator delete'");
2319 else
2320 error ("`...' invalid in specification of `operator delete'");
2321 }
2322 }
2323
2324 if (e3)
2325 arg_types = tree_cons (NULL_TREE, ptr_type_node,
2326 build_tree_list (NULL_TREE, sizetype));
2327 else if (e3 |= e2)
2328 {
2329 if (arg_types == NULL_TREE)
2330 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
2331 else
2332 arg_types = tree_cons (NULL_TREE, ptr_type_node, TREE_CHAIN (arg_types));
2333 }
2334 else e3 |= e1;
2335#endif
2336
2337 if (e2)
2338 arg_types = tree_cons (NULL_TREE, ptr_type_node,
2339 arg_types ? TREE_CHAIN (arg_types): NULL_TREE);
2340 if (e2 || e1)
2341 type = build_function_type (void_type_node, arg_types);
2342
2343 return type;
2344}
2345\f
2346static void
2347mark_vtable_entries (decl)
2348 tree decl;
2349{
2350 tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
2351
2352 for (; entries; entries = TREE_CHAIN (entries))
2353 {
2354 tree fnaddr;
2355 tree fn;
2356
2357 fnaddr = (flag_vtable_thunks ? TREE_VALUE (entries)
2358 : FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries)));
2359
2360 if (TREE_CODE (fnaddr) == NOP_EXPR)
2361 /* RTTI offset. */
2362 continue;
2363
2364 fn = TREE_OPERAND (fnaddr, 0);
2365 TREE_ADDRESSABLE (fn) = 1;
2366 if (TREE_CODE (fn) == THUNK_DECL && DECL_EXTERNAL (fn))
2367 {
2368 DECL_EXTERNAL (fn) = 0;
2369 emit_thunk (fn);
2370 }
2371 mark_used (fn);
2372 }
2373}
2374
2375/* Set DECL up to have the closest approximation of "initialized common"
2376 linkage available. */
2377
2378void
2379comdat_linkage (decl)
2380 tree decl;
2381{
2382 if (flag_weak)
2383 make_decl_one_only (decl);
2384 else if (TREE_CODE (decl) == FUNCTION_DECL || DECL_VIRTUAL_P (decl))
2385 /* We can just emit functions and vtables statically; it doesn't really
2386 matter if we have multiple copies. */
2387 TREE_PUBLIC (decl) = 0;
2388 else
2389 {
2390 /* Static data member template instantiations, however, cannot
2391 have multiple copies. */
2392 if (DECL_INITIAL (decl) == 0
2393 || DECL_INITIAL (decl) == error_mark_node)
2394 DECL_COMMON (decl) = 1;
2395 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
2396 {
2397 DECL_COMMON (decl) = 1;
2398 DECL_INITIAL (decl) = error_mark_node;
2399 }
2400 else
2401 {
2402 /* We can't do anything useful; leave vars for explicit
2403 instantiation. */
2404 DECL_EXTERNAL (decl) = 1;
2405 DECL_NOT_REALLY_EXTERN (decl) = 0;
2406 }
2407 }
2408
2409 if (DECL_LANG_SPECIFIC (decl))
2410 DECL_COMDAT (decl) = 1;
2411}
2412
2413/* For win32 we also want to put explicit instantiations in
2414 linkonce sections, so that they will be merged with implicit
2415 instantiations; otherwise we get duplicate symbol errors. */
2416
2417void
2418maybe_make_one_only (decl)
2419 tree decl;
2420{
2421 /* This is not necessary on targets that support weak symbols, because
2422 the implicit instantiations will defer to the explicit one. */
2423 if (! supports_one_only () || SUPPORTS_WEAK)
2424 return;
2425
2426 /* We can't set DECL_COMDAT on functions, or finish_file will think
2427 we can get away with not emitting them if they aren't used. We need
2428 to for variables so that cp_finish_decl will update their linkage,
2429 because their DECL_INITIAL may not have been set properly yet. */
2430
2431 make_decl_one_only (decl);
2432
2433 if (TREE_CODE (decl) == VAR_DECL && DECL_LANG_SPECIFIC (decl))
2434 DECL_COMDAT (decl) = 1;
2435}
2436
2437/* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
2438 based on TYPE and other static flags.
2439
2440 Note that anything public is tagged TREE_PUBLIC, whether
2441 it's public in this file or in another one. */
2442
2443void
2444import_export_vtable (decl, type, final)
2445 tree decl, type;
2446 int final;
2447{
2448 if (DECL_INTERFACE_KNOWN (decl))
2449 return;
2450
2451 if (TYPE_FOR_JAVA (type))
2452 {
2453 TREE_PUBLIC (decl) = 1;
2454 DECL_EXTERNAL (decl) = 1;
2455 DECL_INTERFACE_KNOWN (decl) = 1;
2456 }
2457 else if (CLASSTYPE_INTERFACE_KNOWN (type))
2458 {
2459 TREE_PUBLIC (decl) = 1;
2460 DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type);
2461 DECL_INTERFACE_KNOWN (decl) = 1;
2462 }
2463 else
2464 {
2465 /* We can only wait to decide if we have real non-inline virtual
2466 functions in our class, or if we come from a template. */
2467
2468 int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type);
2469
2470 if (! found && ! final)
2471 {
2472 tree method;
2473 for (method = TYPE_METHODS (type); method != NULL_TREE;
2474 method = TREE_CHAIN (method))
2475 if (DECL_VINDEX (method) != NULL_TREE
2476 && ! DECL_THIS_INLINE (method)
2477 && ! DECL_ABSTRACT_VIRTUAL_P (method))
2478 {
2479 found = 1;
2480 break;
2481 }
2482 }
2483
2484 if (final || ! found)
2485 {
2486 comdat_linkage (decl);
2487 DECL_EXTERNAL (decl) = 0;
2488 }
2489 else
2490 {
2491 TREE_PUBLIC (decl) = 1;
2492 DECL_EXTERNAL (decl) = 1;
2493 }
2494 }
2495}
2496
2497/* Determine whether or not we want to specifically import or export CTYPE,
2498 using various heuristics. */
2499
2500void
2501import_export_class (ctype)
2502 tree ctype;
2503{
2504 /* -1 for imported, 1 for exported. */
2505 int import_export = 0;
2506
2507 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2508 return;
2509
2510 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma interface,
2511 we will have CLASSTYPE_INTERFACE_ONLY set but not
2512 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
2513 heuristic because someone will supply a #pragma implementation
2514 elsewhere, and deducing it here would produce a conflict. */
2515 if (CLASSTYPE_INTERFACE_ONLY (ctype))
2516 return;
2517
2518#ifdef VALID_MACHINE_TYPE_ATTRIBUTE
2519 /* FIXME this should really use some sort of target-independent macro. */
2520 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
2521 import_export = -1;
2522 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
2523 import_export = 1;
2524#endif
2525
2526 /* If we got -fno-implicit-templates, we import template classes that
2527 weren't explicitly instantiated. */
2528 if (import_export == 0
2529 && CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
2530 && ! flag_implicit_templates)
2531 import_export = -1;
2532
2533 /* Base our import/export status on that of the first non-inline,
2534 non-abstract virtual function, if any. */
2535 if (import_export == 0
2536 && TYPE_VIRTUAL_P (ctype)
2537 && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2538 {
2539 tree method;
2540 for (method = TYPE_METHODS (ctype); method != NULL_TREE;
2541 method = TREE_CHAIN (method))
2542 {
2543 if (DECL_VINDEX (method) != NULL_TREE
2544 && !DECL_THIS_INLINE (method)
2545 && !DECL_ABSTRACT_VIRTUAL_P (method))
2546 {
2547 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
2548 break;
2549 }
2550 }
2551 }
2552
2553#ifdef MULTIPLE_SYMBOL_SPACES
2554 if (import_export == -1)
2555 import_export = 0;
2556#endif
2557
2558 if (import_export)
2559 {
2560 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
2561 CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = (import_export > 0);
2562 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
2563 }
2564}
2565
2566/* We need to describe to the assembler the relationship between
2567 a vtable and the vtable of the parent class. */
2568
2569static void
2570output_vtable_inherit (vars)
2571 tree vars;
2572{
2573 tree parent;
2574 rtx op[2];
2575
2576 op[0] = XEXP (DECL_RTL (vars), 0); /* strip the mem ref */
2577
2578 parent = binfo_for_vtable (vars);
2579
2580 if (parent == TYPE_BINFO (DECL_CONTEXT (vars)))
2581 op[1] = const0_rtx;
2582 else if (parent)
2583 {
2584 parent = TYPE_BINFO_VTABLE (BINFO_TYPE (parent));
2585 op[1] = XEXP (DECL_RTL (parent), 0); /* strip the mem ref */
2586 }
2587 else
2588 my_friendly_abort (980826);
2589
2590 output_asm_insn (".vtable_inherit %c0, %c1", op);
2591}
2592
2593static int
2594finish_vtable_vardecl (t, data)
2595 tree *t;
2596 void *data ATTRIBUTE_UNUSED;
2597{
2598 tree vars = *t;
2599 tree ctype = DECL_CONTEXT (vars);
2600 import_export_class (ctype);
2601 import_export_vtable (vars, ctype, 1);
2602
2603 if (! DECL_EXTERNAL (vars)
2604 && (DECL_INTERFACE_KNOWN (vars)
2605 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars))
2606 || (hack_decl_function_context (vars) && TREE_USED (vars)))
2607 && ! TREE_ASM_WRITTEN (vars))
2608 {
2609 /* Write it out. */
2610 mark_vtable_entries (vars);
2611 if (TREE_TYPE (DECL_INITIAL (vars)) == 0)
2612 store_init_value (vars, DECL_INITIAL (vars));
2613
2614 if (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG)
2615 {
2616 /* Mark the VAR_DECL node representing the vtable itself as a
2617 "gratuitous" one, thereby forcing dwarfout.c to ignore it.
2618 It is rather important that such things be ignored because
2619 any effort to actually generate DWARF for them will run
2620 into trouble when/if we encounter code like:
2621
2622 #pragma interface
2623 struct S { virtual void member (); };
2624
2625 because the artificial declaration of the vtable itself (as
2626 manufactured by the g++ front end) will say that the vtable
2627 is a static member of `S' but only *after* the debug output
2628 for the definition of `S' has already been output. This causes
2629 grief because the DWARF entry for the definition of the vtable
2630 will try to refer back to an earlier *declaration* of the
2631 vtable as a static member of `S' and there won't be one.
2632 We might be able to arrange to have the "vtable static member"
2633 attached to the member list for `S' before the debug info for
2634 `S' get written (which would solve the problem) but that would
2635 require more intrusive changes to the g++ front end. */
2636
2637 DECL_IGNORED_P (vars) = 1;
2638 }
2639
2640 /* Always make vtables weak. */
2641 if (flag_weak)
2642 comdat_linkage (vars);
2643
2644 rest_of_decl_compilation (vars, NULL_PTR, 1, 1);
2645
2646 if (flag_vtable_gc)
2647 output_vtable_inherit (vars);
2648
2649 return 1;
2650 }
2651 else if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars)))
2652 /* We don't know what to do with this one yet. */
2653 return 0;
2654
2655 *t = TREE_CHAIN (vars);
2656 return 0;
2657}
2658
2659static int
2660prune_vtable_vardecl (t, data)
2661 tree *t;
2662 void *data ATTRIBUTE_UNUSED;
2663{
2664 *t = TREE_CHAIN (*t);
2665 return 1;
2666}
2667
2668/* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
2669 inline function or template instantiation at end-of-file. */
2670
2671void
2672import_export_decl (decl)
2673 tree decl;
2674{
2675 if (DECL_INTERFACE_KNOWN (decl))
2676 return;
2677
2678 if (DECL_TEMPLATE_INSTANTIATION (decl)
2679 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2680 {
2681 DECL_NOT_REALLY_EXTERN (decl) = 1;
2682 if ((DECL_IMPLICIT_INSTANTIATION (decl)
2683 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2684 && (flag_implicit_templates
2685 || (flag_implicit_inline_templates && DECL_THIS_INLINE (decl))))
2686 {
2687 if (!TREE_PUBLIC (decl))
2688 /* Templates are allowed to have internal linkage. See
2689 [basic.link]. */
2690 ;
2691 else
2692 comdat_linkage (decl);
2693 }
2694 else
2695 DECL_NOT_REALLY_EXTERN (decl) = 0;
2696 }
2697 else if (DECL_FUNCTION_MEMBER_P (decl))
2698 {
2699 tree ctype = DECL_CLASS_CONTEXT (decl);
2700 import_export_class (ctype);
2701 if (CLASSTYPE_INTERFACE_KNOWN (ctype)
2702 && (flag_new_abi
2703 ? (! DECL_THIS_INLINE (decl))
2704 : (! DECL_ARTIFICIAL (decl) || DECL_VINDEX (decl))))
2705 {
2706 DECL_NOT_REALLY_EXTERN (decl)
2707 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2708 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines
2709 && !DECL_VINDEX (decl)));
2710
2711 /* Always make artificials weak. */
2712 if (DECL_ARTIFICIAL (decl) && flag_weak)
2713 comdat_linkage (decl);
2714 else
2715 maybe_make_one_only (decl);
2716 }
2717 else
2718 comdat_linkage (decl);
2719 }
2720 else if (DECL_TINFO_FN_P (decl))
2721 {
2722 tree ctype = TREE_TYPE (DECL_NAME (decl));
2723
2724 if (IS_AGGR_TYPE (ctype))
2725 import_export_class (ctype);
2726
2727 if (IS_AGGR_TYPE (ctype) && CLASSTYPE_INTERFACE_KNOWN (ctype)
2728 && TYPE_VIRTUAL_P (ctype)
2729 /* If the type is a cv-qualified variant of a type, then we
2730 must emit the tinfo function in this translation unit
2731 since it will not be emitted when the vtable for the type
2732 is output (which is when the unqualified version is
2733 generated). */
2734 && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype)))
2735 {
2736 DECL_NOT_REALLY_EXTERN (decl)
2737 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2738 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines
2739 && !DECL_VINDEX (decl)));
2740
2741 /* Always make artificials weak. */
2742 if (flag_weak)
2743 comdat_linkage (decl);
2744 }
2745 else if (TYPE_BUILT_IN (ctype)
2746 && same_type_p (ctype, TYPE_MAIN_VARIANT (ctype)))
2747 DECL_NOT_REALLY_EXTERN (decl) = 0;
2748 else
2749 comdat_linkage (decl);
2750 }
2751 else
2752 comdat_linkage (decl);
2753
2754 DECL_INTERFACE_KNOWN (decl) = 1;
2755}
2756
2757tree
2758build_cleanup (decl)
2759 tree decl;
2760{
2761 tree temp;
2762 tree type = TREE_TYPE (decl);
2763
2764 if (TREE_CODE (type) == ARRAY_TYPE)
2765 temp = decl;
2766 else
2767 {
2768 mark_addressable (decl);
2769 temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
2770 }
2771 temp = build_delete (TREE_TYPE (temp), temp,
2772 integer_two_node,
2773 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
2774 return temp;
2775}
2776
2777extern int parse_time, varconst_time;
2778
2779static tree
2780get_sentry (base)
2781 tree base;
2782{
2783 tree sname = get_id_2 ("__sn", base);
2784 /* For struct X foo __attribute__((weak)), there is a counter
2785 __snfoo. Since base is already an assembler name, sname should
2786 be globally unique */
2787 tree sentry = IDENTIFIER_GLOBAL_VALUE (sname);
2788 if (! sentry)
2789 {
2790 push_permanent_obstack ();
2791 sentry = build_decl (VAR_DECL, sname, integer_type_node);
2792 TREE_PUBLIC (sentry) = 1;
2793 DECL_ARTIFICIAL (sentry) = 1;
2794 TREE_STATIC (sentry) = 1;
2795 TREE_USED (sentry) = 1;
2796 DECL_COMMON (sentry) = 1;
2797 pushdecl_top_level (sentry);
2798 cp_finish_decl (sentry, NULL_TREE, NULL_TREE, 0, 0);
2799 pop_obstacks ();
2800 }
2801 return sentry;
2802}
2803
2804/* Start the process of running a particular set of global constructors
2805 or destructors. Subroutine of do_[cd]tors. */
2806
2807static void
2808start_objects (method_type, initp)
2809 int method_type, initp;
2810{
2811 tree fnname;
2812 char type[10];
2813
2814 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2815
2816 if (initp != DEFAULT_INIT_PRIORITY)
2817 {
2818 char joiner;
2819
2820#ifdef JOINER
2821 joiner = JOINER;
2822#else
2823 joiner = '_';
2824#endif
2825
2826 sprintf (type, "%c%c%.5u", method_type, joiner, initp);
2827 }
2828 else
2829 sprintf (type, "%c", method_type);
2830
2831 fnname = get_file_function_name_long (type);
2832
2833 start_function (void_list_node,
2834 make_call_declarator (fnname, void_list_node, NULL_TREE,
2835 NULL_TREE),
2836 NULL_TREE, 0);
2837
2838#if defined(ASM_OUTPUT_CONSTRUCTOR) && defined(ASM_OUTPUT_DESTRUCTOR)
2839 /* It can be a static function as long as collect2 does not have
2840 to scan the object file to find its ctor/dtor routine. */
2841 TREE_PUBLIC (current_function_decl) = 0;
2842#endif
2843
2844 store_parm_decls ();
2845 pushlevel (0);
2846 clear_last_expr ();
2847 push_momentary ();
2848 expand_start_bindings (0);
2849
2850 /* We cannot allow these functions to be elided, even if they do not
2851 have external linkage. And, there's no point in deferring
2852 copmilation of thes functions; they're all going to have to be
2853 out anyhow. */
2854 current_function_cannot_inline
2855 = "static constructors and destructors cannot be inlined";
2856}
2857
2858/* Finish the process of running a particular set of global constructors
2859 or destructors. Subroutine of do_[cd]tors. */
2860
2861static void
2862finish_objects (method_type, initp)
2863 int method_type, initp;
2864{
2865 char *fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2866
2867 /* Finish up. */
2868 expand_end_bindings (getdecls (), 1, 0);
2869 poplevel (1, 0, 0);
2870 pop_momentary ();
2871 finish_function (lineno, 0, 0);
2872
2873 if (initp == DEFAULT_INIT_PRIORITY)
2874 {
2875 if (method_type == 'I')
2876 assemble_constructor (fnname);
2877 else
2878 assemble_destructor (fnname);
2879 }
2880
2881#if defined (ASM_OUTPUT_SECTION_NAME) && defined (ASM_OUTPUT_CONSTRUCTOR)
2882 /* If we're using init priority we can't use assemble_*tor, but on ELF
2883 targets we can stick the references into named sections for GNU ld
2884 to collect. */
2885 else
2886 {
2887 char buf[15];
2888 sprintf (buf, ".%ctors.%.5u", method_type == 'I' ? 'c' : 'd',
2889 /* invert the numbering so the linker puts us in the proper
2890 order; constructors are run from right to left, and the
2891 linker sorts in increasing order. */
2892 MAX_INIT_PRIORITY - initp);
2893 named_section (NULL_TREE, buf, 0);
2894 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, fnname),
2895 POINTER_SIZE / BITS_PER_UNIT, 1);
2896 }
2897#endif
2898}
2899
2900/* The names of the parameters to the function created to handle
2901 initializations and destructions for objects with static storage
2902 duration. */
2903#define INITIALIZE_P_IDENTIFIER "__initialize_p"
2904#define PRIORITY_IDENTIFIER "__priority"
2905
2906/* The name of the function we create to handle initializations and
2907 destructions for objects with static storage duration. */
2908#define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2909
2910/* The declaration for the __INITIALIZE_P argument. */
2911static tree initialize_p_decl;
2912
2913/* The declaration for the __PRIORITY argument. */
2914static tree priority_decl;
2915
2916/* The declaration for the static storage duration function. */
2917static tree ssdf_decl;
2918
2919/* All the static storage duration functions created in this
2920 translation unit. */
2921static varray_type ssdf_decls;
2922static size_t ssdf_decls_used;
2923
2924/* A map from priority levels to information about that priority
2925 level. There may be many such levels, so efficient lookup is
2926 important. */
2927static splay_tree priority_info_map;
2928
2929/* Begins the generation of the function that will handle all
2930 initialization and destruction of objects with static storage
2931 duration. The function generated takes two parameters of type
2932 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2933 non-zero, it performs initializations. Otherwise, it performs
2934 destructions. It only performs those initializations or
2935 destructions with the indicated __PRIORITY. The generated function
2936 returns no value.
2937
2938 It is assumed that this function will only be called once per
2939 translation unit. */
2940
2941static void
2942start_static_storage_duration_function ()
2943{
2944 static unsigned ssdf_number;
2945
2946 tree parm_types;
2947 tree type;
2948 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2949
2950 /* Create the identifier for this function. It will be of the form
2951 SSDF_IDENTIFIER_<number>. */
2952 sprintf (id, "%s_%u", SSDF_IDENTIFIER, ssdf_number++);
2953 if (ssdf_number == 0)
2954 {
2955 /* Overflow occurred. That means there are at least 4 billion
2956 initialization functions. */
2957 sorry ("too many initialization functions required");
2958 my_friendly_abort (19990430);
2959 }
2960
2961 /* Create the parameters. */
2962 parm_types = void_list_node;
2963 parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types);
2964 parm_types = perm_tree_cons (NULL_TREE, integer_type_node, parm_types);
2965 type = build_function_type (void_type_node, parm_types);
2966
2967 /* Create the FUNCTION_DECL itself. */
2968 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2969 get_identifier (id),
2970 type);
2971 TREE_PUBLIC (ssdf_decl) = 0;
2972 DECL_ARTIFICIAL (ssdf_decl) = 1;
2973
2974 /* Put this function in the list of functions to be called from the
2975 static constructors and destructors. */
2976 if (!ssdf_decls)
2977 {
2978 VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
2979
2980 /* Take this opportunity to initialize the map from priority
2981 numbers to information about that priority level. */
2982 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2983 /*delete_key_fn=*/0,
2984 /*delete_value_fn=*/
2985 (splay_tree_delete_value_fn) &free);
2986
2987 /* We always need to generate functions for the
2988 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2989 priorities later, we'll be sure to find the
2990 DEFAULT_INIT_PRIORITY. */
2991 get_priority_info (DEFAULT_INIT_PRIORITY);
2992 }
2993
2994 if (ssdf_decls_used == ssdf_decls->num_elements)
2995 VARRAY_GROW (ssdf_decls, 2 * ssdf_decls_used);
2996 VARRAY_TREE (ssdf_decls, ssdf_decls_used) = ssdf_decl;
2997 ++ssdf_decls_used;
2998
2999 /* Create the argument list. */
3000 initialize_p_decl = build_decl (PARM_DECL,
3001 get_identifier (INITIALIZE_P_IDENTIFIER),
3002 integer_type_node);
3003 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
3004 DECL_ARG_TYPE (initialize_p_decl) = integer_type_node;
3005 TREE_USED (initialize_p_decl) = 1;
3006 priority_decl = build_decl (PARM_DECL, get_identifier (PRIORITY_IDENTIFIER),
3007 integer_type_node);
3008 DECL_CONTEXT (priority_decl) = ssdf_decl;
3009 DECL_ARG_TYPE (priority_decl) = integer_type_node;
3010 TREE_USED (priority_decl) = 1;
3011
3012 TREE_CHAIN (initialize_p_decl) = priority_decl;
3013 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
3014
3015 /* Start the function itself. This is equivalent to declarating the
3016 function as:
3017
3018 static void __ssdf (int __initialize_p, init __priority_p);
3019
3020 It is static because we only need to call this function from the
3021 various constructor and destructor functions for this module. */
3022 start_function (/*specs=*/NULL_TREE,
3023 ssdf_decl,
3024 /*attrs=*/NULL_TREE,
3025 /*pre_parsed_p=*/1);
3026
3027 /* Set up the scope of the outermost block in the function. */
3028 store_parm_decls ();
3029 pushlevel (0);
3030 clear_last_expr ();
3031 push_momentary ();
3032 expand_start_bindings (0);
3033
3034 /* This function must not be deferred because we are depending on
3035 its compilation to tell us what is TREE_SYMBOL_REFERENCED. */
3036 current_function_cannot_inline
3037 = "static storage duration functions cannot be inlined";
3038}
3039
3040/* Generate the initialization code for the priority indicated in N. */
3041
3042static int
3043generate_inits_for_priority (n, data)
3044 splay_tree_node n;
3045 void *data ATTRIBUTE_UNUSED;
3046{
3047 int priority = (int) n->key;
3048 priority_info pi = (priority_info) n->value;
3049
3050 /* For each priority N which has been used generate code which looks
3051 like:
3052
3053 if (__priority == N) {
3054 if (__initialize_p)
3055 ...
3056 else
3057 ...
3058 }
3059
3060 We use the sequences we've accumulated to fill in the `...'s. */
3061 expand_start_cond (build_binary_op (EQ_EXPR,
3062 priority_decl,
3063 build_int_2 (priority, 0)),
3064 /*exit_flag=*/0);
3065
3066 /* Do the initializations. */
3067 expand_start_cond (build_binary_op (NE_EXPR,
3068 initialize_p_decl,
3069 integer_zero_node),
3070 /*exit_flag=*/0);
3071 if (pi->initialization_sequence)
3072 {
3073 rtx insns;
3074
3075 push_to_sequence (pi->initialization_sequence);
3076 insns = gen_sequence ();
3077 end_sequence ();
3078
3079 emit_insn (insns);
3080 pi->initialization_sequence = NULL_RTX;
3081 pi->initializations_p = 1;
3082 }
3083
3084 /* Do the destructions. */
3085 expand_start_else ();
3086 if (pi->destruction_sequence)
3087 {
3088 rtx insns;
3089
3090 push_to_sequence (pi->destruction_sequence);
3091 insns = gen_sequence ();
3092 end_sequence ();
3093
3094 emit_insn (insns);
3095 pi->destruction_sequence = NULL_RTX;
3096 pi->destructions_p = 1;
3097 }
3098
3099 /* Close out the conditionals. */
3100 expand_end_cond ();
3101 expand_end_cond ();
3102
3103 /* Don't stop iterating. */
3104 return 0;
3105}
3106
3107/* Finish the generation of the function which performs initialization
3108 and destruction of objects with static storage duration. After
3109 this point, no more such objects can be created. */
3110
3111static void
3112finish_static_storage_duration_function ()
3113{
3114 splay_tree_foreach (priority_info_map,
3115 generate_inits_for_priority,
3116 /*data=*/0);
3117
3118 /* Close out the function. */
3119 expand_end_bindings (getdecls (), 1, 0);
3120 poplevel (1, 0, 0);
3121 pop_momentary ();
3122 finish_function (lineno, 0, 0);
3123}
3124
3125/* Return the information about the indicated PRIORITY level. If no
3126 code to handle this level has yet been generated, generate the
3127 appropriate prologue. */
3128
3129static priority_info
3130get_priority_info (priority)
3131 int priority;
3132{
3133 priority_info pi;
3134 splay_tree_node n;
3135
3136 n = splay_tree_lookup (priority_info_map,
3137 (splay_tree_key) priority);
3138 if (!n)
3139 {
3140 /* Create a new priority information structure, and insert it
3141 into the map. */
3142 pi = (priority_info) xmalloc (sizeof (struct priority_info_s));
3143 pi->initialization_sequence = NULL_RTX;
3144 pi->destruction_sequence = NULL_RTX;
3145 pi->initializations_p = 0;
3146 pi->destructions_p = 0;
3147 splay_tree_insert (priority_info_map,
3148 (splay_tree_key) priority,
3149 (splay_tree_value) pi);
3150 }
3151 else
3152 pi = (priority_info) n->value;
3153
3154 return pi;
3155}
3156
3157/* Generate code to do the static initialization of DECL. The
3158 initialization is INIT. If DECL may be initialized more than once
3159 in different object files, SENTRY is the guard variable to
3160 check. PRIORITY is the priority for the initialization. */
3161
3162static void
3163do_static_initialization (decl, init, sentry, priority)
3164 tree decl;
3165 tree init;
3166 tree sentry;
3167 int priority;
3168{
3169 priority_info pi;
3170
3171 /* Get the priority information for this PRIORITY, */
3172 pi = get_priority_info (priority);
3173 if (!pi->initialization_sequence)
3174 start_sequence ();
3175 else
3176 push_to_sequence (pi->initialization_sequence);
3177
3178 /* Tell the debugger that we are at the location of the static
3179 variable in question. */
3180 emit_note (input_filename, lineno);
3181
3182 /* If there's a SENTRY, we only do the initialization if it is
3183 zero, i.e., if we are the first to initialize it. */
3184 if (sentry)
3185 expand_start_cond (build_binary_op (EQ_EXPR,
3186 build_unary_op (PREINCREMENT_EXPR,
3187 sentry,
3188 /*noconvert=*/0),
3189 integer_one_node),
3190 /*exit_flag=*/0);
3191
3192 /* Prepare a binding level for temporaries created during the
3193 initialization. */
3194 expand_start_target_temps ();
3195
3196 if (IS_AGGR_TYPE (TREE_TYPE (decl))
3197 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
3198 expand_expr (build_aggr_init (decl, init, 0),
3199 const0_rtx, VOIDmode, EXPAND_NORMAL);
3200 else if (TREE_CODE (init) == TREE_VEC)
3201 expand_expr (build_vec_init (decl, TREE_VEC_ELT (init, 0),
3202 TREE_VEC_ELT (init, 1),
3203 TREE_VEC_ELT (init, 2), 0),
3204 const0_rtx, VOIDmode, EXPAND_NORMAL);
3205 else
3206 expand_assignment (decl, init, 0, 0);
3207
3208 /* The expression might have involved increments and decrements. */
3209 emit_queue ();
3210
3211 /* Cleanup any temporaries needed for the initial value. */
3212 expand_end_target_temps ();
3213
3214 /* Cleanup any deferred pops from function calls. This would be done
3215 by expand_end_cond, but we also need it when !SENTRY, since we are
3216 constructing these sequences by parts. */
3217 do_pending_stack_adjust ();
3218
3219 /* Close the conditional opened above. */
3220 if (sentry)
3221 expand_end_cond ();
3222
3223 /* Save the sequence for later use. */
3224 pi->initialization_sequence = get_insns ();
3225 end_sequence ();
3226}
3227
3228/* Generate code to do the static destruction of DECL. If DECL may be
3229 initialized more than once in different object files, SENTRY is the
3230 guard variable to check. PRIORITY is the priority for the
3231 destruction. */
3232
3233static void
3234do_static_destruction (decl, sentry, priority)
3235 tree decl;
3236 tree sentry;
3237 int priority;
3238{
3239 rtx new_insns;
3240 priority_info pi;
3241
3242 /* If we don't need a destructor, there's nothing to do. */
3243 if (!TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
3244 return;
3245
3246 /* Get the priority information for this PRIORITY, */
3247 pi = get_priority_info (priority);
3248 if (!pi->destruction_sequence)
3249 start_sequence ();
3250 else
3251 push_to_sequence (pi->destruction_sequence);
3252
3253 /* Start a new sequence to handle just this destruction. */
3254 start_sequence ();
3255
3256 /* Tell the debugger that we are at the location of the static
3257 variable in question. */
3258 emit_note (input_filename, lineno);
3259
3260 /* If there's a SENTRY, we only do the destruction if it is one,
3261 i.e., if we are the last to destroy it. */
3262 if (sentry)
3263 expand_start_cond (build_binary_op (EQ_EXPR,
3264 build_unary_op (PREDECREMENT_EXPR,
3265 sentry,
3266 /*nonconvert=*/1),
3267 integer_zero_node),
3268 /*exit_flag=*/0);
3269
3270 /* Actually do the destruction. */
3271 expand_expr_stmt (build_cleanup (decl));
3272
3273 /* Cleanup any deferred pops from function calls. This would be done
3274 by expand_end_cond, but we also need it when !SENTRY, since we are
3275 constructing these sequences by parts. */
3276 do_pending_stack_adjust ();
3277
3278 /* Close the conditional opened above. */
3279 if (sentry)
3280 expand_end_cond ();
3281
3282 /* Insert the NEW_INSNS before the current insns. (Destructions are
3283 run in reverse order of initializations.) */
3284 new_insns = gen_sequence ();
3285 end_sequence ();
3286 if (pi->destruction_sequence)
3287 emit_insn_before (new_insns, pi->destruction_sequence);
3288 else
3289 emit_insn (new_insns);
3290
3291 /* Save the sequence for later use. */
3292 pi->destruction_sequence = get_insns ();
3293 end_sequence ();
3294}
3295
3296/* Add code to the static storage duration function that will handle
3297 DECL (a static variable that needs initializing and/or destruction)
3298 with the indicated PRIORITY. If DECL needs initializing, INIT is
3299 the initializer. */
3300
3301static void
3302do_static_initialization_and_destruction (decl, init)
3303 tree decl;
3304 tree init;
3305{
3306 tree sentry = NULL_TREE;
3307 int priority;
3308
3309 /* Deal gracefully with error. */
3310 if (decl == error_mark_node)
3311 return;
3312
3313 /* The only things that can be initialized are variables. */
3314 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 19990420);
3315
3316 /* If this object is not defined, we don't need to do anything
3317 here. */
3318 if (DECL_EXTERNAL (decl))
3319 return;
3320
3321 /* Also, if the initializer already contains errors, we can bail out
3322 now. */
3323 if (init && TREE_CODE (init) == TREE_LIST
3324 && value_member (error_mark_node, init))
3325 return;
3326
3327 /* Trick the compiler into thinking we are at the file and line
3328 where DECL was declared so that error-messages make sense, and so
3329 that the debugger will show somewhat sensible file and line
3330 information. */
3331 input_filename = DECL_SOURCE_FILE (decl);
3332 lineno = DECL_SOURCE_LINE (decl);
3333
3334 /* Because of:
3335
3336 [class.access.spec]
3337
3338 Access control for implicit calls to the constructors,
3339 the conversion functions, or the destructor called to
3340 create and destroy a static data member is performed as
3341 if these calls appeared in the scope of the member's
3342 class.
3343
3344 we pretend we are in a static member function of the class of
3345 which the DECL is a member. */
3346 if (member_p (decl))
3347 {
3348 DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3349 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3350 }
3351
3352 /* We need a sentry if this is an object with external linkage that
3353 might be initialized in more than one place. */
3354 if (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
3355 || DECL_ONE_ONLY (decl)
3356 || DECL_WEAK (decl)))
3357 sentry = get_sentry (DECL_ASSEMBLER_NAME (decl));
3358
3359 /* Generate the code to actually do the intialization and
3360 destruction. */
3361 priority = DECL_INIT_PRIORITY (decl);
3362 if (!priority)
3363 priority = DEFAULT_INIT_PRIORITY;
3364 do_static_initialization (decl, init, sentry, priority);
3365 do_static_destruction (decl, sentry, priority);
3366
3367 /* Now that we're done with DECL we don't need to pretend to be a
3368 member of its class any longer. */
3369 DECL_CLASS_CONTEXT (current_function_decl) = NULL_TREE;
3370 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3371}
3372
3373/* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3374 (otherwise) that will initialize all gobal objects with static
3375 storage duration having the indicated PRIORITY. */
3376
3377static void
3378generate_ctor_or_dtor_function (constructor_p, priority)
3379 int constructor_p;
3380 int priority;
3381{
3382 char function_key;
3383 tree arguments;
3384 size_t i;
3385
3386 /* We use `I' to indicate initialization and `D' to indicate
3387 destruction. */
3388 if (constructor_p)
3389 function_key = 'I';
3390 else
3391 function_key = 'D';
3392
3393 /* Begin the function. */
3394 start_objects (function_key, priority);
3395
3396 /* Call the static storage duration function with appropriate
3397 arguments. */
3398 for (i = 0; i < ssdf_decls_used; ++i)
3399 {
3400 arguments = tree_cons (NULL_TREE, build_int_2 (priority, 0),
3401 NULL_TREE);
3402 arguments = tree_cons (NULL_TREE, build_int_2 (constructor_p, 0),
3403 arguments);
3404 expand_expr_stmt (build_function_call (VARRAY_TREE (ssdf_decls, i),
3405 arguments));
3406 }
3407
3408 /* If we're generating code for the DEFAULT_INIT_PRIORITY, throw in
3409 calls to any functions marked with attributes indicating that
3410 they should be called at initialization- or destruction-time. */
3411 if (priority == DEFAULT_INIT_PRIORITY)
3412 {
3413 tree fns;
3414
3415 for (fns = constructor_p ? static_ctors : static_dtors;
3416 fns;
3417 fns = TREE_CHAIN (fns))
3418 expand_expr_stmt (build_function_call (TREE_VALUE (fns), NULL_TREE));
3419 }
3420
3421 /* Close out the function. */
3422 finish_objects (function_key, priority);
3423}
3424
3425/* Generate constructor and destructor functions for the priority
3426 indicated by N. */
3427
3428static int
3429generate_ctor_and_dtor_functions_for_priority (n, data)
3430 splay_tree_node n;
3431 void *data ATTRIBUTE_UNUSED;
3432{
3433 int priority = (int) n->key;
3434 priority_info pi = (priority_info) n->value;
3435
3436 /* Generate the functions themselves, but only if they are really
3437 needed. */
3438 if (pi->initializations_p
3439 || (priority == DEFAULT_INIT_PRIORITY && static_ctors))
3440 generate_ctor_or_dtor_function (/*constructor_p=*/1,
3441 priority);
3442 if (pi->destructions_p
3443 || (priority == DEFAULT_INIT_PRIORITY && static_dtors))
3444 generate_ctor_or_dtor_function (/*constructor_p=*/0,
3445 priority);
3446
3447 /* Keep iterating. */
3448 return 0;
3449}
3450
3451/* This routine is called from the last rule in yyparse ().
3452 Its job is to create all the code needed to initialize and
3453 destroy the global aggregates. We do the destruction
3454 first, since that way we only need to reverse the decls once. */
3455
3456void
3457finish_file ()
3458{
3459 extern int lineno;
3460 int start_time, this_time;
3461 tree vars;
3462 int reconsider;
3463 size_t i;
3464
3465 at_eof = 1;
3466
3467 /* Bad parse errors. Just forget about it. */
3468 if (! global_bindings_p () || current_class_type || decl_namespace_list)
3469 return;
3470
3471 start_time = get_run_time ();
3472
3473 /* Otherwise, GDB can get confused, because in only knows
3474 about source for LINENO-1 lines. */
3475 lineno -= 1;
3476
3477 interface_unknown = 1;
3478 interface_only = 0;
3479
3480 /* We now have to write out all the stuff we put off writing out.
3481 These include:
3482
3483 o Template specializations that we have not yet instantiated,
3484 but which are needed.
3485 o Initialization and destruction for non-local objects with
3486 static storage duration. (Local objects with static storage
3487 duration are initialized when their scope is first entered,
3488 and are cleaned up via atexit.)
3489 o Virtual function tables.
3490
3491 All of these may cause others to be needed. For example,
3492 instantiating one function may cause another to be needed, and
3493 generating the intiailzer for an object may cause templates to be
3494 instantiated, etc., etc. */
3495
3496 this_time = get_run_time ();
3497 parse_time -= this_time - start_time;
3498 varconst_time += this_time - start_time;
3499 start_time = get_run_time ();
3500 permanent_allocation (1);
3501
3502 do
3503 {
3504 /* Non-zero if we need a static storage duration function on
3505 this iteration through the loop. */
3506 int need_ssdf_p = 0;
3507
3508 reconsider = 0;
3509
3510 /* If there are templates that we've put off instantiating, do
3511 them now. */
3512 instantiate_pending_templates ();
3513
3514 /* Write out virtual tables as required. Note that writing out
3515 the virtual table for a template class may cause the
3516 instantiation of members of that class. */
3517 if (walk_globals (vtable_decl_p,
3518 finish_vtable_vardecl,
3519 /*data=*/0))
3520 reconsider = 1;
3521
3522 /* The list of objects with static storage duration is built up
3523 in reverse order, so we reverse it here. We also clear
3524 STATIC_AGGREGATES so that any new aggregates added during the
3525 initialization of these will be initialized in the correct
3526 order when we next come around the loop. */
3527 vars = nreverse (static_aggregates);
3528 static_aggregates = NULL_TREE;
3529 while (vars)
3530 {
3531 if (! TREE_ASM_WRITTEN (TREE_VALUE (vars)))
3532 rest_of_decl_compilation (TREE_VALUE (vars), 0, 1, 1);
3533 if (!need_ssdf_p)
3534 {
3535 /* We need to start a new initialization function each
3536 time through the loop. That's because we need to
3537 know which vtables have been referenced, and
3538 TREE_SYMBOL_REFERENCED isn't computed until a
3539 function is finished, and written out. That's a
3540 deficiency in the back-end. When this is fixed,
3541 these initialization functions could all become
3542 inline, with resulting performance improvements. */
3543 start_static_storage_duration_function ();
3544 need_ssdf_p = 1;
3545 }
3546
3547 do_static_initialization_and_destruction (TREE_VALUE (vars),
3548 TREE_PURPOSE (vars));
3549 reconsider = 1;
3550 vars = TREE_CHAIN (vars);
3551 }
3552
3553 /* Finish up the static storage duration function for this
3554 round. */
3555 if (need_ssdf_p)
3556 finish_static_storage_duration_function ();
3557
3558 /* Go through the various inline functions, and see if any need
3559 synthesizing. */
3560 for (i = 0; i < saved_inlines_used; ++i)
3561 {
3562 tree decl = VARRAY_TREE (saved_inlines, i);
3563 import_export_decl (decl);
3564 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
3565 && TREE_USED (decl)
3566 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
3567 {
3568 /* Even though we're already at the top-level, we push
3569 there again. That way, when we pop back a few lines
3570 hence, all of our state is restored. Otherwise,
3571 finish_function doesn't clean things up, and we end
3572 up with CURRENT_FUNCTION_DECL set. */
3573 push_to_top_level ();
3574 if (DECL_TINFO_FN_P (decl))
3575 synthesize_tinfo_fn (decl);
3576 else
3577 synthesize_method (decl);
3578 pop_from_top_level ();
3579 reconsider = 1;
3580 }
3581 }
3582
3583 /* Mark all functions that might deal with exception-handling as
3584 referenced. */
3585 mark_all_runtime_matches ();
3586
3587 /* We lie to the back-end, pretending that some functions are
3588 not defined when they really are. This keeps these functions
3589 from being put out unncessarily. But, we must stop lying
3590 when the functions are referenced, or if they are not comdat
3591 since they need to be put out now. */
3592 for (i = 0; i < saved_inlines_used; ++i)
3593 {
3594 tree decl = VARRAY_TREE (saved_inlines, i);
3595
3596 if (DECL_NOT_REALLY_EXTERN (decl)
3597 && DECL_INITIAL (decl)
3598 && (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
3599 || !DECL_COMDAT (decl)))
3600 DECL_EXTERNAL (decl) = 0;
3601 }
3602
3603 if (saved_inlines_used
3604 && wrapup_global_declarations (&VARRAY_TREE (saved_inlines, 0),
3605 saved_inlines_used))
3606 reconsider = 1;
3607 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3608 reconsider = 1;
3609
3610 /* Static data members are just like namespace-scope globals. */
3611 for (i = 0; i < pending_statics_used; ++i)
3612 {
3613 tree decl = VARRAY_TREE (pending_statics, i);
3614 if (TREE_ASM_WRITTEN (decl))
3615 continue;
3616 import_export_decl (decl);
3617 if (DECL_NOT_REALLY_EXTERN (decl) && ! DECL_IN_AGGR_P (decl))
3618 DECL_EXTERNAL (decl) = 0;
3619 }
3620 if (pending_statics
3621 && wrapup_global_declarations (&VARRAY_TREE (pending_statics, 0),
3622 pending_statics_used))
3623 reconsider = 1;
3624 }
3625 while (reconsider);
3626
3627 /* We give C linkage to static constructors and destructors. */
3628 push_lang_context (lang_name_c);
3629
3630 /* Generate initialization and destruction functions for all
3631 priorities for which they are required. */
3632 if (priority_info_map)
3633 splay_tree_foreach (priority_info_map,
3634 generate_ctor_and_dtor_functions_for_priority,
3635 /*data=*/0);
3636
3637 /* We're done with the splay-tree now. */
3638 if (priority_info_map)
3639 splay_tree_delete (priority_info_map);
3640
3641 /* We're done with static constructors, so we can go back to "C++"
3642 linkage now. */
3643 pop_lang_context ();
3644
3645 /* Now delete from the chain of variables all virtual function tables.
3646 We output them all ourselves, because each will be treated
3647 specially. */
3648 walk_globals (vtable_decl_p, prune_vtable_vardecl, /*data=*/0);
3649
3650 /* Now, issue warnings about static, but not defined, functions,
3651 etc. */
3652 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
3653
3654 finish_repo ();
3655
3656 /* The entire file is now complete. If requested, dump everything
3657 file. */
3658 if (flag_dump_translation_unit)
3659 dump_node_to_file (global_namespace, flag_dump_translation_unit);
3660
3661 /* If there's some tool that wants to examine the entire translation
3662 unit, let it do so now. */
3663 if (back_end_hook)
3664 (*back_end_hook) (global_namespace);
3665
3666 this_time = get_run_time ();
3667 parse_time -= this_time - start_time;
3668 varconst_time += this_time - start_time;
3669
3670 if (flag_detailed_statistics)
3671 {
3672 dump_tree_statistics ();
3673 dump_time_statistics ();
3674 }
3675}
3676
3677/* This is something of the form 'A()()()()()+1' that has turned out to be an
3678 expr. Since it was parsed like a type, we need to wade through and fix
3679 that. Unfortunately, since operator() is left-associative, we can't use
3680 tail recursion. In the above example, TYPE is `A', and DECL is
3681 `()()()()()'.
3682
3683 Maybe this shouldn't be recursive, but how often will it actually be
3684 used? (jason) */
3685
3686tree
3687reparse_absdcl_as_expr (type, decl)
3688 tree type, decl;
3689{
3690 /* do build_functional_cast (type, NULL_TREE) at bottom */
3691 if (TREE_OPERAND (decl, 0) == NULL_TREE)
3692 return build_functional_cast (type, NULL_TREE);
3693
3694 /* recurse */
3695 decl = reparse_absdcl_as_expr (type, TREE_OPERAND (decl, 0));
3696
3697 decl = build_x_function_call (decl, NULL_TREE, current_class_ref);
3698
3699 if (TREE_CODE (decl) == CALL_EXPR
3700 && (! TREE_TYPE (decl)
3701 || TREE_CODE (TREE_TYPE (decl)) != VOID_TYPE))
3702 decl = require_complete_type (decl);
3703
3704 return decl;
3705}
3706
3707/* This is something of the form `int ((int)(int)(int)1)' that has turned
3708 out to be an expr. Since it was parsed like a type, we need to wade
3709 through and fix that. Since casts are right-associative, we are
3710 reversing the order, so we don't have to recurse.
3711
3712 In the above example, DECL is the `(int)(int)(int)', and EXPR is the
3713 `1'. */
3714
3715tree
3716reparse_absdcl_as_casts (decl, expr)
3717 tree decl, expr;
3718{
3719 tree type;
3720
3721 if (TREE_CODE (expr) == CONSTRUCTOR
3722 && TREE_TYPE (expr) == 0)
3723 {
3724 type = groktypename (TREE_VALUE (CALL_DECLARATOR_PARMS (decl)));
3725 decl = TREE_OPERAND (decl, 0);
3726
3727 expr = digest_init (type, expr, (tree *) 0);
3728 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
3729 {
3730 int failure = complete_array_type (type, expr, 1);
3731 if (failure)
3732 my_friendly_abort (78);
3733 }
3734 }
3735
3736 while (decl)
3737 {
3738 type = groktypename (TREE_VALUE (CALL_DECLARATOR_PARMS (decl)));
3739 decl = TREE_OPERAND (decl, 0);
3740 expr = build_c_cast (type, expr);
3741 }
3742
3743 if (warn_old_style_cast && ! in_system_header
3744 && current_lang_name != lang_name_c)
3745 warning ("use of old-style cast");
3746
3747 return expr;
3748}
3749
3750/* Given plain tree nodes for an expression, build up the full semantics. */
3751
3752tree
3753build_expr_from_tree (t)
3754 tree t;
3755{
3756 if (t == NULL_TREE || t == error_mark_node)
3757 return t;
3758
3759 switch (TREE_CODE (t))
3760 {
3761 case IDENTIFIER_NODE:
3762 return do_identifier (t, 0, NULL_TREE);
3763
3764 case LOOKUP_EXPR:
3765 if (LOOKUP_EXPR_GLOBAL (t))
3766 return do_scoped_id (TREE_OPERAND (t, 0), 0);
3767 else
3768 return do_identifier (TREE_OPERAND (t, 0), 0, NULL_TREE);
3769
3770 case TEMPLATE_ID_EXPR:
3771 return (lookup_template_function
3772 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3773 build_expr_from_tree (TREE_OPERAND (t, 1))));
3774
3775 case INDIRECT_REF:
3776 return build_x_indirect_ref
3777 (build_expr_from_tree (TREE_OPERAND (t, 0)), "unary *");
3778
3779 case CAST_EXPR:
3780 return build_functional_cast
3781 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3782
3783 case REINTERPRET_CAST_EXPR:
3784 return build_reinterpret_cast
3785 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3786
3787 case CONST_CAST_EXPR:
3788 return build_const_cast
3789 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3790
3791 case DYNAMIC_CAST_EXPR:
3792 return build_dynamic_cast
3793 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3794
3795 case STATIC_CAST_EXPR:
3796 return build_static_cast
3797 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3798
3799 case PREDECREMENT_EXPR:
3800 case PREINCREMENT_EXPR:
3801 case POSTDECREMENT_EXPR:
3802 case POSTINCREMENT_EXPR:
3803 case NEGATE_EXPR:
3804 case BIT_NOT_EXPR:
3805 case ABS_EXPR:
3806 case TRUTH_NOT_EXPR:
3807 case ADDR_EXPR:
3808 case CONVERT_EXPR: /* Unary + */
3809 if (TREE_TYPE (t))
3810 return t;
3811 return build_x_unary_op (TREE_CODE (t),
3812 build_expr_from_tree (TREE_OPERAND (t, 0)));
3813
3814 case PLUS_EXPR:
3815 case MINUS_EXPR:
3816 case MULT_EXPR:
3817 case TRUNC_DIV_EXPR:
3818 case CEIL_DIV_EXPR:
3819 case FLOOR_DIV_EXPR:
3820 case ROUND_DIV_EXPR:
3821 case EXACT_DIV_EXPR:
3822 case BIT_AND_EXPR:
3823 case BIT_ANDTC_EXPR:
3824 case BIT_IOR_EXPR:
3825 case BIT_XOR_EXPR:
3826 case TRUNC_MOD_EXPR:
3827 case FLOOR_MOD_EXPR:
3828 case TRUTH_ANDIF_EXPR:
3829 case TRUTH_ORIF_EXPR:
3830 case TRUTH_AND_EXPR:
3831 case TRUTH_OR_EXPR:
3832 case RSHIFT_EXPR:
3833 case LSHIFT_EXPR:
3834 case RROTATE_EXPR:
3835 case LROTATE_EXPR:
3836 case EQ_EXPR:
3837 case NE_EXPR:
3838 case MAX_EXPR:
3839 case MIN_EXPR:
3840 case LE_EXPR:
3841 case GE_EXPR:
3842 case LT_EXPR:
3843 case GT_EXPR:
3844 case MEMBER_REF:
3845 return build_x_binary_op
3846 (TREE_CODE (t),
3847 build_expr_from_tree (TREE_OPERAND (t, 0)),
3848 build_expr_from_tree (TREE_OPERAND (t, 1)));
3849
3850 case DOTSTAR_EXPR:
3851 return build_m_component_ref
3852 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3853 build_expr_from_tree (TREE_OPERAND (t, 1)));
3854
3855 case SCOPE_REF:
3856 return build_offset_ref (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
3857
3858 case ARRAY_REF:
3859 if (TREE_OPERAND (t, 0) == NULL_TREE)
3860 /* new-type-id */
3861 return build_parse_node (ARRAY_REF, NULL_TREE,
3862 build_expr_from_tree (TREE_OPERAND (t, 1)));
3863 return grok_array_decl (build_expr_from_tree (TREE_OPERAND (t, 0)),
3864 build_expr_from_tree (TREE_OPERAND (t, 1)));
3865
3866 case SIZEOF_EXPR:
3867 case ALIGNOF_EXPR:
3868 {
3869 tree r = build_expr_from_tree (TREE_OPERAND (t, 0));
3870 if (TREE_CODE_CLASS (TREE_CODE (r)) != 't')
3871 r = TREE_TYPE (r);
3872 return TREE_CODE (t) == SIZEOF_EXPR ? c_sizeof (r) : c_alignof (r);
3873 }
3874
3875 case MODOP_EXPR:
3876 return build_x_modify_expr
3877 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3878 TREE_CODE (TREE_OPERAND (t, 1)),
3879 build_expr_from_tree (TREE_OPERAND (t, 2)));
3880
3881 case ARROW_EXPR:
3882 return build_x_arrow
3883 (build_expr_from_tree (TREE_OPERAND (t, 0)));
3884
3885 case NEW_EXPR:
3886 return build_new
3887 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3888 build_expr_from_tree (TREE_OPERAND (t, 1)),
3889 build_expr_from_tree (TREE_OPERAND (t, 2)),
3890 NEW_EXPR_USE_GLOBAL (t));
3891
3892 case DELETE_EXPR:
3893 return delete_sanity
3894 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3895 build_expr_from_tree (TREE_OPERAND (t, 1)),
3896 DELETE_EXPR_USE_VEC (t), DELETE_EXPR_USE_GLOBAL (t));
3897
3898 case COMPOUND_EXPR:
3899 if (TREE_OPERAND (t, 1) == NULL_TREE)
3900 return build_x_compound_expr
3901 (build_expr_from_tree (TREE_OPERAND (t, 0)));
3902 else
3903 my_friendly_abort (42);
3904
3905 case METHOD_CALL_EXPR:
3906 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3907 {
3908 tree ref = TREE_OPERAND (t, 0);
3909 return build_scoped_method_call
3910 (build_expr_from_tree (TREE_OPERAND (t, 1)),
3911 build_expr_from_tree (TREE_OPERAND (ref, 0)),
3912 TREE_OPERAND (ref, 1),
3913 build_expr_from_tree (TREE_OPERAND (t, 2)));
3914 }
3915 else
3916 {
3917 tree fn = TREE_OPERAND (t, 0);
3918
3919 /* We can get a TEMPLATE_ID_EXPR here on code like:
3920
3921 x->f<2>();
3922
3923 so we must resolve that. However, we can also get things
3924 like a BIT_NOT_EXPR here, when referring to a destructor,
3925 and things like that are not correctly resolved by
3926 build_expr_from_tree. So, just use build_expr_from_tree
3927 when we really need it. */
3928 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
3929 fn = lookup_template_function
3930 (TREE_OPERAND (fn, 0),
3931 build_expr_from_tree (TREE_OPERAND (fn, 1)));
3932
3933 return build_method_call
3934 (build_expr_from_tree (TREE_OPERAND (t, 1)),
3935 fn,
3936 build_expr_from_tree (TREE_OPERAND (t, 2)),
3937 NULL_TREE, LOOKUP_NORMAL);
3938 }
3939
3940 case CALL_EXPR:
3941 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3942 {
3943 tree ref = TREE_OPERAND (t, 0);
3944 return build_member_call
3945 (build_expr_from_tree (TREE_OPERAND (ref, 0)),
3946 TREE_OPERAND (ref, 1),
3947 build_expr_from_tree (TREE_OPERAND (t, 1)));
3948 }
3949 else
3950 {
3951 tree name = TREE_OPERAND (t, 0);
3952 tree id;
3953 tree args = build_expr_from_tree (TREE_OPERAND (t, 1));
3954 if (args != NULL_TREE && TREE_CODE (name) == LOOKUP_EXPR
3955 && !LOOKUP_EXPR_GLOBAL (name)
3956 && TREE_CODE ((id = TREE_OPERAND (name, 0))) == IDENTIFIER_NODE
3957 && (!current_class_type
3958 || !lookup_member (current_class_type, id, 0, 0)))
3959 {
3960 /* Do Koenig lookup if there are no class members. */
3961 name = do_identifier (id, 0, args);
3962 }
3963 else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
3964 || ! really_overloaded_fn (name))
3965 name = build_expr_from_tree (name);
3966 return build_x_function_call (name, args, current_class_ref);
3967 }
3968
3969 case COND_EXPR:
3970 return build_x_conditional_expr
3971 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3972 build_expr_from_tree (TREE_OPERAND (t, 1)),
3973 build_expr_from_tree (TREE_OPERAND (t, 2)));
3974
3975 case PSEUDO_DTOR_EXPR:
3976 return (finish_pseudo_destructor_call_expr
3977 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3978 build_expr_from_tree (TREE_OPERAND (t, 1)),
3979 build_expr_from_tree (TREE_OPERAND (t, 2))));
3980
3981 case TREE_LIST:
3982 {
3983 tree purpose, value, chain;
3984
3985 if (t == void_list_node)
3986 return t;
3987
3988 purpose = TREE_PURPOSE (t);
3989 if (purpose)
3990 purpose = build_expr_from_tree (purpose);
3991 value = TREE_VALUE (t);
3992 if (value)
3993 value = build_expr_from_tree (value);
3994 chain = TREE_CHAIN (t);
3995 if (chain && chain != void_type_node)
3996 chain = build_expr_from_tree (chain);
3997 return expr_tree_cons (purpose, value, chain);
3998 }
3999
4000 case COMPONENT_REF:
4001 {
4002 tree object = build_expr_from_tree (TREE_OPERAND (t, 0));
4003 tree field = TREE_OPERAND (t, 1);
4004
4005 /* We use a COMPONENT_REF to indicate things of the form `x.b'
4006 and `x.A::b'. We must distinguish between those cases
4007 here. */
4008 if (TREE_CODE (field) == SCOPE_REF)
4009 return build_object_ref (object,
4010 TREE_OPERAND (field, 0),
4011 TREE_OPERAND (field, 1));
4012 else
4013 return build_x_component_ref (object, field,
4014 NULL_TREE, 1);
4015 }
4016
4017 case THROW_EXPR:
4018 return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0)));
4019
4020 case CONSTRUCTOR:
4021 {
4022 tree r;
4023
4024 /* digest_init will do the wrong thing if we let it. */
4025 if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
4026 return t;
4027
4028 r = build_nt (CONSTRUCTOR, NULL_TREE,
4029 build_expr_from_tree (CONSTRUCTOR_ELTS (t)));
4030 TREE_HAS_CONSTRUCTOR (r) = TREE_HAS_CONSTRUCTOR (t);
4031
4032 if (TREE_TYPE (t))
4033 return digest_init (TREE_TYPE (t), r, 0);
4034 return r;
4035 }
4036
4037 case TYPEID_EXPR:
4038 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 0))) == 't')
4039 return get_typeid (TREE_OPERAND (t, 0));
4040 return build_x_typeid (build_expr_from_tree (TREE_OPERAND (t, 0)));
4041
4042 case VAR_DECL:
4043 return convert_from_reference (t);
4044
4045 default:
4046 return t;
4047 }
4048}
4049
4050/* This is something of the form `int (*a)++' that has turned out to be an
4051 expr. It was only converted into parse nodes, so we need to go through
4052 and build up the semantics. Most of the work is done by
4053 build_expr_from_tree, above.
4054
4055 In the above example, TYPE is `int' and DECL is `*a'. */
4056
4057tree
4058reparse_decl_as_expr (type, decl)
4059 tree type, decl;
4060{
4061 decl = build_expr_from_tree (decl);
4062 if (type)
4063 return build_functional_cast (type, build_expr_list (NULL_TREE, decl));
4064 else
4065 return decl;
4066}
4067
4068/* This is something of the form `int (*a)' that has turned out to be a
4069 decl. It was only converted into parse nodes, so we need to do the
4070 checking that make_{pointer,reference}_declarator do. */
4071
4072tree
4073finish_decl_parsing (decl)
4074 tree decl;
4075{
4076 extern int current_class_depth;
4077
4078 switch (TREE_CODE (decl))
4079 {
4080 case IDENTIFIER_NODE:
4081 return decl;
4082 case INDIRECT_REF:
4083 return make_pointer_declarator
4084 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0)));
4085 case ADDR_EXPR:
4086 return make_reference_declarator
4087 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0)));
4088 case BIT_NOT_EXPR:
4089 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0));
4090 return decl;
4091 case SCOPE_REF:
4092 push_nested_class (TREE_TYPE (TREE_OPERAND (decl, 0)), 3);
4093 TREE_COMPLEXITY (decl) = current_class_depth;
4094 return decl;
4095 case ARRAY_REF:
4096 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0));
4097 return decl;
4098 case TREE_LIST:
4099 /* For attribute handling. */
4100 TREE_VALUE (decl) = finish_decl_parsing (TREE_VALUE (decl));
4101 return decl;
4102 default:
4103 my_friendly_abort (5);
4104 return NULL_TREE;
4105 }
4106}
4107
4108tree
4109check_cp_case_value (value)
4110 tree value;
4111{
4112 if (value == NULL_TREE)
4113 return value;
4114
4115 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4116 STRIP_TYPE_NOPS (value);
4117
4118 if (TREE_READONLY_DECL_P (value))
4119 {
4120 value = decl_constant_value (value);
4121 STRIP_TYPE_NOPS (value);
4122 }
4123 value = fold (value);
4124
4125 if (TREE_CODE (value) != INTEGER_CST
4126 && value != error_mark_node)
4127 {
4128 cp_error ("case label `%E' does not reduce to an integer constant",
4129 value);
4130 value = error_mark_node;
4131 }
4132 else
4133 /* Promote char or short to int. */
4134 value = default_conversion (value);
4135
4136 constant_expression_warning (value);
4137
4138 return value;
4139}
4140
4141/* Return 1 if root encloses child. */
4142
4143static int
4144is_namespace_ancestor (root, child)
4145 tree root, child;
4146{
4147 if (root == child)
4148 return 1;
4149 if (root == global_namespace)
4150 return 1;
4151 if (child == global_namespace)
4152 return 0;
4153 return is_namespace_ancestor (root, CP_DECL_CONTEXT (child));
4154}
4155
4156
4157/* Return the namespace that is the common ancestor
4158 of two given namespaces. */
4159
4160tree
4161namespace_ancestor (ns1, ns2)
4162 tree ns1, ns2;
4163{
4164 if (is_namespace_ancestor (ns1, ns2))
4165 return ns1;
4166 return namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2);
4167}
4168
4169/* Insert used into the using list of user. Set indirect_flag if this
4170 directive is not directly from the source. Also find the common
4171 ancestor and let our users know about the new namespace */
4172static void
4173add_using_namespace (user, used, indirect)
4174 tree user;
4175 tree used;
4176 int indirect;
4177{
4178 tree t;
4179 /* Using oneself is a no-op. */
4180 if (user == used)
4181 return;
4182 my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
4183 my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
4184 /* Check if we already have this. */
4185 t = purpose_member (used, DECL_NAMESPACE_USING (user));
4186 if (t != NULL_TREE)
4187 {
4188 if (!indirect)
4189 /* Promote to direct usage. */
4190 TREE_INDIRECT_USING (t) = 0;
4191 return;
4192 }
4193
4194 /* Add used to the user's using list. */
4195 DECL_NAMESPACE_USING (user)
4196 = perm_tree_cons (used, namespace_ancestor (user, used),
4197 DECL_NAMESPACE_USING (user));
4198
4199 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
4200
4201 /* Add user to the used's users list. */
4202 DECL_NAMESPACE_USERS (used)
4203 = perm_tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
4204
4205 /* Recursively add all namespaces used. */
4206 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
4207 /* indirect usage */
4208 add_using_namespace (user, TREE_PURPOSE (t), 1);
4209
4210 /* Tell everyone using us about the new used namespaces. */
4211 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
4212 add_using_namespace (TREE_PURPOSE (t), used, 1);
4213}
4214
4215/* Combines two sets of overloaded functions into an OVERLOAD chain, removing
4216 duplicates. The first list becomes the tail of the result.
4217
4218 The algorithm is O(n^2). We could get this down to O(n log n) by
4219 doing a sort on the addresses of the functions, if that becomes
4220 necessary. */
4221
4222static tree
4223merge_functions (s1, s2)
4224 tree s1;
4225 tree s2;
4226{
4227 for (; s2; s2 = OVL_NEXT (s2))
4228 {
4229 tree fn = OVL_CURRENT (s2);
4230 if (! ovl_member (fn, s1))
4231 s1 = build_overload (fn, s1);
4232 }
4233 return s1;
4234}
4235
4236/* This should return an error not all definitions define functions.
4237 It is not an error if we find two functions with exactly the
4238 same signature, only if these are selected in overload resolution.
4239 old is the current set of bindings, new the freshly-found binding.
4240 XXX Do we want to give *all* candidates in case of ambiguity?
4241 XXX In what way should I treat extern declarations?
4242 XXX I don't want to repeat the entire duplicate_decls here */
4243
4244static tree
4245ambiguous_decl (name, old, new, flags)
4246 tree name;
4247 tree old;
4248 tree new;
4249 int flags;
4250{
4251 tree val, type;
4252 my_friendly_assert (old != NULL_TREE, 393);
4253 /* Copy the value. */
4254 val = BINDING_VALUE (new);
4255 if (val)
4256 switch (TREE_CODE (val))
4257 {
4258 case TEMPLATE_DECL:
4259 /* If we expect types or namespaces, and not templates,
4260 or this is not a template class. */
4261 if (LOOKUP_QUALIFIERS_ONLY (flags)
4262 && !DECL_CLASS_TEMPLATE_P (val))
4263 val = NULL_TREE;
4264 break;
4265 case TYPE_DECL:
4266 if (LOOKUP_NAMESPACES_ONLY (flags))
4267 val = NULL_TREE;
4268 break;
4269 case NAMESPACE_DECL:
4270 if (LOOKUP_TYPES_ONLY (flags))
4271 val = NULL_TREE;
4272 break;
4273 default:
4274 if (LOOKUP_QUALIFIERS_ONLY (flags))
4275 val = NULL_TREE;
4276 }
4277
4278 if (!BINDING_VALUE (old))
4279 BINDING_VALUE (old) = val;
4280 else if (val && val != BINDING_VALUE (old))
4281 {
4282 if (is_overloaded_fn (BINDING_VALUE (old))
4283 && is_overloaded_fn (val))
4284 {
4285 BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old),
4286 val);
4287 }
4288 else
4289 {
4290 /* Some declarations are functions, some are not. */
4291 if (flags & LOOKUP_COMPLAIN)
4292 {
4293 /* If we've already given this error for this lookup,
4294 BINDING_VALUE (old) is error_mark_node, so let's not
4295 repeat ourselves. */
4296 if (BINDING_VALUE (old) != error_mark_node)
4297 {
4298 cp_error ("use of `%D' is ambiguous", name);
4299 cp_error_at (" first declared as `%#D' here",
4300 BINDING_VALUE (old));
4301 }
4302 cp_error_at (" also declared as `%#D' here", val);
4303 }
4304 return error_mark_node;
4305 }
4306 }
4307 /* ... and copy the type. */
4308 type = BINDING_TYPE (new);
4309 if (LOOKUP_NAMESPACES_ONLY (flags))
4310 type = NULL_TREE;
4311 if (!BINDING_TYPE (old))
4312 BINDING_TYPE (old) = type;
4313 else if (type && BINDING_TYPE (old) != type)
4314 {
4315 if (flags & LOOKUP_COMPLAIN)
4316 {
4317 cp_error ("`%D' denotes an ambiguous type",name);
4318 cp_error_at (" first type here", BINDING_TYPE (old));
4319 cp_error_at (" other type here", type);
4320 }
4321 }
4322 return old;
4323}
4324
4325/* Subroutine of unualified_namespace_lookup:
4326 Add the bindings of NAME in used namespaces to VAL.
4327 We are currently looking for names in namespace SCOPE, so we
4328 look through USINGS for using-directives of namespaces
4329 which have SCOPE as a common ancestor with the current scope.
4330 Returns zero on errors. */
4331
4332int
4333lookup_using_namespace (name, val, usings, scope, flags, spacesp)
4334 tree name, val, usings, scope;
4335 int flags;
4336 tree *spacesp;
4337{
4338 tree iter;
4339 tree val1;
4340 /* Iterate over all used namespaces in current, searching for using
4341 directives of scope. */
4342 for (iter = usings; iter; iter = TREE_CHAIN (iter))
4343 if (TREE_VALUE (iter) == scope)
4344 {
4345 if (spacesp)
4346 *spacesp = scratch_tree_cons (TREE_PURPOSE (iter), NULL_TREE,
4347 *spacesp);
4348 val1 = binding_for_name (name, TREE_PURPOSE (iter));
4349 /* Resolve ambiguities. */
4350 val = ambiguous_decl (name, val, val1, flags);
4351 }
4352 return val != error_mark_node;
4353}
4354
4355/* [namespace.qual]
4356 Accepts the NAME to lookup and its qualifying SCOPE.
4357 Returns the name/type pair found into the CPLUS_BINDING RESULT,
4358 or 0 on error. */
4359
4360int
4361qualified_lookup_using_namespace (name, scope, result, flags)
4362 tree name;
4363 tree scope;
4364 tree result;
4365 int flags;
4366{
4367 /* Maintain a list of namespaces visited... */
4368 tree seen = NULL_TREE;
4369 /* ... and a list of namespace yet to see. */
4370 tree todo = NULL_TREE;
4371 tree usings;
4372 while (scope && (result != error_mark_node))
4373 {
4374 seen = temp_tree_cons (scope, NULL_TREE, seen);
4375 result = ambiguous_decl (name, result,
4376 binding_for_name (name, scope), flags);
4377 if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
4378 /* Consider using directives. */
4379 for (usings = DECL_NAMESPACE_USING (scope); usings;
4380 usings = TREE_CHAIN (usings))
4381 /* If this was a real directive, and we have not seen it. */
4382 if (!TREE_INDIRECT_USING (usings)
4383 && !purpose_member (TREE_PURPOSE (usings), seen))
4384 todo = temp_tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
4385 if (todo)
4386 {
4387 scope = TREE_PURPOSE (todo);
4388 todo = TREE_CHAIN (todo);
4389 }
4390 else
4391 scope = NULL_TREE; /* If there never was a todo list. */
4392 }
4393 return result != error_mark_node;
4394}
4395
4396/* [namespace.memdef]/2 */
4397
4398/* Set the context of a declaration to scope. Complain if we are not
4399 outside scope. */
4400
4401void
4402set_decl_namespace (decl, scope, friendp)
4403 tree decl;
4404 tree scope;
4405 int friendp;
4406{
4407 tree old;
4408 if (scope == std_node)
4409 scope = global_namespace;
4410 /* Get rid of namespace aliases. */
4411 scope = ORIGINAL_NAMESPACE (scope);
4412
4413 /* It is ok for friends to be qualified in parallel space. */
4414 if (!friendp && !is_namespace_ancestor (current_namespace, scope))
4415 cp_error ("declaration of `%D' not in a namespace surrounding `%D'",
4416 decl, scope);
4417 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
4418 if (scope != current_namespace)
4419 {
4420 /* See whether this has been declared in the namespace. */
4421 old = namespace_binding (DECL_NAME (decl), scope);
4422 if (!old)
4423 /* No old declaration at all. */
4424 goto complain;
4425 if (!is_overloaded_fn (decl))
4426 /* Don't compare non-function decls with decls_match here,
4427 since it can't check for the correct constness at this
4428 point. pushdecl will find those errors later. */
4429 return;
4430 /* Since decl is a function, old should contain a function decl. */
4431 if (!is_overloaded_fn (old))
4432 goto complain;
4433 if (processing_template_decl || processing_specialization)
4434 /* We have not yet called push_template_decl to turn the
4435 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
4436 won't match. But, we'll check later, when we construct the
4437 template. */
4438 return;
4439 for (; old; old = OVL_NEXT (old))
4440 if (decls_match (decl, OVL_CURRENT (old)))
4441 return;
4442 }
4443 else
4444 return;
4445 complain:
4446 cp_error ("`%D' should have been declared inside `%D'",
4447 decl, scope);
4448}
4449
4450/* Compute the namespace where a declaration is defined. */
4451
4452static tree
4453decl_namespace (decl)
4454 tree decl;
4455{
4456 while (DECL_CONTEXT (decl))
4457 {
4458 decl = DECL_CONTEXT (decl);
4459 if (TREE_CODE (decl) == NAMESPACE_DECL)
4460 return decl;
4461 if (TREE_CODE_CLASS (TREE_CODE (decl)) == 't')
4462 decl = TYPE_STUB_DECL (decl);
4463 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd', 390);
4464 }
4465
4466 return global_namespace;
4467}
4468
4469/* Return the namespace where the current declaration is declared. */
4470
4471tree
4472current_decl_namespace ()
4473{
4474 tree result;
4475 /* If we have been pushed into a different namespace, use it. */
4476 if (decl_namespace_list)
4477 return TREE_PURPOSE (decl_namespace_list);
4478
4479 if (current_class_type)
4480 result = decl_namespace (TYPE_STUB_DECL (current_class_type));
4481 else if (current_function_decl)
4482 result = decl_namespace (current_function_decl);
4483 else
4484 result = current_namespace;
4485 return result;
4486}
4487
4488/* Temporarily set the namespace for the current declaration. */
4489
4490void
4491push_decl_namespace (decl)
4492 tree decl;
4493{
4494 if (TREE_CODE (decl) != NAMESPACE_DECL)
4495 decl = decl_namespace (decl);
4496 decl_namespace_list = tree_cons (decl, NULL_TREE, decl_namespace_list);
4497}
4498
4499void
4500pop_decl_namespace ()
4501{
4502 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
4503}
4504
4505/* Enter a class or namespace scope. */
4506
4507void
4508push_scope (t)
4509 tree t;
4510{
4511 if (TREE_CODE (t) == NAMESPACE_DECL)
4512 push_decl_namespace (t);
4513 else
4514 pushclass (t, 2);
4515}
4516
4517/* Leave scope pushed by push_scope. */
4518
4519void
4520pop_scope (t)
4521 tree t;
4522{
4523 if (TREE_CODE (t) == NAMESPACE_DECL)
4524 pop_decl_namespace ();
4525 else
4526 popclass ();
4527}
4528
4529/* [basic.lookup.koenig] */
4530/* A non-zero return value in the functions below indicates an error.
4531 All nodes allocated in the procedure are on the scratch obstack. */
4532
4533struct arg_lookup
4534{
4535 tree name;
4536 tree namespaces;
4537 tree classes;
4538 tree functions;
4539};
4540
4541static int arg_assoc PROTO((struct arg_lookup*, tree));
4542static int arg_assoc_args PROTO((struct arg_lookup*, tree));
4543static int arg_assoc_type PROTO((struct arg_lookup*, tree));
4544static int add_function PROTO((struct arg_lookup *, tree));
4545static int arg_assoc_namespace PROTO((struct arg_lookup *, tree));
4546static int arg_assoc_class PROTO((struct arg_lookup *, tree));
4547
4548/* Add a function to the lookup structure.
4549 Returns 1 on error. */
4550
4551static int
4552add_function (k, fn)
4553 struct arg_lookup *k;
4554 tree fn;
4555{
4556 /* We used to check here to see if the function was already in the list,
4557 but that's O(n^2), which is just too expensive for function lookup.
4558 Now we deal with the occasional duplicate in joust. In doing this, we
4559 assume that the number of duplicates will be small compared to the
4560 total number of functions being compared, which should usually be the
4561 case. */
4562
4563 /* We must find only functions, or exactly one non-function. */
4564 if (k->functions && is_overloaded_fn (k->functions)
4565 && is_overloaded_fn (fn))
4566 k->functions = build_overload (fn, k->functions);
4567 else if (k->functions)
4568 {
4569 tree f1 = OVL_CURRENT (k->functions);
4570 tree f2 = fn;
4571 if (is_overloaded_fn (f1))
4572 {
4573 fn = f1; f1 = f2; f2 = fn;
4574 }
4575 cp_error_at ("`%D' is not a function,", f1);
4576 cp_error_at (" conflict with `%D'", f2);
4577 cp_error (" in call to `%D'", k->name);
4578 return 1;
4579 }
4580 else
4581 k->functions = fn;
4582 return 0;
4583}
4584
4585/* Add functions of a namespace to the lookup structure.
4586 Returns 1 on error. */
4587
4588static int
4589arg_assoc_namespace (k, scope)
4590 struct arg_lookup *k;
4591 tree scope;
4592{
4593 tree value;
4594
4595 if (purpose_member (scope, k->namespaces))
4596 return 0;
4597 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4598
4599 value = namespace_binding (k->name, scope);
4600 if (!value)
4601 return 0;
4602
4603 for (; value; value = OVL_NEXT (value))
4604 if (add_function (k, OVL_CURRENT (value)))
4605 return 1;
4606
4607 return 0;
4608}
4609
4610/* Adds everything associated with class to the lookup structure.
4611 Returns 1 on error. */
4612
4613static int
4614arg_assoc_class (k, type)
4615 struct arg_lookup* k;
4616 tree type;
4617{
4618 tree list, friends, context;
4619 int i;
4620
4621 /* Backend build structures, such as __builtin_va_list, aren't
4622 affected by all this. */
4623 if (!CLASS_TYPE_P (type))
4624 return 0;
4625
4626 if (purpose_member (type, k->classes))
4627 return 0;
4628 k->classes = tree_cons (type, NULL_TREE, k->classes);
4629
4630 context = decl_namespace (TYPE_MAIN_DECL (type));
4631 if (arg_assoc_namespace (k, context))
4632 return 1;
4633
4634 /* Process baseclasses. */
4635 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
4636 if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
4637 return 1;
4638
4639 /* Process friends. */
4640 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4641 list = TREE_CHAIN (list))
4642 if (k->name == TREE_PURPOSE (list))
4643 for (friends = TREE_VALUE (list); friends;
4644 friends = TREE_CHAIN (friends))
4645 /* Only interested in global functions with potentially hidden
4646 (i.e. unqualified) declarations. */
4647 if (TREE_PURPOSE (list) == error_mark_node && TREE_VALUE (list)
4648 && decl_namespace (TREE_VALUE (list)) == context)
4649 if (add_function (k, TREE_VALUE (list)))
4650 return 1;
4651
4652 /* Process template arguments. */
4653 if (CLASSTYPE_TEMPLATE_INFO (type))
4654 {
4655 list = innermost_args (CLASSTYPE_TI_ARGS (type));
4656 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4657 arg_assoc (k, TREE_VEC_ELT (list, i));
4658 }
4659
4660 return 0;
4661}
4662
4663/* Adds everything associated with a given type.
4664 Returns 1 on error. */
4665
4666static int
4667arg_assoc_type (k, type)
4668 struct arg_lookup *k;
4669 tree type;
4670{
4671 switch (TREE_CODE (type))
4672 {
4673 case VOID_TYPE:
4674 case INTEGER_TYPE:
4675 case REAL_TYPE:
4676 case COMPLEX_TYPE:
4677 case CHAR_TYPE:
4678 case BOOLEAN_TYPE:
4679 return 0;
4680 case RECORD_TYPE:
4681 if (TYPE_PTRMEMFUNC_P (type))
4682 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4683 return arg_assoc_class (k, type);
4684 case POINTER_TYPE:
4685 case REFERENCE_TYPE:
4686 case ARRAY_TYPE:
4687 return arg_assoc_type (k, TREE_TYPE (type));
4688 case UNION_TYPE:
4689 case ENUMERAL_TYPE:
4690 return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
4691 case OFFSET_TYPE:
4692 /* Pointer to member: associate class type and value type. */
4693 if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
4694 return 1;
4695 return arg_assoc_type (k, TREE_TYPE (type));
4696 case METHOD_TYPE:
4697 /* The basetype is referenced in the first arg type, so just
4698 fall through. */
4699 case FUNCTION_TYPE:
4700 /* Associate the parameter types. */
4701 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4702 return 1;
4703 /* Associate the return type. */
4704 return arg_assoc_type (k, TREE_TYPE (type));
4705 case TEMPLATE_TYPE_PARM:
4706 case TEMPLATE_TEMPLATE_PARM:
4707 return 0;
4708 case LANG_TYPE:
4709 if (type == unknown_type_node)
4710 return 0;
4711 /* else fall through */
4712 default:
4713 my_friendly_abort (390);
4714 }
4715 return 0;
4716}
4717
4718/* Adds everything associated with arguments. Returns 1 on error. */
4719
4720static int
4721arg_assoc_args (k, args)
4722 struct arg_lookup* k;
4723 tree args;
4724{
4725 for (; args; args = TREE_CHAIN (args))
4726 if (arg_assoc (k, TREE_VALUE (args)))
4727 return 1;
4728 return 0;
4729}
4730
4731/* Adds everything associated with a given tree_node. Returns 1 on error. */
4732
4733static int
4734arg_assoc (k, n)
4735 struct arg_lookup* k;
4736 tree n;
4737{
4738 if (n == error_mark_node)
4739 return 0;
4740
4741 if (TREE_CODE_CLASS (TREE_CODE (n)) == 't')
4742 return arg_assoc_type (k, n);
4743
4744 if (! type_unknown_p (n))
4745 return arg_assoc_type (k, TREE_TYPE (n));
4746
4747 if (TREE_CODE (n) == ADDR_EXPR)
4748 n = TREE_OPERAND (n, 0);
4749 if (TREE_CODE (n) == COMPONENT_REF)
4750 n = TREE_OPERAND (n, 1);
4751 if (TREE_CODE (n) == OFFSET_REF)
4752 n = TREE_OPERAND (n, 1);
4753 while (TREE_CODE (n) == TREE_LIST)
4754 n = TREE_VALUE (n);
4755
4756 if (TREE_CODE (n) == FUNCTION_DECL)
4757 return arg_assoc_type (k, TREE_TYPE (n));
4758 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4759 {
4760 /* [basic.lookup.koenig]
4761
4762 If T is a template-id, its associated namespaces and classes
4763 are the namespace in which the template is defined; for
4764 member templates, the member template's class; the namespaces
4765 and classes associated with the types of the template
4766 arguments provided for template type parameters (excluding
4767 template template parameters); the namespaces in which any
4768 template template arguments are defined; and the classes in
4769 which any member templates used as template template
4770 arguments are defined. [Note: non-type template arguments do
4771 not contribute to the set of associated namespaces. ] */
4772 tree template = TREE_OPERAND (n, 0);
4773 tree args = TREE_OPERAND (n, 1);
4774 tree ctx;
4775 tree arg;
4776
4777 /* First, the template. There may actually be more than one if
4778 this is an overloaded function template. But, in that case,
4779 we only need the first; all the functions will be in the same
4780 namespace. */
4781 template = OVL_CURRENT (template);
4782
4783 ctx = CP_DECL_CONTEXT (template);
4784
4785 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4786 {
4787 if (arg_assoc_namespace (k, ctx) == 1)
4788 return 1;
4789 }
4790 /* It must be a member template. */
4791 else if (arg_assoc_class (k, ctx) == 1)
4792 return 1;
4793
4794 /* Now the arguments. */
4795 for (arg = args; arg != NULL_TREE; arg = TREE_CHAIN (arg))
4796 {
4797 tree t = TREE_VALUE (arg);
4798
4799 if (TREE_CODE (t) == TEMPLATE_DECL)
4800 {
4801 ctx = CP_DECL_CONTEXT (t);
4802 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4803 {
4804 if (arg_assoc_namespace (k, ctx) == 1)
4805 return 1;
4806 }
4807 else if (arg_assoc_class (k, ctx) == 1)
4808 return 1;
4809 }
4810 else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't'
4811 && arg_assoc_type (k, t) == 1)
4812 return 1;
4813 }
4814 }
4815 else
4816 {
4817 my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715);
4818
4819 for (; n; n = OVL_CHAIN (n))
4820 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4821 return 1;
4822 }
4823
4824 return 0;
4825}
4826
4827/* Performs Koenig lookup depending on arguments, where fns
4828 are the functions found in normal lookup. */
4829
4830tree
4831lookup_arg_dependent (name, fns, args)
4832 tree name;
4833 tree fns;
4834 tree args;
4835{
4836 struct arg_lookup k;
4837
4838 k.name = name;
4839 k.functions = fns;
4840 k.classes = NULL_TREE;
4841
4842 /* Note that we've already looked at some namespaces during normal
4843 unqualified lookup, unless we found a decl in function scope. */
4844 if (fns && ! TREE_PERMANENT (OVL_CURRENT (fns)))
4845 k.namespaces = NULL_TREE;
4846 else
4847 unqualified_namespace_lookup (name, 0, &k.namespaces);
4848
4849 push_scratch_obstack ();
4850 arg_assoc_args (&k, args);
4851 pop_obstacks ();
4852 return k.functions;
4853}
4854
4855/* Process a namespace-alias declaration. */
4856
4857void
4858do_namespace_alias (alias, namespace)
4859 tree alias, namespace;
4860{
4861 if (TREE_CODE (namespace) != NAMESPACE_DECL)
4862 {
4863 /* The parser did not find it, so it's not there. */
4864 cp_error ("unknown namespace `%D'", namespace);
4865 return;
4866 }
4867
4868 namespace = ORIGINAL_NAMESPACE (namespace);
4869
4870 /* Build the alias. */
4871 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
4872 DECL_NAMESPACE_ALIAS (alias) = namespace;
4873 pushdecl (alias);
4874}
4875
4876/* Check a non-member using-declaration. Return the name and scope
4877 being used, and the USING_DECL, or NULL_TREE on failure. */
4878
4879static tree
4880validate_nonmember_using_decl (decl, scope, name)
4881 tree decl;
4882 tree *scope;
4883 tree *name;
4884{
4885 if (TREE_CODE (decl) == SCOPE_REF
4886 && TREE_OPERAND (decl, 0) == std_node)
4887 {
4888 if (namespace_bindings_p ()
4889 && current_namespace == global_namespace)
4890 /* There's no need for a using declaration at all, here,
4891 since `std' is the same as `::'. We can't just pass this
4892 on because we'll complain later about declaring something
4893 in the same scope as a using declaration with the same
4894 name. We return NULL_TREE which indicates to the caller
4895 that there's no need to do any further processing. */
4896 return NULL_TREE;
4897
4898 *scope = global_namespace;
4899 *name = TREE_OPERAND (decl, 1);
4900 }
4901 else if (TREE_CODE (decl) == SCOPE_REF)
4902 {
4903 *scope = TREE_OPERAND (decl, 0);
4904 *name = TREE_OPERAND (decl, 1);
4905
4906 /* [namespace.udecl]
4907
4908 A using-declaration for a class member shall be a
4909 member-declaration. */
4910 if (TREE_CODE (*scope) != NAMESPACE_DECL)
4911 {
4912 if (TYPE_P (*scope))
4913 cp_error ("`%T' is not a namespace", *scope);
4914 else
4915 cp_error ("`%D' is not a namespace", *scope);
4916 return NULL_TREE;
4917 }
4918 }
4919 else if (TREE_CODE (decl) == IDENTIFIER_NODE
4920 || TREE_CODE (decl) == TYPE_DECL
4921 || TREE_CODE (decl) == TEMPLATE_DECL)
4922 {
4923 *scope = global_namespace;
4924 *name = decl;
4925 }
4926 else
4927 my_friendly_abort (382);
4928 if (TREE_CODE_CLASS (TREE_CODE (*name)) == 'd')
4929 *name = DECL_NAME (*name);
4930 /* Make a USING_DECL. */
4931 return push_using_decl (*scope, *name);
4932}
4933
4934/* Process local and global using-declarations. */
4935
4936static void
4937do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
4938 tree scope, name;
4939 tree oldval, oldtype;
4940 tree *newval, *newtype;
4941{
4942 tree decls;
4943 struct tree_binding _decls;
4944
4945 *newval = *newtype = NULL_TREE;
4946 decls = binding_init (&_decls);
4947 if (!qualified_lookup_using_namespace (name, scope, decls, 0))
4948 /* Lookup error */
4949 return;
4950
4951 if (!BINDING_VALUE (decls) && !BINDING_TYPE (decls))
4952 {
4953 cp_error ("`%D' not declared", name);
4954 return;
4955 }
4956
4957 /* Check for using functions. */
4958 if (BINDING_VALUE (decls) && is_overloaded_fn (BINDING_VALUE (decls)))
4959 {
4960 tree tmp, tmp1;
4961
4962 if (oldval && !is_overloaded_fn (oldval))
4963 {
4964 duplicate_decls (OVL_CURRENT (BINDING_VALUE (decls)), oldval);
4965 oldval = NULL_TREE;
4966 }
4967
4968 *newval = oldval;
4969 for (tmp = BINDING_VALUE (decls); tmp; tmp = OVL_NEXT (tmp))
4970 {
4971 tree new_fn = OVL_CURRENT (tmp);
4972
4973 /* [namespace.udecl]
4974
4975 If a function declaration in namespace scope or block
4976 scope has the same name and the same parameter types as a
4977 function introduced by a using declaration the program is
4978 ill-formed. */
4979 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
4980 {
4981 tree old_fn = OVL_CURRENT (tmp1);
4982
4983 if (!OVL_USED (tmp1)
4984 && compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
4985 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
4986 {
4987 /* There was already a non-using declaration in
4988 this scope with the same parameter types. */
4989 cp_error ("`%D' is already declared in this scope",
4990 name);
4991 break;
4992 }
4993 else if (duplicate_decls (new_fn, old_fn))
4994 /* We're re-using something we already used
4995 before. We don't need to add it again. */
4996 break;
4997 }
4998
4999 /* If we broke out of the loop, there's no reason to add
5000 this function to the using declarations for this
5001 scope. */
5002 if (tmp1)
5003 continue;
5004
5005 *newval = build_overload (OVL_CURRENT (tmp), *newval);
5006 if (TREE_CODE (*newval) != OVERLOAD)
5007 *newval = ovl_cons (*newval, NULL_TREE);
5008 OVL_USED (*newval) = 1;
5009 }
5010 }
5011 else
5012 {
5013 *newval = BINDING_VALUE (decls);
5014 if (oldval)
5015 duplicate_decls (*newval, oldval);
5016 }
5017
5018 *newtype = BINDING_TYPE (decls);
5019 if (oldtype && *newtype && oldtype != *newtype)
5020 {
5021 cp_error ("using directive `%D' introduced ambiguous type `%T'",
5022 name, oldtype);
5023 return;
5024 }
5025}
5026
5027/* Process a using-declaration not appearing in class or local scope. */
5028
5029void
5030do_toplevel_using_decl (decl)
5031 tree decl;
5032{
5033 tree scope, name, binding;
5034 tree oldval, oldtype, newval, newtype;
5035
5036 decl = validate_nonmember_using_decl (decl, &scope, &name);
5037 if (decl == NULL_TREE)
5038 return;
5039
5040 binding = binding_for_name (name, current_namespace);
5041
5042 oldval = BINDING_VALUE (binding);
5043 oldtype = BINDING_TYPE (binding);
5044
5045 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
5046
5047 /* Copy declarations found. */
5048 if (newval)
5049 BINDING_VALUE (binding) = newval;
5050 if (newtype)
5051 BINDING_TYPE (binding) = newtype;
5052 return;
5053}
5054
5055/* Process a using-declaration at function scope. */
5056
5057void
5058do_local_using_decl (decl)
5059 tree decl;
5060{
5061 tree scope, name;
5062 tree oldval, oldtype, newval, newtype;
5063
5064 decl = validate_nonmember_using_decl (decl, &scope, &name);
5065 if (decl == NULL_TREE)
5066 return;
5067
5068 oldval = lookup_name_current_level (name);
5069 oldtype = lookup_type_current_level (name);
5070
5071 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
5072
5073 if (newval)
5074 {
5075 if (is_overloaded_fn (newval))
5076 {
5077 tree fn, term;
5078
5079 /* We only need to push declarations for those functions
5080 that were not already bound in the current level.
5081 The old value might be NULL_TREE, it might be a single
5082 function, or an OVERLOAD. */
5083 if (oldval && TREE_CODE (oldval) == OVERLOAD)
5084 term = OVL_FUNCTION (oldval);
5085 else
5086 term = oldval;
5087 for (fn = newval; fn && OVL_CURRENT (fn) != term;
5088 fn = OVL_NEXT (fn))
5089 push_overloaded_decl (OVL_CURRENT (fn),
5090 PUSH_LOCAL | PUSH_USING);
5091 }
5092 else
5093 push_local_binding (name, newval, PUSH_USING);
5094 }
5095 if (newtype)
5096 set_identifier_type_value (name, newtype);
5097}
5098
5099tree
5100do_class_using_decl (decl)
5101 tree decl;
5102{
5103 tree name, value;
5104
5105 if (TREE_CODE (decl) != SCOPE_REF
5106 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (decl, 0))) != 't')
5107 {
5108 cp_error ("using-declaration for non-member at class scope");
5109 return NULL_TREE;
5110 }
5111 name = TREE_OPERAND (decl, 1);
5112 if (TREE_CODE (name) == BIT_NOT_EXPR)
5113 {
5114 cp_error ("using-declaration for destructor");
5115 return NULL_TREE;
5116 }
5117 if (TREE_CODE (name) == TYPE_DECL)
5118 name = DECL_NAME (name);
5119
5120 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
5121
5122 value = build_lang_decl (USING_DECL, name, void_type_node);
5123 DECL_INITIAL (value) = TREE_OPERAND (decl, 0);
5124 return value;
5125}
5126
5127/* Process a using-directive. */
5128
5129void
5130do_using_directive (namespace)
5131 tree namespace;
5132{
5133 if (namespace == std_node)
5134 return;
5135 /* using namespace A::B::C; */
5136 if (TREE_CODE (namespace) == SCOPE_REF)
5137 namespace = TREE_OPERAND (namespace, 1);
5138 if (TREE_CODE (namespace) == IDENTIFIER_NODE)
5139 {
5140 /* Lookup in lexer did not find a namespace. */
5141 cp_error ("namespace `%T' undeclared", namespace);
5142 return;
5143 }
5144 if (TREE_CODE (namespace) != NAMESPACE_DECL)
5145 {
5146 cp_error ("`%T' is not a namespace", namespace);
5147 return;
5148 }
5149 namespace = ORIGINAL_NAMESPACE (namespace);
5150 if (!toplevel_bindings_p ())
5151 push_using_directive (namespace);
5152 else
5153 /* direct usage */
5154 add_using_namespace (current_namespace, namespace, 0);
5155}
5156
5157void
5158check_default_args (x)
5159 tree x;
5160{
5161 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
5162 int saw_def = 0, i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
5163 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
5164 {
5165 if (TREE_PURPOSE (arg))
5166 saw_def = 1;
5167 else if (saw_def)
5168 {
5169 cp_error_at ("default argument missing for parameter %P of `%+#D'",
5170 i, x);
5171 break;
5172 }
5173 }
5174}
5175
5176void
5177mark_used (decl)
5178 tree decl;
5179{
5180 TREE_USED (decl) = 1;
5181 if (processing_template_decl)
5182 return;
5183 assemble_external (decl);
5184
5185 /* Is it a synthesized method that needs to be synthesized? */
5186 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CLASS_CONTEXT (decl)
5187 && DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
5188 /* Kludge: don't synthesize for default args. */
5189 && current_function_decl)
5190 synthesize_method (decl);
5191
5192 /* If this is a function or variable that is an instance of some
5193 template, we now know that we will need to actually do the
5194 instantiation. A TEMPLATE_DECL may also have DECL_TEMPLATE_INFO,
5195 if it's a partial instantiation, but there's no need to
5196 instantiate such a thing. We check that DECL is not an explicit
5197 instantiation because that is not checked in instantiate_decl. */
5198 if (TREE_CODE (decl) != TEMPLATE_DECL
5199 && DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl)
5200 && !DECL_EXPLICIT_INSTANTIATION (decl))
5201 instantiate_decl (decl);
5202}
5203
5204/* Helper function for named_class_head_sans_basetype nonterminal. We
5205 have just seen something of the form `AGGR SCOPE::ID'. Return a
5206 TYPE_DECL for the type declared by ID in SCOPE. */
5207
5208tree
5209handle_class_head (aggr, scope, id)
5210 tree aggr, scope, id;
5211{
5212 tree decl;
5213
5214 if (TREE_CODE (id) == TYPE_DECL)
5215 decl = id;
5216 else if (DECL_CLASS_TEMPLATE_P (id))
5217 decl = DECL_TEMPLATE_RESULT (id);
5218 else
5219 {
5220 tree current = current_scope();
5221
5222 if (current == NULL_TREE)
5223 current = current_namespace;
5224 if (scope == std_node)
5225 scope = global_namespace;
5226 if (scope == NULL_TREE)
5227 scope = global_namespace;
5228 if (scope == current)
5229 {
5230 /* We've been given AGGR SCOPE::ID, when we're already inside SCOPE.
5231 Be nice about it. */
5232 if (pedantic)
5233 cp_pedwarn ("extra qualification `%T::' on member `%D' ignored",
5234 FROB_CONTEXT (scope), id);
5235 }
5236 else if (scope != global_namespace)
5237 cp_error ("`%T' does not have a nested type named `%D'", scope, id);
5238 else
5239 cp_error ("no file-scope type named `%D'", id);
5240
5241 /* Inject it at the current scope. */
5242 decl = TYPE_MAIN_DECL (xref_tag (aggr, id, 1));
5243 }
5244
5245 /* Enter the SCOPE. If this turns out not to be a definition, the
5246 parser must leave the scope. */
5247 push_scope (CP_DECL_CONTEXT (decl));
5248
5249 /* If we see something like:
5250
5251 template <typename T> struct S::I ....
5252
5253 we must create a TEMPLATE_DECL for the nested type. */
5254 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5255 decl = push_template_decl (decl);
5256
5257 return decl;
5258}
This page took 0.068865 seconds and 5 git commands to generate.