1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* Process declarations and symbol lookup for C front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
40 extern tree
grokdeclarator ();
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. Default to on. */
366 int flag_new_for_scope
= 1;
368 /* Table of language-dependent -f options.
369 STRING is the option name. VARIABLE is the address of the variable.
370 ON_VALUE is the value to store in VARIABLE
371 if `-fSTRING' is seen as an option.
372 (If `-fno-STRING' is seen as an option, the opposite value is stored.) */
374 static struct { char *string
; int *variable
; int on_value
;} lang_f_options
[] =
376 {"signed-char", &flag_signed_char
, 1},
377 {"unsigned-char", &flag_signed_char
, 0},
378 {"signed-bitfields", &flag_signed_bitfields
, 1},
379 {"unsigned-bitfields", &flag_signed_bitfields
, 0},
380 {"short-enums", &flag_short_enums
, 1},
381 {"short-double", &flag_short_double
, 1},
382 {"cond-mismatch", &flag_cond_mismatch
, 1},
383 {"asm", &flag_no_asm
, 0},
384 {"builtin", &flag_no_builtin
, 0},
385 {"ident", &flag_no_ident
, 0},
386 {"labels-ok", &flag_labels_ok
, 1},
387 {"stats", &flag_detailed_statistics
, 1},
388 {"this-is-variable", &flag_this_is_variable
, 1},
389 {"strict-prototype", &flag_strict_prototype
, 1},
390 {"all-virtual", &flag_all_virtual
, 1},
391 {"memoize-lookups", &flag_memoize_lookups
, 1},
392 {"elide-constructors", &flag_elide_constructors
, 1},
393 {"handle-exceptions", &flag_handle_exceptions
, 1},
394 {"handle-signatures", &flag_handle_signatures
, 1},
395 {"default-inline", &flag_default_inline
, 1},
396 {"dollars-in-identifiers", &dollars_in_ident
, 1},
397 {"enum-int-equiv", &flag_int_enum_equivalence
, 1},
399 {"rtti", &flag_rtti
, 1},
400 {"xref", &flag_gnu_xref
, 1},
401 {"nonnull-objects", &flag_assume_nonnull_objects
, 1},
402 {"implement-inlines", &flag_implement_inlines
, 1},
403 {"external-templates", &flag_external_templates
, 1},
404 {"implicit-templates", &flag_implicit_templates
, 1},
405 {"huge-objects", &flag_huge_objects
, 1},
406 {"conserve-space", &flag_conserve_space
, 1},
407 {"vtable-thunks", &flag_vtable_thunks
, 1},
408 {"short-temps", &flag_short_temps
, 1},
409 {"access-control", &flag_access_control
, 1},
410 {"nonansi-builtins", &flag_no_nonansi_builtin
, 0},
411 {"gnu-keywords", &flag_no_gnu_keywords
, 0},
412 {"operator-names", &flag_operator_names
, 1},
413 {"check-new", &flag_check_new
, 1},
414 {"repo", &flag_use_repository
, 1},
415 {"for-scope", &flag_new_for_scope
, 1}
418 /* Decode the string P as a language-specific option.
419 Return 1 if it is recognized (and handle it);
420 return 0 if not recognized. */
423 lang_decode_option (p
)
426 if (!strcmp (p
, "-ftraditional") || !strcmp (p
, "-traditional"))
427 flag_traditional
= 1, dollars_in_ident
= 1, flag_writable_strings
= 1,
428 flag_this_is_variable
= 1, flag_new_for_scope
= 0;
429 /* The +e options are for cfront compatibility. They come in as
430 `-+eN', to kludge around gcc.c's argument handling. */
431 else if (p
[0] == '-' && p
[1] == '+' && p
[2] == 'e')
433 int old_write_virtuals
= write_virtuals
;
436 else if (p
[3] == '0')
438 else if (p
[3] == '2')
440 else error ("invalid +e option");
441 if (old_write_virtuals
!= 0
442 && write_virtuals
!= old_write_virtuals
)
443 error ("conflicting +e options given");
445 else if (p
[0] == '-' && p
[1] == 'f')
447 /* Some kind of -f option.
448 P's value is the option sans `-f'.
449 Search for it in the table of options. */
453 /* Try special -f options. */
455 if (!strcmp (p
, "save-memoized"))
457 flag_memoize_lookups
= 1;
458 flag_save_memoized_contexts
= 1;
461 if (!strcmp (p
, "no-save-memoized"))
463 flag_memoize_lookups
= 0;
464 flag_save_memoized_contexts
= 0;
467 else if (! strncmp (p
, "cadillac", 8))
469 flag_cadillac
= atoi (p
+9);
472 else if (! strncmp (p
, "no-cadillac", 11))
477 else if (! strcmp (p
, "gc"))
480 /* This must come along for the ride. */
484 else if (! strcmp (p
, "no-gc"))
487 /* This must come along for the ride. */
491 else if (! strcmp (p
, "alt-external-templates"))
493 flag_external_templates
= 1;
494 flag_alt_external_templates
= 1;
497 else if (! strcmp (p
, "no-alt-external-templates"))
499 flag_alt_external_templates
= 0;
502 else if (!strcmp (p
, "ansi-overloading"))
504 warning ("-fansi-overloading is no longer meaningful");
507 else if (!strcmp (p
, "repo"))
509 flag_use_repository
= 1;
510 flag_implicit_templates
= 0;
514 !found
&& j
< sizeof (lang_f_options
) / sizeof (lang_f_options
[0]);
517 if (!strcmp (p
, lang_f_options
[j
].string
))
519 *lang_f_options
[j
].variable
= lang_f_options
[j
].on_value
;
520 /* A goto here would be cleaner,
521 but breaks the vax pcc. */
524 if (p
[0] == 'n' && p
[1] == 'o' && p
[2] == '-'
525 && ! strcmp (p
+3, lang_f_options
[j
].string
))
527 *lang_f_options
[j
].variable
= ! lang_f_options
[j
].on_value
;
533 else if (p
[0] == '-' && p
[1] == 'W')
537 /* The -W options control the warning behavior of the compiler. */
540 if (p
[0] == 'n' && p
[1] == 'o' && p
[2] == '-')
543 if (!strcmp (p
, "implicit"))
544 warn_implicit
= setting
;
545 else if (!strcmp (p
, "return-type"))
546 warn_return_type
= setting
;
547 else if (!strcmp (p
, "ctor-dtor-privacy"))
548 warn_ctor_dtor_privacy
= setting
;
549 else if (!strcmp (p
, "write-strings"))
550 warn_write_strings
= setting
;
551 else if (!strcmp (p
, "cast-qual"))
552 warn_cast_qual
= setting
;
553 else if (!strcmp (p
, "traditional"))
554 warn_traditional
= setting
;
555 else if (!strcmp (p
, "char-subscripts"))
556 warn_char_subscripts
= setting
;
557 else if (!strcmp (p
, "pointer-arith"))
558 warn_pointer_arith
= setting
;
559 else if (!strcmp (p
, "strict-prototypes"))
560 warn_strict_prototypes
= setting
;
561 else if (!strcmp (p
, "missing-prototypes"))
562 warn_missing_prototypes
= setting
;
563 else if (!strcmp (p
, "redundant-decls"))
564 warn_redundant_decls
= setting
;
565 else if (!strcmp (p
, "missing-braces"))
566 warn_missing_braces
= setting
;
567 else if (!strcmp (p
, "format"))
568 warn_format
= setting
;
569 else if (!strcmp (p
, "conversion"))
570 warn_conversion
= setting
;
571 else if (!strcmp (p
, "parentheses"))
572 warn_parentheses
= setting
;
573 else if (!strcmp (p
, "non-virtual-dtor"))
574 warn_nonvdtor
= setting
;
575 else if (!strcmp (p
, "extern-inline"))
576 warn_extern_inline
= setting
;
577 else if (!strcmp (p
, "reorder"))
578 warn_reorder
= setting
;
579 else if (!strcmp (p
, "synth"))
580 warn_synth
= setting
;
581 else if (!strcmp (p
, "comment"))
582 ; /* cpp handles this one. */
583 else if (!strcmp (p
, "comments"))
584 ; /* cpp handles this one. */
585 else if (!strcmp (p
, "trigraphs"))
586 ; /* cpp handles this one. */
587 else if (!strcmp (p
, "import"))
588 ; /* cpp handles this one. */
589 else if (!strcmp (p
, "all"))
591 extra_warnings
= setting
;
592 warn_return_type
= setting
;
593 warn_unused
= setting
;
594 warn_implicit
= setting
;
595 warn_ctor_dtor_privacy
= setting
;
596 warn_switch
= setting
;
597 warn_format
= setting
;
598 warn_parentheses
= setting
;
599 warn_missing_braces
= setting
;
600 warn_extern_inline
= setting
;
601 warn_nonvdtor
= setting
;
602 /* We save the value of warn_uninitialized, since if they put
603 -Wuninitialized on the command line, we need to generate a
604 warning about not using it without also specifying -O. */
605 if (warn_uninitialized
!= 1)
606 warn_uninitialized
= (setting
? 2 : 0);
607 warn_template_debugging
= setting
;
608 warn_reorder
= setting
;
611 else if (!strcmp (p
, "overloaded-virtual"))
612 warn_overloaded_virtual
= setting
;
615 else if (!strcmp (p
, "-ansi"))
616 dollars_in_ident
= 0, flag_no_nonansi_builtin
= 1, flag_ansi
= 1,
617 flag_no_gnu_keywords
= 1, flag_operator_names
= 1;
619 /* Undocumented, only ever used when you're invoking cc1plus by hand, since
620 it's probably safe to assume no sane person would ever want to use this
621 under normal circumstances. */
622 else if (!strcmp (p
, "-spew-debug"))
631 /* Incorporate `const' and `volatile' qualifiers for member functions.
632 FUNCTION is a TYPE_DECL or a FUNCTION_DECL.
633 QUALS is a list of qualifiers. */
635 grok_method_quals (ctype
, function
, quals
)
636 tree ctype
, function
, quals
;
638 tree fntype
= TREE_TYPE (function
);
639 tree raises
= TYPE_RAISES_EXCEPTIONS (fntype
);
643 extern tree ridpointers
[];
645 if (TREE_VALUE (quals
) == ridpointers
[(int)RID_CONST
])
647 if (TYPE_READONLY (ctype
))
648 error ("duplicate `%s' %s",
649 IDENTIFIER_POINTER (TREE_VALUE (quals
)),
650 (TREE_CODE (function
) == FUNCTION_DECL
651 ? "for member function" : "in type declaration"));
652 ctype
= build_type_variant (ctype
, 1, TYPE_VOLATILE (ctype
));
653 build_pointer_type (ctype
);
655 else if (TREE_VALUE (quals
) == ridpointers
[(int)RID_VOLATILE
])
657 if (TYPE_VOLATILE (ctype
))
658 error ("duplicate `%s' %s",
659 IDENTIFIER_POINTER (TREE_VALUE (quals
)),
660 (TREE_CODE (function
) == FUNCTION_DECL
661 ? "for member function" : "in type declaration"));
662 ctype
= build_type_variant (ctype
, TYPE_READONLY (ctype
), 1);
663 build_pointer_type (ctype
);
666 my_friendly_abort (20);
667 quals
= TREE_CHAIN (quals
);
670 fntype
= build_cplus_method_type (ctype
, TREE_TYPE (fntype
),
671 (TREE_CODE (fntype
) == METHOD_TYPE
672 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype
))
673 : TYPE_ARG_TYPES (fntype
)));
675 fntype
= build_exception_variant (ctype
, fntype
, raises
);
677 TREE_TYPE (function
) = fntype
;
681 #if 0 /* Not used. */
682 /* This routine replaces cryptic DECL_NAMEs with readable DECL_NAMEs.
683 It leaves DECL_ASSEMBLER_NAMEs with the correct value. */
684 /* This does not yet work with user defined conversion operators
687 substitute_nice_name (decl
)
690 if (DECL_NAME (decl
) && TREE_CODE (DECL_NAME (decl
)) == IDENTIFIER_NODE
)
692 char *n
= decl_as_string (DECL_NAME (decl
), 1);
693 if (n
[strlen (n
) - 1] == ' ')
694 n
[strlen (n
) - 1] = 0;
695 DECL_NAME (decl
) = get_identifier (n
);
700 /* Warn when -fexternal-templates is used and #pragma
701 interface/implementation is not used all the times it should be,
704 warn_if_unknown_interface (decl
)
707 static int already_warned
= 0;
708 if (already_warned
++)
711 if (flag_alt_external_templates
)
713 struct tinst_level
*til
= tinst_for_decl ();
715 char *sf
= input_filename
;
718 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);
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
);
863 if (fn_name
== NULL_TREE
)
865 error ("name missing for member function");
866 fn_name
= get_identifier ("<anonymous>");
867 DECL_NAME (function
) = fn_name
;
871 qualtype
= grok_method_quals (ctype
, function
, quals
);
875 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
876 if (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
878 /* Must add the class instance variable up front. */
879 /* Right now we just make this a pointer. But later
880 we may wish to make it special. */
881 tree type
= TREE_VALUE (arg_types
);
884 if ((flag_this_is_variable
> 0)
885 && (flags
== DTOR_FLAG
|| DECL_CONSTRUCTOR_P (function
)))
888 if (DECL_CONSTRUCTOR_P (function
))
890 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
892 DECL_CONSTRUCTOR_FOR_VBASE_P (function
) = 1;
893 /* In this case we need "in-charge" flag saying whether
894 this constructor is responsible for initialization
895 of virtual baseclasses or not. */
896 parm
= build_decl (PARM_DECL
, in_charge_identifier
, integer_type_node
);
897 /* Mark the artificial `__in_chrg' parameter as "artificial". */
898 SET_DECL_ARTIFICIAL (parm
);
899 DECL_ARG_TYPE (parm
) = integer_type_node
;
900 DECL_REGISTER (parm
) = 1;
901 TREE_CHAIN (parm
) = last_function_parms
;
902 last_function_parms
= parm
;
906 parm
= build_decl (PARM_DECL
, this_identifier
, type
);
907 /* Mark the artificial `this' parameter as "artificial". */
908 SET_DECL_ARTIFICIAL (parm
);
909 DECL_ARG_TYPE (parm
) = type
;
910 /* We can make this a register, so long as we don't
911 accidentally complain if someone tries to take its address. */
912 DECL_REGISTER (parm
) = 1;
914 TREE_READONLY (parm
) = 1;
915 TREE_CHAIN (parm
) = last_function_parms
;
916 last_function_parms
= parm
;
919 if (flags
== DTOR_FLAG
)
922 tree const_integer_type
= build_type_variant (integer_type_node
, 1, 0);
923 int len
= sizeof (DESTRUCTOR_DECL_PREFIX
)-1;
925 arg_types
= hash_tree_chain (const_integer_type
, void_list_node
);
926 TREE_SIDE_EFFECTS (arg_types
) = 1;
927 /* Build the overload name. It will look like `7Example'. */
928 if (IDENTIFIER_TYPE_VALUE (cname
))
929 dbuf
= build_overload_name (IDENTIFIER_TYPE_VALUE (cname
), 1, 1);
930 else if (IDENTIFIER_LOCAL_VALUE (cname
))
931 dbuf
= build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname
)), 1, 1);
933 /* Using ctype fixes the `X::Y::~Y()' crash. The cname has no type when
934 it's defined out of the class definition, since poplevel_class wipes
935 it out. This used to be internal error 346. */
936 dbuf
= build_overload_name (ctype
, 1, 1);
937 buf
= (char *) alloca (strlen (dbuf
) + sizeof (DESTRUCTOR_DECL_PREFIX
));
938 bcopy (DESTRUCTOR_DECL_PREFIX
, buf
, len
);
941 DECL_ASSEMBLER_NAME (function
) = get_identifier (buf
);
942 parm
= build_decl (PARM_DECL
, in_charge_identifier
, const_integer_type
);
943 /* Mark the artificial `__in_chrg' parameter as "artificial". */
944 SET_DECL_ARTIFICIAL (parm
);
945 TREE_USED (parm
) = 1;
947 /* We don't need to mark the __in_chrg parameter itself as `const'
948 since its type is already `const int'. In fact we MUST NOT mark
949 it as `const' cuz that will screw up the debug info (causing it
950 to say that the type of __in_chrg is `const const int'). */
951 TREE_READONLY (parm
) = 1;
953 DECL_ARG_TYPE (parm
) = const_integer_type
;
954 /* This is the same chain as DECL_ARGUMENTS (...). */
955 TREE_CHAIN (last_function_parms
) = parm
;
957 TREE_TYPE (function
) = build_cplus_method_type (qualtype
, void_type_node
,
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
));
970 = build_cplus_method_type (qualtype
,
971 TREE_TYPE (TREE_TYPE (function
)),
973 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (function
));
976 these_arg_types
= arg_types
;
978 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
)
979 /* Only true for static member functions. */
980 these_arg_types
= hash_tree_chain (TYPE_POINTER_TO (qualtype
),
983 DECL_ASSEMBLER_NAME (function
)
984 = build_decl_overload (fn_name
, these_arg_types
,
985 1 + DECL_CONSTRUCTOR_P (function
));
988 /* This code is going into the compiler, but currently, it makes
989 libg++/src/Integer.cc not compile. The problem is that the nice name
990 winds up going into the symbol table, and conversion operations look
991 for the manged name. */
992 substitute_nice_name (function
);
996 DECL_ARGUMENTS (function
) = last_function_parms
;
997 /* First approximations. */
998 DECL_CONTEXT (function
) = ctype
;
999 DECL_CLASS_CONTEXT (function
) = ctype
;
1002 /* Work on the expr used by alignof (this is only called by the parser). */
1010 if (TREE_CODE (expr
) == COMPONENT_REF
1011 && DECL_BIT_FIELD (TREE_OPERAND (expr
, 1)))
1012 error ("`__alignof__' applied to a bit-field");
1014 if (TREE_CODE (expr
) == INDIRECT_REF
)
1016 best
= t
= TREE_OPERAND (expr
, 0);
1017 bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
1019 while (TREE_CODE (t
) == NOP_EXPR
1020 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
1023 t
= TREE_OPERAND (t
, 0);
1024 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
1025 if (thisalign
> bestalign
)
1026 best
= t
, bestalign
= thisalign
;
1028 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
1032 /* ANSI says arrays and fns are converted inside comma.
1033 But we can't convert them in build_compound_expr
1034 because that would break commas in lvalues.
1035 So do the conversion here if operand was a comma. */
1036 if (TREE_CODE (expr
) == COMPOUND_EXPR
1037 && (TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1038 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
))
1039 expr
= default_conversion (expr
);
1040 return c_alignof (TREE_TYPE (expr
));
1044 /* Create an ARRAY_REF, checking for the user doing things backwards
1047 grok_array_decl (array_expr
, index_exp
)
1048 tree array_expr
, index_exp
;
1050 tree type
= TREE_TYPE (array_expr
);
1051 tree p1
, p2
, i1
, i2
;
1053 if (type
== error_mark_node
|| index_exp
== error_mark_node
)
1054 return error_mark_node
;
1055 if (type
== NULL_TREE
)
1057 /* Something has gone very wrong. Assume we are mistakenly reducing
1058 an expression instead of a declaration. */
1059 error ("parser may be lost: is there a '{' missing somewhere?");
1063 if (TREE_CODE (type
) == OFFSET_TYPE
1064 || TREE_CODE (type
) == REFERENCE_TYPE
)
1065 type
= TREE_TYPE (type
);
1067 /* If they have an `operator[]', use that. */
1068 if (TYPE_LANG_SPECIFIC (type
)
1069 && TYPE_OVERLOADS_ARRAY_REF (type
))
1070 return build_opfncall (ARRAY_REF
, LOOKUP_NORMAL
,
1071 array_expr
, index_exp
, NULL_TREE
);
1073 /* Otherwise, create an ARRAY_REF for a pointer or array type. */
1075 if (TREE_CODE (type
) == ARRAY_TYPE
)
1078 p1
= build_expr_type_conversion (WANT_POINTER
, array_expr
, 0);
1080 if (TREE_CODE (TREE_TYPE (index_exp
)) == ARRAY_TYPE
)
1083 p2
= build_expr_type_conversion (WANT_POINTER
, index_exp
, 0);
1085 i1
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, array_expr
, 0);
1086 i2
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, index_exp
, 0);
1088 if ((p1
&& i2
) && (i1
&& p2
))
1089 error ("ambiguous conversion for array subscript");
1092 array_expr
= p1
, index_exp
= i2
;
1094 array_expr
= p2
, index_exp
= i1
;
1097 cp_error ("invalid types `%T[%T]' for array subscript",
1098 type
, TREE_TYPE (index_exp
));
1099 return error_mark_node
;
1102 if (array_expr
== error_mark_node
|| index_exp
== error_mark_node
)
1103 error ("ambiguous conversion for array subscript");
1105 return build_array_ref (array_expr
, index_exp
);
1108 /* Given the cast expression EXP, checking out its validity. Either return
1109 an error_mark_node if there was an unavoidable error, return a cast to
1110 void for trying to delete a pointer w/ the value 0, or return the
1111 call to delete. If DOING_VEC is 1, we handle things differently
1112 for doing an array delete. If DOING_VEC is 2, they gave us the
1113 array size as an argument to delete.
1114 Implements ARM $5.3.4. This is called from the parser. */
1116 delete_sanity (exp
, size
, doing_vec
, use_global_delete
)
1118 int doing_vec
, use_global_delete
;
1120 tree t
= stabilize_reference (convert_from_reference (exp
));
1121 tree type
= TREE_TYPE (t
);
1122 enum tree_code code
= TREE_CODE (type
);
1123 /* For a regular vector delete (aka, no size argument) we will pass
1124 this down as a NULL_TREE into build_vec_delete. */
1125 tree maxindex
= NULL_TREE
;
1126 /* This is used for deleting arrays. */
1132 maxindex
= build_binary_op (MINUS_EXPR
, size
, integer_one_node
, 1);
1133 if (! flag_traditional
)
1134 pedwarn ("anachronistic use of array size in vector delete");
1137 elt_size
= c_sizeof (type
);
1140 if (code
!= POINTER_TYPE
)
1142 cp_error ("type `%#T' argument given to `delete', expected pointer",
1144 return error_mark_node
;
1147 /* Deleting a pointer with the value zero is valid and has no effect. */
1148 if (integer_zerop (t
))
1149 return build1 (NOP_EXPR
, void_type_node
, t
);
1152 if (code
== POINTER_TYPE
)
1155 /* As of Valley Forge, you can delete a pointer to constant. */
1156 /* You can't delete a pointer to constant. */
1157 if (TREE_READONLY (TREE_TYPE (type
)))
1159 error ("`const *' cannot be deleted");
1160 return error_mark_node
;
1163 /* You also can't delete functions. */
1164 if (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
1166 error ("cannot delete a function");
1167 return error_mark_node
;
1172 /* If the type has no destructor, then we should build a regular
1173 delete, instead of a vector delete. Otherwise, we would end
1174 up passing a bogus offset into __builtin_delete, which is
1175 not expecting it. */
1177 && TREE_CODE (type
) == POINTER_TYPE
1178 && !TYPE_HAS_DESTRUCTOR (TREE_TYPE (type
)))
1181 use_global_delete
= 1;
1186 return build_vec_delete (t
, maxindex
, elt_size
, integer_one_node
,
1187 integer_two_node
, use_global_delete
);
1190 if (IS_AGGR_TYPE (TREE_TYPE (type
))
1191 && TYPE_GETS_REG_DELETE (TREE_TYPE (type
)))
1193 /* Only do access checking here; we'll be calling op delete
1194 from the destructor. */
1195 tree tmp
= build_opfncall (DELETE_EXPR
, LOOKUP_NORMAL
, t
,
1196 size_zero_node
, NULL_TREE
);
1197 if (tmp
== error_mark_node
)
1198 return error_mark_node
;
1201 return build_delete (type
, t
, integer_three_node
,
1202 LOOKUP_NORMAL
|LOOKUP_HAS_IN_CHARGE
,
1207 /* Sanity check: report error if this function FUNCTION is not
1208 really a member of the class (CTYPE) it is supposed to belong to.
1209 CNAME is the same here as it is for grokclassfn above. */
1212 check_classfn (ctype
, cname
, function
)
1213 tree ctype
, cname
, function
;
1215 tree fn_name
= DECL_NAME (function
);
1217 tree method_vec
= CLASSTYPE_METHOD_VEC (ctype
);
1221 if (method_vec
!= 0)
1223 methods
= &TREE_VEC_ELT (method_vec
, 0);
1224 end
= TREE_VEC_END (method_vec
);
1226 /* First suss out ctors and dtors. */
1228 && (fn_name
== cname
|| fn_name
== DECL_NAME (*methods
)))
1231 while (++methods
!= end
)
1233 if (fn_name
== DECL_NAME (*methods
))
1239 if (DECL_ASSEMBLER_NAME (function
) == DECL_ASSEMBLER_NAME (fndecl
))
1242 /* This should work, but causes libg++ to fail
1244 /* We have to do more extensive argument checking here, as
1245 the name may have been changed by asm("new_name"). */
1246 if (decls_match (function
, fndecl
))
1249 if (DECL_NAME (function
) == DECL_NAME (fndecl
))
1251 tree p1
= TYPE_ARG_TYPES (TREE_TYPE (function
));
1252 tree p2
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
1254 /* Get rid of the this parameter on functions that become
1256 if (DECL_STATIC_FUNCTION_P (fndecl
)
1257 && TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
1258 p1
= TREE_CHAIN (p1
);
1260 if (comptypes (TREE_TYPE (TREE_TYPE (function
)),
1261 TREE_TYPE (TREE_TYPE (fndecl
)), 1)
1262 && compparms (p1
, p2
, 3))
1266 fndecl
= DECL_CHAIN (fndecl
);
1274 cp_error ("argument list for `%#D' does not match any in class `%T'",
1279 cp_error ("no `%#D' member function declared in class `%T'",
1283 /* If we did not find the method in the class, add it to
1284 avoid spurious errors. */
1285 add_method (ctype
, methods
, function
);
1288 /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
1289 of a structure component, returning a FIELD_DECL node.
1290 QUALS is a list of type qualifiers for this decl (such as for declaring
1291 const member functions).
1293 This is done during the parsing of the struct declaration.
1294 The FIELD_DECL nodes are chained together and the lot of them
1295 are ultimately passed to `build_struct' to make the RECORD_TYPE node.
1299 If class A defines that certain functions in class B are friends, then
1300 the way I have set things up, it is B who is interested in permission
1301 granted by A. However, it is in A's context that these declarations
1302 are parsed. By returning a void_type_node, class A does not attempt
1303 to incorporate the declarations of the friends within its structure.
1305 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
1306 CHANGES TO CODE IN `start_method'. */
1309 grokfield (declarator
, declspecs
, raises
, init
, asmspec_tree
)
1310 tree declarator
, declspecs
, raises
, init
, asmspec_tree
;
1312 register tree value
;
1314 int flags
= LOOKUP_ONLYCONVERTING
;
1316 /* Convert () initializers to = initializers. */
1317 if (init
== NULL_TREE
&& declarator
!= NULL_TREE
1318 && TREE_CODE (declarator
) == CALL_EXPR
1319 && TREE_OPERAND (declarator
, 0)
1320 && (TREE_CODE (TREE_OPERAND (declarator
, 0)) == IDENTIFIER_NODE
1321 || TREE_CODE (TREE_OPERAND (declarator
, 0)) == SCOPE_REF
)
1322 && parmlist_is_exprlist (TREE_OPERAND (declarator
, 1)))
1324 init
= TREE_OPERAND (declarator
, 1);
1325 declarator
= TREE_OPERAND (declarator
, 0);
1330 && TREE_CODE (init
) == TREE_LIST
1331 && TREE_VALUE (init
) == error_mark_node
1332 && TREE_CHAIN (init
) == NULL_TREE
)
1335 value
= grokdeclarator (declarator
, declspecs
, FIELD
, init
!= 0, raises
);
1337 return value
; /* friend or constructor went bad. */
1339 /* Pass friendly classes back. */
1340 if (TREE_CODE (value
) == VOID_TYPE
)
1341 return void_type_node
;
1343 if (DECL_NAME (value
) != NULL_TREE
1344 && IDENTIFIER_POINTER (DECL_NAME (value
))[0] == '_'
1345 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value
)), "_vptr"))
1346 cp_error ("member `%D' conflicts with virtual function table field name", value
);
1348 /* Stash away type declarations. */
1349 if (TREE_CODE (value
) == TYPE_DECL
)
1351 DECL_NONLOCAL (value
) = 1;
1352 DECL_CONTEXT (value
) = current_class_type
;
1353 DECL_CLASS_CONTEXT (value
) = current_class_type
;
1354 CLASSTYPE_LOCAL_TYPEDECLS (current_class_type
) = 1;
1356 /* If we declare a typedef name for something that has no name,
1357 the typedef name is used for linkage. See 7.1.3 p4 94/0158. */
1358 if (TYPE_NAME (TREE_TYPE (value
))
1359 && TREE_CODE (TYPE_NAME (TREE_TYPE (value
))) == TYPE_DECL
1360 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_TYPE (value
))))
1362 TYPE_NAME (TREE_TYPE (value
)) = value
;
1363 TYPE_STUB_DECL (TREE_TYPE (value
)) = value
;
1366 pushdecl_class_level (value
);
1370 if (IS_SIGNATURE (current_class_type
)
1371 && TREE_CODE (value
) != FUNCTION_DECL
)
1373 error ("field declaration not allowed in signature");
1374 return void_type_node
;
1377 if (DECL_IN_AGGR_P (value
))
1379 cp_error ("`%D' is already defined in the class %T", value
,
1380 DECL_CONTEXT (value
));
1381 return void_type_node
;
1385 cadillac_start_decl (value
);
1388 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
1392 if (IS_SIGNATURE (current_class_type
)
1393 && TREE_CODE (value
) == FUNCTION_DECL
)
1395 error ("function declarations cannot have initializers in signature");
1398 else if (TREE_CODE (value
) == FUNCTION_DECL
)
1400 grok_function_init (value
, init
);
1403 else if (pedantic
&& TREE_CODE (value
) != VAR_DECL
)
1404 /* Already complained in grokdeclarator. */
1408 /* We allow initializers to become parameters to base
1410 if (TREE_CODE (init
) == TREE_LIST
)
1412 if (TREE_CHAIN (init
) == NULL_TREE
)
1413 init
= TREE_VALUE (init
);
1415 init
= digest_init (TREE_TYPE (value
), init
, (tree
*)0);
1418 if (TREE_CODE (init
) == CONST_DECL
)
1419 init
= DECL_INITIAL (init
);
1420 else if (TREE_READONLY_DECL_P (init
))
1421 init
= decl_constant_value (init
);
1422 else if (TREE_CODE (init
) == CONSTRUCTOR
)
1423 init
= digest_init (TREE_TYPE (value
), init
, (tree
*)0);
1424 my_friendly_assert (TREE_PERMANENT (init
), 192);
1425 if (init
== error_mark_node
)
1426 /* We must make this look different than `error_mark_node'
1427 because `decl_const_value' would mis-interpret it
1428 as only meaning that this VAR_DECL is defined. */
1429 init
= build1 (NOP_EXPR
, TREE_TYPE (value
), init
);
1430 else if (! TREE_CONSTANT (init
))
1432 /* We can allow references to things that are effectively
1433 static, since references are initialized with the address. */
1434 if (TREE_CODE (TREE_TYPE (value
)) != REFERENCE_TYPE
1435 || (TREE_STATIC (init
) == 0
1436 && (TREE_CODE_CLASS (TREE_CODE (init
)) != 'd'
1437 || DECL_EXTERNAL (init
) == 0)))
1439 error ("field initializer is not constant");
1440 init
= error_mark_node
;
1446 /* The corresponding pop_obstacks is in cp_finish_decl. */
1447 push_obstacks_nochange ();
1449 if (TREE_CODE (value
) == VAR_DECL
)
1451 /* We cannot call pushdecl here, because that would
1452 fill in the value of our TREE_CHAIN. Instead, we
1453 modify cp_finish_decl to do the right thing, namely, to
1454 put this decl out straight away. */
1455 if (TREE_PUBLIC (value
))
1457 /* current_class_type can be NULL_TREE in case of error. */
1458 if (asmspec
== 0 && current_class_type
)
1460 TREE_PUBLIC (value
) = 1;
1461 DECL_INITIAL (value
) = error_mark_node
;
1462 DECL_ASSEMBLER_NAME (value
)
1463 = build_static_name (current_class_type
, DECL_NAME (value
));
1465 pending_statics
= perm_tree_cons (NULL_TREE
, value
, pending_statics
);
1467 /* Static consts need not be initialized in the class definition. */
1468 if (init
!= NULL_TREE
&& TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (value
)))
1470 static int explanation
= 0;
1472 error ("initializer invalid for static member with constructor");
1473 if (explanation
++ == 0)
1474 error ("(you really want to initialize it separately)");
1477 /* Force the compiler to know when an uninitialized static
1478 const member is being used. */
1479 if (TYPE_READONLY (value
) && init
== 0)
1480 TREE_USED (value
) = 1;
1482 DECL_INITIAL (value
) = init
;
1483 DECL_IN_AGGR_P (value
) = 1;
1485 cp_finish_decl (value
, init
, asmspec_tree
, 1, flags
);
1486 pushdecl_class_level (value
);
1489 if (TREE_CODE (value
) == FIELD_DECL
)
1493 /* This must override the asm specifier which was placed
1494 by grokclassfn. Lay this out fresh. */
1495 DECL_RTL (value
) = NULL_RTX
;
1496 DECL_ASSEMBLER_NAME (value
) = get_identifier (asmspec
);
1498 if (DECL_INITIAL (value
) == error_mark_node
)
1499 init
= error_mark_node
;
1500 cp_finish_decl (value
, init
, asmspec_tree
, 1, flags
);
1501 DECL_INITIAL (value
) = init
;
1502 DECL_IN_AGGR_P (value
) = 1;
1505 if (TREE_CODE (value
) == FUNCTION_DECL
)
1507 if (DECL_CHAIN (value
) != NULL_TREE
)
1509 /* Need a fresh node here so that we don't get circularity
1510 when we link these together. */
1511 value
= copy_node (value
);
1512 /* When does this happen? */
1513 my_friendly_assert (init
== NULL_TREE
, 193);
1517 /* This must override the asm specifier which was placed
1518 by grokclassfn. Lay this out fresh. */
1519 DECL_RTL (value
) = NULL_RTX
;
1520 DECL_ASSEMBLER_NAME (value
) = get_identifier (asmspec
);
1522 cp_finish_decl (value
, init
, asmspec_tree
, 1, flags
);
1524 /* Pass friends back this way. */
1525 if (DECL_FRIEND_P (value
))
1526 return void_type_node
;
1528 #if 0 /* Just because a fn is declared doesn't mean we'll try to define it. */
1529 if (current_function_decl
&& ! IS_SIGNATURE (current_class_type
))
1530 cp_error ("method `%#D' of local class must be defined in class body",
1534 DECL_IN_AGGR_P (value
) = 1;
1537 my_friendly_abort (21);
1542 /* Like `grokfield', but for bitfields.
1543 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1546 grokbitfield (declarator
, declspecs
, width
)
1547 tree declarator
, declspecs
, width
;
1549 register tree value
= grokdeclarator (declarator
, declspecs
, BITFIELD
, 0, NULL_TREE
);
1551 if (! value
) return NULL_TREE
; /* friends went bad. */
1553 /* Pass friendly classes back. */
1554 if (TREE_CODE (value
) == VOID_TYPE
)
1555 return void_type_node
;
1557 if (TREE_CODE (value
) == TYPE_DECL
)
1559 cp_error ("cannot declare `%D' to be a bitfield type", value
);
1563 if (IS_SIGNATURE (current_class_type
))
1565 error ("field declaration not allowed in signature");
1566 return void_type_node
;
1569 if (DECL_IN_AGGR_P (value
))
1571 cp_error ("`%D' is already defined in the class %T", value
,
1572 DECL_CONTEXT (value
));
1573 return void_type_node
;
1576 GNU_xref_member (current_class_name
, value
);
1578 if (TREE_STATIC (value
))
1580 cp_error ("static member `%D' cannot be a bitfield", value
);
1583 cp_finish_decl (value
, NULL_TREE
, NULL_TREE
, 0, 0);
1585 if (width
!= error_mark_node
)
1587 /* detect invalid field size. */
1588 if (TREE_CODE (width
) == CONST_DECL
)
1589 width
= DECL_INITIAL (width
);
1590 else if (TREE_READONLY_DECL_P (width
))
1591 width
= decl_constant_value (width
);
1592 if (TREE_CODE (width
) != INTEGER_CST
)
1594 cp_error ("structure field `%D' width not an integer constant",
1596 DECL_INITIAL (value
) = NULL_TREE
;
1600 constant_expression_warning (width
);
1601 DECL_INITIAL (value
) = width
;
1602 DECL_BIT_FIELD (value
) = 1;
1606 DECL_IN_AGGR_P (value
) = 1;
1611 /* Like GROKFIELD, except that the declarator has been
1612 buried in DECLSPECS. Find the declarator, and
1613 return something that looks like it came from
1616 groktypefield (declspecs
, parmlist
)
1620 tree spec
= declspecs
;
1621 tree prev
= NULL_TREE
;
1623 tree type_id
= NULL_TREE
;
1624 tree quals
= NULL_TREE
;
1625 tree lengths
= NULL_TREE
;
1626 tree decl
= NULL_TREE
;
1630 register tree id
= TREE_VALUE (spec
);
1632 if (TREE_CODE (spec
) != TREE_LIST
)
1633 /* Certain parse errors slip through. For example,
1634 `int class ();' is not caught by the parser. Try
1635 weakly to recover here. */
1638 if (TREE_CODE (id
) == TYPE_DECL
1639 || (TREE_CODE (id
) == IDENTIFIER_NODE
&& TREE_TYPE (id
)))
1641 /* We have a constructor/destructor or
1642 conversion operator. Use it. */
1644 TREE_CHAIN (prev
) = TREE_CHAIN (spec
);
1646 declspecs
= TREE_CHAIN (spec
);
1652 spec
= TREE_CHAIN (spec
);
1655 /* Nope, we have a conversion operator to a scalar type or something
1656 else, that includes things like constructor declarations for
1661 tree id
= TREE_VALUE (spec
);
1663 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
1665 if (id
== ridpointers
[(int)RID_INT
]
1666 || id
== ridpointers
[(int)RID_DOUBLE
]
1667 || id
== ridpointers
[(int)RID_FLOAT
]
1668 || id
== ridpointers
[(int)RID_WCHAR
])
1671 error ("extra `%s' ignored",
1672 IDENTIFIER_POINTER (id
));
1676 else if (id
== ridpointers
[(int)RID_LONG
]
1677 || id
== ridpointers
[(int)RID_SHORT
]
1678 || id
== ridpointers
[(int)RID_CHAR
])
1680 lengths
= tree_cons (NULL_TREE
, id
, lengths
);
1682 else if (id
== ridpointers
[(int)RID_VOID
])
1685 error ("spurious `void' type ignored");
1687 error ("conversion to `void' type invalid");
1689 else if (id
== ridpointers
[(int)RID_AUTO
]
1690 || id
== ridpointers
[(int)RID_REGISTER
]
1691 || id
== ridpointers
[(int)RID_TYPEDEF
]
1692 || id
== ridpointers
[(int)RID_CONST
]
1693 || id
== ridpointers
[(int)RID_VOLATILE
])
1695 error ("type specifier `%s' used invalidly",
1696 IDENTIFIER_POINTER (id
));
1698 else if (id
== ridpointers
[(int)RID_FRIEND
]
1699 || id
== ridpointers
[(int)RID_VIRTUAL
]
1700 || id
== ridpointers
[(int)RID_INLINE
]
1701 || id
== ridpointers
[(int)RID_UNSIGNED
]
1702 || id
== ridpointers
[(int)RID_SIGNED
]
1703 || id
== ridpointers
[(int)RID_STATIC
]
1704 || id
== ridpointers
[(int)RID_EXTERN
])
1706 quals
= tree_cons (NULL_TREE
, id
, quals
);
1710 /* Happens when we have a global typedef
1711 and a class-local member function with
1717 else if (TREE_CODE (id
) == RECORD_TYPE
)
1719 type_id
= TYPE_NAME (id
);
1720 if (TREE_CODE (type_id
) == TYPE_DECL
)
1721 type_id
= DECL_NAME (type_id
);
1722 if (type_id
== NULL_TREE
)
1723 error ("identifier for aggregate type conversion omitted");
1725 else if (TREE_CODE_CLASS (TREE_CODE (id
)) == 't')
1726 error ("`operator' missing on conversion operator or tag missing from type");
1728 my_friendly_abort (194);
1729 spec
= TREE_CHAIN (spec
);
1733 declspecs
= chainon (lengths
, quals
);
1736 if (TREE_CHAIN (lengths
))
1737 error ("multiple length specifiers");
1738 type_id
= ridpointers
[(int)RID_INT
];
1739 declspecs
= chainon (lengths
, quals
);
1743 error ("no type given, defaulting to `operator int ...'");
1744 type_id
= ridpointers
[(int)RID_INT
];
1751 decl
= grokdeclarator (build_parse_node (CALL_EXPR
, type_id
, parmlist
, NULL_TREE
),
1752 declspecs
, FIELD
, 0, NULL_TREE
);
1753 if (decl
== NULL_TREE
)
1756 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_CHAIN (decl
) != NULL_TREE
)
1758 /* Need a fresh node here so that we don't get circularity
1759 when we link these together. */
1760 decl
= copy_node (decl
);
1763 if (decl
== void_type_node
1764 || (TREE_CODE (decl
) == FUNCTION_DECL
1765 && TREE_CODE (TREE_TYPE (decl
)) != METHOD_TYPE
))
1766 /* bunch of friends. */
1769 if (DECL_IN_AGGR_P (decl
))
1771 cp_error ("`%D' already defined in the class ", decl
);
1772 return void_type_node
;
1775 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0, 0);
1777 /* If this declaration is common to another declaration
1778 complain about such redundancy, and return NULL_TREE
1779 so that we don't build a circular list. */
1780 if (DECL_CHAIN (decl
))
1782 cp_error ("function `%D' declared twice in class %T", decl
,
1783 DECL_CONTEXT (decl
));
1786 DECL_IN_AGGR_P (decl
) = 1;
1792 grokoptypename (declspecs
, declarator
)
1793 tree declspecs
, declarator
;
1795 tree t
= grokdeclarator (declarator
, declspecs
, TYPENAME
, 0, NULL_TREE
);
1796 return build_typename_overload (t
);
1799 /* When a function is declared with an initializer,
1800 do the right thing. Currently, there are two possibilities:
1805 // initialization possibility #1.
1806 virtual void f () = 0;
1828 // initialization possibility #2
1835 copy_assignment_arg_p (parmtype
, virtualp
)
1839 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
)
1840 parmtype
= TREE_TYPE (parmtype
);
1842 if ((TYPE_MAIN_VARIANT (parmtype
) == current_class_type
)
1843 || (virtualp
&& DERIVED_FROM_P (parmtype
, current_class_type
)))
1850 grok_function_init (decl
, init
)
1854 /* An initializer for a function tells how this function should
1856 tree type
= TREE_TYPE (decl
);
1858 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1859 cp_error ("initializer specified for non-member function `%D'", decl
);
1860 else if (DECL_VINDEX (decl
) == NULL_TREE
)
1861 cp_error ("initializer specified for non-virtual method `%D'", decl
);
1862 else if (integer_zerop (init
))
1865 /* Mark this function as being "defined". */
1866 DECL_INITIAL (decl
) = error_mark_node
;
1867 /* pure virtual destructors must be defined. */
1868 /* pure virtual needs to be defined (as abort) only when put in
1869 vtbl. For wellformed call, it should be itself. pr4737 */
1870 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl
)))
1872 extern tree abort_fndecl
;
1873 /* Give this node rtl from `abort'. */
1874 DECL_RTL (decl
) = DECL_RTL (abort_fndecl
);
1877 DECL_ABSTRACT_VIRTUAL_P (decl
) = 1;
1878 if (DECL_NAME (decl
) == ansi_opname
[(int) MODIFY_EXPR
])
1881 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
))));
1883 if (copy_assignment_arg_p (parmtype
, 1))
1884 TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type
) = 1;
1887 else if (TREE_CODE (init
) == OFFSET_REF
1888 && TREE_OPERAND (init
, 0) == NULL_TREE
1889 && TREE_CODE (TREE_TYPE (init
)) == METHOD_TYPE
)
1891 tree basetype
= DECL_CLASS_CONTEXT (init
);
1892 tree basefn
= TREE_OPERAND (init
, 1);
1893 if (TREE_CODE (basefn
) != FUNCTION_DECL
)
1894 cp_error ("non-method initializer invalid for method `%D'", decl
);
1895 else if (! BINFO_OFFSET_ZEROP (TYPE_BINFO (DECL_CLASS_CONTEXT (basefn
))))
1896 sorry ("base member function from other than first base class");
1899 tree binfo
= get_binfo (basetype
, TYPE_METHOD_BASETYPE (type
), 1);
1900 if (binfo
== error_mark_node
)
1902 else if (binfo
== 0)
1903 error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (init
)),
1904 TYPE_METHOD_BASETYPE (type
));
1907 /* Mark this function as being defined,
1908 and give it new rtl. */
1909 DECL_INITIAL (decl
) = error_mark_node
;
1910 DECL_RTL (decl
) = DECL_RTL (basefn
);
1915 cp_error ("invalid initializer for virtual method `%D'", decl
);
1918 /* When we get a declaration of the form
1920 type cname::fname ...
1922 the node for `cname::fname' gets built here in a special way.
1923 Namely, we push into `cname's scope. When this declaration is
1924 processed, we pop back out. */
1926 build_push_scope (cname
, name
)
1930 extern int current_class_depth
;
1934 if (cname
== error_mark_node
)
1935 return error_mark_node
;
1937 ctype
= IDENTIFIER_TYPE_VALUE (cname
);
1939 if (TREE_CODE (ctype
) == TEMPLATE_TYPE_PARM
)
1941 else if (ctype
== NULL_TREE
|| ! IS_AGGR_TYPE (ctype
))
1943 cp_error ("`%T' not defined as aggregate type", cname
);
1946 else if (IS_SIGNATURE (ctype
))
1948 error ("cannot push into signature scope, scope resolution operator ignored");
1952 rval
= build_parse_node (SCOPE_REF
, cname
, name
);
1954 /* Don't need to push the scope if we're already in it.
1955 We also don't need to push the scope for a ptr-to-member/method. */
1957 if (ctype
== current_class_type
|| TREE_CODE (name
) != IDENTIFIER_NODE
1961 /* We do need to push the scope in this case, since CTYPE helps
1962 determine subsequent initializers (i.e., Foo::Bar x = foo_enum_1;). */
1964 push_nested_class (ctype
, 3);
1965 TREE_COMPLEXITY (rval
) = current_class_depth
;
1970 cplus_decl_attributes (decl
, attributes
, prefix_attributes
)
1971 tree decl
, attributes
, prefix_attributes
;
1973 if (decl
== NULL_TREE
|| decl
== void_type_node
)
1976 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
1977 decl
= DECL_TEMPLATE_RESULT (decl
);
1979 decl_attributes (decl
, attributes
, prefix_attributes
);
1981 if (TREE_CODE (decl
) == TYPE_DECL
)
1982 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (decl
), TREE_TYPE (decl
));
1985 /* CONSTRUCTOR_NAME:
1986 Return the name for the constructor (or destructor) for the
1987 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
1988 IDENTIFIER_NODE. When given a template, this routine doesn't
1989 lose the specialization. */
1991 constructor_name_full (thing
)
1994 if (TREE_CODE (thing
) == UNINSTANTIATED_P_TYPE
)
1995 return DECL_NAME (UPT_TEMPLATE (thing
));
1996 if (IS_AGGR_TYPE_CODE (TREE_CODE (thing
)))
1998 if (TYPE_WAS_ANONYMOUS (thing
) && TYPE_HAS_CONSTRUCTOR (thing
))
1999 thing
= DECL_NAME (TREE_VEC_ELT (TYPE_METHODS (thing
), 0));
2001 thing
= TYPE_NAME (thing
);
2003 if (TREE_CODE (thing
) == TYPE_DECL
2004 || (TREE_CODE (thing
) == TEMPLATE_DECL
2005 && DECL_TEMPLATE_IS_CLASS (thing
)))
2006 thing
= DECL_NAME (thing
);
2007 my_friendly_assert (TREE_CODE (thing
) == IDENTIFIER_NODE
, 197);
2011 /* CONSTRUCTOR_NAME:
2012 Return the name for the constructor (or destructor) for the
2013 specified class. Argument can be RECORD_TYPE, TYPE_DECL, or
2014 IDENTIFIER_NODE. When given a template, return the plain
2015 unspecialized name. */
2017 constructor_name (thing
)
2021 thing
= constructor_name_full (thing
);
2022 t
= IDENTIFIER_TEMPLATE (thing
);
2025 t
= TREE_PURPOSE (t
);
2026 return DECL_NAME (t
);
2029 /* Cache the value of this class's main virtual function table pointer
2030 in a register variable. This will save one indirection if a
2031 more than one virtual function call is made this function. */
2035 extern rtx base_init_expr
;
2037 if (base_init_expr
== 0
2038 && DECL_CONSTRUCTOR_P (current_function_decl
))
2039 emit_base_init (current_class_type
, 0);
2042 /* Record the existence of an addressable inline function. */
2044 mark_inline_for_output (decl
)
2047 decl
= DECL_MAIN_VARIANT (decl
);
2048 if (DECL_SAVED_INLINE (decl
))
2050 my_friendly_assert (TREE_PERMANENT (decl
), 363);
2051 DECL_SAVED_INLINE (decl
) = 1;
2053 if (DECL_PENDING_INLINE_INFO (decl
) != 0
2054 && ! DECL_PENDING_INLINE_INFO (decl
)->deja_vu
)
2056 struct pending_inline
*t
= pending_inlines
;
2057 my_friendly_assert (DECL_SAVED_INSNS (decl
) == 0, 198);
2060 if (t
== DECL_PENDING_INLINE_INFO (decl
))
2066 t
= DECL_PENDING_INLINE_INFO (decl
);
2067 t
->next
= pending_inlines
;
2068 pending_inlines
= t
;
2070 DECL_PENDING_INLINE_INFO (decl
) = 0;
2073 saved_inlines
= perm_tree_cons (NULL_TREE
, decl
, saved_inlines
);
2079 temp_name_counter
= 0;
2082 /* Hand off a unique name which can be used for variable we don't really
2083 want to know about anyway, for example, the anonymous variables which
2084 are needed to make references work. Declare this thing so we can use it.
2085 The variable created will be of type TYPE.
2087 STATICP is nonzero if this variable should be static. */
2090 get_temp_name (type
, staticp
)
2094 char buf
[sizeof (AUTO_TEMP_FORMAT
) + 20];
2096 int toplev
= toplevel_bindings_p ();
2098 push_obstacks_nochange ();
2099 if (toplev
|| staticp
)
2101 end_temporary_allocation ();
2102 sprintf (buf
, AUTO_TEMP_FORMAT
, global_temp_name_counter
++);
2103 decl
= pushdecl_top_level (build_decl (VAR_DECL
, get_identifier (buf
), type
));
2107 sprintf (buf
, AUTO_TEMP_FORMAT
, temp_name_counter
++);
2108 decl
= pushdecl (build_decl (VAR_DECL
, get_identifier (buf
), type
));
2110 TREE_USED (decl
) = 1;
2111 TREE_STATIC (decl
) = staticp
;
2113 /* If this is a local variable, then lay out its rtl now.
2114 Otherwise, callers of this function are responsible for dealing
2115 with this variable's rtl. */
2119 expand_decl_init (decl
);
2126 /* Get a variable which we can use for multiple assignments.
2127 It is not entered into current_binding_level, because
2128 that breaks things when it comes time to do final cleanups
2129 (which take place "outside" the binding contour of the function). */
2131 get_temp_regvar (type
, init
)
2134 static char buf
[sizeof (AUTO_TEMP_FORMAT
) + 20] = { '_' };
2137 sprintf (buf
+1, AUTO_TEMP_FORMAT
, temp_name_counter
++);
2138 decl
= build_decl (VAR_DECL
, get_identifier (buf
), type
);
2139 TREE_USED (decl
) = 1;
2140 DECL_REGISTER (decl
) = 1;
2143 store_init_value (decl
, init
);
2145 /* We can expand these without fear, since they cannot need
2146 constructors or destructors. */
2148 expand_decl_init (decl
);
2150 if (type_needs_gc_entry (type
))
2151 DECL_GC_OFFSET (decl
) = size_int (++current_function_obstack_index
);
2156 /* Make the macro TEMP_NAME_P available to units which do not
2157 include c-tree.h. */
2162 return TEMP_NAME_P (decl
);
2165 /* Finish off the processing of a UNION_TYPE structure.
2166 If there are static members, then all members are
2167 static, and must be laid out together. If the
2168 union is an anonymous union, we arrange for that
2169 as well. PUBLIC_P is nonzero if this union is
2170 not declared static. */
2172 finish_anon_union (anon_union_decl
)
2173 tree anon_union_decl
;
2175 tree type
= TREE_TYPE (anon_union_decl
);
2176 tree field
, main_decl
= NULL_TREE
;
2177 tree elems
= NULL_TREE
;
2178 int public_p
= TREE_PUBLIC (anon_union_decl
);
2179 int static_p
= TREE_STATIC (anon_union_decl
);
2180 int external_p
= DECL_EXTERNAL (anon_union_decl
);
2182 if ((field
= TYPE_FIELDS (type
)) == NULL_TREE
)
2187 error ("global anonymous unions must be declared static");
2191 for (; field
; field
= TREE_CHAIN (field
))
2194 if (TREE_CODE (field
) != FIELD_DECL
)
2197 decl
= build_decl (VAR_DECL
, DECL_NAME (field
), TREE_TYPE (field
));
2198 /* tell `pushdecl' that this is not tentative. */
2199 DECL_INITIAL (decl
) = error_mark_node
;
2200 TREE_PUBLIC (decl
) = public_p
;
2201 TREE_STATIC (decl
) = static_p
;
2202 DECL_EXTERNAL (decl
) = external_p
;
2203 decl
= pushdecl (decl
);
2205 /* Only write out one anon union element--choose the one that
2206 can hold them all. */
2207 if (main_decl
== NULL_TREE
2208 && 1 == simple_cst_equal (DECL_SIZE (decl
),
2209 DECL_SIZE (anon_union_decl
)))
2215 /* ??? This causes there to be no debug info written out
2217 TREE_ASM_WRITTEN (decl
) = 1;
2220 DECL_INITIAL (decl
) = NULL_TREE
;
2221 /* If there's a cleanup to do, it belongs in the
2222 TREE_PURPOSE of the following TREE_LIST. */
2223 elems
= tree_cons (NULL_TREE
, decl
, elems
);
2224 TREE_TYPE (elems
) = type
;
2230 make_decl_rtl (main_decl
, 0, toplevel_bindings_p ());
2231 DECL_RTL (anon_union_decl
) = DECL_RTL (main_decl
);
2235 warning ("anonymous union with no members");
2240 /* The following call assumes that there are never any cleanups
2241 for anonymous unions--a reasonable assumption. */
2242 expand_anon_union_decl (anon_union_decl
, NULL_TREE
, elems
);
2245 cadillac_finish_anon_union (anon_union_decl
);
2248 /* Finish and output a table which is generated by the compiler.
2249 NAME is the name to give the table.
2250 TYPE is the type of the table entry.
2251 INIT is all the elements in the table.
2252 PUBLICP is non-zero if this table should be given external access. */
2254 finish_table (name
, type
, init
, publicp
)
2255 tree name
, type
, init
;
2258 tree itype
, atype
, decl
;
2259 static tree empty_table
;
2263 itype
= build_index_type (size_int (list_length (init
) - 1));
2264 atype
= build_cplus_array_type (type
, itype
);
2265 layout_type (atype
);
2267 if (TREE_VALUE (init
) == integer_zero_node
2268 && TREE_CHAIN (init
) == NULL_TREE
)
2271 if (empty_table
== NULL_TREE
)
2274 empty_table
= get_temp_name (atype
, 1);
2275 init
= build (CONSTRUCTOR
, atype
, NULL_TREE
, init
);
2276 TREE_CONSTANT (init
) = 1;
2277 TREE_STATIC (init
) = 1;
2278 DECL_INITIAL (empty_table
) = init
;
2279 asmspec
= build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table
)),
2280 IDENTIFIER_POINTER (DECL_NAME (empty_table
)));
2281 cp_finish_decl (empty_table
, NULL_TREE
, asmspec
, 0, 0);
2286 if (name
== NULL_TREE
)
2290 decl
= get_temp_name (atype
, 1);
2294 decl
= build_decl (VAR_DECL
, name
, atype
);
2295 decl
= pushdecl (decl
);
2296 TREE_STATIC (decl
) = 1;
2301 TREE_PUBLIC (decl
) = publicp
;
2302 init
= build (CONSTRUCTOR
, atype
, NULL_TREE
, init
);
2303 TREE_CONSTANT (init
) = 1;
2304 TREE_STATIC (init
) = 1;
2305 DECL_INITIAL (decl
) = init
;
2306 asmspec
= build_string (IDENTIFIER_LENGTH (DECL_NAME (decl
)),
2307 IDENTIFIER_POINTER (DECL_NAME (decl
)));
2311 /* This will cause DECL to point to EMPTY_TABLE in rtl-land. */
2312 DECL_EXTERNAL (decl
) = 1;
2313 TREE_STATIC (decl
) = 0;
2315 asmspec
= build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table
)),
2316 IDENTIFIER_POINTER (DECL_NAME (empty_table
)));
2319 cp_finish_decl (decl
, NULL_TREE
, asmspec
, 0, 0);
2323 /* Finish processing a builtin type TYPE. It's name is NAME,
2324 its fields are in the array FIELDS. LEN is the number of elements
2325 in FIELDS minus one, or put another way, it is the maximum subscript
2328 It is given the same alignment as ALIGN_TYPE. */
2330 finish_builtin_type (type
, name
, fields
, len
, align_type
)
2339 TYPE_FIELDS (type
) = fields
[0];
2340 for (i
= 0; i
< len
; i
++)
2342 layout_type (TREE_TYPE (fields
[i
]));
2343 DECL_FIELD_CONTEXT (fields
[i
]) = type
;
2344 TREE_CHAIN (fields
[i
]) = fields
[i
+1];
2346 DECL_FIELD_CONTEXT (fields
[i
]) = type
;
2347 DECL_CLASS_CONTEXT (fields
[i
]) = type
;
2348 TYPE_ALIGN (type
) = TYPE_ALIGN (align_type
);
2350 #if 0 /* not yet, should get fixed properly later */
2351 TYPE_NAME (type
) = make_type_decl (get_identifier (name
), type
);
2353 TYPE_NAME (type
) = build_decl (TYPE_DECL
, get_identifier (name
), type
);
2355 layout_decl (TYPE_NAME (type
), 0);
2358 /* Auxiliary functions to make type signatures for
2359 `operator new' and `operator delete' correspond to
2360 what compiler will be expecting. */
2362 extern tree sizetype
;
2365 coerce_new_type (type
)
2370 if (TREE_CODE (type
) == METHOD_TYPE
)
2371 type
= build_function_type (TREE_TYPE (type
), TREE_CHAIN (TYPE_ARG_TYPES (type
)));
2372 if (TREE_TYPE (type
) != ptr_type_node
)
2373 e1
= 1, error ("`operator new' must return type `void *'");
2375 /* Technically the type must be `size_t', but we may not know
2377 if (TYPE_ARG_TYPES (type
) == NULL_TREE
)
2378 e1
= 1, error ("`operator new' takes type `size_t' parameter");
2379 else if (TREE_CODE (TREE_VALUE (TYPE_ARG_TYPES (type
))) != INTEGER_TYPE
2380 || TYPE_PRECISION (TREE_VALUE (TYPE_ARG_TYPES (type
))) != TYPE_PRECISION (sizetype
))
2381 e2
= 1, error ("`operator new' takes type `size_t' as first parameter");
2383 type
= build_function_type (ptr_type_node
, tree_cons (NULL_TREE
, sizetype
, TREE_CHAIN (TYPE_ARG_TYPES (type
))));
2385 type
= build_function_type (ptr_type_node
, TYPE_ARG_TYPES (type
));
2390 coerce_delete_type (type
)
2393 int e1
= 0, e2
= 0, e3
= 0;
2394 tree arg_types
= TYPE_ARG_TYPES (type
);
2396 if (TREE_CODE (type
) == METHOD_TYPE
)
2398 type
= build_function_type (TREE_TYPE (type
), TREE_CHAIN (arg_types
));
2399 arg_types
= TREE_CHAIN (arg_types
);
2401 if (TREE_TYPE (type
) != void_type_node
)
2402 e1
= 1, error ("`operator delete' must return type `void'");
2403 if (arg_types
== NULL_TREE
2404 || TREE_VALUE (arg_types
) != ptr_type_node
)
2405 e2
= 1, error ("`operator delete' takes type `void *' as first parameter");
2408 && TREE_CHAIN (arg_types
)
2409 && TREE_CHAIN (arg_types
) != void_list_node
)
2411 /* Again, technically this argument must be `size_t', but again
2412 we may not know what that is. */
2413 tree t2
= TREE_VALUE (TREE_CHAIN (arg_types
));
2414 if (TREE_CODE (t2
) != INTEGER_TYPE
2415 || TYPE_PRECISION (t2
) != TYPE_PRECISION (sizetype
))
2416 e3
= 1, error ("second argument to `operator delete' must be of type `size_t'");
2417 else if (TREE_CHAIN (TREE_CHAIN (arg_types
)) != void_list_node
)
2420 if (TREE_CHAIN (TREE_CHAIN (arg_types
)))
2421 error ("too many arguments in declaration of `operator delete'");
2423 error ("`...' invalid in specification of `operator delete'");
2427 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, build_tree_list (NULL_TREE
, sizetype
));
2430 if (arg_types
== NULL_TREE
)
2431 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
2433 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, TREE_CHAIN (arg_types
));
2438 type
= build_function_type (void_type_node
, arg_types
);
2444 mark_vtable_entries (decl
)
2447 tree entries
= TREE_CHAIN (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)));
2449 for (; entries
; entries
= TREE_CHAIN (entries
))
2451 tree fnaddr
= FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (entries
));
2452 tree fn
= TREE_OPERAND (fnaddr
, 0);
2453 TREE_ADDRESSABLE (fn
) = 1;
2454 if (DECL_ABSTRACT_VIRTUAL_P (fn
))
2456 extern tree abort_fndecl
;
2457 if (flag_vtable_thunks
)
2458 fnaddr
= TREE_VALUE (entries
);
2459 TREE_OPERAND (fnaddr
, 0) = fn
= abort_fndecl
;
2461 assemble_external (fn
);
2465 /* Set TREE_PUBLIC and/or DECL_EXTERN on the vtable DECL,
2466 based on TYPE and other static flags.
2468 Note that anything public is tagged TREE_PUBLIC, whether
2469 it's public in this file or in another one. */
2472 import_export_vtable (decl
, type
, final
)
2476 if (DECL_INTERFACE_KNOWN (decl
))
2480 if (write_virtuals
< 2 && write_virtuals
!= 0)
2482 TREE_PUBLIC (decl
) = 1;
2483 if (write_virtuals
< 0)
2484 DECL_EXTERNAL (decl
) = 1;
2485 DECL_INTERFACE_KNOWN (decl
) = 1;
2487 else if (CLASSTYPE_INTERFACE_KNOWN (type
))
2489 TREE_PUBLIC (decl
) = 1;
2490 DECL_EXTERNAL (decl
) = ! CLASSTYPE_VTABLE_NEEDS_WRITING (type
);
2491 DECL_INTERFACE_KNOWN (decl
) = 1;
2495 /* We can only wait to decide if we have real non-inline virtual
2496 functions in our class, or if we come from a template. */
2498 int found
= CLASSTYPE_TEMPLATE_INSTANTIATION (type
);
2500 if (! found
&& ! final
)
2503 for (method
= CLASSTYPE_METHODS (type
); method
!= NULL_TREE
;
2504 method
= DECL_NEXT_METHOD (method
))
2505 if (DECL_VINDEX (method
) != NULL_TREE
2506 && ! DECL_THIS_INLINE (method
)
2507 && ! DECL_ABSTRACT_VIRTUAL_P (method
))
2514 if (final
|| ! found
)
2516 #ifdef ASSEMBLE_EXTERNAL
2517 if (TREE_PUBLIC (decl
))
2518 cp_error ("all virtual functions redeclared inline");
2521 DECL_WEAK (decl
) = 1;
2523 TREE_PUBLIC (decl
) = 0;
2524 DECL_EXTERNAL (decl
) = 0;
2528 TREE_PUBLIC (decl
) = 1;
2529 DECL_EXTERNAL (decl
) = 1;
2535 import_export_template (type
)
2538 if (CLASSTYPE_IMPLICIT_INSTANTIATION (type
)
2539 && ! flag_implicit_templates
2540 && CLASSTYPE_INTERFACE_UNKNOWN (type
))
2542 SET_CLASSTYPE_INTERFACE_KNOWN (type
);
2543 CLASSTYPE_INTERFACE_ONLY (type
) = 1;
2544 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 0;
2549 finish_prevtable_vardecl (prev
, vars
)
2552 tree ctype
= DECL_CONTEXT (vars
);
2553 import_export_template (ctype
);
2555 if (CLASSTYPE_INTERFACE_UNKNOWN (ctype
) && TYPE_VIRTUAL_P (ctype
)
2556 && ! CLASSTYPE_TEMPLATE_INSTANTIATION (ctype
))
2559 for (method
= CLASSTYPE_METHODS (ctype
); method
!= NULL_TREE
;
2560 method
= DECL_NEXT_METHOD (method
))
2562 if (DECL_VINDEX (method
) != NULL_TREE
2563 && !DECL_THIS_INLINE (method
)
2564 && !DECL_ABSTRACT_VIRTUAL_P (method
))
2566 SET_CLASSTYPE_INTERFACE_KNOWN (ctype
);
2567 CLASSTYPE_VTABLE_NEEDS_WRITING (ctype
) = ! DECL_EXTERNAL (method
);
2568 CLASSTYPE_INTERFACE_ONLY (ctype
) = DECL_EXTERNAL (method
);
2574 import_export_vtable (vars
, ctype
, 1);
2576 /* We cannot use TREE_USED here, as it may be set by the expanding of a
2577 ctor that is used to build a global object. The long term plan is to
2578 make the TD entries statically initialized and move this to
2579 finish_vtable_vardecl time. */
2580 if (flag_rtti
&& write_virtuals
>= 0
2581 && ! DECL_EXTERNAL (vars
) && (TREE_PUBLIC (vars
) || 1 || TREE_USED (vars
)))
2583 /* Kick out the type descriptor before we dump out global
2584 initializers, as they are initialized at run time and
2585 we have to find them when we scan for things that need initialized
2586 at the top level. */
2587 build_t_desc (ctype
, 1);
2592 finish_vtable_vardecl (prev
, vars
)
2595 if (write_virtuals
>= 0
2596 && ! DECL_EXTERNAL (vars
) && (TREE_PUBLIC (vars
) || TREE_USED (vars
)))
2599 /* The long term plan it to make the TD entries statically initialized,
2600 have the entries built and emitted here. When that happens, this
2601 can be enabled, and the other call to build_t_desc removed. */
2602 /* Kick out the type descriptor before writing out the vtable. */
2604 build_t_desc (DECL_CONTEXT (vars
), 1);
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);
2642 else if (! TREE_USED (vars
))
2643 /* We don't know what to do with this one yet. */
2646 /* We know that PREV must be non-zero here. */
2647 TREE_CHAIN (prev
) = TREE_CHAIN (vars
);
2651 prune_vtable_vardecl (prev
, vars
)
2654 /* We know that PREV must be non-zero here. */
2655 TREE_CHAIN (prev
) = TREE_CHAIN (vars
);
2659 walk_vtables (typedecl_fn
, vardecl_fn
)
2660 register void (*typedecl_fn
)();
2661 register void (*vardecl_fn
)();
2665 for (prev
= 0, vars
= getdecls (); vars
; vars
= TREE_CHAIN (vars
))
2667 register tree type
= TREE_TYPE (vars
);
2669 if (TREE_CODE (vars
) == VAR_DECL
&& DECL_VIRTUAL_P (vars
))
2671 if (vardecl_fn
) (*vardecl_fn
) (prev
, vars
);
2673 if (prev
&& TREE_CHAIN (prev
) != vars
)
2676 else if (TREE_CODE (vars
) == TYPE_DECL
2677 && type
!= error_mark_node
2678 && TYPE_LANG_SPECIFIC (type
)
2679 && CLASSTYPE_VSIZE (type
))
2681 if (typedecl_fn
) (*typedecl_fn
) (prev
, vars
);
2689 finish_sigtable_vardecl (prev
, vars
)
2692 /* We don't need to mark sigtable entries as addressable here as is done
2693 for vtables. Since sigtables, unlike vtables, are always written out,
2694 that was already done in build_signature_table_constructor. */
2696 rest_of_decl_compilation (vars
, NULL_PTR
, 1, 1);
2698 /* We know that PREV must be non-zero here. */
2699 TREE_CHAIN (prev
) = TREE_CHAIN (vars
);
2703 walk_sigtables (typedecl_fn
, vardecl_fn
)
2704 register void (*typedecl_fn
)();
2705 register void (*vardecl_fn
)();
2709 for (prev
= 0, vars
= getdecls (); vars
; vars
= TREE_CHAIN (vars
))
2711 register tree type
= TREE_TYPE (vars
);
2713 if (TREE_CODE (vars
) == TYPE_DECL
2714 && type
!= error_mark_node
2715 && IS_SIGNATURE (type
))
2717 if (typedecl_fn
) (*typedecl_fn
) (prev
, vars
);
2719 else if (TREE_CODE (vars
) == VAR_DECL
2720 && TREE_TYPE (vars
) != error_mark_node
2721 && IS_SIGNATURE (TREE_TYPE (vars
)))
2723 if (vardecl_fn
) (*vardecl_fn
) (prev
, vars
);
2730 /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an
2731 inline function at end-of-file. */
2734 import_export_inline (decl
)
2737 if (DECL_INTERFACE_KNOWN (decl
))
2740 if (DECL_TEMPLATE_INSTANTIATION (decl
))
2742 if (DECL_IMPLICIT_INSTANTIATION (decl
) && flag_implicit_templates
)
2745 DECL_WEAK (decl
) = 1;
2747 TREE_PUBLIC (decl
) = 0;
2750 DECL_NOT_REALLY_EXTERN (decl
) = 0;
2752 else if (DECL_FUNCTION_MEMBER_P (decl
))
2754 tree ctype
= DECL_CLASS_CONTEXT (decl
);
2755 if (CLASSTYPE_INTERFACE_KNOWN (ctype
))
2757 DECL_NOT_REALLY_EXTERN (decl
)
2758 = ! (CLASSTYPE_INTERFACE_ONLY (ctype
)
2759 || (DECL_THIS_INLINE (decl
) && ! flag_implement_inlines
));
2761 else if (SUPPORTS_WEAK
)
2762 DECL_WEAK (decl
) = 1;
2764 TREE_PUBLIC (decl
) = 0;
2766 else if (DECL_C_STATIC (decl
))
2767 TREE_PUBLIC (decl
) = 0;
2768 else if (SUPPORTS_WEAK
)
2769 DECL_WEAK (decl
) = 1;
2771 TREE_PUBLIC (decl
) = 0;
2773 DECL_INTERFACE_KNOWN (decl
) = 1;
2776 extern int parse_time
, varconst_time
;
2778 #define TIMEVAR(VAR, BODY) \
2779 do { int otime = get_run_time (); BODY; VAR += get_run_time () - otime; } while (0)
2781 /* This routine is called from the last rule in yyparse ().
2782 Its job is to create all the code needed to initialize and
2783 destroy the global aggregates. We do the destruction
2784 first, since that way we only need to reverse the decls once. */
2790 int start_time
, this_time
;
2794 int needs_cleaning
= 0, needs_messing_up
= 0;
2796 if (flag_detailed_statistics
)
2797 dump_tree_statistics ();
2799 /* Bad parse errors. Just forget about it. */
2800 if (! global_bindings_p () || current_class_type
)
2803 start_time
= get_run_time ();
2805 /* Push into C language context, because that's all
2807 push_lang_context (lang_name_c
);
2809 /* Otherwise, GDB can get confused, because in only knows
2810 about source for LINENO-1 lines. */
2813 interface_unknown
= 1;
2817 /* The reason for pushing garbage onto the global_binding_level is to
2818 ensure that we can slice out _DECLs which pertain to virtual function
2819 tables. If the last thing pushed onto the global_binding_level was a
2820 virtual function table, then slicing it out would slice away all the
2821 decls (i.e., we lose the head of the chain).
2823 There are several ways of getting the same effect, from changing the
2824 way that iterators over the chain treat the elements that pertain to
2825 virtual function tables, moving the implementation of this code to
2826 decl.c (where we can manipulate global_binding_level directly),
2827 popping the garbage after pushing it and slicing away the vtable
2828 stuff, or just leaving it alone. */
2830 /* Make last thing in global scope not be a virtual function table. */
2831 #if 0 /* not yet, should get fixed properly later */
2832 vars
= make_type_decl (get_identifier (" @%$#@!"), integer_type_node
);
2834 vars
= build_decl (TYPE_DECL
, get_identifier (" @%$#@!"), integer_type_node
);
2836 DECL_IGNORED_P (vars
) = 1;
2837 SET_DECL_ARTIFICIAL (vars
);
2841 /* Walk to mark the inline functions we need, then output them so
2842 that we can pick up any other tdecls that those routines need. */
2843 walk_vtables ((void (*)())0, finish_prevtable_vardecl
);
2845 vars
= static_aggregates
;
2847 if (static_ctors
|| vars
|| might_have_exceptions_p ())
2848 needs_messing_up
= 1;
2852 /* See if we really need the hassle. */
2853 while (vars
&& needs_cleaning
== 0)
2855 tree decl
= TREE_VALUE (vars
);
2856 tree type
= TREE_TYPE (decl
);
2857 if (TYPE_NEEDS_DESTRUCTOR (type
))
2860 needs_messing_up
= 1;
2864 needs_messing_up
|= TYPE_NEEDS_CONSTRUCTING (type
);
2865 vars
= TREE_CHAIN (vars
);
2868 if (needs_cleaning
== 0)
2871 fnname
= get_file_function_name ('D');
2872 start_function (void_list_node
, build_parse_node (CALL_EXPR
, fnname
, void_list_node
, NULL_TREE
), 0, 0);
2873 fnname
= DECL_ASSEMBLER_NAME (current_function_decl
);
2874 store_parm_decls ();
2879 expand_start_bindings (0);
2881 /* These must be done in backward order to destroy,
2882 in which they happen to be! */
2883 for (vars
= static_aggregates
; vars
; vars
= TREE_CHAIN (vars
))
2885 tree decl
= TREE_VALUE (vars
);
2886 tree type
= TREE_TYPE (decl
);
2887 tree temp
= TREE_PURPOSE (vars
);
2889 if (TYPE_NEEDS_DESTRUCTOR (type
))
2891 if (TREE_STATIC (vars
))
2892 expand_start_cond (build_binary_op (NE_EXPR
, temp
, integer_zero_node
, 1), 0);
2893 if (TREE_CODE (type
) == ARRAY_TYPE
)
2897 mark_addressable (decl
);
2898 temp
= build1 (ADDR_EXPR
, TYPE_POINTER_TO (type
), decl
);
2900 temp
= build_delete (TREE_TYPE (temp
), temp
,
2901 integer_two_node
, LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0);
2902 expand_expr_stmt (temp
);
2904 if (TREE_STATIC (vars
))
2909 for (; static_dtors
; static_dtors
= TREE_CHAIN (static_dtors
))
2910 expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors
),
2913 expand_end_bindings (getdecls(), 1, 0);
2917 finish_function (lineno
, 0, 0);
2919 assemble_destructor (IDENTIFIER_POINTER (fnname
));
2921 /* if it needed cleaning, then it will need messing up: drop through */
2924 /* Must do this while we think we are at the top level. */
2925 vars
= nreverse (static_aggregates
);
2926 if (needs_messing_up
)
2928 fnname
= get_file_function_name ('I');
2929 start_function (void_list_node
, build_parse_node (CALL_EXPR
, fnname
, void_list_node
, NULL_TREE
), 0, 0);
2930 fnname
= DECL_ASSEMBLER_NAME (current_function_decl
);
2931 store_parm_decls ();
2936 expand_start_bindings (0);
2938 if (might_have_exceptions_p ())
2939 register_exception_table ();
2943 tree decl
= TREE_VALUE (vars
);
2944 tree init
= TREE_PURPOSE (vars
);
2945 tree old_cleanups
= cleanups_this_call
;
2947 /* If this was a static attribute within some function's scope,
2948 then don't initialize it here. Also, don't bother
2949 with initializers that contain errors. */
2950 if (TREE_STATIC (vars
)
2951 || (init
&& TREE_CODE (init
) == TREE_LIST
2952 && value_member (error_mark_node
, init
)))
2954 vars
= TREE_CHAIN (vars
);
2958 if (TREE_CODE (decl
) == VAR_DECL
)
2960 /* Set these global variables so that GDB at least puts
2961 us near the declaration which required the initialization. */
2962 input_filename
= DECL_SOURCE_FILE (decl
);
2963 lineno
= DECL_SOURCE_LINE (decl
);
2964 emit_note (input_filename
, lineno
);
2966 /* 9.5p5: The initializer of a static member of a class has
2967 the same access rights as a member function. */
2968 DECL_CLASS_CONTEXT (current_function_decl
) = DECL_CONTEXT (decl
);
2969 DECL_STATIC_FUNCTION_P (current_function_decl
) = 1;
2974 if (TREE_CODE (init
) == VAR_DECL
)
2976 /* This behavior results when there are
2977 multiple declarations of an aggregate,
2978 the last of which defines it. */
2979 if (DECL_RTL (init
) == DECL_RTL (decl
))
2981 my_friendly_assert (DECL_INITIAL (decl
) == error_mark_node
2982 || (TREE_CODE (DECL_INITIAL (decl
)) == CONSTRUCTOR
2983 && CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)) == NULL_TREE
),
2985 init
= DECL_INITIAL (init
);
2986 if (TREE_CODE (init
) == CONSTRUCTOR
2987 && CONSTRUCTOR_ELTS (init
) == NULL_TREE
)
2990 else if (TREE_TYPE (decl
) == TREE_TYPE (init
))
2993 my_friendly_abort (200);
2995 /* point to real decl's rtl anyway. */
2996 DECL_RTL (init
) = DECL_RTL (decl
);
2997 my_friendly_assert (DECL_INITIAL (decl
) == error_mark_node
,
2999 init
= DECL_INITIAL (init
);
3005 if (IS_AGGR_TYPE (TREE_TYPE (decl
))
3006 || TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
3007 expand_aggr_init (decl
, init
, 0, 0);
3008 else if (TREE_CODE (init
) == TREE_VEC
)
3010 expand_expr (expand_vec_init (decl
, TREE_VEC_ELT (init
, 0),
3011 TREE_VEC_ELT (init
, 1),
3012 TREE_VEC_ELT (init
, 2), 0),
3013 const0_rtx
, VOIDmode
, 0);
3017 expand_assignment (decl
, init
, 0, 0);
3019 DECL_CLASS_CONTEXT (current_function_decl
) = NULL_TREE
;
3021 else if (TREE_CODE (decl
) == SAVE_EXPR
)
3023 if (! PARM_DECL_EXPR (decl
))
3025 /* a `new' expression at top level. */
3026 expand_expr (decl
, const0_rtx
, VOIDmode
, 0);
3028 expand_aggr_init (build_indirect_ref (decl
, NULL_PTR
), init
, 0, 0);
3031 else if (decl
== error_mark_node
)
3033 else my_friendly_abort (22);
3034 vars
= TREE_CHAIN (vars
);
3035 /* Cleanup any temporaries needed for the initial value. */
3036 expand_cleanups_to (old_cleanups
);
3039 for (; static_ctors
; static_ctors
= TREE_CHAIN (static_ctors
))
3040 expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors
),
3043 expand_end_bindings (getdecls(), 1, 0);
3047 finish_function (lineno
, 0, 0);
3048 assemble_constructor (IDENTIFIER_POINTER (fnname
));
3051 permanent_allocation (1);
3053 /* Done with C language context needs. */
3054 pop_lang_context ();
3056 /* Now write out any static class variables (which may have since
3057 learned how to be initialized). */
3058 while (pending_statics
)
3060 tree decl
= TREE_VALUE (pending_statics
);
3061 if (TREE_USED (decl
) == 1
3062 || TREE_READONLY (decl
) == 0
3063 || DECL_INITIAL (decl
) == 0)
3064 rest_of_decl_compilation (decl
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), 1, 1);
3065 pending_statics
= TREE_CHAIN (pending_statics
);
3068 this_time
= get_run_time ();
3069 parse_time
-= this_time
- start_time
;
3070 varconst_time
+= this_time
- start_time
;
3072 start_time
= get_run_time ();
3074 if (flag_handle_signatures
)
3075 walk_sigtables ((void (*)())0, finish_sigtable_vardecl
);
3077 for (fnname
= saved_inlines
; fnname
; fnname
= TREE_CHAIN (fnname
))
3079 tree decl
= TREE_VALUE (fnname
);
3080 import_export_inline (decl
);
3081 if (DECL_ARTIFICIAL (decl
) && ! DECL_INITIAL (decl
)
3082 && TREE_PUBLIC (decl
) && ! DECL_WEAK (decl
)
3083 && DECL_NOT_REALLY_EXTERN (decl
))
3084 synthesize_method (decl
);
3087 /* Now write out inline functions which had their addresses taken and
3088 which were not declared virtual and which were not declared `extern
3091 int reconsider
= 1; /* More may be referenced; check again */
3095 tree last
= saved_inlines
= tree_cons (NULL_TREE
, NULL_TREE
,
3097 tree last_head
= last
;
3098 tree place
= TREE_CHAIN (saved_inlines
);
3101 walk_vtables ((void (*)())0, finish_vtable_vardecl
);
3103 for (; place
; place
= TREE_CHAIN (place
))
3105 tree decl
= TREE_VALUE (place
);
3107 /* Slice out the empty elements put in just above in the
3108 previous reconsidering. */
3109 if (decl
== NULL_TREE
)
3111 TREE_CHAIN (last
) = TREE_CHAIN (place
);
3115 if (DECL_ARTIFICIAL (decl
) && ! DECL_INITIAL (decl
))
3117 if (TREE_USED (decl
))
3119 synthesize_method (decl
);
3120 if (TREE_ASM_WRITTEN (decl
))
3130 if (TREE_ASM_WRITTEN (decl
) || DECL_SAVED_INSNS (decl
) == 0)
3132 TREE_CHAIN (last
) = TREE_CHAIN (place
);
3136 if ((TREE_PUBLIC (decl
) && ! DECL_WEAK (decl
))
3137 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))
3138 || flag_keep_inline_functions
)
3140 TREE_CHAIN (last
) = TREE_CHAIN (place
);
3142 if (DECL_NOT_REALLY_EXTERN (decl
))
3144 DECL_EXTERNAL (decl
) = 0;
3146 temporary_allocation ();
3147 output_inline_function (decl
);
3148 permanent_allocation (1);
3159 /* Now delete from the chain of variables all virtual function tables.
3160 We output them all ourselves, because each will be treated specially. */
3162 walk_vtables ((void (*)())0, prune_vtable_vardecl
);
3164 for (vars
= getdecls (); vars
; vars
= TREE_CHAIN (vars
))
3166 if (TREE_CODE (vars
) == THUNK_DECL
)
3168 else if (TREE_CODE (vars
) == FUNCTION_DECL
3169 && ! DECL_INTERFACE_KNOWN (vars
)
3170 && DECL_C_STATIC (vars
))
3171 TREE_PUBLIC (vars
) = 0;
3174 if (might_have_exceptions_p ())
3175 emit_exception_table ();
3177 if (write_virtuals
== 2)
3179 /* Now complain about an virtual function tables promised
3180 but not delivered. */
3181 while (pending_vtables
)
3183 if (TREE_PURPOSE (pending_vtables
) == NULL_TREE
)
3184 error ("virtual function table for `%s' not defined",
3185 IDENTIFIER_POINTER (TREE_VALUE (pending_vtables
)));
3186 pending_vtables
= TREE_CHAIN (pending_vtables
);
3192 this_time
= get_run_time ();
3193 parse_time
-= this_time
- start_time
;
3194 varconst_time
+= this_time
- start_time
;
3196 if (flag_detailed_statistics
)
3197 dump_time_statistics ();
3200 /* This is something of the form 'A()()()()()+1' that has turned out to be an
3201 expr. Since it was parsed like a type, we need to wade through and fix
3202 that. Unfortunately, since operator() is left-associative, we can't use
3203 tail recursion. In the above example, TYPE is `A', and DECL is
3206 Maybe this shouldn't be recursive, but how often will it actually be
3209 reparse_absdcl_as_expr (type
, decl
)
3212 /* do build_functional_cast (type, NULL_TREE) at bottom */
3213 if (TREE_OPERAND (decl
, 0) == NULL_TREE
)
3214 return build_functional_cast (type
, NULL_TREE
);
3217 decl
= reparse_decl_as_expr (type
, TREE_OPERAND (decl
, 0));
3219 decl
= build_x_function_call (decl
, NULL_TREE
, current_class_decl
);
3221 if (TREE_CODE (decl
) == CALL_EXPR
&& TREE_TYPE (decl
) != void_type_node
)
3222 decl
= require_complete_type (decl
);
3227 /* This is something of the form `int ((int)(int)(int)1)' that has turned
3228 out to be an expr. Since it was parsed like a type, we need to wade
3229 through and fix that. Since casts are right-associative, we are
3230 reversing the order, so we don't have to recurse.
3232 In the above example, DECL is the `(int)(int)(int)', and EXPR is the
3235 reparse_absdcl_as_casts (decl
, expr
)
3240 if (TREE_CODE (expr
) == CONSTRUCTOR
)
3242 type
= groktypename (TREE_VALUE (TREE_OPERAND (decl
, 1)));
3243 decl
= TREE_OPERAND (decl
, 0);
3245 if (IS_SIGNATURE (type
))
3247 error ("cast specifies signature type");
3248 return error_mark_node
;
3251 expr
= digest_init (type
, expr
, (tree
*) 0);
3252 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_SIZE (type
) == 0)
3254 int failure
= complete_array_type (type
, expr
, 1);
3256 my_friendly_abort (78);
3262 type
= groktypename (TREE_VALUE (TREE_OPERAND (decl
, 1)));
3263 decl
= TREE_OPERAND (decl
, 0);
3264 expr
= build_c_cast (type
, expr
, 0);
3270 /* Recursive helper function for reparse_decl_as_expr. It may be a good
3271 idea to reimplement this using an explicit stack, rather than recursion. */
3273 reparse_decl_as_expr1 (decl
)
3276 switch (TREE_CODE (decl
))
3278 case IDENTIFIER_NODE
:
3279 return do_identifier (decl
);
3281 return build_x_indirect_ref
3282 (reparse_decl_as_expr1 (TREE_OPERAND (decl
, 0)), "unary *");
3284 return build_x_unary_op (ADDR_EXPR
,
3285 reparse_decl_as_expr1 (TREE_OPERAND (decl
, 0)));
3287 return build_x_unary_op (BIT_NOT_EXPR
,
3288 reparse_decl_as_expr1 (TREE_OPERAND (decl
, 0)));
3290 return build_offset_ref (TREE_OPERAND (decl
, 0), TREE_OPERAND (decl
, 1));
3292 return grok_array_decl (reparse_decl_as_expr1 (TREE_OPERAND (decl
, 0)),
3293 TREE_OPERAND (decl
, 1));
3295 my_friendly_abort (5);
3300 /* This is something of the form `int (*a)++' that has turned out to be an
3301 expr. It was only converted into parse nodes, so we need to go through
3302 and build up the semantics. Most of the work is done by
3303 reparse_decl_as_expr1, above.
3305 In the above example, TYPE is `int' and DECL is `*a'. */
3307 reparse_decl_as_expr (type
, decl
)
3310 decl
= reparse_decl_as_expr1 (decl
);
3312 return build_functional_cast (type
, build_tree_list (NULL_TREE
, decl
));
3317 /* This is something of the form `int (*a)' that has turned out to be a
3318 decl. It was only converted into parse nodes, so we need to do the
3319 checking that make_{pointer,reference}_declarator do. */
3322 finish_decl_parsing (decl
)
3325 extern int current_class_depth
;
3327 switch (TREE_CODE (decl
))
3329 case IDENTIFIER_NODE
:
3332 return make_pointer_declarator
3333 (NULL_TREE
, finish_decl_parsing (TREE_OPERAND (decl
, 0)));
3335 return make_reference_declarator
3336 (NULL_TREE
, finish_decl_parsing (TREE_OPERAND (decl
, 0)));
3338 TREE_OPERAND (decl
, 0) = finish_decl_parsing (TREE_OPERAND (decl
, 0));
3341 push_nested_class (TREE_TYPE (TREE_OPERAND (decl
, 0)), 3);
3342 TREE_COMPLEXITY (decl
) = current_class_depth
;
3345 TREE_OPERAND (decl
, 0) = finish_decl_parsing (TREE_OPERAND (decl
, 0));
3348 my_friendly_abort (5);
3354 check_cp_case_value (value
)
3357 if (value
== NULL_TREE
)
3360 /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
3361 Strip such NOP_EXPRs. */
3362 if (TREE_CODE (value
) == NOP_EXPR
3363 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
3364 value
= TREE_OPERAND (value
, 0);
3366 if (TREE_READONLY_DECL_P (value
))
3368 value
= decl_constant_value (value
);
3369 /* build_c_cast puts on a NOP_EXPR to make a non-lvalue.
3370 Strip such NOP_EXPRs. */
3371 if (TREE_CODE (value
) == NOP_EXPR
3372 && TREE_TYPE (value
) == TREE_TYPE (TREE_OPERAND (value
, 0)))
3373 value
= TREE_OPERAND (value
, 0);
3375 value
= fold (value
);
3377 if (TREE_CODE (value
) != INTEGER_CST
3378 && value
!= error_mark_node
)
3380 cp_error ("case label `%E' does not reduce to an integer constant",
3382 value
= error_mark_node
;
3385 /* Promote char or short to int. */
3386 value
= default_conversion (value
);
3388 constant_expression_warning (value
);
3393 tree current_namespace
;
3395 /* Get the inner part of a namespace id. It doesn't have any prefix, nor
3396 postfix. Returns 0 if in global namespace. */
3400 tree x
= current_namespace
;
3402 x
= TREE_PURPOSE (x
);
3406 /* Build up a DECL_ASSEMBLER_NAME for NAME in the current namespace. */
3408 current_namespace_id (name
)
3411 tree old_id
= get_namespace_id ();
3414 /* Global names retain old encoding. */
3418 buf
= (char *) alloca (8 + IDENTIFIER_LENGTH (old_id
)
3419 + IDENTIFIER_LENGTH (name
));
3420 sprintf (buf
, "__ns_%s_%s", IDENTIFIER_POINTER (old_id
),
3421 IDENTIFIER_POINTER (name
));
3422 return get_identifier (buf
);
3426 do_namespace_alias (alias
, namespace)
3427 tree alias
, namespace;
3432 do_toplevel_using_decl (decl
)
3435 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
3438 if (TREE_CODE (decl
) == SCOPE_REF
)
3439 decl
= resolve_scope_to_name (NULL_TREE
, decl
);
3441 /* Is this the right way to do an id list? */
3442 if (TREE_CODE (decl
) != TREE_LIST
)
3449 pushdecl (TREE_VALUE (decl
));
3450 decl
= TREE_CHAIN (decl
);
3455 do_class_using_decl (decl
)
3458 return error_mark_node
;
3462 do_using_directive (namespace)