1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
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. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
40 #ifndef SUPPORTS_ONE_ONLY
41 #define SUPPORTS_ONE_ONLY 0
44 extern tree get_file_function_name ();
45 extern tree cleanups_this_call;
46 static void grok_function_init PROTO((tree, tree));
47 void import_export_decl ();
48 extern int current_class_depth;
50 /* A list of virtual function tables we must make sure to write out. */
53 /* A list of static class variables. This is needed, because a
54 static class variable can be declared inside the class without
55 an initializer, and then initialized, staticly, outside the class. */
58 /* A list of functions which were declared inline, but which we
59 may need to emit outline anyway. */
60 static tree saved_inlines;
62 /* Used to help generate temporary names which are unique within
63 a function. Reset to 0 by start_function. */
65 int temp_name_counter;
67 /* Same, but not reset. Local temp variables and global temp variables
68 can have the same name. */
69 static int global_temp_name_counter;
71 /* Flag used when debugging spew.c */
73 extern int spew_debug;
75 /* Nonzero if we're done parsing and into end-of-file activities. */
79 /* Functions called along with real static constructors and destructors. */
81 tree static_ctors, static_dtors;
83 /* C (and C++) language-specific option variables. */
85 /* Nonzero means allow type mismatches in conditional expressions;
86 just make their values `void'. */
88 int flag_cond_mismatch;
90 /* Nonzero means give `double' the same size as `float'. */
92 int flag_short_double;
94 /* Nonzero means don't recognize the keyword `asm'. */
98 /* Nonzero means don't recognize any extension keywords. */
100 int flag_no_gnu_keywords;
102 /* Nonzero means don't recognize the non-ANSI builtin functions. */
106 /* Nonzero means don't recognize the non-ANSI builtin functions.
109 int flag_no_nonansi_builtin;
111 /* Nonzero means do some things the same way PCC does. */
113 int flag_traditional;
115 /* Nonzero means to treat bitfields as unsigned unless they say `signed'. */
117 int flag_signed_bitfields = 1;
119 /* Nonzero means handle `#ident' directives. 0 means ignore them. */
123 /* Nonzero means enable obscure ANSI features and disable GNU extensions
124 that might cause ANSI-compliant code to be miscompiled. */
128 /* Nonzero means do emit exported implementations of functions even if
129 they can be inlined. */
131 int flag_implement_inlines = 1;
133 /* Nonzero means do emit exported implementations of templates, instead of
134 multiple static copies in each file that needs a definition. */
136 int flag_external_templates;
138 /* Nonzero means that the decision to emit or not emit the implementation of a
139 template depends on where the template is instantiated, rather than where
142 int flag_alt_external_templates;
144 /* Nonzero means that implicit instantiations will be emitted if needed. */
146 int flag_implicit_templates = 1;
148 /* Nonzero means warn about implicit declarations. */
150 int warn_implicit = 1;
152 /* Nonzero means warn when all ctors or dtors are private, and the class
155 int warn_ctor_dtor_privacy = 1;
157 /* True if we want to implement vtables using "thunks".
158 The default is off by default, on if explicitly supported. */
160 #ifdef ASM_OUTPUT_MI_THUNK
161 int flag_vtable_thunks = 1;
163 int flag_vtable_thunks;
166 /* True if we want to deal with repository information. */
168 int flag_use_repository;
170 /* Nonzero means give string constants the type `const char *'
171 to get extra warnings from them. These warnings will be too numerous
172 to be useful, except in thoroughly ANSIfied programs. */
174 int warn_write_strings;
176 /* Nonzero means warn about pointer casts that can drop a type qualifier
177 from the pointer target type. */
181 /* Nonzero means warn that dbx info for template class methods isn't fully
184 int warn_template_debugging;
186 /* Warn about traditional constructs whose meanings changed in ANSI C. */
188 int warn_traditional;
190 /* Nonzero means warn about sizeof(function) or addition/subtraction
191 of function pointers. */
193 int warn_pointer_arith = 1;
195 /* Nonzero means warn for non-prototype function decls
196 or non-prototyped defs without previous prototype. */
198 int warn_strict_prototypes;
200 /* Nonzero means warn for any function def without prototype decl. */
202 int warn_missing_prototypes;
204 /* Nonzero means warn about multiple (redundant) decls for the same single
205 variable or function. */
207 int warn_redundant_decls;
209 /* Warn if initializer is not completely bracketed. */
211 int warn_missing_braces;
213 /* Warn about comparison of signed and unsigned values. */
215 int warn_sign_compare;
217 /* Warn about *printf or *scanf format/argument anomalies. */
221 /* Warn about a subscript that has type char. */
223 int warn_char_subscripts;
225 /* Warn if a type conversion is done that might have confusing results. */
229 /* Warn if adding () is suggested. */
231 int warn_parentheses;
233 /* Non-zero means warn in function declared in derived class has the
234 same name as a virtual in the base class, but fails to match the
235 type signature of any virtual function in the base class. */
236 int warn_overloaded_virtual;
238 /* Non-zero means warn when declaring a class that has a non virtual
239 destructor, when it really ought to have a virtual one. */
242 /* Non-zero means warn when a function is declared extern and later inline. */
243 int warn_extern_inline;
245 /* Non-zero means warn when the compiler will reorder code. */
248 /* Non-zero means warn when synthesis behavior differs from Cfront's. */
251 /* Nonzero means `$' can be in an identifier.
252 See cccp.c for reasons why this breaks some obscure ANSI C programs. */
254 #ifndef DOLLARS_IN_IDENTIFIERS
255 #define DOLLARS_IN_IDENTIFIERS 1
257 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
259 /* Nonzero for -fno-strict-prototype switch: do not consider empty
260 argument prototype to mean function takes no arguments. */
262 int flag_strict_prototype = 2;
263 int strict_prototype = 1;
264 int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus = 1;
266 /* Nonzero means that labels can be used as first-class objects */
270 /* Non-zero means to collect statistics which might be expensive
271 and to print them when we are done. */
272 int flag_detailed_statistics;
274 /* C++ specific flags. */
275 /* Nonzero for -fall-virtual: make every member function (except
276 constructors) lay down in the virtual function table. Calls
277 can then either go through the virtual function table or not,
280 int flag_all_virtual;
282 /* Zero means that `this' is a *const. This gives nice behavior in the
283 2.0 world. 1 gives 1.2-compatible behavior. 2 gives Spring behavior.
284 -2 means we're constructing an object and it has fixed type. */
286 int flag_this_is_variable;
288 /* Nonzero means memoize our member lookups. */
290 int flag_memoize_lookups; int flag_save_memoized_contexts;
292 /* 3 means write out only virtuals function tables `defined'
293 in this implementation file.
294 2 means write out only specific virtual function tables
295 and give them (C) public access.
296 1 means write out virtual function tables and give them
298 0 means write out virtual function tables and give them
299 (C) static access (default).
300 -1 means declare virtual function tables extern. */
304 /* Nonzero means we should attempt to elide constructors when possible. */
306 int flag_elide_constructors;
308 /* Nonzero means recognize and handle exception handling constructs.
309 Use ansi syntax and semantics. WORK IN PROGRESS! */
311 int flag_handle_exceptions;
313 /* Nonzero means recognize and handle signature language constructs. */
315 int flag_handle_signatures;
317 /* Nonzero means that member functions defined in class scope are
318 inline by default. */
320 int flag_default_inline = 1;
322 /* Controls whether enums and ints freely convert.
323 1 means with complete freedom.
324 0 means enums can convert to ints, but not vice-versa. */
325 int flag_int_enum_equivalence;
327 /* Controls whether compiler generates 'type descriptor' that give
328 run-time type information. */
331 /* Nonzero if we wish to output cross-referencing information
332 for the GNU class browser. */
333 extern int flag_gnu_xref;
335 /* Nonzero if compiler can make `reasonable' assumptions about
336 references and objects. For example, the compiler must be
337 conservative about the following and not assume that `a' is nonnull:
342 In general, it is `reasonable' to assume that for many programs,
343 and better code can be generated in that case. */
345 int flag_assume_nonnull_objects = 1;
347 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
350 int flag_huge_objects;
352 /* Nonzero if we want to conserve space in the .o files. We do this
353 by putting uninitialized data and runtime initialized data into
354 .common instead of .data at the expense of not flagging multiple
357 int flag_conserve_space;
359 /* Nonzero if we want to obey access control semantics. */
361 int flag_access_control = 1;
363 /* Nonzero if we want to understand the operator names, i.e. 'bitand'. */
365 int flag_operator_names;
367 /* Nonzero if we want to check the return value of new and avoid calling
368 constructors if it is a null pointer. */
372 /* Nonzero if we want the new ANSI rules for pushing a new scope for `for'
373 initialization variables.
374 0: Old rules, set by -fno-for-scope.
375 2: New ANSI rules, set by -ffor-scope.
376 1: Try to implement new ANSI rules, but with backup compatibility
377 (and warnings). This is the default, for now. */
379 int flag_new_for_scope = 1;
381 /* Nonzero if we want to emit defined symbols with common-like linkage as
382 weak symbols where possible, in order to conform to C++ semantics.
383 Otherwise, emit them as local symbols. */
387 /* Table of language-dependent -f options.
388 STRING is the option name. VARIABLE is the address of the variable.
389 ON_VALUE is the value to store in VARIABLE
390 if `-fSTRING' is seen as an option.
391 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
393 static struct { char *string; int *variable; int on_value;} lang_f_options[] =
395 {"signed-char", &flag_signed_char, 1},
396 {"unsigned-char", &flag_signed_char, 0},
397 {"signed-bitfields", &flag_signed_bitfields, 1},
398 {"unsigned-bitfields", &flag_signed_bitfields, 0},
399 {"short-enums", &flag_short_enums, 1},
400 {"short-double", &flag_short_double, 1},
401 {"cond-mismatch", &flag_cond_mismatch, 1},
402 {"asm", &flag_no_asm, 0},
403 {"builtin", &flag_no_builtin, 0},
404 {"ident", &flag_no_ident, 0},
405 {"labels-ok", &flag_labels_ok, 1},
406 {"stats", &flag_detailed_statistics, 1},
407 {"this-is-variable", &flag_this_is_variable, 1},
408 {"strict-prototype", &flag_strict_prototype, 1},
409 {"all-virtual", &flag_all_virtual, 1},
410 {"memoize-lookups", &flag_memoize_lookups, 1},
411 {"elide-constructors", &flag_elide_constructors, 1},
412 {"handle-exceptions", &flag_handle_exceptions, 1},
413 {"handle-signatures", &flag_handle_signatures, 1},
414 {"default-inline", &flag_default_inline, 1},
415 {"dollars-in-identifiers", &dollars_in_ident, 1},
416 {"enum-int-equiv", &flag_int_enum_equivalence, 1},
417 {"rtti", &flag_rtti, 1},
418 {"xref", &flag_gnu_xref, 1},
419 {"nonnull-objects", &flag_assume_nonnull_objects, 1},
420 {"implement-inlines", &flag_implement_inlines, 1},
421 {"external-templates", &flag_external_templates, 1},
422 {"implicit-templates", &flag_implicit_templates, 1},
423 {"huge-objects", &flag_huge_objects, 1},
424 {"conserve-space", &flag_conserve_space, 1},
425 {"vtable-thunks", &flag_vtable_thunks, 1},
426 {"short-temps", &flag_short_temps, 1},
427 {"access-control", &flag_access_control, 1},
428 {"nonansi-builtins", &flag_no_nonansi_builtin, 0},
429 {"gnu-keywords", &flag_no_gnu_keywords, 0},
430 {"operator-names", &flag_operator_names, 1},
431 {"check-new", &flag_check_new, 1},
432 {"repo", &flag_use_repository, 1},
433 {"for-scope", &flag_new_for_scope, 2},
434 {"weak", &flag_weak, 1}
437 /* Decode the string P as a language-specific option.
438 Return 1 if it is recognized (and handle it);
439 return 0 if not recognized. */
442 lang_decode_option (p)
445 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
446 flag_traditional = 1, dollars_in_ident = 1, flag_writable_strings = 1,
447 flag_this_is_variable = 1, flag_new_for_scope = 0;
448 /* The +e options are for cfront compatibility. They come in as
449 `-+eN', to kludge around gcc.c's argument handling. */
450 else if (p[0] == '-' && p[1] == '+' && p[2] == 'e')
452 int old_write_virtuals = write_virtuals;
455 else if (p[3] == '0')
457 else if (p[3] == '2')
459 else error ("invalid +e option");
460 if (old_write_virtuals != 0
461 && write_virtuals != old_write_virtuals)
462 error ("conflicting +e options given");
464 else if (p[0] == '-' && p[1] == 'f')
466 /* Some kind of -f option.
467 P's value is the option sans `-f'.
468 Search for it in the table of options. */
472 /* Try special -f options. */
474 if (!strcmp (p, "save-memoized"))
476 flag_memoize_lookups = 1;
477 flag_save_memoized_contexts = 1;
480 if (!strcmp (p, "no-save-memoized"))
482 flag_memoize_lookups = 0;
483 flag_save_memoized_contexts = 0;
486 else if (! strcmp (p, "alt-external-templates"))
488 flag_external_templates = 1;
489 flag_alt_external_templates = 1;
492 else if (! strcmp (p, "no-alt-external-templates"))
494 flag_alt_external_templates = 0;
497 else if (!strcmp (p, "ansi-overloading"))
499 warning ("-fansi-overloading is no longer meaningful");
502 else if (!strcmp (p, "repo"))
504 flag_use_repository = 1;
505 flag_implicit_templates = 0;
509 !found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]);
512 if (!strcmp (p, lang_f_options[j].string))
514 *lang_f_options[j].variable = lang_f_options[j].on_value;
515 /* A goto here would be cleaner,
516 but breaks the vax pcc. */
519 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
520 && ! strcmp (p+3, lang_f_options[j].string))
522 *lang_f_options[j].variable = ! lang_f_options[j].on_value;
528 else if (p[0] == '-' && p[1] == 'W')
532 /* The -W options control the warning behavior of the compiler. */
535 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
538 if (!strcmp (p, "implicit"))
539 warn_implicit = setting;
540 else if (!strcmp (p, "return-type"))
541 warn_return_type = setting;
542 else if (!strcmp (p, "ctor-dtor-privacy"))
543 warn_ctor_dtor_privacy = setting;
544 else if (!strcmp (p, "write-strings"))
545 warn_write_strings = setting;
546 else if (!strcmp (p, "cast-qual"))
547 warn_cast_qual = setting;
548 else if (!strcmp (p, "traditional"))
549 warn_traditional = setting;
550 else if (!strcmp (p, "char-subscripts"))
551 warn_char_subscripts = setting;
552 else if (!strcmp (p, "pointer-arith"))
553 warn_pointer_arith = setting;
554 else if (!strcmp (p, "strict-prototypes"))
555 warn_strict_prototypes = setting;
556 else if (!strcmp (p, "missing-prototypes"))
557 warn_missing_prototypes = setting;
558 else if (!strcmp (p, "redundant-decls"))
559 warn_redundant_decls = setting;
560 else if (!strcmp (p, "missing-braces"))
561 warn_missing_braces = setting;
562 else if (!strcmp (p, "sign-compare"))
563 warn_sign_compare = setting;
564 else if (!strcmp (p, "format"))
565 warn_format = setting;
566 else if (!strcmp (p, "conversion"))
567 warn_conversion = setting;
568 else if (!strcmp (p, "parentheses"))
569 warn_parentheses = setting;
570 else if (!strcmp (p, "non-virtual-dtor"))
571 warn_nonvdtor = setting;
572 else if (!strcmp (p, "extern-inline"))
573 warn_extern_inline = setting;
574 else if (!strcmp (p, "reorder"))
575 warn_reorder = setting;
576 else if (!strcmp (p, "synth"))
577 warn_synth = setting;
578 else if (!strcmp (p, "comment"))
579 ; /* cpp handles this one. */
580 else if (!strcmp (p, "comments"))
581 ; /* cpp handles this one. */
582 else if (!strcmp (p, "trigraphs"))
583 ; /* cpp handles this one. */
584 else if (!strcmp (p, "import"))
585 ; /* cpp handles this one. */
586 else if (!strcmp (p, "all"))
588 warn_return_type = setting;
589 warn_unused = setting;
590 warn_implicit = setting;
591 warn_ctor_dtor_privacy = setting;
592 warn_switch = setting;
593 warn_format = setting;
594 warn_parentheses = setting;
595 warn_missing_braces = setting;
596 warn_sign_compare = setting;
597 warn_extern_inline = setting;
598 warn_nonvdtor = setting;
599 /* We save the value of warn_uninitialized, since if they put
600 -Wuninitialized on the command line, we need to generate a
601 warning about not using it without also specifying -O. */
602 if (warn_uninitialized != 1)
603 warn_uninitialized = (setting ? 2 : 0);
604 warn_template_debugging = setting;
605 warn_reorder = setting;
608 else if (!strcmp (p, "overloaded-virtual"))
609 warn_overloaded_virtual = setting;
612 else if (!strcmp (p, "-ansi"))
613 dollars_in_ident = 0, flag_no_nonansi_builtin = 1, flag_ansi = 1,
614 flag_no_gnu_keywords = 1, flag_operator_names = 1;
616 /* Undocumented, only ever used when you're invoking cc1plus by hand, since
617 it's probably safe to assume no sane person would ever want to use this
618 under normal circumstances. */
619 else if (!strcmp (p, "-spew-debug"))
628 /* Incorporate `const' and `volatile' qualifiers for member functions.
629 FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
630 QUALS is a list of qualifiers. */
632 grok_method_quals (ctype, function, quals)
633 tree ctype, function, quals;
635 tree fntype = TREE_TYPE (function);
636 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
640 extern tree ridpointers[];
642 if (TREE_VALUE (quals) == ridpointers[(int)RID_CONST])
644 if (TYPE_READONLY (ctype))
645 error ("duplicate `%s' %s",
646 IDENTIFIER_POINTER (TREE_VALUE (quals)),
647 (TREE_CODE (function) == FUNCTION_DECL
648 ? "for member function" : "in type declaration"));
649 ctype = build_type_variant (ctype, 1, TYPE_VOLATILE (ctype));
650 build_pointer_type (ctype);
652 else if (TREE_VALUE (quals) == ridpointers[(int)RID_VOLATILE])
654 if (TYPE_VOLATILE (ctype))
655 error ("duplicate `%s' %s",
656 IDENTIFIER_POINTER (TREE_VALUE (quals)),
657 (TREE_CODE (function) == FUNCTION_DECL
658 ? "for member function" : "in type declaration"));
659 ctype = build_type_variant (ctype, TYPE_READONLY (ctype), 1);
660 build_pointer_type (ctype);
663 my_friendly_abort (20);
664 quals = TREE_CHAIN (quals);
667 fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype),
668 (TREE_CODE (fntype) == METHOD_TYPE
669 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
670 : TYPE_ARG_TYPES (fntype)));
672 fntype = build_exception_variant (fntype, raises);
674 TREE_TYPE (function) = fntype;
678 #if 0 /* Not used. */
679 /* This routine replaces cryptic DECL_NAMEs with readable DECL_NAMEs.
680 It leaves DECL_ASSEMBLER_NAMEs with the correct value. */
681 /* This does not yet work with user defined conversion operators
684 substitute_nice_name (decl)
687 if (DECL_NAME (decl) && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE)
689 char *n = decl_as_string (DECL_NAME (decl), 1);
690 if (n[strlen (n) - 1] == ' ')
691 n[strlen (n) - 1] = 0;
692 DECL_NAME (decl) = get_identifier (n);
697 /* Warn when -fexternal-templates is used and #pragma
698 interface/implementation is not used all the times it should be,
701 warn_if_unknown_interface (decl)
704 static int already_warned = 0;
705 if (already_warned++)
708 if (flag_alt_external_templates)
710 struct tinst_level *til = tinst_for_decl ();
712 char *sf = input_filename;
717 input_filename = til->file;
719 cp_warning ("template `%#D' instantiated in file without #pragma interface",
725 cp_warning_at ("template `%#D' defined in file without #pragma interface",
729 /* A subroutine of the parser, to handle a component list. */
731 grok_x_components (specs, components)
732 tree specs, components;
734 register tree t, x, tcode;
736 /* We just got some friends. They have been recorded elsewhere. */
737 if (components == void_type_node)
740 if (components == NULL_TREE)
742 t = groktypename (build_decl_list (specs, NULL_TREE));
746 error ("error in component specification");
750 switch (TREE_CODE (t))
753 /* Static anonymous unions come out as VAR_DECLs. */
754 if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE
755 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (t))))
758 /* We return SPECS here, because in the parser it was ending
759 up with not doing anything to $$, which is what SPECS
765 /* This code may be needed for UNION_TYPEs as
767 tcode = record_type_node;
768 if (CLASSTYPE_DECLARED_CLASS (t))
769 tcode = class_type_node;
770 else if (IS_SIGNATURE (t))
771 tcode = signature_type_node;
773 t = xref_tag (tcode, TYPE_IDENTIFIER (t), NULL_TREE, 0);
774 if (TYPE_CONTEXT (t))
775 CLASSTYPE_NO_GLOBALIZE (t) = 1;
781 if (TREE_CODE (t) == UNION_TYPE)
782 tcode = union_type_node;
784 tcode = enum_type_node;
786 t = xref_tag (tcode, TYPE_IDENTIFIER (t), NULL_TREE, 0);
787 if (TREE_CODE (t) == UNION_TYPE && TYPE_CONTEXT (t))
788 CLASSTYPE_NO_GLOBALIZE (t) = 1;
789 if (TREE_CODE (t) == UNION_TYPE
790 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
792 struct pending_inline **p;
793 x = build_lang_field_decl (FIELD_DECL, NULL_TREE, t);
795 /* Wipe out memory of synthesized methods */
796 TYPE_HAS_CONSTRUCTOR (t) = 0;
797 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
798 TYPE_HAS_INIT_REF (t) = 0;
799 TYPE_HAS_CONST_INIT_REF (t) = 0;
800 TYPE_HAS_ASSIGN_REF (t) = 0;
801 TYPE_HAS_ASSIGNMENT (t) = 0;
802 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
804 p = &pending_inlines;
805 for (; *p; *p = (*p)->next)
806 if (DECL_CONTEXT ((*p)->fndecl) != t)
809 else if (TREE_CODE (t) == ENUMERAL_TYPE)
810 x = grok_enum_decls (t, NULL_TREE);
817 if (t != void_type_node)
818 error ("empty component declaration");
824 t = TREE_TYPE (components);
825 if (TREE_CODE (t) == ENUMERAL_TYPE && TREE_NONLOCAL_FLAG (t))
826 return grok_enum_decls (t, components);
832 /* Classes overload their constituent function names automatically.
833 When a function name is declared in a record structure,
834 its name is changed to it overloaded name. Since names for
835 constructors and destructors can conflict, we place a leading
838 CNAME is the name of the class we are grokking for.
840 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
842 FLAGS contains bits saying what's special about today's
843 arguments. 1 == DESTRUCTOR. 2 == OPERATOR.
845 If FUNCTION is a destructor, then we must add the `auto-delete' field
846 as a second parameter. There is some hair associated with the fact
847 that we must "declare" this variable in the manner consistent with the
848 way the rest of the arguments were declared.
850 QUALS are the qualifiers for the this pointer. */
853 grokclassfn (ctype, cname, function, flags, quals)
854 tree ctype, cname, function;
855 enum overload_flags flags;
858 tree fn_name = DECL_NAME (function);
862 tree fntype = TREE_TYPE (function);
863 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
865 if (fn_name == NULL_TREE)
867 error ("name missing for member function");
868 fn_name = get_identifier ("<anonymous>");
869 DECL_NAME (function) = fn_name;
873 qualtype = grok_method_quals (ctype, function, quals);
877 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
878 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
880 /* Must add the class instance variable up front. */
881 /* Right now we just make this a pointer. But later
882 we may wish to make it special. */
883 tree type = TREE_VALUE (arg_types);
886 if ((flag_this_is_variable > 0)
887 && (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)))
890 if (DECL_CONSTRUCTOR_P (function))
892 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
894 DECL_CONSTRUCTOR_FOR_VBASE_P (function) = 1;
895 /* In this case we need "in-charge" flag saying whether
896 this constructor is responsible for initialization
897 of virtual baseclasses or not. */
898 parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
899 /* Mark the artificial `__in_chrg' parameter as "artificial". */
900 SET_DECL_ARTIFICIAL (parm);
901 DECL_ARG_TYPE (parm) = integer_type_node;
902 TREE_READONLY (parm) = 1;
903 TREE_CHAIN (parm) = last_function_parms;
904 last_function_parms = parm;
908 parm = build_decl (PARM_DECL, this_identifier, type);
909 /* Mark the artificial `this' parameter as "artificial". */
910 SET_DECL_ARTIFICIAL (parm);
911 DECL_ARG_TYPE (parm) = type;
912 /* We can make this a register, so long as we don't
913 accidentally complain if someone tries to take its address. */
914 DECL_REGISTER (parm) = 1;
916 TREE_READONLY (parm) = 1;
917 TREE_CHAIN (parm) = last_function_parms;
918 last_function_parms = parm;
921 if (flags == DTOR_FLAG)
924 tree const_integer_type = build_type_variant (integer_type_node, 1, 0);
925 int len = sizeof (DESTRUCTOR_DECL_PREFIX)-1;
927 arg_types = hash_tree_chain (const_integer_type, void_list_node);
928 TREE_SIDE_EFFECTS (arg_types) = 1;
929 /* Build the overload name. It will look like `7Example'. */
930 if (IDENTIFIER_TYPE_VALUE (cname))
931 dbuf = build_overload_name (IDENTIFIER_TYPE_VALUE (cname), 1, 1);
932 else if (IDENTIFIER_LOCAL_VALUE (cname))
933 dbuf = build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname)), 1, 1);
935 /* Using ctype fixes the `X::Y::~Y()' crash. The cname has no type when
936 it's defined out of the class definition, since poplevel_class wipes
937 it out. This used to be internal error 346. */
938 dbuf = build_overload_name (ctype, 1, 1);
939 buf = (char *) alloca (strlen (dbuf) + sizeof (DESTRUCTOR_DECL_PREFIX));
940 bcopy (DESTRUCTOR_DECL_PREFIX, buf, len);
943 DECL_ASSEMBLER_NAME (function) = get_identifier (buf);
944 parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
945 /* Mark the artificial `__in_chrg' parameter as "artificial". */
946 SET_DECL_ARTIFICIAL (parm);
947 TREE_READONLY (parm) = 1;
948 DECL_ARG_TYPE (parm) = integer_type_node;
949 /* This is the same chain as DECL_ARGUMENTS (...). */
950 TREE_CHAIN (last_function_parms) = parm;
952 fntype = build_cplus_method_type (qualtype, void_type_node,
956 fntype = build_exception_variant (fntype, raises);
958 TREE_TYPE (function) = fntype;
959 TYPE_HAS_DESTRUCTOR (ctype) = 1;
963 tree these_arg_types;
965 if (DECL_CONSTRUCTOR_FOR_VBASE_P (function))
967 arg_types = hash_tree_chain (integer_type_node,
968 TREE_CHAIN (arg_types));
969 fntype = build_cplus_method_type (qualtype,
970 TREE_TYPE (TREE_TYPE (function)),
974 fntype = build_exception_variant (fntype, raises);
976 TREE_TYPE (function) = fntype;
977 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
980 these_arg_types = arg_types;
982 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
983 /* Only true for static member functions. */
984 these_arg_types = hash_tree_chain (build_pointer_type (qualtype),
987 DECL_ASSEMBLER_NAME (function)
988 = build_decl_overload (fn_name, these_arg_types,
989 1 + DECL_CONSTRUCTOR_P (function));
992 /* This code is going into the compiler, but currently, it makes
993 libg++/src/Integer.cc not compile. The problem is that the nice name
994 winds up going into the symbol table, and conversion operations look
995 for the manged name. */
996 substitute_nice_name (function);
1000 DECL_ARGUMENTS (function) = last_function_parms;
1001 /* First approximations. */
1002 DECL_CONTEXT (function) = ctype;
1003 DECL_CLASS_CONTEXT (function) = ctype;
1006 /* Work on the expr used by alignof (this is only called by the parser). */
1014 if (TREE_CODE (expr) == COMPONENT_REF
1015 && DECL_BIT_FIELD (TREE_OPERAND (expr, 1)))
1016 error ("`__alignof__' applied to a bit-field");
1018 if (TREE_CODE (expr) == INDIRECT_REF)
1020 best = t = TREE_OPERAND (expr, 0);
1021 bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1023 while (TREE_CODE (t) == NOP_EXPR
1024 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
1027 t = TREE_OPERAND (t, 0);
1028 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1029 if (thisalign > bestalign)
1030 best = t, bestalign = thisalign;
1032 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
1036 /* ANSI says arrays and fns are converted inside comma.
1037 But we can't convert them in build_compound_expr
1038 because that would break commas in lvalues.
1039 So do the conversion here if operand was a comma. */
1040 if (TREE_CODE (expr) == COMPOUND_EXPR
1041 && (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1042 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE))
1043 expr = default_conversion (expr);
1044 return c_alignof (TREE_TYPE (expr));
1048 /* Create an ARRAY_REF, checking for the user doing things backwards
1051 grok_array_decl (array_expr, index_exp)
1052 tree array_expr, index_exp;
1054 tree type = TREE_TYPE (array_expr);
1055 tree p1, p2, i1, i2;
1057 if (type == error_mark_node || index_exp == error_mark_node)
1058 return error_mark_node;
1059 if (current_template_parms)
1060 return build_min (ARRAY_REF, type ? TREE_TYPE (type) : NULL_TREE,
1061 array_expr, index_exp);
1063 if (type == NULL_TREE)
1065 /* Something has gone very wrong. Assume we are mistakenly reducing
1066 an expression instead of a declaration. */
1067 error ("parser may be lost: is there a '{' missing somewhere?");
1071 if (TREE_CODE (type) == OFFSET_TYPE
1072 || TREE_CODE (type) == REFERENCE_TYPE)
1073 type = TREE_TYPE (type);
1075 /* If they have an `operator[]', use that. */
1076 if (TYPE_LANG_SPECIFIC (type)
1077 && TYPE_OVERLOADS_ARRAY_REF (complete_type (type)))
1078 return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
1079 array_expr, index_exp, NULL_TREE);
1081 /* Otherwise, create an ARRAY_REF for a pointer or array type. */
1083 if (TREE_CODE (type) == ARRAY_TYPE)
1086 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0);
1088 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
1091 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0);
1093 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0);
1094 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0);
1096 if ((p1 && i2) && (i1 && p2))
1097 error ("ambiguous conversion for array subscript");
1100 array_expr = p1, index_exp = i2;
1102 array_expr = p2, index_exp = i1;
1105 cp_error ("invalid types `%T[%T]' for array subscript",
1106 type, TREE_TYPE (index_exp));
1107 return error_mark_node;
1110 if (array_expr == error_mark_node || index_exp == error_mark_node)
1111 error ("ambiguous conversion for array subscript");
1113 return build_array_ref (array_expr, index_exp);
1116 /* Given the cast expression EXP, checking out its validity. Either return
1117 an error_mark_node if there was an unavoidable error, return a cast to
1118 void for trying to delete a pointer w/ the value 0, or return the
1119 call to delete. If DOING_VEC is 1, we handle things differently
1120 for doing an array delete. If DOING_VEC is 2, they gave us the
1121 array size as an argument to delete.
1122 Implements ARM $5.3.4. This is called from the parser. */
1124 delete_sanity (exp, size, doing_vec, use_global_delete)
1126 int doing_vec, use_global_delete;
1130 enum tree_code code;
1131 /* For a regular vector delete (aka, no size argument) we will pass
1132 this down as a NULL_TREE into build_vec_delete. */
1133 tree maxindex = NULL_TREE;
1135 if (exp == error_mark_node)
1138 if (current_template_parms)
1140 t = build_min (DELETE_EXPR, void_type_node, exp, size);
1141 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
1142 DELETE_EXPR_USE_VEC (t) = doing_vec;
1146 t = stabilize_reference (convert_from_reference (exp));
1147 type = TREE_TYPE (t);
1148 code = TREE_CODE (type);
1153 maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
1154 if (! flag_traditional)
1155 pedwarn ("anachronistic use of array size in vector delete");
1160 if (code != POINTER_TYPE)
1162 cp_error ("type `%#T' argument given to `delete', expected pointer",
1164 return error_mark_node;
1167 /* Deleting a pointer with the value zero is valid and has no effect. */
1168 if (integer_zerop (t))
1169 return build1 (NOP_EXPR, void_type_node, t);
1172 if (code == POINTER_TYPE)
1175 /* As of Valley Forge, you can delete a pointer to constant. */
1176 /* You can't delete a pointer to constant. */
1177 if (TREE_READONLY (TREE_TYPE (type)))
1179 error ("`const *' cannot be deleted");
1180 return error_mark_node;
1183 /* You also can't delete functions. */
1184 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
1186 error ("cannot delete a function");
1187 return error_mark_node;
1192 /* If the type has no destructor, then we should build a regular
1193 delete, instead of a vector delete. Otherwise, we would end
1194 up passing a bogus offset into __builtin_delete, which is
1195 not expecting it. */
1197 && TREE_CODE (type) == POINTER_TYPE
1198 && !TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)))
1201 use_global_delete = 1;
1206 return build_vec_delete (t, maxindex, integer_one_node,
1207 integer_two_node, use_global_delete);
1210 if (IS_AGGR_TYPE (TREE_TYPE (type))
1211 && TYPE_GETS_REG_DELETE (TREE_TYPE (type)))
1213 /* Only do access checking here; we'll be calling op delete
1214 from the destructor. */
1215 tree tmp = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, t,
1216 size_zero_node, NULL_TREE);
1217 if (tmp == error_mark_node)
1218 return error_mark_node;
1221 return build_delete (type, t, integer_three_node,
1222 LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE,
1227 /* Sanity check: report error if this function FUNCTION is not
1228 really a member of the class (CTYPE) it is supposed to belong to.
1229 CNAME is the same here as it is for grokclassfn above. */
1232 check_classfn (ctype, function)
1233 tree ctype, function;
1235 tree fn_name = DECL_NAME (function);
1237 tree method_vec = CLASSTYPE_METHOD_VEC (complete_type (ctype));
1241 if (method_vec != 0)
1243 methods = &TREE_VEC_ELT (method_vec, 0);
1244 end = TREE_VEC_END (method_vec);
1246 /* First suss out ctors and dtors. */
1247 if (*methods && fn_name == DECL_NAME (*methods)
1248 && DECL_CONSTRUCTOR_P (function))
1250 if (*++methods && fn_name == DECL_NAME (*methods)
1251 && DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function)))
1254 while (++methods != end)
1256 if (fn_name == DECL_NAME (*methods))
1262 if (DECL_ASSEMBLER_NAME (function) == DECL_ASSEMBLER_NAME (fndecl))
1265 /* This doesn't work for static member functions that are
1266 pretending to be methods. */
1267 /* We have to do more extensive argument checking here, as
1268 the name may have been changed by asm("new_name"). */
1269 if (decls_match (function, fndecl))
1272 if (DECL_NAME (function) == DECL_NAME (fndecl))
1274 tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
1275 tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1277 /* Get rid of the this parameter on functions that become
1279 if (DECL_STATIC_FUNCTION_P (fndecl)
1280 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
1281 p1 = TREE_CHAIN (p1);
1283 if (comptypes (TREE_TYPE (TREE_TYPE (function)),
1284 TREE_TYPE (TREE_TYPE (fndecl)), 1)
1285 && compparms (p1, p2, 3))
1289 fndecl = DECL_CHAIN (fndecl);
1298 tree fndecl = *methods;
1299 cp_error ("prototype for `%#D' does not match any in class `%T'",
1301 cp_error_at ("candidate%s: %+#D", DECL_CHAIN (fndecl) ? "s are" : " is",
1303 while (fndecl = DECL_CHAIN (fndecl), fndecl)
1304 cp_error_at (" %#D", fndecl);
1309 cp_error ("no `%#D' member function declared in class `%T'",
1313 /* If we did not find the method in the class, add it to avoid
1315 add_method (ctype, methods, function);
1319 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
1320 of a structure component, returning a FIELD_DECL node.
1321 QUALS is a list of type qualifiers for this decl (such as for declaring
1322 const member functions).
1324 This is done during the parsing of the struct declaration.
1325 The FIELD_DECL nodes are chained together and the lot of them
1326 are ultimately passed to `build_struct' to make the RECORD_TYPE node.
1330 If class A defines that certain functions in class B are friends, then
1331 the way I have set things up, it is B who is interested in permission
1332 granted by A. However, it is in A's context that these declarations
1333 are parsed. By returning a void_type_node, class A does not attempt
1334 to incorporate the declarations of the friends within its structure.
1336 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
1337 CHANGES TO CODE IN `start_method'. */
1340 grokfield (declarator, declspecs, raises, init, asmspec_tree, attrlist)
1341 tree declarator, declspecs, raises, init, asmspec_tree, attrlist;
1343 register tree value;
1345 int flags = LOOKUP_ONLYCONVERTING;
1347 /* Convert () initializers to = initializers. */
1348 if (init == NULL_TREE && declarator != NULL_TREE
1349 && TREE_CODE (declarator) == CALL_EXPR
1350 && TREE_OPERAND (declarator, 0)
1351 && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE
1352 || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF)
1353 && parmlist_is_exprlist (TREE_OPERAND (declarator, 1)))
1355 init = TREE_OPERAND (declarator, 1);
1356 declarator = TREE_OPERAND (declarator, 0);
1360 if (declspecs == NULL_TREE
1361 && TREE_CODE (declarator) == SCOPE_REF)
1363 /* Access declaration */
1364 if (! IS_AGGR_TYPE_CODE (TREE_CODE (TREE_OPERAND (declarator, 0))))
1366 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
1367 pop_nested_class (1);
1368 return do_class_using_decl (declarator);
1372 && TREE_CODE (init) == TREE_LIST
1373 && TREE_VALUE (init) == error_mark_node
1374 && TREE_CHAIN (init) == NULL_TREE)
1377 value = grokdeclarator (declarator, declspecs, FIELD, init != 0,
1380 return value; /* friend or constructor went bad. */
1382 /* Pass friendly classes back. */
1383 if (TREE_CODE (value) == VOID_TYPE)
1384 return void_type_node;
1386 if (DECL_NAME (value) != NULL_TREE
1387 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
1388 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
1389 cp_error ("member `%D' conflicts with virtual function table field name", value);
1391 /* Stash away type declarations. */
1392 if (TREE_CODE (value) == TYPE_DECL)
1394 DECL_NONLOCAL (value) = 1;
1395 DECL_CONTEXT (value) = current_class_type;
1396 DECL_CLASS_CONTEXT (value) = current_class_type;
1397 CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1;
1399 pushdecl_class_level (value);
1403 if (IS_SIGNATURE (current_class_type)
1404 && TREE_CODE (value) != FUNCTION_DECL)
1406 error ("field declaration not allowed in signature");
1407 return void_type_node;
1410 if (DECL_IN_AGGR_P (value))
1412 cp_error ("`%D' is already defined in the class %T", value,
1413 DECL_CONTEXT (value));
1414 return void_type_node;
1418 asmspec = TREE_STRING_POINTER (asmspec_tree);
1422 if (IS_SIGNATURE (current_class_type)
1423 && TREE_CODE (value) == FUNCTION_DECL)
1425 error ("function declarations cannot have initializers in signature");
1428 else if (TREE_CODE (value) == FUNCTION_DECL)
1430 grok_function_init (value, init);
1433 else if (pedantic && TREE_CODE (value) != VAR_DECL)
1434 /* Already complained in grokdeclarator. */
1438 /* We allow initializers to become parameters to base
1440 if (TREE_CODE (init) == TREE_LIST)
1442 if (TREE_CHAIN (init) == NULL_TREE)
1443 init = TREE_VALUE (init);
1445 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1448 if (TREE_CODE (init) == CONST_DECL)
1449 init = DECL_INITIAL (init);
1450 else if (TREE_READONLY_DECL_P (init))
1451 init = decl_constant_value (init);
1452 else if (TREE_CODE (init) == CONSTRUCTOR)
1453 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1454 my_friendly_assert (TREE_PERMANENT (init), 192);
1455 if (init == error_mark_node)
1456 /* We must make this look different than `error_mark_node'
1457 because `decl_const_value' would mis-interpret it
1458 as only meaning that this VAR_DECL is defined. */
1459 init = build1 (NOP_EXPR, TREE_TYPE (value), init);
1460 else if (current_template_parms)
1462 else if (! TREE_CONSTANT (init))
1464 /* We can allow references to things that are effectively
1465 static, since references are initialized with the address. */
1466 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
1467 || (TREE_STATIC (init) == 0
1468 && (TREE_CODE_CLASS (TREE_CODE (init)) != 'd'
1469 || DECL_EXTERNAL (init) == 0)))
1471 error ("field initializer is not constant");
1472 init = error_mark_node;
1478 /* The corresponding pop_obstacks is in cp_finish_decl. */
1479 push_obstacks_nochange ();
1481 if (current_template_parms && ! current_function_decl
1482 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
1483 push_template_decl (value);
1486 cplus_decl_attributes (value, TREE_PURPOSE (attrlist),
1487 TREE_VALUE (attrlist));
1489 if (TREE_CODE (value) == VAR_DECL)
1491 /* We cannot call pushdecl here, because that would
1492 fill in the value of our TREE_CHAIN. Instead, we
1493 modify cp_finish_decl to do the right thing, namely, to
1494 put this decl out straight away. */
1495 if (TREE_PUBLIC (value))
1497 /* current_class_type can be NULL_TREE in case of error. */
1498 if (asmspec == 0 && current_class_type)
1500 TREE_PUBLIC (value) = 1;
1501 DECL_INITIAL (value) = error_mark_node;
1502 DECL_ASSEMBLER_NAME (value)
1503 = build_static_name (current_class_type, DECL_NAME (value));
1505 if (! current_template_parms)
1506 pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics);
1508 /* Static consts need not be initialized in the class definition. */
1509 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value)))
1511 static int explanation = 0;
1513 error ("initializer invalid for static member with constructor");
1514 if (explanation++ == 0)
1515 error ("(you really want to initialize it separately)");
1518 /* Force the compiler to know when an uninitialized static
1519 const member is being used. */
1520 if (TYPE_READONLY (value) && init == 0)
1521 TREE_USED (value) = 1;
1523 DECL_INITIAL (value) = init;
1524 DECL_IN_AGGR_P (value) = 1;
1525 DECL_CONTEXT (value) = current_class_type;
1526 DECL_CLASS_CONTEXT (value) = current_class_type;
1528 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1529 pushdecl_class_level (value);
1532 if (TREE_CODE (value) == FIELD_DECL)
1536 /* This must override the asm specifier which was placed
1537 by grokclassfn. Lay this out fresh. */
1538 DECL_RTL (value) = NULL_RTX;
1539 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
1541 if (DECL_INITIAL (value) == error_mark_node)
1542 init = error_mark_node;
1543 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1544 DECL_INITIAL (value) = init;
1545 DECL_IN_AGGR_P (value) = 1;
1548 if (TREE_CODE (value) == FUNCTION_DECL)
1550 check_default_args (value);
1551 if (DECL_CHAIN (value) != NULL_TREE)
1553 /* Need a fresh node here so that we don't get circularity
1554 when we link these together. */
1555 value = copy_node (value);
1556 /* When does this happen? */
1557 my_friendly_assert (init == NULL_TREE, 193);
1561 /* This must override the asm specifier which was placed
1562 by grokclassfn. Lay this out fresh. */
1563 DECL_RTL (value) = NULL_RTX;
1564 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
1566 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1568 /* Pass friends back this way. */
1569 if (DECL_FRIEND_P (value))
1570 return void_type_node;
1572 #if 0 /* Just because a fn is declared doesn't mean we'll try to define it. */
1573 if (current_function_decl && ! IS_SIGNATURE (current_class_type))
1574 cp_error ("method `%#D' of local class must be defined in class body",
1578 DECL_IN_AGGR_P (value) = 1;
1581 my_friendly_abort (21);
1586 /* Like `grokfield', but for bitfields.
1587 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1590 grokbitfield (declarator, declspecs, width)
1591 tree declarator, declspecs, width;
1593 register tree value = grokdeclarator (declarator, declspecs, BITFIELD,
1594 0, NULL_TREE, NULL_TREE);
1596 if (! value) return NULL_TREE; /* friends went bad. */
1598 /* Pass friendly classes back. */
1599 if (TREE_CODE (value) == VOID_TYPE)
1600 return void_type_node;
1602 if (TREE_CODE (value) == TYPE_DECL)
1604 cp_error ("cannot declare `%D' to be a bitfield type", value);
1608 if (IS_SIGNATURE (current_class_type))
1610 error ("field declaration not allowed in signature");
1611 return void_type_node;
1614 if (DECL_IN_AGGR_P (value))
1616 cp_error ("`%D' is already defined in the class %T", value,
1617 DECL_CONTEXT (value));
1618 return void_type_node;
1621 GNU_xref_member (current_class_name, value);
1623 if (TREE_STATIC (value))
1625 cp_error ("static member `%D' cannot be a bitfield", value);
1628 cp_finish_decl (value, NULL_TREE, NULL_TREE, 0, 0);
1630 if (width != error_mark_node)
1632 constant_expression_warning (width);
1633 DECL_INITIAL (value) = width;
1634 DECL_BIT_FIELD (value) = 1;
1637 DECL_IN_AGGR_P (value) = 1;
1642 /* Like GROKFIELD, except that the declarator has been
1643 buried in DECLSPECS. Find the declarator, and
1644 return something that looks like it came from
1647 groktypefield (declspecs, parmlist)
1651 tree spec = declspecs;
1652 tree prev = NULL_TREE;
1654 tree type_id = NULL_TREE;
1655 tree quals = NULL_TREE;
1656 tree lengths = NULL_TREE;
1657 tree decl = NULL_TREE;
1661 register tree id = TREE_VALUE (spec);
1663 if (TREE_CODE (spec) != TREE_LIST)
1664 /* Certain parse errors slip through. For example,
1665 `int class ();' is not caught by the parser. Try
1666 weakly to recover here. */
1669 if (TREE_CODE (id) == TYPE_DECL
1670 || (TREE_CODE (id) == IDENTIFIER_NODE && TREE_TYPE (id)))
1672 /* We have a constructor/destructor or
1673 conversion operator. Use it. */
1675 TREE_CHAIN (prev) = TREE_CHAIN (spec);
1677 declspecs = TREE_CHAIN (spec);
1683 spec = TREE_CHAIN (spec);
1686 /* Nope, we have a conversion operator to a scalar type or something
1687 else, that includes things like constructor declarations for
1692 tree id = TREE_VALUE (spec);
1694 if (TREE_CODE (id) == IDENTIFIER_NODE)
1696 if (id == ridpointers[(int)RID_INT]
1697 || id == ridpointers[(int)RID_DOUBLE]
1698 || id == ridpointers[(int)RID_FLOAT]
1699 || id == ridpointers[(int)RID_WCHAR])
1702 error ("extra `%s' ignored",
1703 IDENTIFIER_POINTER (id));
1707 else if (id == ridpointers[(int)RID_LONG]
1708 || id == ridpointers[(int)RID_SHORT]
1709 || id == ridpointers[(int)RID_CHAR])
1711 lengths = tree_cons (NULL_TREE, id, lengths);
1713 else if (id == ridpointers[(int)RID_VOID])
1716 error ("spurious `void' type ignored");
1718 error ("conversion to `void' type invalid");
1720 else if (id == ridpointers[(int)RID_AUTO]
1721 || id == ridpointers[(int)RID_REGISTER]
1722 || id == ridpointers[(int)RID_TYPEDEF]
1723 || id == ridpointers[(int)RID_CONST]
1724 || id == ridpointers[(int)RID_VOLATILE])
1726 error ("type specifier `%s' used invalidly",
1727 IDENTIFIER_POINTER (id));
1729 else if (id == ridpointers[(int)RID_FRIEND]
1730 || id == ridpointers[(int)RID_VIRTUAL]
1731 || id == ridpointers[(int)RID_INLINE]
1732 || id == ridpointers[(int)RID_UNSIGNED]
1733 || id == ridpointers[(int)RID_SIGNED]
1734 || id == ridpointers[(int)RID_STATIC]
1735 || id == ridpointers[(int)RID_EXTERN])
1737 quals = tree_cons (NULL_TREE, id, quals);
1741 /* Happens when we have a global typedef
1742 and a class-local member function with
1748 else if (TREE_CODE (id) == RECORD_TYPE)
1750 type_id = TYPE_NAME (id);
1751 if (TREE_CODE (type_id) == TYPE_DECL)
1752 type_id = DECL_NAME (type_id);
1753 if (type_id == NULL_TREE)
1754 error ("identifier for aggregate type conversion omitted");
1756 else if (TREE_CODE_CLASS (TREE_CODE (id)) == 't')
1757 error ("`operator' missing on conversion operator or tag missing from type");
1759 my_friendly_abort (194);
1760 spec = TREE_CHAIN (spec);
1764 declspecs = chainon (lengths, quals);
1767 if (TREE_CHAIN (lengths))
1768 error ("multiple length specifiers");
1769 type_id = ridpointers[(int)RID_INT];
1770 declspecs = chainon (lengths, quals);
1774 error ("no type given, defaulting to `operator int ...'");
1775 type_id = ridpointers[(int)RID_INT];
1782 decl = grokdeclarator (build_parse_node (CALL_EXPR, type_id, parmlist, NULL_TREE),
1783 declspecs, FIELD, 0, NULL_TREE, NULL_TREE);
1784 if (decl == NULL_TREE)
1787 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CHAIN (decl) != NULL_TREE)
1789 /* Need a fresh node here so that we don't get circularity
1790 when we link these together. */
1791 decl = copy_node (decl);
1794 if (decl == void_type_node
1795 || (TREE_CODE (decl) == FUNCTION_DECL
1796 && TREE_CODE (TREE_TYPE (decl)) != METHOD_TYPE))
1797 /* bunch of friends. */
1800 if (DECL_IN_AGGR_P (decl))
1802 cp_error ("`%D' already defined in the class ", decl);
1803 return void_type_node;
1806 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0, 0);
1808 /* If this declaration is common to another declaration
1809 complain about such redundancy, and return NULL_TREE
1810 so that we don't build a circular list. */
1811 if (DECL_CHAIN (decl))
1813 cp_error ("function `%D' declared twice in class %T", decl,
1814 DECL_CONTEXT (decl));
1817 DECL_IN_AGGR_P (decl) = 1;
1823 grokoptypename (declspecs, declarator)
1824 tree declspecs, declarator;
1826 tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0,
1827 NULL_TREE, NULL_TREE);
1828 return build_typename_overload (t);
1831 /* When a function is declared with an initializer,
1832 do the right thing. Currently, there are two possibilities:
1837 // initialization possibility #1.
1838 virtual void f () = 0;
1860 // initialization possibility #2
1867 copy_assignment_arg_p (parmtype, virtualp)
1871 if (TREE_CODE (parmtype) == REFERENCE_TYPE)
1872 parmtype = TREE_TYPE (parmtype);
1874 if ((TYPE_MAIN_VARIANT (parmtype) == current_class_type)
1875 || (virtualp && DERIVED_FROM_P (parmtype, current_class_type)))
1882 grok_function_init (decl, init)
1886 /* An initializer for a function tells how this function should
1888 tree type = TREE_TYPE (decl);
1890 if (TREE_CODE (type) == FUNCTION_TYPE)
1891 cp_error ("initializer specified for non-member function `%D'", decl);
1893 /* We'll check for this in finish_struct_1. */
1894 else if (DECL_VINDEX (decl) == NULL_TREE)
1895 cp_error ("initializer specified for non-virtual method `%D'", decl);
1897 else if (integer_zerop (init))
1900 /* Mark this function as being "defined". */
1901 DECL_INITIAL (decl) = error_mark_node;
1902 /* pure virtual destructors must be defined. */
1903 /* pure virtual needs to be defined (as abort) only when put in
1904 vtbl. For wellformed call, it should be itself. pr4737 */
1905 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)))
1907 extern tree abort_fndecl;
1908 /* Give this node rtl from `abort'. */
1909 DECL_RTL (decl) = DECL_RTL (abort_fndecl);
1912 DECL_ABSTRACT_VIRTUAL_P (decl) = 1;
1913 if (DECL_NAME (decl) == ansi_opname [(int) MODIFY_EXPR])
1916 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))));
1918 if (copy_assignment_arg_p (parmtype, 1))
1919 TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
1922 else if (TREE_CODE (init) == OFFSET_REF
1923 && TREE_OPERAND (init, 0) == NULL_TREE
1924 && TREE_CODE (TREE_TYPE (init)) == METHOD_TYPE)
1926 tree basetype = DECL_CLASS_CONTEXT (init);
1927 tree basefn = TREE_OPERAND (init, 1);
1928 if (TREE_CODE (basefn) != FUNCTION_DECL)
1929 cp_error ("non-method initializer invalid for method `%D'", decl);
1930 else if (! BINFO_OFFSET_ZEROP (TYPE_BINFO (DECL_CLASS_CONTEXT (basefn))))
1931 sorry ("base member function from other than first base class");
1934 tree binfo = get_binfo (basetype, TYPE_METHOD_BASETYPE (type), 1);
1935 if (binfo == error_mark_node)
1937 else if (binfo == 0)
1938 error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (init)),
1939 TYPE_METHOD_BASETYPE (type));
1942 /* Mark this function as being defined,
1943 and give it new rtl. */
1944 DECL_INITIAL (decl) = error_mark_node;
1945 DECL_RTL (decl) = DECL_RTL (basefn);
1950 cp_error ("invalid initializer for virtual method `%D'", decl);
1954 cplus_decl_attributes (decl, attributes, prefix_attributes)
1955 tree decl, attributes, prefix_attributes;
1957 if (decl == NULL_TREE || decl == void_type_node)
1960 if (TREE_CODE (decl) == TEMPLATE_DECL)
1961 decl = DECL_TEMPLATE_RESULT (decl);
1963 decl_attributes (decl, attributes, prefix_attributes);
1965 if (TREE_CODE (decl) == TYPE_DECL)
1966 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (decl), TREE_TYPE (decl));
1969 /* CONSTRUCTOR_NAME:
1970 Return the name for the constructor (or destructor) for the
1971 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
1972 IDENTIFIER_NODE. When given a template, this routine doesn't
1973 lose the specialization. */
1975 constructor_name_full (thing)
1978 if (TREE_CODE (thing) == TEMPLATE_TYPE_PARM)
1979 thing = TYPE_NAME (thing);
1980 else if (IS_AGGR_TYPE_CODE (TREE_CODE (thing)))
1982 if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing))
1983 thing = DECL_NAME (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (thing), 0));
1985 thing = TYPE_NAME (thing);
1987 if (TREE_CODE (thing) == TYPE_DECL
1988 || (TREE_CODE (thing) == TEMPLATE_DECL
1989 && TREE_CODE (DECL_TEMPLATE_RESULT (thing)) == TYPE_DECL))
1990 thing = DECL_NAME (thing);
1991 my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197);
1995 /* CONSTRUCTOR_NAME:
1996 Return the name for the constructor (or destructor) for the
1997 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
1998 IDENTIFIER_NODE. When given a template, return the plain
1999 unspecialized name. */
2001 constructor_name (thing)
2005 thing = constructor_name_full (thing);
2006 t = IDENTIFIER_TEMPLATE (thing);
2012 /* Cache the value of this class's main virtual function table pointer
2013 in a register variable. This will save one indirection if a
2014 more than one virtual function call is made this function. */
2018 extern tree base_init_expr;
2020 if (base_init_expr == 0
2021 && DECL_CONSTRUCTOR_P (current_function_decl))
2023 if (current_template_parms)
2024 add_tree (build_min_nt
2026 current_member_init_list, current_base_init_list));
2028 emit_base_init (current_class_type, 0);
2032 /* Record the existence of an addressable inline function. */
2034 mark_inline_for_output (decl)
2037 decl = DECL_MAIN_VARIANT (decl);
2038 if (DECL_SAVED_INLINE (decl))
2040 my_friendly_assert (TREE_PERMANENT (decl), 363);
2041 DECL_SAVED_INLINE (decl) = 1;
2043 if (DECL_PENDING_INLINE_INFO (decl) != 0
2044 && ! DECL_PENDING_INLINE_INFO (decl)->deja_vu)
2046 struct pending_inline *t = pending_inlines;
2047 my_friendly_assert (DECL_SAVED_INSNS (decl) == 0, 198);
2050 if (t == DECL_PENDING_INLINE_INFO (decl))
2056 t = DECL_PENDING_INLINE_INFO (decl);
2057 t->next = pending_inlines;
2058 pending_inlines = t;
2060 DECL_PENDING_INLINE_INFO (decl) = 0;
2063 saved_inlines = perm_tree_cons (NULL_TREE, decl, saved_inlines);
2069 temp_name_counter = 0;
2072 /* Hand off a unique name which can be used for variable we don't really
2073 want to know about anyway, for example, the anonymous variables which
2074 are needed to make references work. Declare this thing so we can use it.
2075 The variable created will be of type TYPE.
2077 STATICP is nonzero if this variable should be static. */
2080 get_temp_name (type, staticp)
2084 char buf[sizeof (AUTO_TEMP_FORMAT) + 20];
2086 int toplev = toplevel_bindings_p ();
2088 push_obstacks_nochange ();
2089 if (toplev || staticp)
2091 end_temporary_allocation ();
2092 sprintf (buf, AUTO_TEMP_FORMAT, global_temp_name_counter++);
2093 decl = pushdecl_top_level (build_decl (VAR_DECL, get_identifier (buf), type));
2097 sprintf (buf, AUTO_TEMP_FORMAT, temp_name_counter++);
2098 decl = pushdecl (build_decl (VAR_DECL, get_identifier (buf), type));
2100 TREE_USED (decl) = 1;
2101 TREE_STATIC (decl) = staticp;
2102 DECL_ARTIFICIAL (decl) = 1;
2104 /* If this is a local variable, then lay out its rtl now.
2105 Otherwise, callers of this function are responsible for dealing
2106 with this variable's rtl. */
2110 expand_decl_init (decl);
2117 /* Get a variable which we can use for multiple assignments.
2118 It is not entered into current_binding_level, because
2119 that breaks things when it comes time to do final cleanups
2120 (which take place "outside" the binding contour of the function). */
2122 get_temp_regvar (type, init)
2125 static char buf[sizeof (AUTO_TEMP_FORMAT) + 20] = { '_' };
2128 sprintf (buf+1, AUTO_TEMP_FORMAT, temp_name_counter++);
2129 decl = build_decl (VAR_DECL, get_identifier (buf), type);
2130 TREE_USED (decl) = 1;
2131 DECL_REGISTER (decl) = 1;
2134 store_init_value (decl, init);
2136 /* We can expand these without fear, since they cannot need
2137 constructors or destructors. */
2139 expand_decl_init (decl);
2144 /* Make the macro TEMP_NAME_P available to units which do not
2145 include c-tree.h. */
2150 return TEMP_NAME_P (decl);
2153 /* Finish off the processing of a UNION_TYPE structure.
2154 If there are static members, then all members are
2155 static, and must be laid out together. If the
2156 union is an anonymous union, we arrange for that
2157 as well. PUBLIC_P is nonzero if this union is
2158 not declared static. */
2160 finish_anon_union (anon_union_decl)
2161 tree anon_union_decl;
2163 tree type = TREE_TYPE (anon_union_decl);
2164 tree field, main_decl = NULL_TREE;
2165 tree elems = NULL_TREE;
2166 int public_p = TREE_PUBLIC (anon_union_decl);
2167 int static_p = TREE_STATIC (anon_union_decl);
2168 int external_p = DECL_EXTERNAL (anon_union_decl);
2170 if ((field = TYPE_FIELDS (type)) == NULL_TREE)
2175 error ("global anonymous unions must be declared static");
2179 for (; field; field = TREE_CHAIN (field))
2182 if (TREE_CODE (field) != FIELD_DECL)
2185 if (TREE_PRIVATE (field))
2186 cp_pedwarn_at ("private member `%#D' in anonymous union", field);
2187 else if (TREE_PROTECTED (field))
2188 cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
2190 decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
2191 /* tell `pushdecl' that this is not tentative. */
2192 DECL_INITIAL (decl) = error_mark_node;
2193 TREE_PUBLIC (decl) = public_p;
2194 TREE_STATIC (decl) = static_p;
2195 DECL_EXTERNAL (decl) = external_p;
2196 decl = pushdecl (decl);
2198 /* Only write out one anon union element--choose the one that
2199 can hold them all. */
2200 if (main_decl == NULL_TREE
2201 && 1 == simple_cst_equal (DECL_SIZE (decl),
2202 DECL_SIZE (anon_union_decl)))
2208 /* ??? This causes there to be no debug info written out
2210 TREE_ASM_WRITTEN (decl) = 1;
2213 DECL_INITIAL (decl) = NULL_TREE;
2214 /* If there's a cleanup to do, it belongs in the
2215 TREE_PURPOSE of the following TREE_LIST. */
2216 elems = tree_cons (NULL_TREE, decl, elems);
2217 TREE_TYPE (elems) = type;
2223 make_decl_rtl (main_decl, 0, toplevel_bindings_p ());
2224 DECL_RTL (anon_union_decl) = DECL_RTL (main_decl);
2228 warning ("anonymous union with no members");
2233 /* The following call assumes that there are never any cleanups
2234 for anonymous unions--a reasonable assumption. */
2235 expand_anon_union_decl (anon_union_decl, NULL_TREE, elems);
2238 /* Finish and output a table which is generated by the compiler.
2239 NAME is the name to give the table.
2240 TYPE is the type of the table entry.
2241 INIT is all the elements in the table.
2242 PUBLICP is non-zero if this table should be given external access. */
2244 finish_table (name, type, init, publicp)
2245 tree name, type, init;
2248 tree itype, atype, decl;
2249 static tree empty_table;
2253 itype = build_index_type (size_int (list_length (init) - 1));
2254 atype = build_cplus_array_type (type, itype);
2255 layout_type (atype);
2257 if (TREE_VALUE (init) == integer_zero_node
2258 && TREE_CHAIN (init) == NULL_TREE)
2261 if (empty_table == NULL_TREE)
2264 empty_table = get_temp_name (atype, 1);
2265 init = build (CONSTRUCTOR, atype, NULL_TREE, init);
2266 TREE_CONSTANT (init) = 1;
2267 TREE_STATIC (init) = 1;
2268 DECL_INITIAL (empty_table) = init;
2269 asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
2270 IDENTIFIER_POINTER (DECL_NAME (empty_table)));
2271 cp_finish_decl (empty_table, NULL_TREE, asmspec, 0, 0);
2276 if (name == NULL_TREE)
2280 decl = get_temp_name (atype, 1);
2284 decl = build_decl (VAR_DECL, name, atype);
2285 decl = pushdecl (decl);
2286 TREE_STATIC (decl) = 1;
2291 TREE_PUBLIC (decl) = publicp;
2292 init = build (CONSTRUCTOR, atype, NULL_TREE, init);
2293 TREE_CONSTANT (init) = 1;
2294 TREE_STATIC (init) = 1;
2295 DECL_INITIAL (decl) = init;
2296 asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (decl)),
2297 IDENTIFIER_POINTER (DECL_NAME (decl)));
2301 /* This will cause DECL to point to EMPTY_TABLE in rtl-land. */
2302 DECL_EXTERNAL (decl) = 1;
2303 TREE_STATIC (decl) = 0;
2305 asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
2306 IDENTIFIER_POINTER (DECL_NAME (empty_table)));
2309 cp_finish_decl (decl, NULL_TREE, asmspec, 0, 0);
2313 /* Finish processing a builtin type TYPE. It's name is NAME,
2314 its fields are in the array FIELDS. LEN is the number of elements
2315 in FIELDS minus one, or put another way, it is the maximum subscript
2318 It is given the same alignment as ALIGN_TYPE. */
2320 finish_builtin_type (type, name, fields, len, align_type)
2329 TYPE_FIELDS (type) = fields[0];
2330 for (i = 0; i < len; i++)
2332 layout_type (TREE_TYPE (fields[i]));
2333 DECL_FIELD_CONTEXT (fields[i]) = type;
2334 TREE_CHAIN (fields[i]) = fields[i+1];
2336 DECL_FIELD_CONTEXT (fields[i]) = type;
2337 DECL_CLASS_CONTEXT (fields[i]) = type;
2338 TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
2340 #if 0 /* not yet, should get fixed properly later */
2341 TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
2343 TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
2345 layout_decl (TYPE_NAME (type), 0);
2348 /* Auxiliary functions to make type signatures for
2349 `operator new' and `operator delete' correspond to
2350 what compiler will be expecting. */
2352 extern tree sizetype;
2355 coerce_new_type (type)
2360 if (TREE_CODE (type) == METHOD_TYPE)
2361 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type)));
2362 if (TREE_TYPE (type) != ptr_type_node)
2363 e1 = 1, error ("`operator new' must return type `void *'");
2365 /* Technically the type must be `size_t', but we may not know
2367 if (TYPE_ARG_TYPES (type) == NULL_TREE)
2368 e1 = 1, error ("`operator new' takes type `size_t' parameter");
2369 else if (TREE_CODE (TREE_VALUE (TYPE_ARG_TYPES (type))) != INTEGER_TYPE
2370 || TYPE_PRECISION (TREE_VALUE (TYPE_ARG_TYPES (type))) != TYPE_PRECISION (sizetype))
2371 e2 = 1, error ("`operator new' takes type `size_t' as first parameter");
2373 type = build_function_type (ptr_type_node, tree_cons (NULL_TREE, sizetype, TREE_CHAIN (TYPE_ARG_TYPES (type))));
2375 type = build_function_type (ptr_type_node, TYPE_ARG_TYPES (type));
2380 coerce_delete_type (type)
2383 int e1 = 0, e2 = 0, e3 = 0;
2384 tree arg_types = TYPE_ARG_TYPES (type);
2386 if (TREE_CODE (type) == METHOD_TYPE)
2388 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (arg_types));
2389 arg_types = TREE_CHAIN (arg_types);
2391 if (TREE_TYPE (type) != void_type_node)
2392 e1 = 1, error ("`operator delete' must return type `void'");
2393 if (arg_types == NULL_TREE
2394 || TREE_VALUE (arg_types) != ptr_type_node)
2395 e2 = 1, error ("`operator delete' takes type `void *' as first parameter");
2398 && TREE_CHAIN (arg_types)
2399 && TREE_CHAIN (arg_types) != void_list_node)
2401 /* Again, technically this argument must be `size_t', but again
2402 we may not know what that is. */
2403 tree t2 = TREE_VALUE (TREE_CHAIN (arg_types));
2404 if (TREE_CODE (t2) != INTEGER_TYPE
2405 || TYPE_PRECISION (t2) != TYPE_PRECISION (sizetype))
2406 e3 = 1, error ("second argument to `operator delete' must be of type `size_t'");
2407 else if (TREE_CHAIN (TREE_CHAIN (arg_types)) != void_list_node)
2410 if (TREE_CHAIN (TREE_CHAIN (arg_types)))
2411 error ("too many arguments in declaration of `operator delete'");
2413 error ("`...' invalid in specification of `operator delete'");
2417 arg_types = tree_cons (NULL_TREE, ptr_type_node, build_tree_list (NULL_TREE, sizetype));
2420 if (arg_types == NULL_TREE)
2421 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
2423 arg_types = tree_cons (NULL_TREE, ptr_type_node, TREE_CHAIN (arg_types));
2428 type = build_function_type (void_type_node, arg_types);
2433 extern tree abort_fndecl;
2436 mark_vtable_entries (decl)
2439 tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
2443 tree fnaddr = (flag_vtable_thunks ? TREE_VALUE (TREE_CHAIN (entries))
2444 : FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries)));
2445 tree fn = TREE_OPERAND (fnaddr, 0);
2446 TREE_ADDRESSABLE (fn) = 1;
2449 skip_rtti_stuff (&entries);
2451 for (; entries; entries = TREE_CHAIN (entries))
2453 tree fnaddr = (flag_vtable_thunks ? TREE_VALUE (entries)
2454 : FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries)));
2455 tree fn = TREE_OPERAND (fnaddr, 0);
2456 TREE_ADDRESSABLE (fn) = 1;
2457 if (DECL_LANG_SPECIFIC (fn) && DECL_ABSTRACT_VIRTUAL_P (fn))
2458 TREE_OPERAND (fnaddr, 0) = fn = abort_fndecl;
2459 if (TREE_CODE (fn) == THUNK_DECL && DECL_EXTERNAL (fn))
2461 DECL_EXTERNAL (fn) = 0;
2468 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
2469 based on TYPE and other static flags.
2471 Note that anything public is tagged TREE_PUBLIC, whether
2472 it's public in this file or in another one. */
2475 import_export_vtable (decl, type, final)
2479 if (DECL_INTERFACE_KNOWN (decl))
2483 if (write_virtuals < 2 && write_virtuals != 0)
2485 TREE_PUBLIC (decl) = 1;
2486 if (write_virtuals < 0)
2487 DECL_EXTERNAL (decl) = 1;
2488 DECL_INTERFACE_KNOWN (decl) = 1;
2490 else if (CLASSTYPE_INTERFACE_KNOWN (type))
2492 TREE_PUBLIC (decl) = 1;
2493 DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type);
2494 DECL_INTERFACE_KNOWN (decl) = 1;
2498 /* We can only wait to decide if we have real non-inline virtual
2499 functions in our class, or if we come from a template. */
2501 int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type);
2503 if (! found && ! final)
2506 for (method = TYPE_METHODS (type); method != NULL_TREE;
2507 method = TREE_CHAIN (method))
2508 if (DECL_VINDEX (method) != NULL_TREE
2509 && ! DECL_THIS_INLINE (method)
2510 && ! DECL_ABSTRACT_VIRTUAL_P (method))
2517 if (final || ! found)
2519 #ifdef DECL_ONE_ONLY
2520 if (SUPPORTS_ONE_ONLY)
2522 TREE_PUBLIC (decl) = 1;
2523 DECL_ONE_ONLY (decl) = 1;
2529 TREE_PUBLIC (decl) = 1;
2530 DECL_WEAK (decl) = 1;
2532 #ifdef ASSEMBLE_EXTERNAL
2533 else if (TREE_PUBLIC (decl))
2534 cp_error ("all virtual functions redeclared inline");
2537 TREE_PUBLIC (decl) = 0;
2538 DECL_EXTERNAL (decl) = 0;
2542 TREE_PUBLIC (decl) = 1;
2543 DECL_EXTERNAL (decl) = 1;
2549 import_export_template (type)
2552 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
2553 && ! flag_implicit_templates
2554 && CLASSTYPE_INTERFACE_UNKNOWN (type))
2556 SET_CLASSTYPE_INTERFACE_KNOWN (type);
2557 CLASSTYPE_INTERFACE_ONLY (type) = 1;
2558 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 0;
2563 finish_prevtable_vardecl (prev, vars)
2566 tree ctype = DECL_CONTEXT (vars);
2567 import_export_template (ctype);
2569 if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype)
2570 && ! (SUPPORTS_ONE_ONLY > 1)
2571 && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2574 for (method = TYPE_METHODS (ctype); method != NULL_TREE;
2575 method = TREE_CHAIN (method))
2577 if (DECL_VINDEX (method) != NULL_TREE
2578 && !DECL_THIS_INLINE (method)
2579 && !DECL_ABSTRACT_VIRTUAL_P (method))
2581 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
2582 CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = ! DECL_EXTERNAL (method);
2583 CLASSTYPE_INTERFACE_ONLY (ctype) = DECL_EXTERNAL (method);
2589 import_export_vtable (vars, ctype, 1);
2594 finish_vtable_vardecl (prev, vars)
2597 if (write_virtuals >= 0
2598 && ! DECL_EXTERNAL (vars)
2599 && ((TREE_PUBLIC (vars) && ! DECL_WEAK (vars)
2600 #ifdef DECL_ONE_ONLY
2601 && ! DECL_ONE_ONLY (vars)
2604 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars)))
2605 && ! TREE_ASM_WRITTEN (vars))
2608 mark_vtable_entries (vars);
2609 if (TREE_TYPE (DECL_INITIAL (vars)) == 0)
2610 store_init_value (vars, DECL_INITIAL (vars));
2612 #ifdef DWARF_DEBUGGING_INFO
2613 if (write_symbols == DWARF_DEBUG)
2615 /* Mark the VAR_DECL node representing the vtable itself as a
2616 "gratuitous" one, thereby forcing dwarfout.c to ignore it.
2617 It is rather important that such things be ignored because
2618 any effort to actually generate DWARF for them will run
2619 into trouble when/if we encounter code like:
2622 struct S { virtual void member (); };
2624 because the artificial declaration of the vtable itself (as
2625 manufactured by the g++ front end) will say that the vtable
2626 is a static member of `S' but only *after* the debug output
2627 for the definition of `S' has already been output. This causes
2628 grief because the DWARF entry for the definition of the vtable
2629 will try to refer back to an earlier *declaration* of the
2630 vtable as a static member of `S' and there won't be one.
2631 We might be able to arrange to have the "vtable static member"
2632 attached to the member list for `S' before the debug info for
2633 `S' get written (which would solve the problem) but that would
2634 require more intrusive changes to the g++ front end. */
2636 DECL_IGNORED_P (vars) = 1;
2638 #endif /* DWARF_DEBUGGING_INFO */
2640 rest_of_decl_compilation (vars, NULL_PTR, 1, 1);
2643 else if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (vars)))
2644 /* We don't know what to do with this one yet. */
2647 /* We know that PREV must be non-zero here. */
2648 TREE_CHAIN (prev) = TREE_CHAIN (vars);
2653 prune_vtable_vardecl (prev, vars)
2656 /* We know that PREV must be non-zero here. */
2657 TREE_CHAIN (prev) = TREE_CHAIN (vars);
2662 walk_vtables (typedecl_fn, vardecl_fn)
2663 register void (*typedecl_fn)();
2664 register int (*vardecl_fn)();
2669 for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars))
2671 register tree type = TREE_TYPE (vars);
2673 if (TREE_CODE (vars) == VAR_DECL && DECL_VIRTUAL_P (vars))
2676 flag |= (*vardecl_fn) (prev, vars);
2678 if (prev && TREE_CHAIN (prev) != vars)
2681 else if (TREE_CODE (vars) == TYPE_DECL
2682 && type != error_mark_node
2683 && TYPE_LANG_SPECIFIC (type)
2684 && CLASSTYPE_VSIZE (type))
2686 if (typedecl_fn) (*typedecl_fn) (prev, vars);
2696 finish_sigtable_vardecl (prev, vars)
2699 /* We don't need to mark sigtable entries as addressable here as is done
2700 for vtables. Since sigtables, unlike vtables, are always written out,
2701 that was already done in build_signature_table_constructor. */
2703 rest_of_decl_compilation (vars, NULL_PTR, 1, 1);
2705 /* We know that PREV must be non-zero here. */
2706 TREE_CHAIN (prev) = TREE_CHAIN (vars);
2710 walk_sigtables (typedecl_fn, vardecl_fn)
2711 register void (*typedecl_fn)();
2712 register void (*vardecl_fn)();
2716 for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars))
2718 register tree type = TREE_TYPE (vars);
2720 if (TREE_CODE (vars) == TYPE_DECL
2721 && type != error_mark_node
2722 && IS_SIGNATURE (type))
2724 if (typedecl_fn) (*typedecl_fn) (prev, vars);
2726 else if (TREE_CODE (vars) == VAR_DECL
2727 && TREE_TYPE (vars) != error_mark_node
2728 && IS_SIGNATURE (TREE_TYPE (vars)))
2730 if (vardecl_fn) (*vardecl_fn) (prev, vars);
2737 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
2738 inline function or template instantiation at end-of-file. */
2741 import_export_decl (decl)
2744 if (DECL_INTERFACE_KNOWN (decl))
2747 if (DECL_TEMPLATE_INSTANTIATION (decl))
2749 DECL_NOT_REALLY_EXTERN (decl) = 1;
2750 if (DECL_IMPLICIT_INSTANTIATION (decl) && flag_implicit_templates)
2752 if (TREE_CODE (decl) == FUNCTION_DECL)
2754 #ifdef DECL_ONE_ONLY
2755 if (SUPPORTS_ONE_ONLY)
2756 DECL_ONE_ONLY (decl) = 1;
2760 DECL_WEAK (decl) = 1;
2762 TREE_PUBLIC (decl) = 0;
2764 /* Dynamically initialized vars go into common. */
2765 else if (DECL_INITIAL (decl) == NULL_TREE
2766 || DECL_INITIAL (decl) == error_mark_node)
2767 DECL_COMMON (decl) = 1;
2768 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
2770 DECL_COMMON (decl) = 1;
2771 DECL_INITIAL (decl) = error_mark_node;
2773 #ifdef DECL_ONE_ONLY
2774 else if (SUPPORTS_ONE_ONLY)
2775 DECL_ONE_ONLY (decl) = 1;
2777 /* Statically initialized vars are weak or comdat, if supported. */
2779 DECL_WEAK (decl) = 1;
2780 /* else leave vars public so multiple defs will break. */
2783 DECL_NOT_REALLY_EXTERN (decl) = 0;
2785 else if (DECL_FUNCTION_MEMBER_P (decl))
2787 tree ctype = DECL_CLASS_CONTEXT (decl);
2788 if (CLASSTYPE_INTERFACE_KNOWN (ctype) && ! DECL_ARTIFICIAL (decl))
2790 DECL_NOT_REALLY_EXTERN (decl)
2791 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2792 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines));
2794 #ifdef DECL_ONE_ONLY
2795 else if (SUPPORTS_ONE_ONLY)
2796 DECL_ONE_ONLY (decl) = 1;
2799 DECL_WEAK (decl) = 1;
2801 TREE_PUBLIC (decl) = 0;
2803 /* tinfo function */
2804 else if (DECL_ARTIFICIAL (decl) && DECL_MUTABLE_P (decl))
2806 tree ctype = TREE_TYPE (DECL_NAME (decl));
2807 if (IS_AGGR_TYPE (ctype) && CLASSTYPE_INTERFACE_KNOWN (ctype))
2809 DECL_NOT_REALLY_EXTERN (decl)
2810 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2811 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines));
2813 else if (TYPE_BUILT_IN (ctype) && ctype == TYPE_MAIN_VARIANT (ctype))
2814 DECL_NOT_REALLY_EXTERN (decl) = 0;
2815 #ifdef DECL_ONE_ONLY
2816 else if (SUPPORTS_ONE_ONLY)
2817 DECL_ONE_ONLY (decl) = 1;
2820 DECL_WEAK (decl) = 1;
2822 TREE_PUBLIC (decl) = 0;
2824 else if (DECL_C_STATIC (decl))
2825 TREE_PUBLIC (decl) = 0;
2826 #ifdef DECL_ONE_ONLY
2827 else if (SUPPORTS_ONE_ONLY)
2828 DECL_ONE_ONLY (decl) = 1;
2831 DECL_WEAK (decl) = 1;
2833 TREE_PUBLIC (decl) = 0;
2835 DECL_INTERFACE_KNOWN (decl) = 1;
2839 build_cleanup (decl)
2843 tree type = TREE_TYPE (decl);
2845 if (TREE_CODE (type) == ARRAY_TYPE)
2849 mark_addressable (decl);
2850 temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
2852 temp = build_delete (TREE_TYPE (temp), temp,
2854 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
2858 extern int parse_time, varconst_time;
2859 extern tree pending_templates;
2861 #define TIMEVAR(VAR, BODY) \
2862 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
2864 extern struct obstack permanent_obstack;
2865 extern tree get_id_2 ();
2871 tree sname = get_id_2 ("__sn", base);
2872 tree sentry = IDENTIFIER_GLOBAL_VALUE (sname);
2875 push_obstacks (&permanent_obstack, &permanent_obstack);
2876 sentry = build_decl (VAR_DECL, sname, integer_type_node);
2877 TREE_PUBLIC (sentry) = 1;
2878 DECL_ARTIFICIAL (sentry) = 1;
2879 TREE_STATIC (sentry) = 1;
2880 TREE_USED (sentry) = 1;
2881 DECL_COMMON (sentry) = 1;
2882 pushdecl_top_level (sentry);
2883 cp_finish_decl (sentry, NULL_TREE, NULL_TREE, 0, 0);
2889 /* This routine is called from the last rule in yyparse ().
2890 Its job is to create all the code needed to initialize and
2891 destroy the global aggregates. We do the destruction
2892 first, since that way we only need to reverse the decls once. */
2898 int start_time, this_time;
2902 int needs_cleaning = 0, needs_messing_up = 0;
2906 if (flag_detailed_statistics)
2907 dump_tree_statistics ();
2909 /* Bad parse errors. Just forget about it. */
2910 if (! global_bindings_p () || current_class_type)
2913 start_time = get_run_time ();
2915 /* Otherwise, GDB can get confused, because in only knows
2916 about source for LINENO-1 lines. */
2919 interface_unknown = 1;
2922 for (fnname = pending_templates; fnname; fnname = TREE_CHAIN (fnname))
2924 tree decl = TREE_VALUE (fnname);
2925 instantiate_decl (decl);
2928 /* Push into C language context, because that's all
2930 push_lang_context (lang_name_c);
2933 /* The reason for pushing garbage onto the global_binding_level is to
2934 ensure that we can slice out _DECLs which pertain to virtual function
2935 tables. If the last thing pushed onto the global_binding_level was a
2936 virtual function table, then slicing it out would slice away all the
2937 decls (i.e., we lose the head of the chain).
2939 There are several ways of getting the same effect, from changing the
2940 way that iterators over the chain treat the elements that pertain to
2941 virtual function tables, moving the implementation of this code to
2942 decl.c (where we can manipulate global_binding_level directly),
2943 popping the garbage after pushing it and slicing away the vtable
2944 stuff, or just leaving it alone. */
2946 /* Make last thing in global scope not be a virtual function table. */
2947 #if 0 /* not yet, should get fixed properly later */
2948 vars = make_type_decl (get_identifier (" @%$#@!"), integer_type_node);
2950 vars = build_decl (TYPE_DECL, get_identifier (" @%$#@!"), integer_type_node);
2952 DECL_IGNORED_P (vars) = 1;
2953 SET_DECL_ARTIFICIAL (vars);
2957 /* Walk to mark the inline functions we need, then output them so
2958 that we can pick up any other tdecls that those routines need. */
2959 walk_vtables ((void (*)())0, finish_prevtable_vardecl);
2961 for (vars = pending_statics; vars; vars = TREE_CHAIN (vars))
2963 tree decl = TREE_VALUE (vars);
2965 if (DECL_TEMPLATE_INSTANTIATION (decl)
2966 && ! DECL_IN_AGGR_P (decl))
2968 import_export_decl (decl);
2969 DECL_EXTERNAL (decl) = ! DECL_NOT_REALLY_EXTERN (decl);
2973 vars = static_aggregates;
2975 if (static_ctors || vars || might_have_exceptions_p ())
2976 needs_messing_up = 1;
2980 /* See if we really need the hassle. */
2981 while (vars && needs_cleaning == 0)
2983 tree decl = TREE_VALUE (vars);
2984 tree type = TREE_TYPE (decl);
2985 if (TYPE_NEEDS_DESTRUCTOR (type) && ! TREE_STATIC (vars))
2991 vars = TREE_CHAIN (vars);
2994 if (needs_cleaning == 0)
2997 fnname = get_file_function_name ('D');
2998 start_function (void_list_node,
2999 build_parse_node (CALL_EXPR, fnname, void_list_node,
3001 NULL_TREE, NULL_TREE, 0);
3002 fnname = DECL_ASSEMBLER_NAME (current_function_decl);
3003 store_parm_decls ();
3008 expand_start_bindings (0);
3010 /* These must be done in backward order to destroy,
3011 in which they happen to be! */
3012 for (vars = static_aggregates; vars; vars = TREE_CHAIN (vars))
3014 tree decl = TREE_VALUE (vars);
3015 tree type = TREE_TYPE (decl);
3016 tree temp = TREE_PURPOSE (vars);
3018 if (TYPE_NEEDS_DESTRUCTOR (type) && ! TREE_STATIC (vars)
3019 && ! DECL_EXTERNAL (decl))
3021 int protect = (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
3022 #ifdef DECL_ONE_ONLY
3023 || DECL_ONE_ONLY (decl)
3025 || DECL_WEAK (decl)));
3027 temp = build_cleanup (decl);
3031 tree sentry = get_sentry (DECL_ASSEMBLER_NAME (decl));
3032 sentry = build_unary_op (PREDECREMENT_EXPR, sentry, 0);
3033 sentry = build_binary_op (EQ_EXPR, sentry, integer_zero_node, 1);
3034 expand_start_cond (sentry, 0);
3037 expand_expr_stmt (temp);
3044 for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
3045 expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
3048 expand_end_bindings (getdecls (), 1, 0);
3052 finish_function (lineno, 0, 0);
3054 assemble_destructor (IDENTIFIER_POINTER (fnname));
3056 /* if it needed cleaning, then it will need messing up: drop through */
3059 /* Must do this while we think we are at the top level. */
3060 vars = nreverse (static_aggregates);
3061 if (needs_messing_up)
3063 fnname = get_file_function_name ('I');
3064 start_function (void_list_node,
3065 build_parse_node (CALL_EXPR, fnname,
3066 void_list_node, NULL_TREE),
3067 NULL_TREE, NULL_TREE, 0);
3068 fnname = DECL_ASSEMBLER_NAME (current_function_decl);
3069 store_parm_decls ();
3074 expand_start_bindings (0);
3076 if (might_have_exceptions_p ())
3077 register_exception_table ();
3081 extern int temp_slot_level;
3082 extern int target_temp_slot_level;
3083 tree decl = TREE_VALUE (vars);
3084 tree init = TREE_PURPOSE (vars);
3085 tree old_cleanups = cleanups_this_call;
3086 int old_temp_level = target_temp_slot_level;
3089 target_temp_slot_level = temp_slot_level;
3091 /* If this was a static attribute within some function's scope,
3092 then don't initialize it here. Also, don't bother
3093 with initializers that contain errors. */
3094 if (TREE_STATIC (vars)
3095 || DECL_EXTERNAL (decl)
3096 || (init && TREE_CODE (init) == TREE_LIST
3097 && value_member (error_mark_node, init)))
3100 if (TREE_CODE (decl) == VAR_DECL)
3102 int protect = (TREE_PUBLIC (decl) && (DECL_COMMON (decl)
3103 #ifdef DECL_ONE_ONLY
3104 || DECL_ONE_ONLY (decl)
3106 || DECL_WEAK (decl)));
3108 /* Set these global variables so that GDB at least puts
3109 us near the declaration which required the initialization. */
3110 input_filename = DECL_SOURCE_FILE (decl);
3111 lineno = DECL_SOURCE_LINE (decl);
3112 emit_note (input_filename, lineno);
3114 /* 9.5p5: The initializer of a static member of a class has
3115 the same access rights as a member function. */
3116 DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3117 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3121 tree sentry = get_sentry (DECL_ASSEMBLER_NAME (decl));
3122 sentry = build_unary_op (PREINCREMENT_EXPR, sentry, 0);
3123 sentry = build_binary_op
3124 (EQ_EXPR, sentry, integer_one_node, 1);
3125 expand_start_cond (sentry, 0);
3128 if (IS_AGGR_TYPE (TREE_TYPE (decl))
3129 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
3130 expand_aggr_init (decl, init, 0, 0);
3131 else if (TREE_CODE (init) == TREE_VEC)
3133 expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0),
3134 TREE_VEC_ELT (init, 1),
3135 TREE_VEC_ELT (init, 2), 0),
3136 const0_rtx, VOIDmode, 0);
3139 expand_assignment (decl, init, 0, 0);
3144 DECL_CLASS_CONTEXT (current_function_decl) = NULL_TREE;
3145 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3147 else if (decl == error_mark_node)
3149 else my_friendly_abort (22);
3151 /* Cleanup any temporaries needed for the initial value. */
3152 expand_cleanups_to (old_cleanups);
3156 target_temp_slot_level = old_temp_level;
3158 vars = TREE_CHAIN (vars);
3161 for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
3162 expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
3165 expand_end_bindings (getdecls (), 1, 0);
3169 finish_function (lineno, 0, 0);
3170 assemble_constructor (IDENTIFIER_POINTER (fnname));
3173 expand_builtin_throw ();
3175 permanent_allocation (1);
3177 /* Done with C language context needs. */
3178 pop_lang_context ();
3180 /* Now write out any static class variables (which may have since
3181 learned how to be initialized). */
3182 while (pending_statics)
3184 tree decl = TREE_VALUE (pending_statics);
3186 if (TREE_USED (decl) == 1
3187 || TREE_READONLY (decl) == 0
3188 || DECL_INITIAL (decl) == 0)
3190 DECL_DEFER_OUTPUT (decl) = 0;
3191 rest_of_decl_compilation (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1, 1);
3193 pending_statics = TREE_CHAIN (pending_statics);
3196 this_time = get_run_time ();
3197 parse_time -= this_time - start_time;
3198 varconst_time += this_time - start_time;
3200 start_time = get_run_time ();
3202 if (flag_handle_signatures)
3203 walk_sigtables ((void (*)())0, finish_sigtable_vardecl);
3205 for (fnname = saved_inlines; fnname; fnname = TREE_CHAIN (fnname))
3207 tree decl = TREE_VALUE (fnname);
3208 import_export_decl (decl);
3211 /* Now write out inline functions which had their addresses taken and
3212 which were not declared virtual and which were not declared `extern
3215 int reconsider = 1; /* More may be referenced; check again */
3219 tree *p = &saved_inlines;
3222 /* We need to do this each time so that newly completed template
3223 types don't wind up at the front of the list. Sigh. */
3224 vars = build_decl (TYPE_DECL, make_anon_name (), integer_type_node);
3225 DECL_IGNORED_P (vars) = 1;
3226 SET_DECL_ARTIFICIAL (vars);
3229 reconsider |= walk_vtables ((void (*)())0, finish_vtable_vardecl);
3233 tree decl = TREE_VALUE (*p);
3235 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
3237 && (! DECL_REALLY_EXTERN (decl) || DECL_INLINE (decl)))
3239 if (DECL_MUTABLE_P (decl))
3240 synthesize_tinfo_fn (decl);
3242 synthesize_method (decl);
3246 /* Catch new template instantiations. */
3247 if (decl != TREE_VALUE (*p))
3250 if (TREE_ASM_WRITTEN (decl)
3251 || (DECL_SAVED_INSNS (decl) == 0 && ! DECL_ARTIFICIAL (decl)))
3252 *p = TREE_CHAIN (*p);
3253 else if (DECL_INITIAL (decl) == 0)
3254 p = &TREE_CHAIN (*p);
3255 else if ((TREE_PUBLIC (decl) && ! DECL_WEAK (decl)
3256 #ifdef DECL_ONE_ONLY
3257 && ! DECL_ONE_ONLY (decl)
3260 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
3261 || flag_keep_inline_functions)
3263 if (DECL_NOT_REALLY_EXTERN (decl))
3265 DECL_EXTERNAL (decl) = 0;
3267 /* We can't inline this function after it's been
3268 emitted, so just disable inlining. We want a
3269 variant of output_inline_function that doesn't
3270 prevent subsequent integration... */
3272 temporary_allocation ();
3273 output_inline_function (decl);
3274 permanent_allocation (1);
3277 *p = TREE_CHAIN (*p);
3280 p = &TREE_CHAIN (*p);
3285 /* Now delete from the chain of variables all virtual function tables.
3286 We output them all ourselves, because each will be treated specially. */
3288 walk_vtables ((void (*)())0, prune_vtable_vardecl);
3290 for (vars = getdecls (); vars; vars = TREE_CHAIN (vars))
3292 if (TREE_CODE (vars) == FUNCTION_DECL
3293 && ! DECL_INTERFACE_KNOWN (vars)
3294 && DECL_C_STATIC (vars))
3295 TREE_PUBLIC (vars) = 0;
3298 if (might_have_exceptions_p ())
3299 emit_exception_table ();
3301 if (write_virtuals == 2)
3303 /* Now complain about an virtual function tables promised
3304 but not delivered. */
3305 while (pending_vtables)
3307 if (TREE_PURPOSE (pending_vtables) == NULL_TREE)
3308 error ("virtual function table for `%s' not defined",
3309 IDENTIFIER_POINTER (TREE_VALUE (pending_vtables)));
3310 pending_vtables = TREE_CHAIN (pending_vtables);
3316 this_time = get_run_time ();
3317 parse_time -= this_time - start_time;
3318 varconst_time += this_time - start_time;
3320 if (flag_detailed_statistics)
3321 dump_time_statistics ();
3324 /* This is something of the form 'A()()()()()+1' that has turned out to be an
3325 expr. Since it was parsed like a type, we need to wade through and fix
3326 that. Unfortunately, since operator() is left-associative, we can't use
3327 tail recursion. In the above example, TYPE is `A', and DECL is
3330 Maybe this shouldn't be recursive, but how often will it actually be
3333 reparse_absdcl_as_expr (type, decl)
3336 /* do build_functional_cast (type, NULL_TREE) at bottom */
3337 if (TREE_OPERAND (decl, 0) == NULL_TREE)
3338 return build_functional_cast (type, NULL_TREE);
3341 decl = reparse_decl_as_expr (type, TREE_OPERAND (decl, 0));
3343 decl = build_x_function_call (decl, NULL_TREE, current_class_ref);
3345 if (TREE_CODE (decl) == CALL_EXPR && TREE_TYPE (decl) != void_type_node)
3346 decl = require_complete_type (decl);
3351 /* This is something of the form `int ((int)(int)(int)1)' that has turned
3352 out to be an expr. Since it was parsed like a type, we need to wade
3353 through and fix that. Since casts are right-associative, we are
3354 reversing the order, so we don't have to recurse.
3356 In the above example, DECL is the `(int)(int)(int)', and EXPR is the
3359 reparse_absdcl_as_casts (decl, expr)
3364 if (TREE_CODE (expr) == CONSTRUCTOR
3365 && TREE_TYPE (expr) == 0)
3367 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1)));
3368 decl = TREE_OPERAND (decl, 0);
3370 if (IS_SIGNATURE (type))
3372 error ("cast specifies signature type");
3373 return error_mark_node;
3376 expr = digest_init (type, expr, (tree *) 0);
3377 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
3379 int failure = complete_array_type (type, expr, 1);
3381 my_friendly_abort (78);
3387 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1)));
3388 decl = TREE_OPERAND (decl, 0);
3389 expr = build_c_cast (type, expr, 0);
3395 /* Given plain tree nodes for an expression, build up the full semantics. */
3398 build_expr_from_tree (t)
3401 if (t == NULL_TREE || t == error_mark_node)
3404 switch (TREE_CODE (t))
3406 case IDENTIFIER_NODE:
3407 return do_identifier (t, 0);
3410 if (LOOKUP_EXPR_GLOBAL (t))
3411 return do_scoped_id (TREE_OPERAND (t, 0), 0);
3413 return do_identifier (TREE_OPERAND (t, 0), 0);
3416 return build_x_indirect_ref
3417 (build_expr_from_tree (TREE_OPERAND (t, 0)), "unary *");
3420 return build_functional_cast
3421 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3423 case REINTERPRET_CAST_EXPR:
3424 return build_reinterpret_cast
3425 (TREE_TYPE (t), build_expr_from_tree (TREE_OPERAND (t, 0)));
3427 case PREDECREMENT_EXPR:
3428 case PREINCREMENT_EXPR:
3429 case POSTDECREMENT_EXPR:
3430 case POSTINCREMENT_EXPR:
3434 case TRUTH_NOT_EXPR:
3436 case CONVERT_EXPR: /* Unary + */
3439 return build_x_unary_op (TREE_CODE (t),
3440 build_expr_from_tree (TREE_OPERAND (t, 0)));
3445 case TRUNC_DIV_EXPR:
3447 case FLOOR_DIV_EXPR:
3448 case ROUND_DIV_EXPR:
3449 case EXACT_DIV_EXPR:
3451 case BIT_ANDTC_EXPR:
3454 case TRUNC_MOD_EXPR:
3455 case FLOOR_MOD_EXPR:
3456 case TRUTH_ANDIF_EXPR:
3457 case TRUTH_ORIF_EXPR:
3458 case TRUTH_AND_EXPR:
3473 return build_x_binary_op
3475 build_expr_from_tree (TREE_OPERAND (t, 0)),
3476 build_expr_from_tree (TREE_OPERAND (t, 1)));
3479 return build_m_component_ref
3480 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3481 build_expr_from_tree (TREE_OPERAND (t, 1)));
3484 return build_offset_ref (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
3487 if (TREE_OPERAND (t, 0) == NULL_TREE)
3489 return build_parse_node (ARRAY_REF, NULL_TREE,
3490 build_expr_from_tree (TREE_OPERAND (t, 1)));
3491 return grok_array_decl (build_expr_from_tree (TREE_OPERAND (t, 0)),
3492 build_expr_from_tree (TREE_OPERAND (t, 1)));
3496 tree r = build_expr_from_tree (TREE_OPERAND (t, 0));
3497 if (TREE_CODE_CLASS (TREE_CODE (r)) != 't')
3499 return c_sizeof (r);
3503 return build_x_modify_expr
3504 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3505 TREE_CODE (TREE_OPERAND (t, 1)),
3506 build_expr_from_tree (TREE_OPERAND (t, 2)));
3509 return build_x_arrow
3510 (build_expr_from_tree (TREE_OPERAND (t, 0)));
3514 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3515 build_expr_from_tree (TREE_OPERAND (t, 1)),
3516 build_expr_from_tree (TREE_OPERAND (t, 2)),
3517 NEW_EXPR_USE_GLOBAL (t));
3520 return delete_sanity
3521 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3522 build_expr_from_tree (TREE_OPERAND (t, 1)),
3523 DELETE_EXPR_USE_VEC (t), DELETE_EXPR_USE_GLOBAL (t));
3526 if (TREE_OPERAND (t, 1) == NULL_TREE)
3527 return build_x_compound_expr
3528 (build_expr_from_tree (TREE_OPERAND (t, 0)));
3530 my_friendly_abort (42);
3532 case METHOD_CALL_EXPR:
3533 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3535 tree ref = TREE_OPERAND (t, 0);
3536 return build_scoped_method_call
3537 (build_expr_from_tree (TREE_OPERAND (t, 1)),
3538 build_expr_from_tree (TREE_OPERAND (ref, 0)),
3539 TREE_OPERAND (ref, 1),
3540 build_expr_from_tree (TREE_OPERAND (t, 2)));
3542 return build_method_call
3543 (build_expr_from_tree (TREE_OPERAND (t, 1)),
3544 TREE_OPERAND (t, 0),
3545 build_expr_from_tree (TREE_OPERAND (t, 2)),
3546 NULL_TREE, LOOKUP_NORMAL);
3549 if (TREE_CODE (TREE_OPERAND (t, 0)) == SCOPE_REF)
3551 tree ref = TREE_OPERAND (t, 0);
3552 return build_member_call
3553 (build_expr_from_tree (TREE_OPERAND (ref, 0)),
3554 TREE_OPERAND (ref, 1),
3555 build_expr_from_tree (TREE_OPERAND (t, 1)));
3559 tree name = TREE_OPERAND (t, 0);
3560 if (! really_overloaded_fn (name))
3561 name = build_expr_from_tree (name);
3562 return build_x_function_call
3563 (name, build_expr_from_tree (TREE_OPERAND (t, 1)),
3568 return build_x_conditional_expr
3569 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3570 build_expr_from_tree (TREE_OPERAND (t, 1)),
3571 build_expr_from_tree (TREE_OPERAND (t, 2)));
3575 tree purpose, value, chain;
3577 if (t == void_list_node)
3580 purpose = TREE_PURPOSE (t);
3582 purpose = build_expr_from_tree (purpose);
3583 value = TREE_VALUE (t);
3585 value = build_expr_from_tree (value);
3586 chain = TREE_CHAIN (t);
3587 if (chain && chain != void_type_node)
3588 chain = build_expr_from_tree (chain);
3589 return tree_cons (purpose, value, chain);
3593 return build_component_ref
3594 (build_expr_from_tree (TREE_OPERAND (t, 0)),
3595 TREE_OPERAND (t, 1), NULL_TREE, 1);
3598 return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0)));
3605 /* This is something of the form `int (*a)++' that has turned out to be an
3606 expr. It was only converted into parse nodes, so we need to go through
3607 and build up the semantics. Most of the work is done by
3608 build_expr_from_tree, above.
3610 In the above example, TYPE is `int' and DECL is `*a'. */
3612 reparse_decl_as_expr (type, decl)
3615 decl = build_expr_from_tree (decl);
3617 return build_functional_cast (type, build_tree_list (NULL_TREE, decl));
3622 /* This is something of the form `int (*a)' that has turned out to be a
3623 decl. It was only converted into parse nodes, so we need to do the
3624 checking that make_{pointer,reference}_declarator do. */
3627 finish_decl_parsing (decl)
3630 extern int current_class_depth;
3632 switch (TREE_CODE (decl))
3634 case IDENTIFIER_NODE:
3637 return make_pointer_declarator
3638 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0)));
3640 return make_reference_declarator
3641 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0)));
3643 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0));
3646 push_nested_class (TREE_TYPE (TREE_OPERAND (decl, 0)), 3);
3647 TREE_COMPLEXITY (decl) = current_class_depth;
3650 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0));
3653 my_friendly_abort (5);
3659 check_cp_case_value (value)
3662 if (value == NULL_TREE)
3665 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3666 STRIP_TYPE_NOPS (value);
3668 if (TREE_READONLY_DECL_P (value))
3670 value = decl_constant_value (value);
3671 STRIP_TYPE_NOPS (value);
3673 value = fold (value);
3675 if (TREE_CODE (value) != INTEGER_CST
3676 && value != error_mark_node)
3678 cp_error ("case label `%E' does not reduce to an integer constant",
3680 value = error_mark_node;
3683 /* Promote char or short to int. */
3684 value = default_conversion (value);
3686 constant_expression_warning (value);
3691 tree current_namespace;
3693 /* Get the inner part of a namespace id. It doesn't have any prefix, nor
3694 postfix. Returns 0 if in global namespace. */
3698 tree x = current_namespace;
3700 x = TREE_PURPOSE (x);
3704 /* Build up a DECL_ASSEMBLER_NAME for NAME in the current namespace. */
3706 current_namespace_id (name)
3709 tree old_id = get_namespace_id ();
3712 /* Global names retain old encoding. */
3716 buf = (char *) alloca (8 + IDENTIFIER_LENGTH (old_id)
3717 + IDENTIFIER_LENGTH (name));
3718 sprintf (buf, "__ns_%s_%s", IDENTIFIER_POINTER (old_id),
3719 IDENTIFIER_POINTER (name));
3720 return get_identifier (buf);
3724 do_namespace_alias (alias, namespace)
3725 tree alias, namespace;
3727 sorry ("namespace alias");
3731 do_toplevel_using_decl (decl)
3734 if (decl == NULL_TREE || decl == error_mark_node)
3737 if (TREE_CODE (decl) == SCOPE_REF)
3738 decl = resolve_scope_to_name (NULL_TREE, decl);
3740 /* Is this the right way to do an id list? */
3741 if (TREE_CODE (decl) != TREE_LIST)
3748 pushdecl (TREE_VALUE (decl));
3749 decl = TREE_CHAIN (decl);
3754 do_class_using_decl (decl)
3759 if (TREE_CODE (decl) != SCOPE_REF)
3761 cp_error ("using-declaration for non-member at class scope");
3764 name = TREE_OPERAND (decl, 1);
3765 if (TREE_CODE (name) == BIT_NOT_EXPR)
3767 cp_error ("using-declaration for destructor");
3771 value = build_lang_field_decl (USING_DECL, name, void_type_node);
3772 DECL_INITIAL (value) = TREE_OPERAND (decl, 0);
3777 do_using_directive (namespace)
3780 sorry ("using directive");
3784 check_default_args (x)
3787 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
3788 int saw_def = 0, i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
3789 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
3791 if (TREE_PURPOSE (arg))
3795 cp_error ("default argument missing for parameter %P of `%#D'",
3806 TREE_USED (decl) = 1;
3807 if (current_template_parms)
3809 assemble_external (decl);
3810 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3811 instantiate_decl (decl);