1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995 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. */
41 extern tree get_file_function_name ();
42 extern tree cleanups_this_call;
43 static void grok_function_init ();
45 /* A list of virtual function tables we must make sure to write out. */
48 /* A list of static class variables. This is needed, because a
49 static class variable can be declared inside the class without
50 an initializer, and then initialized, staticly, outside the class. */
53 /* A list of functions which were declared inline, but which we
54 may need to emit outline anyway. */
55 static tree saved_inlines;
57 /* Used to help generate temporary names which are unique within
58 a function. Reset to 0 by start_function. */
60 int temp_name_counter;
62 /* Same, but not reset. Local temp variables and global temp variables
63 can have the same name. */
64 static int global_temp_name_counter;
66 /* Flag used when debugging spew.c */
68 extern int spew_debug;
70 /* Functions called along with real static constructors and destructors. */
72 tree static_ctors, static_dtors;
74 /* C (and C++) language-specific option variables. */
76 /* Nonzero means allow type mismatches in conditional expressions;
77 just make their values `void'. */
79 int flag_cond_mismatch;
81 /* Nonzero means give `double' the same size as `float'. */
83 int flag_short_double;
85 /* Nonzero means don't recognize the keyword `asm'. */
89 /* Nonzero means don't recognize any extension keywords. */
91 int flag_no_gnu_keywords;
93 /* Nonzero means don't recognize the non-ANSI builtin functions. */
97 /* Nonzero means don't recognize the non-ANSI builtin functions.
100 int flag_no_nonansi_builtin;
102 /* Nonzero means do some things the same way PCC does. */
104 int flag_traditional;
106 /* Nonzero means to treat bitfields as unsigned unless they say `signed'. */
108 int flag_signed_bitfields = 1;
110 /* Nonzero means handle `#ident' directives. 0 means ignore them. */
114 /* Nonzero means enable obscure ANSI features and disable GNU extensions
115 that might cause ANSI-compliant code to be miscompiled. */
119 /* Nonzero means do emit exported implementations of functions even if
120 they can be inlined. */
122 int flag_implement_inlines = 1;
124 /* Nonzero means do emit exported implementations of templates, instead of
125 multiple static copies in each file that needs a definition. */
127 int flag_external_templates;
129 /* Nonzero means that the decision to emit or not emit the implementation of a
130 template depends on where the template is instantiated, rather than where
133 int flag_alt_external_templates;
135 /* Nonzero means that implicit instantiations will be emitted if needed. */
137 int flag_implicit_templates = 1;
139 /* Nonzero means warn about implicit declarations. */
141 int warn_implicit = 1;
143 /* Nonzero means warn when all ctors or dtors are private, and the class
146 int warn_ctor_dtor_privacy = 1;
148 /* True if we want to implement vtbvales using "thunks".
149 The default is off now, but will be on later. */
151 int flag_vtable_thunks;
153 /* True if we want to deal with repository information. */
155 int flag_use_repository;
157 /* Nonzero means give string constants the type `const char *'
158 to get extra warnings from them. These warnings will be too numerous
159 to be useful, except in thoroughly ANSIfied programs. */
161 int warn_write_strings;
163 /* Nonzero means warn about pointer casts that can drop a type qualifier
164 from the pointer target type. */
168 /* Nonzero means warn that dbx info for template class methods isn't fully
171 int warn_template_debugging;
173 /* Warn about traditional constructs whose meanings changed in ANSI C. */
175 int warn_traditional;
177 /* Nonzero means warn about sizeof(function) or addition/subtraction
178 of function pointers. */
180 int warn_pointer_arith;
182 /* Nonzero means warn for non-prototype function decls
183 or non-prototyped defs without previous prototype. */
185 int warn_strict_prototypes;
187 /* Nonzero means warn for any function def without prototype decl. */
189 int warn_missing_prototypes;
191 /* Nonzero means warn about multiple (redundant) decls for the same single
192 variable or function. */
194 int warn_redundant_decls;
196 /* Warn if initializer is not completely bracketed. */
198 int warn_missing_braces;
200 /* Warn about *printf or *scanf format/argument anomalies. */
204 /* Warn about a subscript that has type char. */
206 int warn_char_subscripts;
208 /* Warn if a type conversion is done that might have confusing results. */
212 /* Warn if adding () is suggested. */
214 int warn_parentheses;
216 /* Non-zero means warn in function declared in derived class has the
217 same name as a virtual in the base class, but fails to match the
218 type signature of any virtual function in the base class. */
219 int warn_overloaded_virtual;
221 /* Non-zero means warn when declaring a class that has a non virtual
222 destructor, when it really ought to have a virtual one. */
225 /* Non-zero means warn when a function is declared extern and later inline. */
226 int warn_extern_inline;
228 /* Non-zero means warn when the compiler will reorder code. */
231 /* Non-zero means warn when synthesis behavior differs from Cfront's. */
234 /* Nonzero means `$' can be in an identifier.
235 See cccp.c for reasons why this breaks some obscure ANSI C programs. */
237 #ifndef DOLLARS_IN_IDENTIFIERS
238 #define DOLLARS_IN_IDENTIFIERS 1
240 int dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
242 /* Nonzero for -fno-strict-prototype switch: do not consider empty
243 argument prototype to mean function takes no arguments. */
245 int flag_strict_prototype = 2;
246 int strict_prototype = 1;
247 int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus = 1;
249 /* Nonzero means that labels can be used as first-class objects */
253 /* Non-zero means to collect statistics which might be expensive
254 and to print them when we are done. */
255 int flag_detailed_statistics;
257 /* C++ specific flags. */
258 /* Nonzero for -fall-virtual: make every member function (except
259 constructors) lay down in the virtual function table. Calls
260 can then either go through the virtual function table or not,
263 int flag_all_virtual;
265 /* Zero means that `this' is a *const. This gives nice behavior in the
266 2.0 world. 1 gives 1.2-compatible behavior. 2 gives Spring behavior.
267 -2 means we're constructing an object and it has fixed type. */
269 int flag_this_is_variable;
271 /* Nonzero means memoize our member lookups. */
273 int flag_memoize_lookups; int flag_save_memoized_contexts;
275 /* 3 means write out only virtuals function tables `defined'
276 in this implementation file.
277 2 means write out only specific virtual function tables
278 and give them (C) public access.
279 1 means write out virtual function tables and give them
281 0 means write out virtual function tables and give them
282 (C) static access (default).
283 -1 means declare virtual function tables extern. */
287 /* Nonzero means we should attempt to elide constructors when possible. */
289 int flag_elide_constructors;
291 /* Nonzero means recognize and handle exception handling constructs.
292 Use ansi syntax and semantics. WORK IN PROGRESS! */
294 int flag_handle_exceptions;
296 /* Nonzero means recognize and handle signature language constructs. */
298 int flag_handle_signatures;
300 /* Nonzero means that member functions defined in class scope are
301 inline by default. */
303 int flag_default_inline = 1;
305 /* Controls whether enums and ints freely convert.
306 1 means with complete freedom.
307 0 means enums can convert to ints, but not vice-versa. */
308 int flag_int_enum_equivalence;
310 /* Controls whether compiler is operating under LUCID's Cadillac
311 system. 1 means yes, 0 means no. */
314 /* Controls whether compiler generates code to build objects
315 that can be collected when they become garbage. */
318 /* Controls whether compiler generates 'type descriptor' that give
319 run-time type information. */
322 /* Nonzero if we wish to output cross-referencing information
323 for the GNU class browser. */
324 extern int flag_gnu_xref;
326 /* Nonzero if compiler can make `reasonable' assumptions about
327 references and objects. For example, the compiler must be
328 conservative about the following and not assume that `a' is nonnull:
333 In general, it is `reasonable' to assume that for many programs,
334 and better code can be generated in that case. */
336 int flag_assume_nonnull_objects = 1;
338 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
341 int flag_huge_objects;
343 /* Nonzero if we want to conserve space in the .o files. We do this
344 by putting uninitialized data and runtime initialized data into
345 .common instead of .data at the expense of not flagging multiple
348 int flag_conserve_space;
350 /* Nonzero if we want to obey access control semantics. */
352 int flag_access_control = 1;
354 /* Nonzero if we want to understand the operator names, i.e. 'bitand'. */
356 int flag_operator_names;
358 /* Nonzero if we want to check the return value of new and avoid calling
359 constructors if it is a null pointer. */
363 /* Nonzero if we want the new ANSI rules for pushing a new scope for `for'
364 initialization variables.
365 0: Old rules, set by -fno-for-scope.
366 2: New ANSI rules, set by -ffor-scope.
367 1: Try to implement new ANSI rules, but with backup compatibility
368 (and warnings). This is the default, for now. */
370 int flag_new_for_scope = 1;
372 /* Table of language-dependent -f options.
373 STRING is the option name. VARIABLE is the address of the variable.
374 ON_VALUE is the value to store in VARIABLE
375 if `-fSTRING' is seen as an option.
376 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
378 static struct { char *string; int *variable; int on_value;} lang_f_options[] =
380 {"signed-char", &flag_signed_char, 1},
381 {"unsigned-char", &flag_signed_char, 0},
382 {"signed-bitfields", &flag_signed_bitfields, 1},
383 {"unsigned-bitfields", &flag_signed_bitfields, 0},
384 {"short-enums", &flag_short_enums, 1},
385 {"short-double", &flag_short_double, 1},
386 {"cond-mismatch", &flag_cond_mismatch, 1},
387 {"asm", &flag_no_asm, 0},
388 {"builtin", &flag_no_builtin, 0},
389 {"ident", &flag_no_ident, 0},
390 {"labels-ok", &flag_labels_ok, 1},
391 {"stats", &flag_detailed_statistics, 1},
392 {"this-is-variable", &flag_this_is_variable, 1},
393 {"strict-prototype", &flag_strict_prototype, 1},
394 {"all-virtual", &flag_all_virtual, 1},
395 {"memoize-lookups", &flag_memoize_lookups, 1},
396 {"elide-constructors", &flag_elide_constructors, 1},
397 {"handle-exceptions", &flag_handle_exceptions, 1},
398 {"handle-signatures", &flag_handle_signatures, 1},
399 {"default-inline", &flag_default_inline, 1},
400 {"dollars-in-identifiers", &dollars_in_ident, 1},
401 {"enum-int-equiv", &flag_int_enum_equivalence, 1},
403 {"rtti", &flag_rtti, 1},
404 {"xref", &flag_gnu_xref, 1},
405 {"nonnull-objects", &flag_assume_nonnull_objects, 1},
406 {"implement-inlines", &flag_implement_inlines, 1},
407 {"external-templates", &flag_external_templates, 1},
408 {"implicit-templates", &flag_implicit_templates, 1},
409 {"huge-objects", &flag_huge_objects, 1},
410 {"conserve-space", &flag_conserve_space, 1},
411 {"vtable-thunks", &flag_vtable_thunks, 1},
412 {"short-temps", &flag_short_temps, 1},
413 {"access-control", &flag_access_control, 1},
414 {"nonansi-builtins", &flag_no_nonansi_builtin, 0},
415 {"gnu-keywords", &flag_no_gnu_keywords, 0},
416 {"operator-names", &flag_operator_names, 1},
417 {"check-new", &flag_check_new, 1},
418 {"repo", &flag_use_repository, 1},
419 {"for-scope", &flag_new_for_scope, 2}
422 /* Decode the string P as a language-specific option.
423 Return 1 if it is recognized (and handle it);
424 return 0 if not recognized. */
427 lang_decode_option (p)
430 if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
431 flag_traditional = 1, dollars_in_ident = 1, flag_writable_strings = 1,
432 flag_this_is_variable = 1, flag_new_for_scope = 0;
433 /* The +e options are for cfront compatibility. They come in as
434 `-+eN', to kludge around gcc.c's argument handling. */
435 else if (p[0] == '-' && p[1] == '+' && p[2] == 'e')
437 int old_write_virtuals = write_virtuals;
440 else if (p[3] == '0')
442 else if (p[3] == '2')
444 else error ("invalid +e option");
445 if (old_write_virtuals != 0
446 && write_virtuals != old_write_virtuals)
447 error ("conflicting +e options given");
449 else if (p[0] == '-' && p[1] == 'f')
451 /* Some kind of -f option.
452 P's value is the option sans `-f'.
453 Search for it in the table of options. */
457 /* Try special -f options. */
459 if (!strcmp (p, "save-memoized"))
461 flag_memoize_lookups = 1;
462 flag_save_memoized_contexts = 1;
465 if (!strcmp (p, "no-save-memoized"))
467 flag_memoize_lookups = 0;
468 flag_save_memoized_contexts = 0;
471 else if (! strncmp (p, "cadillac", 8))
473 flag_cadillac = atoi (p+9);
476 else if (! strncmp (p, "no-cadillac", 11))
481 else if (! strcmp (p, "gc"))
484 /* This must come along for the ride. */
488 else if (! strcmp (p, "no-gc"))
491 /* This must come along for the ride. */
495 else if (! strcmp (p, "alt-external-templates"))
497 flag_external_templates = 1;
498 flag_alt_external_templates = 1;
501 else if (! strcmp (p, "no-alt-external-templates"))
503 flag_alt_external_templates = 0;
506 else if (!strcmp (p, "ansi-overloading"))
508 warning ("-fansi-overloading is no longer meaningful");
511 else if (!strcmp (p, "repo"))
513 flag_use_repository = 1;
514 flag_implicit_templates = 0;
518 !found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]);
521 if (!strcmp (p, lang_f_options[j].string))
523 *lang_f_options[j].variable = lang_f_options[j].on_value;
524 /* A goto here would be cleaner,
525 but breaks the vax pcc. */
528 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
529 && ! strcmp (p+3, lang_f_options[j].string))
531 *lang_f_options[j].variable = ! lang_f_options[j].on_value;
537 else if (p[0] == '-' && p[1] == 'W')
541 /* The -W options control the warning behavior of the compiler. */
544 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
547 if (!strcmp (p, "implicit"))
548 warn_implicit = setting;
549 else if (!strcmp (p, "return-type"))
550 warn_return_type = setting;
551 else if (!strcmp (p, "ctor-dtor-privacy"))
552 warn_ctor_dtor_privacy = setting;
553 else if (!strcmp (p, "write-strings"))
554 warn_write_strings = setting;
555 else if (!strcmp (p, "cast-qual"))
556 warn_cast_qual = setting;
557 else if (!strcmp (p, "traditional"))
558 warn_traditional = setting;
559 else if (!strcmp (p, "char-subscripts"))
560 warn_char_subscripts = setting;
561 else if (!strcmp (p, "pointer-arith"))
562 warn_pointer_arith = setting;
563 else if (!strcmp (p, "strict-prototypes"))
564 warn_strict_prototypes = setting;
565 else if (!strcmp (p, "missing-prototypes"))
566 warn_missing_prototypes = setting;
567 else if (!strcmp (p, "redundant-decls"))
568 warn_redundant_decls = setting;
569 else if (!strcmp (p, "missing-braces"))
570 warn_missing_braces = setting;
571 else if (!strcmp (p, "format"))
572 warn_format = setting;
573 else if (!strcmp (p, "conversion"))
574 warn_conversion = setting;
575 else if (!strcmp (p, "parentheses"))
576 warn_parentheses = setting;
577 else if (!strcmp (p, "non-virtual-dtor"))
578 warn_nonvdtor = setting;
579 else if (!strcmp (p, "extern-inline"))
580 warn_extern_inline = setting;
581 else if (!strcmp (p, "reorder"))
582 warn_reorder = setting;
583 else if (!strcmp (p, "synth"))
584 warn_synth = setting;
585 else if (!strcmp (p, "comment"))
586 ; /* cpp handles this one. */
587 else if (!strcmp (p, "comments"))
588 ; /* cpp handles this one. */
589 else if (!strcmp (p, "trigraphs"))
590 ; /* cpp handles this one. */
591 else if (!strcmp (p, "import"))
592 ; /* cpp handles this one. */
593 else if (!strcmp (p, "all"))
595 extra_warnings = setting;
596 warn_return_type = setting;
597 warn_unused = setting;
598 warn_implicit = setting;
599 warn_ctor_dtor_privacy = setting;
600 warn_switch = setting;
601 warn_format = setting;
602 warn_parentheses = setting;
603 warn_missing_braces = setting;
604 warn_extern_inline = setting;
605 warn_nonvdtor = setting;
606 /* We save the value of warn_uninitialized, since if they put
607 -Wuninitialized on the command line, we need to generate a
608 warning about not using it without also specifying -O. */
609 if (warn_uninitialized != 1)
610 warn_uninitialized = (setting ? 2 : 0);
611 warn_template_debugging = setting;
612 warn_reorder = setting;
615 else if (!strcmp (p, "overloaded-virtual"))
616 warn_overloaded_virtual = setting;
619 else if (!strcmp (p, "-ansi"))
620 dollars_in_ident = 0, flag_no_nonansi_builtin = 1, flag_ansi = 1,
621 flag_no_gnu_keywords = 1, flag_operator_names = 1;
623 /* Undocumented, only ever used when you're invoking cc1plus by hand, since
624 it's probably safe to assume no sane person would ever want to use this
625 under normal circumstances. */
626 else if (!strcmp (p, "-spew-debug"))
635 /* Incorporate `const' and `volatile' qualifiers for member functions.
636 FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
637 QUALS is a list of qualifiers. */
639 grok_method_quals (ctype, function, quals)
640 tree ctype, function, quals;
642 tree fntype = TREE_TYPE (function);
643 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
647 extern tree ridpointers[];
649 if (TREE_VALUE (quals) == ridpointers[(int)RID_CONST])
651 if (TYPE_READONLY (ctype))
652 error ("duplicate `%s' %s",
653 IDENTIFIER_POINTER (TREE_VALUE (quals)),
654 (TREE_CODE (function) == FUNCTION_DECL
655 ? "for member function" : "in type declaration"));
656 ctype = build_type_variant (ctype, 1, TYPE_VOLATILE (ctype));
657 build_pointer_type (ctype);
659 else if (TREE_VALUE (quals) == ridpointers[(int)RID_VOLATILE])
661 if (TYPE_VOLATILE (ctype))
662 error ("duplicate `%s' %s",
663 IDENTIFIER_POINTER (TREE_VALUE (quals)),
664 (TREE_CODE (function) == FUNCTION_DECL
665 ? "for member function" : "in type declaration"));
666 ctype = build_type_variant (ctype, TYPE_READONLY (ctype), 1);
667 build_pointer_type (ctype);
670 my_friendly_abort (20);
671 quals = TREE_CHAIN (quals);
674 fntype = build_cplus_method_type (ctype, TREE_TYPE (fntype),
675 (TREE_CODE (fntype) == METHOD_TYPE
676 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
677 : TYPE_ARG_TYPES (fntype)));
679 fntype = build_exception_variant (fntype, raises);
681 TREE_TYPE (function) = fntype;
685 #if 0 /* Not used. */
686 /* This routine replaces cryptic DECL_NAMEs with readable DECL_NAMEs.
687 It leaves DECL_ASSEMBLER_NAMEs with the correct value. */
688 /* This does not yet work with user defined conversion operators
691 substitute_nice_name (decl)
694 if (DECL_NAME (decl) && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE)
696 char *n = decl_as_string (DECL_NAME (decl), 1);
697 if (n[strlen (n) - 1] == ' ')
698 n[strlen (n) - 1] = 0;
699 DECL_NAME (decl) = get_identifier (n);
704 /* Warn when -fexternal-templates is used and #pragma
705 interface/implementation is not used all the times it should be,
708 warn_if_unknown_interface (decl)
711 static int already_warned = 0;
712 if (already_warned++)
715 if (flag_alt_external_templates)
717 struct tinst_level *til = tinst_for_decl ();
719 char *sf = input_filename;
724 input_filename = til->file;
726 cp_warning ("template `%#D' instantiated in file without #pragma interface",
732 cp_warning_at ("template `%#D' defined in file without #pragma interface",
736 /* A subroutine of the parser, to handle a component list. */
738 grok_x_components (specs, components)
739 tree specs, components;
741 register tree t, x, tcode;
743 /* We just got some friends. They have been recorded elsewhere. */
744 if (components == void_type_node)
747 if (components == NULL_TREE)
749 t = groktypename (build_decl_list (specs, NULL_TREE));
753 error ("error in component specification");
757 switch (TREE_CODE (t))
760 /* Static anonymous unions come out as VAR_DECLs. */
761 if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE
762 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (t))))
765 /* We return SPECS here, because in the parser it was ending
766 up with not doing anything to $$, which is what SPECS
772 /* This code may be needed for UNION_TYPEs as
774 tcode = record_type_node;
775 if (CLASSTYPE_DECLARED_CLASS(t))
776 tcode = class_type_node;
777 else if (IS_SIGNATURE(t))
778 tcode = signature_type_node;
780 t = xref_tag (tcode, TYPE_IDENTIFIER (t), NULL_TREE, 0);
782 CLASSTYPE_NO_GLOBALIZE(t) = 1;
788 if (TREE_CODE(t) == UNION_TYPE)
789 tcode = union_type_node;
791 tcode = enum_type_node;
793 t = xref_tag (tcode, TYPE_IDENTIFIER (t), NULL_TREE, 0);
794 if (TREE_CODE(t) == UNION_TYPE && TYPE_CONTEXT(t))
795 CLASSTYPE_NO_GLOBALIZE(t) = 1;
796 if (TREE_CODE (t) == UNION_TYPE
797 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
799 struct pending_inline **p;
800 x = build_lang_field_decl (FIELD_DECL, NULL_TREE, t);
802 /* Wipe out memory of synthesized methods */
803 TYPE_HAS_CONSTRUCTOR (t) = 0;
804 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
805 TYPE_HAS_INIT_REF (t) = 0;
806 TYPE_HAS_CONST_INIT_REF (t) = 0;
807 TYPE_HAS_ASSIGN_REF (t) = 0;
808 TYPE_HAS_ASSIGNMENT (t) = 0;
809 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
811 p = &pending_inlines;
812 for (; *p; *p = (*p)->next)
813 if (DECL_CONTEXT ((*p)->fndecl) != t)
816 else if (TREE_CODE (t) == ENUMERAL_TYPE)
817 x = grok_enum_decls (t, NULL_TREE);
824 if (t != void_type_node)
825 error ("empty component declaration");
831 t = TREE_TYPE (components);
832 if (TREE_CODE (t) == ENUMERAL_TYPE && TREE_NONLOCAL_FLAG (t))
833 return grok_enum_decls (t, components);
839 /* Classes overload their constituent function names automatically.
840 When a function name is declared in a record structure,
841 its name is changed to it overloaded name. Since names for
842 constructors and destructors can conflict, we place a leading
845 CNAME is the name of the class we are grokking for.
847 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
849 FLAGS contains bits saying what's special about today's
850 arguments. 1 == DESTRUCTOR. 2 == OPERATOR.
852 If FUNCTION is a destructor, then we must add the `auto-delete' field
853 as a second parameter. There is some hair associated with the fact
854 that we must "declare" this variable in the manner consistent with the
855 way the rest of the arguments were declared.
857 QUALS are the qualifiers for the this pointer. */
860 grokclassfn (ctype, cname, function, flags, quals)
861 tree ctype, cname, function;
862 enum overload_flags flags;
865 tree fn_name = DECL_NAME (function);
869 tree fntype = TREE_TYPE (function);
870 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
872 if (fn_name == NULL_TREE)
874 error ("name missing for member function");
875 fn_name = get_identifier ("<anonymous>");
876 DECL_NAME (function) = fn_name;
880 qualtype = grok_method_quals (ctype, function, quals);
884 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
885 if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
887 /* Must add the class instance variable up front. */
888 /* Right now we just make this a pointer. But later
889 we may wish to make it special. */
890 tree type = TREE_VALUE (arg_types);
893 if ((flag_this_is_variable > 0)
894 && (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function)))
897 if (DECL_CONSTRUCTOR_P (function))
899 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
901 DECL_CONSTRUCTOR_FOR_VBASE_P (function) = 1;
902 /* In this case we need "in-charge" flag saying whether
903 this constructor is responsible for initialization
904 of virtual baseclasses or not. */
905 parm = build_decl (PARM_DECL, in_charge_identifier, integer_type_node);
906 /* Mark the artificial `__in_chrg' parameter as "artificial". */
907 SET_DECL_ARTIFICIAL (parm);
908 DECL_ARG_TYPE (parm) = integer_type_node;
909 DECL_REGISTER (parm) = 1;
910 TREE_CHAIN (parm) = last_function_parms;
911 last_function_parms = parm;
915 parm = build_decl (PARM_DECL, this_identifier, type);
916 /* Mark the artificial `this' parameter as "artificial". */
917 SET_DECL_ARTIFICIAL (parm);
918 DECL_ARG_TYPE (parm) = type;
919 /* We can make this a register, so long as we don't
920 accidentally complain if someone tries to take its address. */
921 DECL_REGISTER (parm) = 1;
923 TREE_READONLY (parm) = 1;
924 TREE_CHAIN (parm) = last_function_parms;
925 last_function_parms = parm;
928 if (flags == DTOR_FLAG)
931 tree const_integer_type = build_type_variant (integer_type_node, 1, 0);
932 int len = sizeof (DESTRUCTOR_DECL_PREFIX)-1;
934 arg_types = hash_tree_chain (const_integer_type, void_list_node);
935 TREE_SIDE_EFFECTS (arg_types) = 1;
936 /* Build the overload name. It will look like `7Example'. */
937 if (IDENTIFIER_TYPE_VALUE (cname))
938 dbuf = build_overload_name (IDENTIFIER_TYPE_VALUE (cname), 1, 1);
939 else if (IDENTIFIER_LOCAL_VALUE (cname))
940 dbuf = build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname)), 1, 1);
942 /* Using ctype fixes the `X::Y::~Y()' crash. The cname has no type when
943 it's defined out of the class definition, since poplevel_class wipes
944 it out. This used to be internal error 346. */
945 dbuf = build_overload_name (ctype, 1, 1);
946 buf = (char *) alloca (strlen (dbuf) + sizeof (DESTRUCTOR_DECL_PREFIX));
947 bcopy (DESTRUCTOR_DECL_PREFIX, buf, len);
950 DECL_ASSEMBLER_NAME (function) = get_identifier (buf);
951 parm = build_decl (PARM_DECL, in_charge_identifier, const_integer_type);
952 /* Mark the artificial `__in_chrg' parameter as "artificial". */
953 SET_DECL_ARTIFICIAL (parm);
954 TREE_USED (parm) = 1;
956 /* We don't need to mark the __in_chrg parameter itself as `const'
957 since its type is already `const int'. In fact we MUST NOT mark
958 it as `const' cuz that will screw up the debug info (causing it
959 to say that the type of __in_chrg is `const const int'). */
960 TREE_READONLY (parm) = 1;
962 DECL_ARG_TYPE (parm) = const_integer_type;
963 /* This is the same chain as DECL_ARGUMENTS (...). */
964 TREE_CHAIN (last_function_parms) = parm;
966 fntype = build_cplus_method_type (qualtype, void_type_node,
970 fntype = build_exception_variant (fntype, raises);
972 TREE_TYPE (function) = fntype;
973 TYPE_HAS_DESTRUCTOR (ctype) = 1;
977 tree these_arg_types;
979 if (DECL_CONSTRUCTOR_FOR_VBASE_P (function))
981 arg_types = hash_tree_chain (integer_type_node,
982 TREE_CHAIN (arg_types));
983 fntype = build_cplus_method_type (qualtype,
984 TREE_TYPE (TREE_TYPE (function)),
988 fntype = build_exception_variant (fntype, raises);
990 TREE_TYPE (function) = fntype;
991 arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
994 these_arg_types = arg_types;
996 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
997 /* Only true for static member functions. */
998 these_arg_types = hash_tree_chain (build_pointer_type (qualtype),
1001 DECL_ASSEMBLER_NAME (function)
1002 = build_decl_overload (fn_name, these_arg_types,
1003 1 + DECL_CONSTRUCTOR_P (function));
1006 /* This code is going into the compiler, but currently, it makes
1007 libg++/src/Integer.cc not compile. The problem is that the nice name
1008 winds up going into the symbol table, and conversion operations look
1009 for the manged name. */
1010 substitute_nice_name (function);
1014 DECL_ARGUMENTS (function) = last_function_parms;
1015 /* First approximations. */
1016 DECL_CONTEXT (function) = ctype;
1017 DECL_CLASS_CONTEXT (function) = ctype;
1020 /* Work on the expr used by alignof (this is only called by the parser). */
1028 if (TREE_CODE (expr) == COMPONENT_REF
1029 && DECL_BIT_FIELD (TREE_OPERAND (expr, 1)))
1030 error ("`__alignof__' applied to a bit-field");
1032 if (TREE_CODE (expr) == INDIRECT_REF)
1034 best = t = TREE_OPERAND (expr, 0);
1035 bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1037 while (TREE_CODE (t) == NOP_EXPR
1038 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
1041 t = TREE_OPERAND (t, 0);
1042 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1043 if (thisalign > bestalign)
1044 best = t, bestalign = thisalign;
1046 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
1050 /* ANSI says arrays and fns are converted inside comma.
1051 But we can't convert them in build_compound_expr
1052 because that would break commas in lvalues.
1053 So do the conversion here if operand was a comma. */
1054 if (TREE_CODE (expr) == COMPOUND_EXPR
1055 && (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1056 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE))
1057 expr = default_conversion (expr);
1058 return c_alignof (TREE_TYPE (expr));
1062 /* Create an ARRAY_REF, checking for the user doing things backwards
1065 grok_array_decl (array_expr, index_exp)
1066 tree array_expr, index_exp;
1068 tree type = TREE_TYPE (array_expr);
1069 tree p1, p2, i1, i2;
1071 if (type == error_mark_node || index_exp == error_mark_node)
1072 return error_mark_node;
1073 if (type == NULL_TREE)
1075 /* Something has gone very wrong. Assume we are mistakenly reducing
1076 an expression instead of a declaration. */
1077 error ("parser may be lost: is there a '{' missing somewhere?");
1081 if (TREE_CODE (type) == OFFSET_TYPE
1082 || TREE_CODE (type) == REFERENCE_TYPE)
1083 type = TREE_TYPE (type);
1085 /* If they have an `operator[]', use that. */
1086 if (TYPE_LANG_SPECIFIC (type)
1087 && TYPE_OVERLOADS_ARRAY_REF (type))
1088 return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
1089 array_expr, index_exp, NULL_TREE);
1091 /* Otherwise, create an ARRAY_REF for a pointer or array type. */
1093 if (TREE_CODE (type) == ARRAY_TYPE)
1096 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, 0);
1098 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
1101 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, 0);
1103 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr, 0);
1104 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp, 0);
1106 if ((p1 && i2) && (i1 && p2))
1107 error ("ambiguous conversion for array subscript");
1110 array_expr = p1, index_exp = i2;
1112 array_expr = p2, index_exp = i1;
1115 cp_error ("invalid types `%T[%T]' for array subscript",
1116 type, TREE_TYPE (index_exp));
1117 return error_mark_node;
1120 if (array_expr == error_mark_node || index_exp == error_mark_node)
1121 error ("ambiguous conversion for array subscript");
1123 return build_array_ref (array_expr, index_exp);
1126 /* Given the cast expression EXP, checking out its validity. Either return
1127 an error_mark_node if there was an unavoidable error, return a cast to
1128 void for trying to delete a pointer w/ the value 0, or return the
1129 call to delete. If DOING_VEC is 1, we handle things differently
1130 for doing an array delete. If DOING_VEC is 2, they gave us the
1131 array size as an argument to delete.
1132 Implements ARM $5.3.4. This is called from the parser. */
1134 delete_sanity (exp, size, doing_vec, use_global_delete)
1136 int doing_vec, use_global_delete;
1138 tree t = stabilize_reference (convert_from_reference (exp));
1139 tree type = TREE_TYPE (t);
1140 enum tree_code code = TREE_CODE (type);
1141 /* For a regular vector delete (aka, no size argument) we will pass
1142 this down as a NULL_TREE into build_vec_delete. */
1143 tree maxindex = NULL_TREE;
1144 /* This is used for deleting arrays. */
1150 maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
1151 if (! flag_traditional)
1152 pedwarn ("anachronistic use of array size in vector delete");
1155 elt_size = c_sizeof (type);
1158 if (code != POINTER_TYPE)
1160 cp_error ("type `%#T' argument given to `delete', expected pointer",
1162 return error_mark_node;
1165 /* Deleting a pointer with the value zero is valid and has no effect. */
1166 if (integer_zerop (t))
1167 return build1 (NOP_EXPR, void_type_node, t);
1170 if (code == POINTER_TYPE)
1173 /* As of Valley Forge, you can delete a pointer to constant. */
1174 /* You can't delete a pointer to constant. */
1175 if (TREE_READONLY (TREE_TYPE (type)))
1177 error ("`const *' cannot be deleted");
1178 return error_mark_node;
1181 /* You also can't delete functions. */
1182 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
1184 error ("cannot delete a function");
1185 return error_mark_node;
1190 /* If the type has no destructor, then we should build a regular
1191 delete, instead of a vector delete. Otherwise, we would end
1192 up passing a bogus offset into __builtin_delete, which is
1193 not expecting it. */
1195 && TREE_CODE (type) == POINTER_TYPE
1196 && !TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)))
1199 use_global_delete = 1;
1204 return build_vec_delete (t, maxindex, elt_size, integer_one_node,
1205 integer_two_node, use_global_delete);
1208 if (IS_AGGR_TYPE (TREE_TYPE (type))
1209 && TYPE_GETS_REG_DELETE (TREE_TYPE (type)))
1211 /* Only do access checking here; we'll be calling op delete
1212 from the destructor. */
1213 tree tmp = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, t,
1214 size_zero_node, NULL_TREE);
1215 if (tmp == error_mark_node)
1216 return error_mark_node;
1219 return build_delete (type, t, integer_three_node,
1220 LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE,
1225 /* Sanity check: report error if this function FUNCTION is not
1226 really a member of the class (CTYPE) it is supposed to belong to.
1227 CNAME is the same here as it is for grokclassfn above. */
1230 check_classfn (ctype, cname, function)
1231 tree ctype, cname, function;
1233 tree fn_name = DECL_NAME (function);
1235 tree method_vec = CLASSTYPE_METHOD_VEC (ctype);
1239 if (method_vec != 0)
1241 methods = &TREE_VEC_ELT (method_vec, 0);
1242 end = TREE_VEC_END (method_vec);
1244 /* First suss out ctors and dtors. */
1245 if (*methods && fn_name == DECL_NAME (*methods))
1248 while (++methods != end)
1250 if (fn_name == DECL_NAME (*methods))
1256 if (DECL_ASSEMBLER_NAME (function) == DECL_ASSEMBLER_NAME (fndecl))
1259 /* This should work, but causes libg++ to fail
1261 /* We have to do more extensive argument checking here, as
1262 the name may have been changed by asm("new_name"). */
1263 if (decls_match (function, fndecl))
1266 if (DECL_NAME (function) == DECL_NAME (fndecl))
1268 tree p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
1269 tree p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
1271 /* Get rid of the this parameter on functions that become
1273 if (DECL_STATIC_FUNCTION_P (fndecl)
1274 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
1275 p1 = TREE_CHAIN (p1);
1277 if (comptypes (TREE_TYPE (TREE_TYPE (function)),
1278 TREE_TYPE (TREE_TYPE (fndecl)), 1)
1279 && compparms (p1, p2, 3))
1281 if (DECL_STATIC_FUNCTION_P (fndecl)
1282 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
1283 revert_static_member_fn (&function, NULL, NULL);
1288 fndecl = DECL_CHAIN (fndecl);
1297 tree fndecl = *methods;
1298 cp_error ("prototype for `%#D' does not match any in class `%T'",
1300 cp_error_at ("candidate%s: %+#D", DECL_CHAIN (fndecl) ? "s are" : " is",
1302 while (fndecl = DECL_CHAIN (fndecl), fndecl)
1303 cp_error_at (" %#D", fndecl);
1308 cp_error ("no `%#D' member function declared in class `%T'",
1312 /* If we did not find the method in the class, add it to
1313 avoid spurious errors. */
1314 add_method (ctype, methods, function);
1318 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
1319 of a structure component, returning a FIELD_DECL node.
1320 QUALS is a list of type qualifiers for this decl (such as for declaring
1321 const member functions).
1323 This is done during the parsing of the struct declaration.
1324 The FIELD_DECL nodes are chained together and the lot of them
1325 are ultimately passed to `build_struct' to make the RECORD_TYPE node.
1329 If class A defines that certain functions in class B are friends, then
1330 the way I have set things up, it is B who is interested in permission
1331 granted by A. However, it is in A's context that these declarations
1332 are parsed. By returning a void_type_node, class A does not attempt
1333 to incorporate the declarations of the friends within its structure.
1335 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
1336 CHANGES TO CODE IN `start_method'. */
1339 grokfield (declarator, declspecs, raises, init, asmspec_tree, attrlist)
1340 tree declarator, declspecs, raises, init, asmspec_tree, attrlist;
1342 register tree value;
1344 int flags = LOOKUP_ONLYCONVERTING;
1346 /* Convert () initializers to = initializers. */
1347 if (init == NULL_TREE && declarator != NULL_TREE
1348 && TREE_CODE (declarator) == CALL_EXPR
1349 && TREE_OPERAND (declarator, 0)
1350 && (TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE
1351 || TREE_CODE (TREE_OPERAND (declarator, 0)) == SCOPE_REF)
1352 && parmlist_is_exprlist (TREE_OPERAND (declarator, 1)))
1354 init = TREE_OPERAND (declarator, 1);
1355 declarator = TREE_OPERAND (declarator, 0);
1360 && TREE_CODE (init) == TREE_LIST
1361 && TREE_VALUE (init) == error_mark_node
1362 && TREE_CHAIN (init) == NULL_TREE)
1365 value = grokdeclarator (declarator, declspecs, FIELD, init != 0,
1368 return value; /* friend or constructor went bad. */
1370 /* Pass friendly classes back. */
1371 if (TREE_CODE (value) == VOID_TYPE)
1372 return void_type_node;
1374 if (DECL_NAME (value) != NULL_TREE
1375 && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
1376 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
1377 cp_error ("member `%D' conflicts with virtual function table field name", value);
1379 /* Stash away type declarations. */
1380 if (TREE_CODE (value) == TYPE_DECL)
1382 DECL_NONLOCAL (value) = 1;
1383 DECL_CONTEXT (value) = current_class_type;
1384 DECL_CLASS_CONTEXT (value) = current_class_type;
1385 CLASSTYPE_LOCAL_TYPEDECLS (current_class_type) = 1;
1387 /* If we declare a typedef name for something that has no name,
1388 the typedef name is used for linkage. See 7.1.3 p4 94/0158. */
1389 if (TYPE_NAME (TREE_TYPE (value))
1390 && TREE_CODE (TYPE_NAME (TREE_TYPE (value))) == TYPE_DECL
1391 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (value))))
1393 TYPE_NAME (TREE_TYPE (value)) = value;
1394 TYPE_STUB_DECL (TREE_TYPE (value)) = value;
1397 pushdecl_class_level (value);
1401 if (IS_SIGNATURE (current_class_type)
1402 && TREE_CODE (value) != FUNCTION_DECL)
1404 error ("field declaration not allowed in signature");
1405 return void_type_node;
1408 if (DECL_IN_AGGR_P (value))
1410 cp_error ("`%D' is already defined in the class %T", value,
1411 DECL_CONTEXT (value));
1412 return void_type_node;
1416 cadillac_start_decl (value);
1419 asmspec = TREE_STRING_POINTER (asmspec_tree);
1423 if (IS_SIGNATURE (current_class_type)
1424 && TREE_CODE (value) == FUNCTION_DECL)
1426 error ("function declarations cannot have initializers in signature");
1429 else if (TREE_CODE (value) == FUNCTION_DECL)
1431 grok_function_init (value, init);
1434 else if (pedantic && TREE_CODE (value) != VAR_DECL)
1435 /* Already complained in grokdeclarator. */
1439 /* We allow initializers to become parameters to base
1441 if (TREE_CODE (init) == TREE_LIST)
1443 if (TREE_CHAIN (init) == NULL_TREE)
1444 init = TREE_VALUE (init);
1446 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1449 if (TREE_CODE (init) == CONST_DECL)
1450 init = DECL_INITIAL (init);
1451 else if (TREE_READONLY_DECL_P (init))
1452 init = decl_constant_value (init);
1453 else if (TREE_CODE (init) == CONSTRUCTOR)
1454 init = digest_init (TREE_TYPE (value), init, (tree *)0);
1455 my_friendly_assert (TREE_PERMANENT (init), 192);
1456 if (init == error_mark_node)
1457 /* We must make this look different than `error_mark_node'
1458 because `decl_const_value' would mis-interpret it
1459 as only meaning that this VAR_DECL is defined. */
1460 init = build1 (NOP_EXPR, TREE_TYPE (value), init);
1461 else if (! TREE_CONSTANT (init))
1463 /* We can allow references to things that are effectively
1464 static, since references are initialized with the address. */
1465 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
1466 || (TREE_STATIC (init) == 0
1467 && (TREE_CODE_CLASS (TREE_CODE (init)) != 'd'
1468 || DECL_EXTERNAL (init) == 0)))
1470 error ("field initializer is not constant");
1471 init = error_mark_node;
1477 /* The corresponding pop_obstacks is in cp_finish_decl. */
1478 push_obstacks_nochange ();
1481 cplus_decl_attributes (value, TREE_PURPOSE (attrlist),
1482 TREE_VALUE (attrlist));
1484 if (TREE_CODE (value) == VAR_DECL)
1486 /* We cannot call pushdecl here, because that would
1487 fill in the value of our TREE_CHAIN. Instead, we
1488 modify cp_finish_decl to do the right thing, namely, to
1489 put this decl out straight away. */
1490 if (TREE_PUBLIC (value))
1492 /* current_class_type can be NULL_TREE in case of error. */
1493 if (asmspec == 0 && current_class_type)
1495 TREE_PUBLIC (value) = 1;
1496 DECL_INITIAL (value) = error_mark_node;
1497 DECL_ASSEMBLER_NAME (value)
1498 = build_static_name (current_class_type, DECL_NAME (value));
1500 pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics);
1502 /* Static consts need not be initialized in the class definition. */
1503 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value)))
1505 static int explanation = 0;
1507 error ("initializer invalid for static member with constructor");
1508 if (explanation++ == 0)
1509 error ("(you really want to initialize it separately)");
1512 /* Force the compiler to know when an uninitialized static
1513 const member is being used. */
1514 if (TYPE_READONLY (value) && init == 0)
1515 TREE_USED (value) = 1;
1517 DECL_INITIAL (value) = init;
1518 DECL_IN_AGGR_P (value) = 1;
1520 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1521 pushdecl_class_level (value);
1524 if (TREE_CODE (value) == FIELD_DECL)
1528 /* This must override the asm specifier which was placed
1529 by grokclassfn. Lay this out fresh. */
1530 DECL_RTL (value) = NULL_RTX;
1531 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
1533 if (DECL_INITIAL (value) == error_mark_node)
1534 init = error_mark_node;
1535 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1536 DECL_INITIAL (value) = init;
1537 DECL_IN_AGGR_P (value) = 1;
1540 if (TREE_CODE (value) == FUNCTION_DECL)
1542 check_default_args (value);
1543 if (DECL_CHAIN (value) != NULL_TREE)
1545 /* Need a fresh node here so that we don't get circularity
1546 when we link these together. */
1547 value = copy_node (value);
1548 /* When does this happen? */
1549 my_friendly_assert (init == NULL_TREE, 193);
1553 /* This must override the asm specifier which was placed
1554 by grokclassfn. Lay this out fresh. */
1555 DECL_RTL (value) = NULL_RTX;
1556 DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
1558 cp_finish_decl (value, init, asmspec_tree, 1, flags);
1560 /* Pass friends back this way. */
1561 if (DECL_FRIEND_P (value))
1562 return void_type_node;
1564 #if 0 /* Just because a fn is declared doesn't mean we'll try to define it. */
1565 if (current_function_decl && ! IS_SIGNATURE (current_class_type))
1566 cp_error ("method `%#D' of local class must be defined in class body",
1570 DECL_IN_AGGR_P (value) = 1;
1573 my_friendly_abort (21);
1578 /* Like `grokfield', but for bitfields.
1579 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1582 grokbitfield (declarator, declspecs, width)
1583 tree declarator, declspecs, width;
1585 register tree value = grokdeclarator (declarator, declspecs, BITFIELD,
1586 0, NULL_TREE, NULL_TREE);
1588 if (! value) return NULL_TREE; /* friends went bad. */
1590 /* Pass friendly classes back. */
1591 if (TREE_CODE (value) == VOID_TYPE)
1592 return void_type_node;
1594 if (TREE_CODE (value) == TYPE_DECL)
1596 cp_error ("cannot declare `%D' to be a bitfield type", value);
1600 if (IS_SIGNATURE (current_class_type))
1602 error ("field declaration not allowed in signature");
1603 return void_type_node;
1606 if (DECL_IN_AGGR_P (value))
1608 cp_error ("`%D' is already defined in the class %T", value,
1609 DECL_CONTEXT (value));
1610 return void_type_node;
1613 GNU_xref_member (current_class_name, value);
1615 if (TREE_STATIC (value))
1617 cp_error ("static member `%D' cannot be a bitfield", value);
1620 cp_finish_decl (value, NULL_TREE, NULL_TREE, 0, 0);
1622 if (width != error_mark_node)
1624 /* detect invalid field size. */
1625 if (TREE_CODE (width) == CONST_DECL)
1626 width = DECL_INITIAL (width);
1627 else if (TREE_READONLY_DECL_P (width))
1628 width = decl_constant_value (width);
1629 if (TREE_CODE (width) != INTEGER_CST)
1631 cp_error ("structure field `%D' width not an integer constant",
1633 DECL_INITIAL (value) = NULL_TREE;
1637 constant_expression_warning (width);
1638 DECL_INITIAL (value) = width;
1639 DECL_BIT_FIELD (value) = 1;
1643 DECL_IN_AGGR_P (value) = 1;
1648 /* Like GROKFIELD, except that the declarator has been
1649 buried in DECLSPECS. Find the declarator, and
1650 return something that looks like it came from
1653 groktypefield (declspecs, parmlist)
1657 tree spec = declspecs;
1658 tree prev = NULL_TREE;
1660 tree type_id = NULL_TREE;
1661 tree quals = NULL_TREE;
1662 tree lengths = NULL_TREE;
1663 tree decl = NULL_TREE;
1667 register tree id = TREE_VALUE (spec);
1669 if (TREE_CODE (spec) != TREE_LIST)
1670 /* Certain parse errors slip through. For example,
1671 `int class ();' is not caught by the parser. Try
1672 weakly to recover here. */
1675 if (TREE_CODE (id) == TYPE_DECL
1676 || (TREE_CODE (id) == IDENTIFIER_NODE && TREE_TYPE (id)))
1678 /* We have a constructor/destructor or
1679 conversion operator. Use it. */
1681 TREE_CHAIN (prev) = TREE_CHAIN (spec);
1683 declspecs = TREE_CHAIN (spec);
1689 spec = TREE_CHAIN (spec);
1692 /* Nope, we have a conversion operator to a scalar type or something
1693 else, that includes things like constructor declarations for
1698 tree id = TREE_VALUE (spec);
1700 if (TREE_CODE (id) == IDENTIFIER_NODE)
1702 if (id == ridpointers[(int)RID_INT]
1703 || id == ridpointers[(int)RID_DOUBLE]
1704 || id == ridpointers[(int)RID_FLOAT]
1705 || id == ridpointers[(int)RID_WCHAR])
1708 error ("extra `%s' ignored",
1709 IDENTIFIER_POINTER (id));
1713 else if (id == ridpointers[(int)RID_LONG]
1714 || id == ridpointers[(int)RID_SHORT]
1715 || id == ridpointers[(int)RID_CHAR])
1717 lengths = tree_cons (NULL_TREE, id, lengths);
1719 else if (id == ridpointers[(int)RID_VOID])
1722 error ("spurious `void' type ignored");
1724 error ("conversion to `void' type invalid");
1726 else if (id == ridpointers[(int)RID_AUTO]
1727 || id == ridpointers[(int)RID_REGISTER]
1728 || id == ridpointers[(int)RID_TYPEDEF]
1729 || id == ridpointers[(int)RID_CONST]
1730 || id == ridpointers[(int)RID_VOLATILE])
1732 error ("type specifier `%s' used invalidly",
1733 IDENTIFIER_POINTER (id));
1735 else if (id == ridpointers[(int)RID_FRIEND]
1736 || id == ridpointers[(int)RID_VIRTUAL]
1737 || id == ridpointers[(int)RID_INLINE]
1738 || id == ridpointers[(int)RID_UNSIGNED]
1739 || id == ridpointers[(int)RID_SIGNED]
1740 || id == ridpointers[(int)RID_STATIC]
1741 || id == ridpointers[(int)RID_EXTERN])
1743 quals = tree_cons (NULL_TREE, id, quals);
1747 /* Happens when we have a global typedef
1748 and a class-local member function with
1754 else if (TREE_CODE (id) == RECORD_TYPE)
1756 type_id = TYPE_NAME (id);
1757 if (TREE_CODE (type_id) == TYPE_DECL)
1758 type_id = DECL_NAME (type_id);
1759 if (type_id == NULL_TREE)
1760 error ("identifier for aggregate type conversion omitted");
1762 else if (TREE_CODE_CLASS (TREE_CODE (id)) == 't')
1763 error ("`operator' missing on conversion operator or tag missing from type");
1765 my_friendly_abort (194);
1766 spec = TREE_CHAIN (spec);
1770 declspecs = chainon (lengths, quals);
1773 if (TREE_CHAIN (lengths))
1774 error ("multiple length specifiers");
1775 type_id = ridpointers[(int)RID_INT];
1776 declspecs = chainon (lengths, quals);
1780 error ("no type given, defaulting to `operator int ...'");
1781 type_id = ridpointers[(int)RID_INT];
1788 decl = grokdeclarator (build_parse_node (CALL_EXPR, type_id, parmlist, NULL_TREE),
1789 declspecs, FIELD, 0, NULL_TREE, NULL_TREE);
1790 if (decl == NULL_TREE)
1793 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CHAIN (decl) != NULL_TREE)
1795 /* Need a fresh node here so that we don't get circularity
1796 when we link these together. */
1797 decl = copy_node (decl);
1800 if (decl == void_type_node
1801 || (TREE_CODE (decl) == FUNCTION_DECL
1802 && TREE_CODE (TREE_TYPE (decl)) != METHOD_TYPE))
1803 /* bunch of friends. */
1806 if (DECL_IN_AGGR_P (decl))
1808 cp_error ("`%D' already defined in the class ", decl);
1809 return void_type_node;
1812 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0, 0);
1814 /* If this declaration is common to another declaration
1815 complain about such redundancy, and return NULL_TREE
1816 so that we don't build a circular list. */
1817 if (DECL_CHAIN (decl))
1819 cp_error ("function `%D' declared twice in class %T", decl,
1820 DECL_CONTEXT (decl));
1823 DECL_IN_AGGR_P (decl) = 1;
1829 grokoptypename (declspecs, declarator)
1830 tree declspecs, declarator;
1832 tree t = grokdeclarator (declarator, declspecs, TYPENAME, 0,
1833 NULL_TREE, NULL_TREE);
1834 return build_typename_overload (t);
1837 /* When a function is declared with an initializer,
1838 do the right thing. Currently, there are two possibilities:
1843 // initialization possibility #1.
1844 virtual void f () = 0;
1866 // initialization possibility #2
1873 copy_assignment_arg_p (parmtype, virtualp)
1877 if (TREE_CODE (parmtype) == REFERENCE_TYPE)
1878 parmtype = TREE_TYPE (parmtype);
1880 if ((TYPE_MAIN_VARIANT (parmtype) == current_class_type)
1881 || (virtualp && DERIVED_FROM_P (parmtype, current_class_type)))
1888 grok_function_init (decl, init)
1892 /* An initializer for a function tells how this function should
1894 tree type = TREE_TYPE (decl);
1896 if (TREE_CODE (type) == FUNCTION_TYPE)
1897 cp_error ("initializer specified for non-member function `%D'", decl);
1898 else if (DECL_VINDEX (decl) == NULL_TREE)
1899 cp_error ("initializer specified for non-virtual method `%D'", decl);
1900 else if (integer_zerop (init))
1903 /* Mark this function as being "defined". */
1904 DECL_INITIAL (decl) = error_mark_node;
1905 /* pure virtual destructors must be defined. */
1906 /* pure virtual needs to be defined (as abort) only when put in
1907 vtbl. For wellformed call, it should be itself. pr4737 */
1908 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)))
1910 extern tree abort_fndecl;
1911 /* Give this node rtl from `abort'. */
1912 DECL_RTL (decl) = DECL_RTL (abort_fndecl);
1915 DECL_ABSTRACT_VIRTUAL_P (decl) = 1;
1916 if (DECL_NAME (decl) == ansi_opname [(int) MODIFY_EXPR])
1919 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl))));
1921 if (copy_assignment_arg_p (parmtype, 1))
1922 TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
1925 else if (TREE_CODE (init) == OFFSET_REF
1926 && TREE_OPERAND (init, 0) == NULL_TREE
1927 && TREE_CODE (TREE_TYPE (init)) == METHOD_TYPE)
1929 tree basetype = DECL_CLASS_CONTEXT (init);
1930 tree basefn = TREE_OPERAND (init, 1);
1931 if (TREE_CODE (basefn) != FUNCTION_DECL)
1932 cp_error ("non-method initializer invalid for method `%D'", decl);
1933 else if (! BINFO_OFFSET_ZEROP (TYPE_BINFO (DECL_CLASS_CONTEXT (basefn))))
1934 sorry ("base member function from other than first base class");
1937 tree binfo = get_binfo (basetype, TYPE_METHOD_BASETYPE (type), 1);
1938 if (binfo == error_mark_node)
1940 else if (binfo == 0)
1941 error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (init)),
1942 TYPE_METHOD_BASETYPE (type));
1945 /* Mark this function as being defined,
1946 and give it new rtl. */
1947 DECL_INITIAL (decl) = error_mark_node;
1948 DECL_RTL (decl) = DECL_RTL (basefn);
1953 cp_error ("invalid initializer for virtual method `%D'", decl);
1956 /* When we get a declaration of the form
1958 type cname::fname ...
1960 the node for `cname::fname' gets built here in a special way.
1961 Namely, we push into `cname's scope. When this declaration is
1962 processed, we pop back out. */
1964 build_push_scope (cname, name)
1968 extern int current_class_depth;
1972 if (cname == error_mark_node)
1973 return error_mark_node;
1975 ctype = IDENTIFIER_TYPE_VALUE (cname);
1977 if (TREE_CODE (ctype) == TEMPLATE_TYPE_PARM)
1979 else if (ctype == NULL_TREE || ! IS_AGGR_TYPE (ctype))
1981 cp_error ("`%T' not defined as aggregate type", cname);
1984 else if (IS_SIGNATURE (ctype))
1986 error ("cannot push into signature scope, scope resolution operator ignored");
1990 rval = build_parse_node (SCOPE_REF, cname, name);
1992 /* Don't need to push the scope if we're already in it.
1993 We also don't need to push the scope for a ptr-to-member/method. */
1995 if (ctype == current_class_type || TREE_CODE (name) != IDENTIFIER_NODE
1999 /* We do need to push the scope in this case, since CTYPE helps
2000 determine subsequent initializers (i.e., Foo::Bar x = foo_enum_1;). */
2002 push_nested_class (ctype, 3);
2003 TREE_COMPLEXITY (rval) = current_class_depth;
2008 cplus_decl_attributes (decl, attributes, prefix_attributes)
2009 tree decl, attributes, prefix_attributes;
2011 if (decl == NULL_TREE || decl == void_type_node)
2014 if (TREE_CODE (decl) == TEMPLATE_DECL)
2015 decl = DECL_TEMPLATE_RESULT (decl);
2017 decl_attributes (decl, attributes, prefix_attributes);
2019 if (TREE_CODE (decl) == TYPE_DECL)
2020 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (decl), TREE_TYPE (decl));
2023 /* CONSTRUCTOR_NAME:
2024 Return the name for the constructor (or destructor) for the
2025 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
2026 IDENTIFIER_NODE. When given a template, this routine doesn't
2027 lose the specialization. */
2029 constructor_name_full (thing)
2032 if (TREE_CODE (thing) == UNINSTANTIATED_P_TYPE)
2033 return DECL_NAME (UPT_TEMPLATE (thing));
2034 if (IS_AGGR_TYPE_CODE (TREE_CODE (thing)))
2036 if (TYPE_WAS_ANONYMOUS (thing) && TYPE_HAS_CONSTRUCTOR (thing))
2037 thing = DECL_NAME (TREE_VEC_ELT (TYPE_METHODS (thing), 0));
2039 thing = TYPE_NAME (thing);
2041 if (TREE_CODE (thing) == TYPE_DECL
2042 || (TREE_CODE (thing) == TEMPLATE_DECL
2043 && DECL_TEMPLATE_IS_CLASS (thing)))
2044 thing = DECL_NAME (thing);
2045 my_friendly_assert (TREE_CODE (thing) == IDENTIFIER_NODE, 197);
2049 /* CONSTRUCTOR_NAME:
2050 Return the name for the constructor (or destructor) for the
2051 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
2052 IDENTIFIER_NODE. When given a template, return the plain
2053 unspecialized name. */
2055 constructor_name (thing)
2059 thing = constructor_name_full (thing);
2060 t = IDENTIFIER_TEMPLATE (thing);
2063 t = TREE_PURPOSE (t);
2064 return DECL_NAME (t);
2067 /* Cache the value of this class's main virtual function table pointer
2068 in a register variable. This will save one indirection if a
2069 more than one virtual function call is made this function. */
2073 extern tree base_init_expr;
2075 if (base_init_expr == 0
2076 && DECL_CONSTRUCTOR_P (current_function_decl))
2077 emit_base_init (current_class_type, 0);
2080 /* Record the existence of an addressable inline function. */
2082 mark_inline_for_output (decl)
2085 decl = DECL_MAIN_VARIANT (decl);
2086 if (DECL_SAVED_INLINE (decl))
2088 my_friendly_assert (TREE_PERMANENT (decl), 363);
2089 DECL_SAVED_INLINE (decl) = 1;
2091 if (DECL_PENDING_INLINE_INFO (decl) != 0
2092 && ! DECL_PENDING_INLINE_INFO (decl)->deja_vu)
2094 struct pending_inline *t = pending_inlines;
2095 my_friendly_assert (DECL_SAVED_INSNS (decl) == 0, 198);
2098 if (t == DECL_PENDING_INLINE_INFO (decl))
2104 t = DECL_PENDING_INLINE_INFO (decl);
2105 t->next = pending_inlines;
2106 pending_inlines = t;
2108 DECL_PENDING_INLINE_INFO (decl) = 0;
2111 saved_inlines = perm_tree_cons (NULL_TREE, decl, saved_inlines);
2117 temp_name_counter = 0;
2120 /* Hand off a unique name which can be used for variable we don't really
2121 want to know about anyway, for example, the anonymous variables which
2122 are needed to make references work. Declare this thing so we can use it.
2123 The variable created will be of type TYPE.
2125 STATICP is nonzero if this variable should be static. */
2128 get_temp_name (type, staticp)
2132 char buf[sizeof (AUTO_TEMP_FORMAT) + 20];
2134 int toplev = toplevel_bindings_p ();
2136 push_obstacks_nochange ();
2137 if (toplev || staticp)
2139 end_temporary_allocation ();
2140 sprintf (buf, AUTO_TEMP_FORMAT, global_temp_name_counter++);
2141 decl = pushdecl_top_level (build_decl (VAR_DECL, get_identifier (buf), type));
2145 sprintf (buf, AUTO_TEMP_FORMAT, temp_name_counter++);
2146 decl = pushdecl (build_decl (VAR_DECL, get_identifier (buf), type));
2148 TREE_USED (decl) = 1;
2149 TREE_STATIC (decl) = staticp;
2151 /* If this is a local variable, then lay out its rtl now.
2152 Otherwise, callers of this function are responsible for dealing
2153 with this variable's rtl. */
2157 expand_decl_init (decl);
2164 /* Get a variable which we can use for multiple assignments.
2165 It is not entered into current_binding_level, because
2166 that breaks things when it comes time to do final cleanups
2167 (which take place "outside" the binding contour of the function). */
2169 get_temp_regvar (type, init)
2172 static char buf[sizeof (AUTO_TEMP_FORMAT) + 20] = { '_' };
2175 sprintf (buf+1, AUTO_TEMP_FORMAT, temp_name_counter++);
2176 decl = build_decl (VAR_DECL, get_identifier (buf), type);
2177 TREE_USED (decl) = 1;
2178 DECL_REGISTER (decl) = 1;
2181 store_init_value (decl, init);
2183 /* We can expand these without fear, since they cannot need
2184 constructors or destructors. */
2186 expand_decl_init (decl);
2188 if (type_needs_gc_entry (type))
2189 DECL_GC_OFFSET (decl) = size_int (++current_function_obstack_index);
2194 /* Make the macro TEMP_NAME_P available to units which do not
2195 include c-tree.h. */
2200 return TEMP_NAME_P (decl);
2203 /* Finish off the processing of a UNION_TYPE structure.
2204 If there are static members, then all members are
2205 static, and must be laid out together. If the
2206 union is an anonymous union, we arrange for that
2207 as well. PUBLIC_P is nonzero if this union is
2208 not declared static. */
2210 finish_anon_union (anon_union_decl)
2211 tree anon_union_decl;
2213 tree type = TREE_TYPE (anon_union_decl);
2214 tree field, main_decl = NULL_TREE;
2215 tree elems = NULL_TREE;
2216 int public_p = TREE_PUBLIC (anon_union_decl);
2217 int static_p = TREE_STATIC (anon_union_decl);
2218 int external_p = DECL_EXTERNAL (anon_union_decl);
2220 if ((field = TYPE_FIELDS (type)) == NULL_TREE)
2225 error ("global anonymous unions must be declared static");
2229 for (; field; field = TREE_CHAIN (field))
2232 if (TREE_CODE (field) != FIELD_DECL)
2235 if (TREE_PRIVATE (field))
2236 cp_pedwarn_at ("private member `%#D' in anonymous union", field);
2237 else if (TREE_PROTECTED (field))
2238 cp_pedwarn_at ("protected member `%#D' in anonymous union", field);
2240 decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
2241 /* tell `pushdecl' that this is not tentative. */
2242 DECL_INITIAL (decl) = error_mark_node;
2243 TREE_PUBLIC (decl) = public_p;
2244 TREE_STATIC (decl) = static_p;
2245 DECL_EXTERNAL (decl) = external_p;
2246 decl = pushdecl (decl);
2248 /* Only write out one anon union element--choose the one that
2249 can hold them all. */
2250 if (main_decl == NULL_TREE
2251 && 1 == simple_cst_equal (DECL_SIZE (decl),
2252 DECL_SIZE (anon_union_decl)))
2258 /* ??? This causes there to be no debug info written out
2260 TREE_ASM_WRITTEN (decl) = 1;
2263 DECL_INITIAL (decl) = NULL_TREE;
2264 /* If there's a cleanup to do, it belongs in the
2265 TREE_PURPOSE of the following TREE_LIST. */
2266 elems = tree_cons (NULL_TREE, decl, elems);
2267 TREE_TYPE (elems) = type;
2273 make_decl_rtl (main_decl, 0, toplevel_bindings_p ());
2274 DECL_RTL (anon_union_decl) = DECL_RTL (main_decl);
2278 warning ("anonymous union with no members");
2283 /* The following call assumes that there are never any cleanups
2284 for anonymous unions--a reasonable assumption. */
2285 expand_anon_union_decl (anon_union_decl, NULL_TREE, elems);
2288 cadillac_finish_anon_union (anon_union_decl);
2291 /* Finish and output a table which is generated by the compiler.
2292 NAME is the name to give the table.
2293 TYPE is the type of the table entry.
2294 INIT is all the elements in the table.
2295 PUBLICP is non-zero if this table should be given external access. */
2297 finish_table (name, type, init, publicp)
2298 tree name, type, init;
2301 tree itype, atype, decl;
2302 static tree empty_table;
2306 itype = build_index_type (size_int (list_length (init) - 1));
2307 atype = build_cplus_array_type (type, itype);
2308 layout_type (atype);
2310 if (TREE_VALUE (init) == integer_zero_node
2311 && TREE_CHAIN (init) == NULL_TREE)
2314 if (empty_table == NULL_TREE)
2317 empty_table = get_temp_name (atype, 1);
2318 init = build (CONSTRUCTOR, atype, NULL_TREE, init);
2319 TREE_CONSTANT (init) = 1;
2320 TREE_STATIC (init) = 1;
2321 DECL_INITIAL (empty_table) = init;
2322 asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
2323 IDENTIFIER_POINTER (DECL_NAME (empty_table)));
2324 cp_finish_decl (empty_table, NULL_TREE, asmspec, 0, 0);
2329 if (name == NULL_TREE)
2333 decl = get_temp_name (atype, 1);
2337 decl = build_decl (VAR_DECL, name, atype);
2338 decl = pushdecl (decl);
2339 TREE_STATIC (decl) = 1;
2344 TREE_PUBLIC (decl) = publicp;
2345 init = build (CONSTRUCTOR, atype, NULL_TREE, init);
2346 TREE_CONSTANT (init) = 1;
2347 TREE_STATIC (init) = 1;
2348 DECL_INITIAL (decl) = init;
2349 asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (decl)),
2350 IDENTIFIER_POINTER (DECL_NAME (decl)));
2354 /* This will cause DECL to point to EMPTY_TABLE in rtl-land. */
2355 DECL_EXTERNAL (decl) = 1;
2356 TREE_STATIC (decl) = 0;
2358 asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
2359 IDENTIFIER_POINTER (DECL_NAME (empty_table)));
2362 cp_finish_decl (decl, NULL_TREE, asmspec, 0, 0);
2366 /* Finish processing a builtin type TYPE. It's name is NAME,
2367 its fields are in the array FIELDS. LEN is the number of elements
2368 in FIELDS minus one, or put another way, it is the maximum subscript
2371 It is given the same alignment as ALIGN_TYPE. */
2373 finish_builtin_type (type, name, fields, len, align_type)
2382 TYPE_FIELDS (type) = fields[0];
2383 for (i = 0; i < len; i++)
2385 layout_type (TREE_TYPE (fields[i]));
2386 DECL_FIELD_CONTEXT (fields[i]) = type;
2387 TREE_CHAIN (fields[i]) = fields[i+1];
2389 DECL_FIELD_CONTEXT (fields[i]) = type;
2390 DECL_CLASS_CONTEXT (fields[i]) = type;
2391 TYPE_ALIGN (type) = TYPE_ALIGN (align_type);
2393 #if 0 /* not yet, should get fixed properly later */
2394 TYPE_NAME (type) = make_type_decl (get_identifier (name), type);
2396 TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type);
2398 layout_decl (TYPE_NAME (type), 0);
2401 /* Auxiliary functions to make type signatures for
2402 `operator new' and `operator delete' correspond to
2403 what compiler will be expecting. */
2405 extern tree sizetype;
2408 coerce_new_type (type)
2413 if (TREE_CODE (type) == METHOD_TYPE)
2414 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (TYPE_ARG_TYPES (type)));
2415 if (TREE_TYPE (type) != ptr_type_node)
2416 e1 = 1, error ("`operator new' must return type `void *'");
2418 /* Technically the type must be `size_t', but we may not know
2420 if (TYPE_ARG_TYPES (type) == NULL_TREE)
2421 e1 = 1, error ("`operator new' takes type `size_t' parameter");
2422 else if (TREE_CODE (TREE_VALUE (TYPE_ARG_TYPES (type))) != INTEGER_TYPE
2423 || TYPE_PRECISION (TREE_VALUE (TYPE_ARG_TYPES (type))) != TYPE_PRECISION (sizetype))
2424 e2 = 1, error ("`operator new' takes type `size_t' as first parameter");
2426 type = build_function_type (ptr_type_node, tree_cons (NULL_TREE, sizetype, TREE_CHAIN (TYPE_ARG_TYPES (type))));
2428 type = build_function_type (ptr_type_node, TYPE_ARG_TYPES (type));
2433 coerce_delete_type (type)
2436 int e1 = 0, e2 = 0, e3 = 0;
2437 tree arg_types = TYPE_ARG_TYPES (type);
2439 if (TREE_CODE (type) == METHOD_TYPE)
2441 type = build_function_type (TREE_TYPE (type), TREE_CHAIN (arg_types));
2442 arg_types = TREE_CHAIN (arg_types);
2444 if (TREE_TYPE (type) != void_type_node)
2445 e1 = 1, error ("`operator delete' must return type `void'");
2446 if (arg_types == NULL_TREE
2447 || TREE_VALUE (arg_types) != ptr_type_node)
2448 e2 = 1, error ("`operator delete' takes type `void *' as first parameter");
2451 && TREE_CHAIN (arg_types)
2452 && TREE_CHAIN (arg_types) != void_list_node)
2454 /* Again, technically this argument must be `size_t', but again
2455 we may not know what that is. */
2456 tree t2 = TREE_VALUE (TREE_CHAIN (arg_types));
2457 if (TREE_CODE (t2) != INTEGER_TYPE
2458 || TYPE_PRECISION (t2) != TYPE_PRECISION (sizetype))
2459 e3 = 1, error ("second argument to `operator delete' must be of type `size_t'");
2460 else if (TREE_CHAIN (TREE_CHAIN (arg_types)) != void_list_node)
2463 if (TREE_CHAIN (TREE_CHAIN (arg_types)))
2464 error ("too many arguments in declaration of `operator delete'");
2466 error ("`...' invalid in specification of `operator delete'");
2470 arg_types = tree_cons (NULL_TREE, ptr_type_node, build_tree_list (NULL_TREE, sizetype));
2473 if (arg_types == NULL_TREE)
2474 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
2476 arg_types = tree_cons (NULL_TREE, ptr_type_node, TREE_CHAIN (arg_types));
2481 type = build_function_type (void_type_node, arg_types);
2487 mark_vtable_entries (decl)
2490 tree entries = CONSTRUCTOR_ELTS (DECL_INITIAL (decl));
2492 skip_rtti_stuff (&entries);
2494 for (; entries; entries = TREE_CHAIN (entries))
2496 tree fnaddr = FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries));
2497 tree fn = TREE_OPERAND (fnaddr, 0);
2498 TREE_ADDRESSABLE (fn) = 1;
2499 if (DECL_ABSTRACT_VIRTUAL_P (fn))
2501 extern tree abort_fndecl;
2502 if (flag_vtable_thunks)
2503 fnaddr = TREE_VALUE (entries);
2504 TREE_OPERAND (fnaddr, 0) = fn = abort_fndecl;
2506 assemble_external (fn);
2510 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
2511 based on TYPE and other static flags.
2513 Note that anything public is tagged TREE_PUBLIC, whether
2514 it's public in this file or in another one. */
2517 import_export_vtable (decl, type, final)
2521 if (DECL_INTERFACE_KNOWN (decl))
2525 if (write_virtuals < 2 && write_virtuals != 0)
2527 TREE_PUBLIC (decl) = 1;
2528 if (write_virtuals < 0)
2529 DECL_EXTERNAL (decl) = 1;
2530 DECL_INTERFACE_KNOWN (decl) = 1;
2532 else if (CLASSTYPE_INTERFACE_KNOWN (type))
2534 TREE_PUBLIC (decl) = 1;
2535 DECL_EXTERNAL (decl) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type);
2536 DECL_INTERFACE_KNOWN (decl) = 1;
2540 /* We can only wait to decide if we have real non-inline virtual
2541 functions in our class, or if we come from a template. */
2543 int found = CLASSTYPE_TEMPLATE_INSTANTIATION (type);
2545 if (! found && ! final)
2548 for (method = CLASSTYPE_METHODS (type); method != NULL_TREE;
2549 method = DECL_NEXT_METHOD (method))
2550 if (DECL_VINDEX (method) != NULL_TREE
2551 && ! DECL_THIS_INLINE (method)
2552 && ! DECL_ABSTRACT_VIRTUAL_P (method))
2559 if (final || ! found)
2561 #ifdef ASSEMBLE_EXTERNAL
2562 if (TREE_PUBLIC (decl))
2563 cp_error ("all virtual functions redeclared inline");
2566 DECL_WEAK (decl) = 1;
2568 TREE_PUBLIC (decl) = 0;
2569 DECL_EXTERNAL (decl) = 0;
2573 TREE_PUBLIC (decl) = 1;
2574 DECL_EXTERNAL (decl) = 1;
2580 import_export_template (type)
2583 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type)
2584 && ! flag_implicit_templates
2585 && CLASSTYPE_INTERFACE_UNKNOWN (type))
2587 SET_CLASSTYPE_INTERFACE_KNOWN (type);
2588 CLASSTYPE_INTERFACE_ONLY (type) = 1;
2589 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 0;
2594 finish_prevtable_vardecl (prev, vars)
2597 tree ctype = DECL_CONTEXT (vars);
2598 import_export_template (ctype);
2600 if (CLASSTYPE_INTERFACE_UNKNOWN (ctype) && TYPE_VIRTUAL_P (ctype)
2601 && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype))
2604 for (method = CLASSTYPE_METHODS (ctype); method != NULL_TREE;
2605 method = DECL_NEXT_METHOD (method))
2607 if (DECL_VINDEX (method) != NULL_TREE
2608 && !DECL_THIS_INLINE (method)
2609 && !DECL_ABSTRACT_VIRTUAL_P (method))
2611 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
2612 CLASSTYPE_VTABLE_NEEDS_WRITING (ctype) = ! DECL_EXTERNAL (method);
2613 CLASSTYPE_INTERFACE_ONLY (ctype) = DECL_EXTERNAL (method);
2619 import_export_vtable (vars, ctype, 1);
2621 /* We cannot use TREE_USED here, as it may be set by the expanding of a
2622 ctor that is used to build a global object. The long term plan is to
2623 make the TD entries statically initialized and move this to
2624 finish_vtable_vardecl time. */
2625 if (flag_rtti && write_virtuals >= 0
2626 && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || 1 || TREE_USED (vars)))
2628 /* Kick out the type descriptor before we dump out global
2629 initializers, as they are initialized at run time and
2630 we have to find them when we scan for things that need initialized
2631 at the top level. */
2632 build_t_desc (ctype, 1);
2637 finish_vtable_vardecl (prev, vars)
2640 if (write_virtuals >= 0
2641 && ! DECL_EXTERNAL (vars) && (TREE_PUBLIC (vars) || TREE_USED (vars)))
2644 /* The long term plan it to make the TD entries statically initialized,
2645 have the entries built and emitted here. When that happens, this
2646 can be enabled, and the other call to build_t_desc removed. */
2647 /* Kick out the type descriptor before writing out the vtable. */
2649 build_t_desc (DECL_CONTEXT (vars), 1);
2653 mark_vtable_entries (vars);
2654 if (TREE_TYPE (DECL_INITIAL (vars)) == 0)
2655 store_init_value (vars, DECL_INITIAL (vars));
2657 #ifdef DWARF_DEBUGGING_INFO
2658 if (write_symbols == DWARF_DEBUG)
2660 /* Mark the VAR_DECL node representing the vtable itself as a
2661 "gratuitous" one, thereby forcing dwarfout.c to ignore it.
2662 It is rather important that such things be ignored because
2663 any effort to actually generate DWARF for them will run
2664 into trouble when/if we encounter code like:
2667 struct S { virtual void member (); };
2669 because the artificial declaration of the vtable itself (as
2670 manufactured by the g++ front end) will say that the vtable
2671 is a static member of `S' but only *after* the debug output
2672 for the definition of `S' has already been output. This causes
2673 grief because the DWARF entry for the definition of the vtable
2674 will try to refer back to an earlier *declaration* of the
2675 vtable as a static member of `S' and there won't be one.
2676 We might be able to arrange to have the "vtable static member"
2677 attached to the member list for `S' before the debug info for
2678 `S' get written (which would solve the problem) but that would
2679 require more intrusive changes to the g++ front end. */
2681 DECL_IGNORED_P (vars) = 1;
2683 #endif /* DWARF_DEBUGGING_INFO */
2685 rest_of_decl_compilation (vars, NULL_PTR, 1, 1);
2687 else if (! TREE_USED (vars))
2688 /* We don't know what to do with this one yet. */
2691 /* We know that PREV must be non-zero here. */
2692 TREE_CHAIN (prev) = TREE_CHAIN (vars);
2696 prune_vtable_vardecl (prev, vars)
2699 /* We know that PREV must be non-zero here. */
2700 TREE_CHAIN (prev) = TREE_CHAIN (vars);
2704 walk_vtables (typedecl_fn, vardecl_fn)
2705 register void (*typedecl_fn)();
2706 register void (*vardecl_fn)();
2710 for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars))
2712 register tree type = TREE_TYPE (vars);
2714 if (TREE_CODE (vars) == VAR_DECL && DECL_VIRTUAL_P (vars))
2716 if (vardecl_fn) (*vardecl_fn) (prev, vars);
2718 if (prev && TREE_CHAIN (prev) != vars)
2721 else if (TREE_CODE (vars) == TYPE_DECL
2722 && type != error_mark_node
2723 && TYPE_LANG_SPECIFIC (type)
2724 && CLASSTYPE_VSIZE (type))
2726 if (typedecl_fn) (*typedecl_fn) (prev, vars);
2734 finish_sigtable_vardecl (prev, vars)
2737 /* We don't need to mark sigtable entries as addressable here as is done
2738 for vtables. Since sigtables, unlike vtables, are always written out,
2739 that was already done in build_signature_table_constructor. */
2741 rest_of_decl_compilation (vars, NULL_PTR, 1, 1);
2743 /* We know that PREV must be non-zero here. */
2744 TREE_CHAIN (prev) = TREE_CHAIN (vars);
2748 walk_sigtables (typedecl_fn, vardecl_fn)
2749 register void (*typedecl_fn)();
2750 register void (*vardecl_fn)();
2754 for (prev = 0, vars = getdecls (); vars; vars = TREE_CHAIN (vars))
2756 register tree type = TREE_TYPE (vars);
2758 if (TREE_CODE (vars) == TYPE_DECL
2759 && type != error_mark_node
2760 && IS_SIGNATURE (type))
2762 if (typedecl_fn) (*typedecl_fn) (prev, vars);
2764 else if (TREE_CODE (vars) == VAR_DECL
2765 && TREE_TYPE (vars) != error_mark_node
2766 && IS_SIGNATURE (TREE_TYPE (vars)))
2768 if (vardecl_fn) (*vardecl_fn) (prev, vars);
2775 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
2776 inline function at end-of-file. */
2779 import_export_inline (decl)
2782 if (DECL_INTERFACE_KNOWN (decl))
2785 if (DECL_TEMPLATE_INSTANTIATION (decl))
2787 if (DECL_IMPLICIT_INSTANTIATION (decl) && flag_implicit_templates)
2790 DECL_WEAK (decl) = 1;
2792 TREE_PUBLIC (decl) = 0;
2795 DECL_NOT_REALLY_EXTERN (decl) = 0;
2797 else if (DECL_FUNCTION_MEMBER_P (decl))
2799 tree ctype = DECL_CLASS_CONTEXT (decl);
2800 if (CLASSTYPE_INTERFACE_KNOWN (ctype) && ! DECL_ARTIFICIAL (decl))
2802 DECL_NOT_REALLY_EXTERN (decl)
2803 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2804 || (DECL_THIS_INLINE (decl) && ! flag_implement_inlines));
2806 else if (SUPPORTS_WEAK)
2807 DECL_WEAK (decl) = 1;
2809 TREE_PUBLIC (decl) = 0;
2811 else if (DECL_C_STATIC (decl))
2812 TREE_PUBLIC (decl) = 0;
2813 else if (SUPPORTS_WEAK)
2814 DECL_WEAK (decl) = 1;
2816 TREE_PUBLIC (decl) = 0;
2818 DECL_INTERFACE_KNOWN (decl) = 1;
2821 extern int parse_time, varconst_time;
2823 #define TIMEVAR(VAR, BODY) \
2824 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
2826 /* This routine is called from the last rule in yyparse ().
2827 Its job is to create all the code needed to initialize and
2828 destroy the global aggregates. We do the destruction
2829 first, since that way we only need to reverse the decls once. */
2835 int start_time, this_time;
2839 int needs_cleaning = 0, needs_messing_up = 0;
2841 if (flag_detailed_statistics)
2842 dump_tree_statistics ();
2844 /* Bad parse errors. Just forget about it. */
2845 if (! global_bindings_p () || current_class_type)
2848 start_time = get_run_time ();
2850 /* Push into C language context, because that's all
2852 push_lang_context (lang_name_c);
2854 /* Otherwise, GDB can get confused, because in only knows
2855 about source for LINENO-1 lines. */
2858 interface_unknown = 1;
2862 /* The reason for pushing garbage onto the global_binding_level is to
2863 ensure that we can slice out _DECLs which pertain to virtual function
2864 tables. If the last thing pushed onto the global_binding_level was a
2865 virtual function table, then slicing it out would slice away all the
2866 decls (i.e., we lose the head of the chain).
2868 There are several ways of getting the same effect, from changing the
2869 way that iterators over the chain treat the elements that pertain to
2870 virtual function tables, moving the implementation of this code to
2871 decl.c (where we can manipulate global_binding_level directly),
2872 popping the garbage after pushing it and slicing away the vtable
2873 stuff, or just leaving it alone. */
2875 /* Make last thing in global scope not be a virtual function table. */
2876 #if 0 /* not yet, should get fixed properly later */
2877 vars = make_type_decl (get_identifier (" @%$#@!"), integer_type_node);
2879 vars = build_decl (TYPE_DECL, get_identifier (" @%$#@!"), integer_type_node);
2881 DECL_IGNORED_P (vars) = 1;
2882 SET_DECL_ARTIFICIAL (vars);
2886 /* Walk to mark the inline functions we need, then output them so
2887 that we can pick up any other tdecls that those routines need. */
2888 walk_vtables ((void (*)())0, finish_prevtable_vardecl);
2890 vars = static_aggregates;
2892 if (static_ctors || vars || might_have_exceptions_p ())
2893 needs_messing_up = 1;
2897 /* See if we really need the hassle. */
2898 while (vars && needs_cleaning == 0)
2900 tree decl = TREE_VALUE (vars);
2901 tree type = TREE_TYPE (decl);
2902 if (TYPE_NEEDS_DESTRUCTOR (type))
2905 needs_messing_up = 1;
2909 needs_messing_up |= TYPE_NEEDS_CONSTRUCTING (type);
2910 vars = TREE_CHAIN (vars);
2913 if (needs_cleaning == 0)
2916 fnname = get_file_function_name ('D');
2917 start_function (void_list_node,
2918 build_parse_node (CALL_EXPR, fnname, void_list_node,
2920 NULL_TREE, NULL_TREE, 0);
2921 fnname = DECL_ASSEMBLER_NAME (current_function_decl);
2922 store_parm_decls ();
2927 expand_start_bindings (0);
2929 /* These must be done in backward order to destroy,
2930 in which they happen to be! */
2931 for (vars = static_aggregates; vars; vars = TREE_CHAIN (vars))
2933 tree decl = TREE_VALUE (vars);
2934 tree type = TREE_TYPE (decl);
2935 tree temp = TREE_PURPOSE (vars);
2937 if (TYPE_NEEDS_DESTRUCTOR (type))
2939 if (TREE_STATIC (vars))
2940 expand_start_cond (build_binary_op (NE_EXPR, temp, integer_zero_node, 1), 0);
2941 if (TREE_CODE (type) == ARRAY_TYPE)
2945 mark_addressable (decl);
2946 temp = build1 (ADDR_EXPR, build_pointer_type (type), decl);
2948 temp = build_delete (TREE_TYPE (temp), temp,
2949 integer_two_node, LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
2950 expand_expr_stmt (temp);
2952 if (TREE_STATIC (vars))
2957 for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
2958 expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
2961 expand_end_bindings (getdecls(), 1, 0);
2965 finish_function (lineno, 0, 0);
2967 assemble_destructor (IDENTIFIER_POINTER (fnname));
2969 /* if it needed cleaning, then it will need messing up: drop through */
2972 /* Must do this while we think we are at the top level. */
2973 vars = nreverse (static_aggregates);
2974 if (needs_messing_up)
2976 fnname = get_file_function_name ('I');
2977 start_function (void_list_node,
2978 build_parse_node (CALL_EXPR, fnname,
2979 void_list_node, NULL_TREE),
2980 NULL_TREE, NULL_TREE, 0);
2981 fnname = DECL_ASSEMBLER_NAME (current_function_decl);
2982 store_parm_decls ();
2987 expand_start_bindings (0);
2989 if (might_have_exceptions_p ())
2990 register_exception_table ();
2994 tree decl = TREE_VALUE (vars);
2995 tree init = TREE_PURPOSE (vars);
2996 tree old_cleanups = cleanups_this_call;
2998 /* If this was a static attribute within some function's scope,
2999 then don't initialize it here. Also, don't bother
3000 with initializers that contain errors. */
3001 if (TREE_STATIC (vars)
3002 || (init && TREE_CODE (init) == TREE_LIST
3003 && value_member (error_mark_node, init)))
3005 vars = TREE_CHAIN (vars);
3009 if (TREE_CODE (decl) == VAR_DECL)
3011 /* Set these global variables so that GDB at least puts
3012 us near the declaration which required the initialization. */
3013 input_filename = DECL_SOURCE_FILE (decl);
3014 lineno = DECL_SOURCE_LINE (decl);
3015 emit_note (input_filename, lineno);
3017 /* 9.5p5: The initializer of a static member of a class has
3018 the same access rights as a member function. */
3019 DECL_CLASS_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3020 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3022 if (IS_AGGR_TYPE (TREE_TYPE (decl))
3023 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
3024 expand_aggr_init (decl, init, 0, 0);
3025 else if (TREE_CODE (init) == TREE_VEC)
3027 expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0),
3028 TREE_VEC_ELT (init, 1),
3029 TREE_VEC_ELT (init, 2), 0),
3030 const0_rtx, VOIDmode, 0);
3034 expand_assignment (decl, init, 0, 0);
3036 DECL_CLASS_CONTEXT (current_function_decl) = NULL_TREE;
3038 else if (TREE_CODE (decl) == SAVE_EXPR)
3040 if (! PARM_DECL_EXPR (decl))
3042 /* a `new' expression at top level. */
3043 expand_expr (decl, const0_rtx, VOIDmode, 0);
3045 if (TREE_CODE (init) == TREE_VEC)
3047 expand_expr (expand_vec_init (decl, TREE_VEC_ELT (init, 0),
3048 TREE_VEC_ELT (init, 1),
3049 TREE_VEC_ELT (init, 2), 0),
3050 const0_rtx, VOIDmode, 0);
3054 expand_aggr_init (build_indirect_ref (decl, NULL_PTR), init, 0, 0);
3057 else if (decl == error_mark_node)
3059 else my_friendly_abort (22);
3060 vars = TREE_CHAIN (vars);
3061 /* Cleanup any temporaries needed for the initial value. */
3062 expand_cleanups_to (old_cleanups);
3065 for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
3066 expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
3069 expand_end_bindings (getdecls(), 1, 0);
3073 finish_function (lineno, 0, 0);
3074 assemble_constructor (IDENTIFIER_POINTER (fnname));
3077 expand_builtin_throw ();
3079 permanent_allocation (1);
3081 /* Done with C language context needs. */
3082 pop_lang_context ();
3084 /* Now write out any static class variables (which may have since
3085 learned how to be initialized). */
3086 while (pending_statics)
3088 tree decl = TREE_VALUE (pending_statics);
3089 if (TREE_USED (decl) == 1
3090 || TREE_READONLY (decl) == 0
3091 || DECL_INITIAL (decl) == 0)
3092 rest_of_decl_compilation (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), 1, 1);
3093 pending_statics = TREE_CHAIN (pending_statics);
3096 this_time = get_run_time ();
3097 parse_time -= this_time - start_time;
3098 varconst_time += this_time - start_time;
3100 start_time = get_run_time ();
3102 if (flag_handle_signatures)
3103 walk_sigtables ((void (*)())0, finish_sigtable_vardecl);
3105 for (fnname = saved_inlines; fnname; fnname = TREE_CHAIN (fnname))
3107 tree decl = TREE_VALUE (fnname);
3108 import_export_inline (decl);
3109 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl)
3110 && TREE_PUBLIC (decl) && ! DECL_WEAK (decl)
3111 && DECL_NOT_REALLY_EXTERN (decl))
3112 synthesize_method (decl);
3115 /* Now write out inline functions which had their addresses taken and
3116 which were not declared virtual and which were not declared `extern
3119 int reconsider = 1; /* More may be referenced; check again */
3123 tree last = saved_inlines = tree_cons (NULL_TREE, NULL_TREE,
3125 tree last_head = last;
3126 tree place = TREE_CHAIN (saved_inlines);
3129 walk_vtables ((void (*)())0, finish_vtable_vardecl);
3131 for (; place; place = TREE_CHAIN (place))
3133 tree decl = TREE_VALUE (place);
3135 /* Slice out the empty elements put in just above in the
3136 previous reconsidering. */
3137 if (decl == NULL_TREE)
3139 TREE_CHAIN (last) = TREE_CHAIN (place);
3143 if (DECL_ARTIFICIAL (decl) && ! DECL_INITIAL (decl))
3145 if (TREE_USED (decl))
3147 synthesize_method (decl);
3148 if (TREE_ASM_WRITTEN (decl))
3158 if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0)
3160 TREE_CHAIN (last) = TREE_CHAIN (place);
3164 if ((TREE_PUBLIC (decl) && ! DECL_WEAK (decl))
3165 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
3166 || flag_keep_inline_functions)
3168 TREE_CHAIN (last) = TREE_CHAIN (place);
3170 if (DECL_NOT_REALLY_EXTERN (decl))
3172 DECL_EXTERNAL (decl) = 0;
3174 temporary_allocation ();
3175 output_inline_function (decl);
3176 permanent_allocation (1);
3187 /* Now delete from the chain of variables all virtual function tables.
3188 We output them all ourselves, because each will be treated specially. */
3190 walk_vtables ((void (*)())0, prune_vtable_vardecl);
3192 for (vars = getdecls (); vars; vars = TREE_CHAIN (vars))
3194 if (TREE_CODE (vars) == THUNK_DECL)
3196 else if (TREE_CODE (vars) == FUNCTION_DECL
3197 && ! DECL_INTERFACE_KNOWN (vars)
3198 && DECL_C_STATIC (vars))
3199 TREE_PUBLIC (vars) = 0;
3202 if (might_have_exceptions_p ())
3203 emit_exception_table ();
3205 if (write_virtuals == 2)
3207 /* Now complain about an virtual function tables promised
3208 but not delivered. */
3209 while (pending_vtables)
3211 if (TREE_PURPOSE (pending_vtables) == NULL_TREE)
3212 error ("virtual function table for `%s' not defined",
3213 IDENTIFIER_POINTER (TREE_VALUE (pending_vtables)));
3214 pending_vtables = TREE_CHAIN (pending_vtables);
3220 this_time = get_run_time ();
3221 parse_time -= this_time - start_time;
3222 varconst_time += this_time - start_time;
3224 if (flag_detailed_statistics)
3225 dump_time_statistics ();
3228 /* This is something of the form 'A()()()()()+1' that has turned out to be an
3229 expr. Since it was parsed like a type, we need to wade through and fix
3230 that. Unfortunately, since operator() is left-associative, we can't use
3231 tail recursion. In the above example, TYPE is `A', and DECL is
3234 Maybe this shouldn't be recursive, but how often will it actually be
3237 reparse_absdcl_as_expr (type, decl)
3240 /* do build_functional_cast (type, NULL_TREE) at bottom */
3241 if (TREE_OPERAND (decl, 0) == NULL_TREE)
3242 return build_functional_cast (type, NULL_TREE);
3245 decl = reparse_decl_as_expr (type, TREE_OPERAND (decl, 0));
3247 decl = build_x_function_call (decl, NULL_TREE, current_class_decl);
3249 if (TREE_CODE (decl) == CALL_EXPR && TREE_TYPE (decl) != void_type_node)
3250 decl = require_complete_type (decl);
3255 /* This is something of the form `int ((int)(int)(int)1)' that has turned
3256 out to be an expr. Since it was parsed like a type, we need to wade
3257 through and fix that. Since casts are right-associative, we are
3258 reversing the order, so we don't have to recurse.
3260 In the above example, DECL is the `(int)(int)(int)', and EXPR is the
3263 reparse_absdcl_as_casts (decl, expr)
3268 if (TREE_CODE (expr) == CONSTRUCTOR)
3270 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1)));
3271 decl = TREE_OPERAND (decl, 0);
3273 if (IS_SIGNATURE (type))
3275 error ("cast specifies signature type");
3276 return error_mark_node;
3279 expr = digest_init (type, expr, (tree *) 0);
3280 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0)
3282 int failure = complete_array_type (type, expr, 1);
3284 my_friendly_abort (78);
3290 type = groktypename (TREE_VALUE (TREE_OPERAND (decl, 1)));
3291 decl = TREE_OPERAND (decl, 0);
3292 expr = build_c_cast (type, expr, 0);
3298 /* Recursive helper function for reparse_decl_as_expr. It may be a good
3299 idea to reimplement this using an explicit stack, rather than recursion. */
3301 reparse_decl_as_expr1 (decl)
3304 switch (TREE_CODE (decl))
3306 case IDENTIFIER_NODE:
3307 return do_identifier (decl);
3309 return build_x_indirect_ref
3310 (reparse_decl_as_expr1 (TREE_OPERAND (decl, 0)), "unary *");
3312 return build_x_unary_op (ADDR_EXPR,
3313 reparse_decl_as_expr1 (TREE_OPERAND (decl, 0)));
3315 return build_x_unary_op (BIT_NOT_EXPR,
3316 reparse_decl_as_expr1 (TREE_OPERAND (decl, 0)));
3318 return build_offset_ref (TREE_OPERAND (decl, 0), TREE_OPERAND (decl, 1));
3320 return grok_array_decl (reparse_decl_as_expr1 (TREE_OPERAND (decl, 0)),
3321 TREE_OPERAND (decl, 1));
3323 my_friendly_abort (5);
3328 /* This is something of the form `int (*a)++' that has turned out to be an
3329 expr. It was only converted into parse nodes, so we need to go through
3330 and build up the semantics. Most of the work is done by
3331 reparse_decl_as_expr1, above.
3333 In the above example, TYPE is `int' and DECL is `*a'. */
3335 reparse_decl_as_expr (type, decl)
3338 decl = reparse_decl_as_expr1 (decl);
3340 return build_functional_cast (type, build_tree_list (NULL_TREE, decl));
3345 /* This is something of the form `int (*a)' that has turned out to be a
3346 decl. It was only converted into parse nodes, so we need to do the
3347 checking that make_{pointer,reference}_declarator do. */
3350 finish_decl_parsing (decl)
3353 extern int current_class_depth;
3355 switch (TREE_CODE (decl))
3357 case IDENTIFIER_NODE:
3360 return make_pointer_declarator
3361 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0)));
3363 return make_reference_declarator
3364 (NULL_TREE, finish_decl_parsing (TREE_OPERAND (decl, 0)));
3366 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0));
3369 push_nested_class (TREE_TYPE (TREE_OPERAND (decl, 0)), 3);
3370 TREE_COMPLEXITY (decl) = current_class_depth;
3373 TREE_OPERAND (decl, 0) = finish_decl_parsing (TREE_OPERAND (decl, 0));
3376 my_friendly_abort (5);
3382 check_cp_case_value (value)
3385 if (value == NULL_TREE)
3388 /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
3389 Strip such NOP_EXPRs. */
3390 if (TREE_CODE (value) == NOP_EXPR
3391 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
3392 value = TREE_OPERAND (value, 0);
3394 if (TREE_READONLY_DECL_P (value))
3396 value = decl_constant_value (value);
3397 /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
3398 Strip such NOP_EXPRs. */
3399 if (TREE_CODE (value) == NOP_EXPR
3400 && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0)))
3401 value = TREE_OPERAND (value, 0);
3403 value = fold (value);
3405 if (TREE_CODE (value) != INTEGER_CST
3406 && value != error_mark_node)
3408 cp_error ("case label `%E' does not reduce to an integer constant",
3410 value = error_mark_node;
3413 /* Promote char or short to int. */
3414 value = default_conversion (value);
3416 constant_expression_warning (value);
3421 tree current_namespace;
3423 /* Get the inner part of a namespace id. It doesn't have any prefix, nor
3424 postfix. Returns 0 if in global namespace. */
3428 tree x = current_namespace;
3430 x = TREE_PURPOSE (x);
3434 /* Build up a DECL_ASSEMBLER_NAME for NAME in the current namespace. */
3436 current_namespace_id (name)
3439 tree old_id = get_namespace_id ();
3442 /* Global names retain old encoding. */
3446 buf = (char *) alloca (8 + IDENTIFIER_LENGTH (old_id)
3447 + IDENTIFIER_LENGTH (name));
3448 sprintf (buf, "__ns_%s_%s", IDENTIFIER_POINTER (old_id),
3449 IDENTIFIER_POINTER (name));
3450 return get_identifier (buf);
3454 do_namespace_alias (alias, namespace)
3455 tree alias, namespace;
3460 do_toplevel_using_decl (decl)
3463 if (decl == NULL_TREE || decl == error_mark_node)
3466 if (TREE_CODE (decl) == SCOPE_REF)
3467 decl = resolve_scope_to_name (NULL_TREE, decl);
3469 /* Is this the right way to do an id list? */
3470 if (TREE_CODE (decl) != TREE_LIST)
3477 pushdecl (TREE_VALUE (decl));
3478 decl = TREE_CHAIN (decl);
3483 do_class_using_decl (decl)
3488 /* Ignore for now, unimplemented. */
3493 do_using_directive (namespace)
3499 check_default_args (x)
3502 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
3503 int saw_def = 0, i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
3504 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
3506 if (TREE_PURPOSE (arg))
3510 cp_error ("default argument missing for parameter %P of `%#D'",