1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
45 #define obstack_chunk_alloc xmalloc
46 #define obstack_chunk_free free
48 extern tree builtin_return_address_fndecl;
50 extern struct obstack permanent_obstack;
52 extern int current_class_depth;
54 extern tree static_ctors, static_dtors;
56 extern int static_labelno;
58 extern tree current_namespace;
59 extern tree global_namespace;
61 /* Stack of places to restore the search obstack back to. */
63 /* Obstack used for remembering local class declarations (like
64 enums and static (const) members. */
66 struct obstack decl_obstack;
67 static struct stack_level *decl_stack;
69 #ifndef CHAR_TYPE_SIZE
70 #define CHAR_TYPE_SIZE BITS_PER_UNIT
73 #ifndef SHORT_TYPE_SIZE
74 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
78 #define INT_TYPE_SIZE BITS_PER_WORD
81 #ifndef LONG_TYPE_SIZE
82 #define LONG_TYPE_SIZE BITS_PER_WORD
85 #ifndef LONG_LONG_TYPE_SIZE
86 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
89 #ifndef WCHAR_UNSIGNED
90 #define WCHAR_UNSIGNED 0
93 #ifndef FLOAT_TYPE_SIZE
94 #define FLOAT_TYPE_SIZE BITS_PER_WORD
97 #ifndef DOUBLE_TYPE_SIZE
98 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
101 #ifndef LONG_DOUBLE_TYPE_SIZE
102 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
105 #ifndef BOOL_TYPE_SIZE
106 #ifdef SLOW_BYTE_ACCESS
107 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
109 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
113 /* We let tm.h override the types used here, to handle trivial differences
114 such as the choice of unsigned int or long unsigned int for size_t.
115 When machines start needing nontrivial differences in the size type,
116 it would be best to do something here to figure out automatically
117 from other information what type to use. */
120 #define SIZE_TYPE "long unsigned int"
124 #define PTRDIFF_TYPE "long int"
128 #define WCHAR_TYPE "int"
131 static tree grokparms PROTO((tree, int));
132 static tree lookup_nested_type PROTO((tree, tree));
133 static char *redeclaration_error_message PROTO((tree, tree));
134 static tree push_overloaded_decl PROTO((tree, int));
135 static void push_overloaded_decl_top_level PROTO((tree, int));
137 static struct stack_level *push_decl_level PROTO((struct stack_level *,
139 static void push_binding_level PROTO((struct binding_level *, int,
141 static void pop_binding_level PROTO((void));
142 static void suspend_binding_level PROTO((void));
143 static void resume_binding_level PROTO((struct binding_level *));
144 static struct binding_level *make_binding_level PROTO((void));
145 static int namespace_bindings_p PROTO((void));
146 static void declare_namespace_level PROTO((void));
147 static tree get_unique_name PROTO((void));
148 static void signal_catch PROTO((int));
149 static void storedecls PROTO((tree));
150 static void storetags PROTO((tree));
151 static void require_complete_types_for_parms PROTO((tree));
152 static void push_overloaded_decl_1 PROTO((tree));
153 static int ambi_op_p PROTO((tree));
154 static int unary_op_p PROTO((tree));
155 static tree store_bindings PROTO((tree, tree));
156 static tree lookup_tag_reverse PROTO((tree, tree));
157 static tree obscure_complex_init PROTO((tree, tree));
158 static tree maybe_build_cleanup_1 PROTO((tree, tree));
159 static tree lookup_name_real PROTO((tree, int, int));
160 static void warn_extern_redeclared_static PROTO((tree, tree));
161 static void grok_reference_init PROTO((tree, tree, tree));
162 static tree grokfndecl PROTO((tree, tree, tree, tree, int,
163 enum overload_flags, tree,
164 tree, tree, int, int, int, int, int, int, tree));
165 static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
166 static tree lookup_tag PROTO((enum tree_code, tree,
167 struct binding_level *, int));
168 static void set_identifier_type_value_with_scope
169 PROTO((tree, tree, struct binding_level *));
170 static void record_builtin_type PROTO((enum rid, char *, tree));
171 static int member_function_or_else PROTO((tree, tree, char *));
172 static void bad_specifiers PROTO((tree, char *, int, int, int, int,
175 #if defined (DEBUG_CP_BINDING_LEVELS)
176 static void indent PROTO((void));
179 /* A node which has tree code ERROR_MARK, and whose type is itself.
180 All erroneous expressions are replaced with this node. All functions
181 that accept nodes as arguments should avoid generating error messages
182 if this node is one of the arguments, since it is undesirable to get
183 multiple error messages from one error in the input. */
185 tree error_mark_node;
187 /* Erroneous argument lists can use this *IFF* they do not modify it. */
188 tree error_mark_list;
190 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
192 tree short_integer_type_node;
193 tree integer_type_node;
194 tree long_integer_type_node;
195 tree long_long_integer_type_node;
197 tree short_unsigned_type_node;
198 tree unsigned_type_node;
199 tree long_unsigned_type_node;
200 tree long_long_unsigned_type_node;
202 tree ptrdiff_type_node;
204 tree unsigned_char_type_node;
205 tree signed_char_type_node;
207 tree wchar_type_node;
208 tree signed_wchar_type_node;
209 tree unsigned_wchar_type_node;
211 tree wchar_decl_node;
213 tree float_type_node;
214 tree double_type_node;
215 tree long_double_type_node;
217 tree complex_integer_type_node;
218 tree complex_float_type_node;
219 tree complex_double_type_node;
220 tree complex_long_double_type_node;
222 tree intQI_type_node;
223 tree intHI_type_node;
224 tree intSI_type_node;
225 tree intDI_type_node;
226 tree intTI_type_node;
228 tree unsigned_intQI_type_node;
229 tree unsigned_intHI_type_node;
230 tree unsigned_intSI_type_node;
231 tree unsigned_intDI_type_node;
232 tree unsigned_intTI_type_node;
234 /* A VOID_TYPE node, and the same, packaged in a TREE_LIST. */
236 tree void_type_node, void_list_node;
239 /* Nodes for types `void *' and `const void *'. */
242 tree const_ptr_type_node;
244 /* Nodes for types `char *' and `const char *'. */
246 tree string_type_node, const_string_type_node;
248 /* Type `char[256]' or something like it.
249 Used when an array of char is needed and the size is irrelevant. */
251 tree char_array_type_node;
253 /* Type `int[256]' or something like it.
254 Used when an array of int needed and the size is irrelevant. */
256 tree int_array_type_node;
258 /* Type `wchar_t[256]' or something like it.
259 Used when a wide string literal is created. */
261 tree wchar_array_type_node;
263 /* The bool data type, and constants */
264 tree boolean_type_node, boolean_true_node, boolean_false_node;
266 /* Type `int ()' -- used for implicit declaration of functions. */
268 tree default_function_type;
270 /* Function types `double (double)' and `double (double, double)', etc. */
272 static tree double_ftype_double, double_ftype_double_double;
273 static tree int_ftype_int, long_ftype_long;
274 static tree float_ftype_float;
275 static tree ldouble_ftype_ldouble;
277 /* Function type `int (const void *, const void *, size_t)' */
278 static tree int_ftype_cptr_cptr_sizet;
281 tree vtable_entry_type;
282 tree delta_type_node;
284 /* Old rtti stuff. */
285 tree __baselist_desc_type_node;
286 tree __i_desc_type_node, __m_desc_type_node;
287 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
289 tree __t_desc_type_node;
291 tree __tp_desc_type_node;
293 tree __access_mode_type_node;
294 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
295 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
296 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
298 /* Not needed yet? May be needed one day? */
299 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
300 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
301 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
304 /* Indicates that there is a type value in some namespace, although
305 that is not necessarily in scope at the moment. */
307 static tree global_type_node;
309 tree class_star_type_node;
310 tree class_type_node, record_type_node, union_type_node, enum_type_node;
311 tree unknown_type_node;
312 tree opaque_type_node, signature_type_node;
313 tree sigtable_entry_type;
315 /* Array type `vtable_entry_type[]' */
322 /* In a destructor, the point at which all derived class destroying
323 has been done, just before any base class destroying will be done. */
327 /* In a destructor, the last insn emitted after the start of the
328 function and the parms. */
330 static rtx last_dtor_insn;
332 /* In a constructor, the last insn emitted after the start of the
333 function and the parms, the exception specification and any
334 function-try-block. The constructor initializers are emitted after
337 static rtx last_parm_cleanup_insn;
339 /* In a constructor, the point at which we are ready to return
340 the pointer to the initialized object. */
344 /* A FUNCTION_DECL which can call `abort'. Not necessarily the
345 one that the user will declare, but sufficient to be called
346 by routines that want to abort the program. */
350 extern rtx cleanup_label, return_label;
352 /* If original DECL_RESULT of current function was a register,
353 but due to being an addressable named return value, would up
354 on the stack, this variable holds the named return value's
355 original location. */
356 static rtx original_result_rtx;
358 /* Sequence of insns which represents base initialization. */
361 /* C++: Keep these around to reduce calls to `get_identifier'.
362 Identifiers for `this' in member functions and the auto-delete
363 parameter for destructors. */
364 tree this_identifier, in_charge_identifier;
365 tree ctor_identifier, dtor_identifier;
366 /* Used in pointer to member functions, in vtables, and in sigtables. */
367 tree pfn_identifier, index_identifier, delta_identifier, delta2_identifier;
368 tree pfn_or_delta2_identifier, tag_identifier;
369 tree vt_off_identifier;
371 struct named_label_list
373 struct binding_level *binding_level;
376 char *filename_o_goto;
378 struct named_label_list *next;
381 /* A list (chain of TREE_LIST nodes) of named label uses.
382 The TREE_PURPOSE field is the list of variables defined
383 in the label's scope defined at the point of use.
384 The TREE_VALUE field is the LABEL_DECL used.
385 The TREE_TYPE field holds `current_binding_level' at the
386 point of the label's use.
388 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
390 Look at the pretty struct named_label_list. See the pretty struct
391 with the pretty named fields that describe what they do. See the
392 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
394 Used only for jumps to as-yet undefined labels, since
395 jumps to defined labels can have their validity checked
398 static struct named_label_list *named_label_uses = NULL;
400 /* A list of objects which have constructors or destructors
401 which reside in the global scope. The decl is stored in
402 the TREE_VALUE slot and the initializer is stored
403 in the TREE_PURPOSE slot. */
404 tree static_aggregates;
408 /* Two expressions that are constants with value zero.
409 The first is of type `int', the second of type `void *'. */
411 tree integer_zero_node;
412 tree null_pointer_node;
414 /* The value for __null (NULL), either of type `void *' or, with -ansi,
415 an integer type of the same size. */
419 /* A node for the integer constants 1, 2, and 3. */
421 tree integer_one_node, integer_two_node, integer_three_node;
423 /* While defining an enum type, this is 1 plus the last enumerator
426 static tree enum_next_value;
428 /* Nonzero means that there was overflow computing enum_next_value. */
430 static int enum_overflow;
432 /* Parsing a function declarator leaves a list of parameter names
433 or a chain or parameter decls here. */
435 tree last_function_parms;
437 /* Parsing a function declarator leaves here a chain of structure
438 and enum types declared in the parmlist. */
440 static tree last_function_parm_tags;
442 /* After parsing the declarator that starts a function definition,
443 `start_function' puts here the list of parameter names or chain of decls.
444 `store_parm_decls' finds it here. */
446 static tree current_function_parms;
448 /* Similar, for last_function_parm_tags. */
449 static tree current_function_parm_tags;
451 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
452 that have names. Here so we can clear out their names' definitions
453 at the end of the function. */
455 static tree named_labels;
457 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
459 static tree shadowed_labels;
461 /* The FUNCTION_DECL for the function currently being compiled,
462 or 0 if between functions. */
463 tree current_function_decl;
465 /* Set to 0 at beginning of a function definition, set to 1 if
466 a return statement that specifies a return value is seen. */
468 int current_function_returns_value;
470 /* Set to 0 at beginning of a function definition, set to 1 if
471 a return statement with no argument is seen. */
473 int current_function_returns_null;
475 /* Set to 0 at beginning of a function definition, and whenever
476 a label (case or named) is defined. Set to value of expression
477 returned from function when that value can be transformed into
478 a named return value. */
480 tree current_function_return_value;
482 /* Set to nonzero by `grokdeclarator' for a function
483 whose return type is defaulted, if warnings for this are desired. */
485 static int warn_about_return_type;
487 /* Nonzero means give `double' the same size as `float'. */
489 extern int flag_short_double;
491 /* Nonzero means don't recognize any builtin functions. */
493 extern int flag_no_builtin;
495 /* Nonzero means don't recognize the non-ANSI builtin functions.
498 extern int flag_no_nonansi_builtin;
500 /* Nonzero means enable obscure ANSI features and disable GNU extensions
501 that might cause ANSI-compliant code to be miscompiled. */
503 extern int flag_ansi;
505 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
507 extern int flag_huge_objects;
509 /* Nonzero if we want to conserve space in the .o files. We do this
510 by putting uninitialized data and runtime initialized data into
511 .common instead of .data at the expense of not flagging multiple
513 extern int flag_conserve_space;
515 /* Pointers to the base and current top of the language name stack. */
517 extern tree *current_lang_base, *current_lang_stack;
519 /* C and C++ flags are in decl2.c. */
521 /* Set to 0 at beginning of a constructor, set to 1
522 if that function does an allocation before referencing its
523 instance variable. */
524 static int current_function_assigns_this;
525 int current_function_just_assigned_this;
527 /* Set to 0 at beginning of a function. Set non-zero when
528 store_parm_decls is called. Don't call store_parm_decls
529 if this flag is non-zero! */
530 int current_function_parms_stored;
532 /* Flag used when debugging spew.c */
534 extern int spew_debug;
536 /* This is a copy of the class_shadowed list of the previous class binding
537 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
538 when entering another class scope (i.e. a cache miss). */
539 extern tree previous_class_values;
541 /* A expression of value 0 with the same precision as a sizetype
543 tree signed_size_zero_node;
546 /* Allocate a level of searching. */
550 push_decl_level (stack, obstack)
551 struct stack_level *stack;
552 struct obstack *obstack;
554 struct stack_level tem;
557 return push_stack_level (obstack, (char *)&tem, sizeof (tem));
560 /* For each binding contour we allocate a binding_level structure
561 which records the names defined in that contour.
564 1) one for each function definition,
565 where internal declarations of the parameters appear.
566 2) one for each compound statement,
567 to record its declarations.
569 The current meaning of a name can be found by searching the levels
570 from the current one out to the global one.
572 Off to the side, may be the class_binding_level. This exists only
573 to catch class-local declarations. It is otherwise nonexistent.
575 Also there may be binding levels that catch cleanups that must be
576 run when exceptions occur. */
578 /* Note that the information in the `names' component of the global contour
579 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
583 /* A chain of _DECL nodes for all variables, constants, functions,
584 and typedef types. These are in the reverse of the order
588 /* A list of structure, union and enum definitions, for looking up
590 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
591 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
592 or ENUMERAL_TYPE node.
594 C++: the TREE_VALUE nodes can be simple types for
595 component_bindings. */
598 /* A list of USING_DECL nodes. */
601 /* For each level, a list of shadowed outer-level local definitions
602 to be restored when this level is popped.
603 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
604 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
607 /* Same, for IDENTIFIER_CLASS_VALUE. */
610 /* Same, for IDENTIFIER_TYPE_VALUE. */
613 /* For each level (except not the global one),
614 a chain of BLOCK nodes for all the levels
615 that were entered and exited one level down. */
618 /* The BLOCK node for this level, if one has been preallocated.
619 If 0, the BLOCK is allocated (if needed) when the level is popped. */
622 /* The binding level which this one is contained in (inherits from). */
623 struct binding_level *level_chain;
625 /* List of decls in `names' that have incomplete
626 structure or union types. */
629 /* List of VAR_DECLS saved from a previous for statement.
630 These would be dead in ANSI-conforming code, but might
631 be referenced in ARM-era code. */
632 tree dead_vars_from_for;
634 /* 1 for the level that holds the parameters of a function.
635 2 for the level that holds a class declaration.
636 3 for levels that hold parameter declarations. */
637 unsigned parm_flag : 4;
639 /* 1 means make a BLOCK for this level regardless of all else.
640 2 for temporary binding contours created by the compiler. */
643 /* Nonzero if this level "doesn't exist" for tags. */
644 unsigned tag_transparent : 1;
646 /* Nonzero if this level can safely have additional
647 cleanup-needing variables added to it. */
648 unsigned more_cleanups_ok : 1;
649 unsigned have_cleanups : 1;
651 /* Nonzero if this level is for storing the decls for template
652 parameters and generic decls; these decls will be discarded and
653 replaced with a TEMPLATE_DECL. */
654 unsigned pseudo_global : 1;
656 /* This is set for a namespace binding level. */
657 unsigned namespace_p : 1;
659 /* True if this level is that of a for-statement where we need to
660 worry about ambiguous (ARM or ANSI) scope rules. */
661 unsigned is_for_scope : 1;
663 /* Two bits left for this word. */
665 #if defined(DEBUG_CP_BINDING_LEVELS)
666 /* Binding depth at which this level began. */
667 unsigned binding_depth;
668 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
671 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
673 /* The (non-class) binding level currently in effect. */
675 static struct binding_level *current_binding_level;
677 /* The binding level of the current class, if any. */
679 static struct binding_level *class_binding_level;
681 /* The current (class or non-class) binding level currently in effect. */
683 #define inner_binding_level \
684 (class_binding_level ? class_binding_level : current_binding_level)
686 /* A chain of binding_level structures awaiting reuse. */
688 static struct binding_level *free_binding_level;
690 /* The outermost binding level, for names of file scope.
691 This is created when the compiler is started and exists
692 through the entire run. */
694 static struct binding_level *global_binding_level;
696 /* Binding level structures are initialized by copying this one. */
698 static struct binding_level clear_binding_level;
700 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
702 static int keep_next_level_flag;
704 #if defined(DEBUG_CP_BINDING_LEVELS)
705 static int binding_depth = 0;
706 static int is_class_level = 0;
713 for (i = 0; i < binding_depth*2; i++)
716 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
718 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
721 push_binding_level (newlevel, tag_transparent, keep)
722 struct binding_level *newlevel;
723 int tag_transparent, keep;
725 /* Add this level to the front of the chain (stack) of levels that
727 *newlevel = clear_binding_level;
728 if (class_binding_level)
730 newlevel->level_chain = class_binding_level;
731 class_binding_level = (struct binding_level *)0;
735 newlevel->level_chain = current_binding_level;
737 current_binding_level = newlevel;
738 newlevel->tag_transparent = tag_transparent;
739 newlevel->more_cleanups_ok = 1;
740 newlevel->keep = keep;
741 #if defined(DEBUG_CP_BINDING_LEVELS)
742 newlevel->binding_depth = binding_depth;
744 fprintf (stderr, "push %s level 0x%08x line %d\n",
745 (is_class_level) ? "class" : "block", newlevel, lineno);
748 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
754 if (class_binding_level)
755 current_binding_level = class_binding_level;
757 if (global_binding_level)
759 /* Cannot pop a level, if there are none left to pop. */
760 if (current_binding_level == global_binding_level)
761 my_friendly_abort (123);
763 /* Pop the current level, and free the structure for reuse. */
764 #if defined(DEBUG_CP_BINDING_LEVELS)
767 fprintf (stderr, "pop %s level 0x%08x line %d\n",
768 (is_class_level) ? "class" : "block",
769 current_binding_level, lineno);
770 if (is_class_level != (current_binding_level == class_binding_level))
773 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
776 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
778 register struct binding_level *level = current_binding_level;
779 current_binding_level = current_binding_level->level_chain;
780 level->level_chain = free_binding_level;
781 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
782 if (level->binding_depth != binding_depth)
784 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
785 free_binding_level = level;
787 class_binding_level = current_binding_level;
788 if (class_binding_level->parm_flag != 2)
789 class_binding_level = 0;
790 while (current_binding_level->parm_flag == 2)
791 current_binding_level = current_binding_level->level_chain;
796 suspend_binding_level ()
798 if (class_binding_level)
799 current_binding_level = class_binding_level;
801 if (global_binding_level)
803 /* Cannot suspend a level, if there are none left to suspend. */
804 if (current_binding_level == global_binding_level)
805 my_friendly_abort (123);
807 /* Suspend the current level. */
808 #if defined(DEBUG_CP_BINDING_LEVELS)
811 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
812 (is_class_level) ? "class" : "block",
813 current_binding_level, lineno);
814 if (is_class_level != (current_binding_level == class_binding_level))
817 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
820 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
822 current_binding_level = current_binding_level->level_chain;
823 class_binding_level = current_binding_level;
824 if (class_binding_level->parm_flag != 2)
825 class_binding_level = 0;
826 while (current_binding_level->parm_flag == 2)
827 current_binding_level = current_binding_level->level_chain;
832 resume_binding_level (b)
833 struct binding_level *b;
835 /* Resuming binding levels is meant only for namespaces,
836 and those cannot nest into classes. */
837 my_friendly_assert(!class_binding_level, 386);
838 /* Also, resuming a non-directly nested namespace is a no-no. */
839 my_friendly_assert(b->level_chain == current_binding_level, 386);
840 current_binding_level = b;
841 #if defined(DEBUG_CP_BINDING_LEVELS)
842 b->binding_depth = binding_depth;
844 fprintf (stderr, "resume %s level 0x%08x line %d\n",
845 (is_class_level) ? "class" : "block", b, lineno);
848 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
851 /* Create a new `struct binding_level'. */
854 struct binding_level *
855 make_binding_level ()
858 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
861 /* Nonzero if we are currently in the global binding level. */
866 return current_binding_level == global_binding_level;
869 /* Nonzero if we are currently in a toplevel binding level. This
870 means either the global binding level or a namespace in a toplevel
872 Since there are no non-toplevel namespace levels, this really
873 means any namespace or pseudo-global level. */
876 toplevel_bindings_p ()
878 return current_binding_level->namespace_p
879 || current_binding_level->pseudo_global;
882 /* Nonzero if this is a namespace scope. */
885 namespace_bindings_p ()
887 return current_binding_level->namespace_p;
893 keep_next_level_flag = 1;
896 /* Nonzero if the current level needs to have a BLOCK made. */
901 return (current_binding_level->blocks != NULL_TREE
902 || current_binding_level->keep
903 || current_binding_level->names != NULL_TREE
904 || (current_binding_level->tags != NULL_TREE
905 && !current_binding_level->tag_transparent));
908 /* Identify this binding level as a level of parameters. */
911 declare_parm_level ()
913 current_binding_level->parm_flag = 1;
917 declare_pseudo_global_level ()
919 current_binding_level->pseudo_global = 1;
923 declare_namespace_level ()
925 current_binding_level->namespace_p = 1;
929 pseudo_global_level_p ()
931 return current_binding_level->pseudo_global;
935 set_class_shadows (shadows)
938 class_binding_level->class_shadowed = shadows;
941 /* Enter a new binding level.
942 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
943 not for that of tags. */
946 pushlevel (tag_transparent)
949 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
951 /* If this is the top level of a function,
952 just make sure that NAMED_LABELS is 0.
953 They should have been set to 0 at the end of the previous function. */
955 if (current_binding_level == global_binding_level)
956 my_friendly_assert (named_labels == NULL_TREE, 134);
958 /* Reuse or create a struct for this binding level. */
960 #if defined(DEBUG_CP_BINDING_LEVELS)
962 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
963 if (free_binding_level)
964 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
966 newlevel = free_binding_level;
967 free_binding_level = free_binding_level->level_chain;
971 newlevel = make_binding_level ();
974 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
975 GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
976 keep_next_level_flag = 0;
980 note_level_for_for ()
982 current_binding_level->is_for_scope = 1;
986 pushlevel_temporary (tag_transparent)
989 pushlevel (tag_transparent);
990 current_binding_level->keep = 2;
993 /* Note we don't call push_momentary() here. Otherwise, it would cause
994 cleanups to be allocated on the momentary obstack, and they will be
995 overwritten by the next statement. */
997 expand_start_bindings (0);
1000 /* Exit a binding level.
1001 Pop the level off, and restore the state of the identifier-decl mappings
1002 that were in effect when this level was entered.
1004 If KEEP == 1, this level had explicit declarations, so
1005 and create a "block" (a BLOCK node) for the level
1006 to record its declarations and subblocks for symbol table output.
1008 If KEEP == 2, this level's subblocks go to the front,
1009 not the back of the current binding level. This happens,
1010 for instance, when code for constructors and destructors
1011 need to generate code at the end of a function which must
1012 be moved up to the front of the function.
1014 If FUNCTIONBODY is nonzero, this level is the body of a function,
1015 so create a block as if KEEP were set and also clear out all
1018 If REVERSE is nonzero, reverse the order of decls before putting
1019 them into the BLOCK. */
1022 poplevel (keep, reverse, functionbody)
1028 /* The chain of decls was accumulated in reverse order.
1029 Put it into forward order, just for cleanliness. */
1031 int tmp = functionbody;
1032 int real_functionbody = current_binding_level->keep == 2
1033 ? ((functionbody = 0), tmp) : functionbody;
1034 tree tags = functionbody >= 0 ? current_binding_level->tags : 0;
1035 tree subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1036 tree block = NULL_TREE;
1038 int block_previously_created;
1040 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1041 (HOST_WIDE_INT) current_binding_level->level_chain,
1042 current_binding_level->parm_flag,
1043 current_binding_level->keep);
1045 if (current_binding_level->keep == 1)
1048 /* Get the decls in the order they were written.
1049 Usually current_binding_level->names is in reverse order.
1050 But parameter decls were previously put in forward order. */
1053 current_binding_level->names
1054 = decls = nreverse (current_binding_level->names);
1056 decls = current_binding_level->names;
1058 /* Output any nested inline functions within this block
1059 if they weren't already output. */
1061 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1062 if (TREE_CODE (decl) == FUNCTION_DECL
1063 && ! TREE_ASM_WRITTEN (decl)
1064 && DECL_INITIAL (decl) != NULL_TREE
1065 && TREE_ADDRESSABLE (decl)
1066 && decl_function_context (decl) == current_function_decl)
1068 /* If this decl was copied from a file-scope decl
1069 on account of a block-scope extern decl,
1070 propagate TREE_ADDRESSABLE to the file-scope decl. */
1071 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1072 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1075 push_function_context ();
1076 output_inline_function (decl);
1077 pop_function_context ();
1081 /* If there were any declarations or structure tags in that level,
1082 or if this level is a function body,
1083 create a BLOCK to record them for the life of this function. */
1086 block_previously_created = (current_binding_level->this_block != NULL_TREE);
1087 if (block_previously_created)
1088 block = current_binding_level->this_block;
1089 else if (keep == 1 || functionbody)
1090 block = make_node (BLOCK);
1091 if (block != NULL_TREE)
1093 if (block_previously_created)
1095 if (decls || tags || subblocks)
1097 if (BLOCK_VARS (block) || BLOCK_TYPE_TAGS (block))
1099 warning ("internal compiler error: debugging info corrupted");
1101 BLOCK_VARS (block) = decls;
1102 BLOCK_TYPE_TAGS (block) = tags;
1104 /* We can have previous subblocks and new subblocks when
1105 doing fixup_gotos with complex cleanups. We chain the new
1106 subblocks onto the end of any pre-existing subblocks. */
1107 BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1110 /* If we created the block earlier on, and we are just
1111 diddling it now, then it already should have a proper
1112 BLOCK_END_NOTE value associated with it. */
1116 BLOCK_VARS (block) = decls;
1117 BLOCK_TYPE_TAGS (block) = tags;
1118 BLOCK_SUBBLOCKS (block) = subblocks;
1119 /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
1120 remember_end_note (block);
1124 /* In each subblock, record that this is its superior. */
1127 for (link = subblocks; link; link = TREE_CHAIN (link))
1128 BLOCK_SUPERCONTEXT (link) = block;
1130 /* Clear out the meanings of the local variables of this level. */
1132 if (current_binding_level->is_for_scope && flag_new_for_scope == 1)
1134 struct binding_level *outer = current_binding_level->level_chain;
1135 for (link = decls; link; link = TREE_CHAIN (link))
1137 if (TREE_CODE (link) == VAR_DECL)
1138 DECL_DEAD_FOR_LOCAL (link) = 1;
1140 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
1143 /* Save declarations made in a 'for' statement so we can support pre-ANSI
1144 'for' scoping semantics. */
1146 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1148 tree id = TREE_PURPOSE (link);
1149 tree decl = IDENTIFIER_LOCAL_VALUE (id);
1151 if (decl && DECL_DEAD_FOR_LOCAL (decl))
1153 /* In this case keep the dead for-decl visible,
1154 but remember what (if anything) it shadowed. */
1155 DECL_SHADOWED_FOR_VAR (decl) = TREE_VALUE (link);
1156 TREE_CHAIN (decl) = outer->dead_vars_from_for;
1157 outer->dead_vars_from_for = decl;
1160 IDENTIFIER_LOCAL_VALUE (id) = TREE_VALUE (link);
1163 else /* Not special for scope. */
1165 for (link = decls; link; link = TREE_CHAIN (link))
1167 if (DECL_NAME (link) != NULL_TREE)
1169 /* If the ident. was used or addressed via a local extern decl,
1170 don't forget that fact. */
1171 if (DECL_EXTERNAL (link))
1173 if (TREE_USED (link))
1174 TREE_USED (DECL_ASSEMBLER_NAME (link)) = 1;
1175 if (TREE_ADDRESSABLE (link))
1176 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1178 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = NULL_TREE;
1182 /* Restore all name-meanings of the outer levels
1183 that were shadowed by this level. */
1185 for (link = current_binding_level->shadowed;
1186 link; link = TREE_CHAIN (link))
1187 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1189 /* We first restore the regular decls and *then* the dead_vars_from_for
1190 to handle this case:
1194 for (int i; ; ) { ...} // i#2
1198 In this case, we want remove the binding for i#3, restoring
1199 that of i#2. Then we want to remove the binding for i#2,
1200 and restore that of i#1. */
1202 link = current_binding_level->dead_vars_from_for;
1203 for (; link != NULL_TREE; link = TREE_CHAIN (link))
1205 tree id = DECL_NAME (link);
1206 if (IDENTIFIER_LOCAL_VALUE (id) == link)
1207 IDENTIFIER_LOCAL_VALUE (id) = DECL_SHADOWED_FOR_VAR (link);
1210 for (link = current_binding_level->class_shadowed;
1211 link; link = TREE_CHAIN (link))
1212 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1213 for (link = current_binding_level->type_shadowed;
1214 link; link = TREE_CHAIN (link))
1215 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1218 /* If the level being exited is the top level of a function,
1219 check over all the labels. */
1223 /* If this is the top level block of a function,
1224 the vars are the function's parameters.
1225 Don't leave them in the BLOCK because they are
1226 found in the FUNCTION_DECL instead. */
1228 BLOCK_VARS (block) = 0;
1230 /* Clear out the definitions of all label names,
1231 since their scopes end here. */
1233 for (link = named_labels; link; link = TREE_CHAIN (link))
1235 register tree label = TREE_VALUE (link);
1237 if (DECL_INITIAL (label) == NULL_TREE)
1239 cp_error_at ("label `%D' used but not defined", label);
1240 /* Avoid crashing later. */
1241 define_label (input_filename, 1, DECL_NAME (label));
1243 else if (warn_unused && !TREE_USED (label))
1244 cp_warning_at ("label `%D' defined but not used", label);
1245 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), NULL_TREE);
1247 /* Put the labels into the "variables" of the
1248 top-level block, so debugger can see them. */
1249 TREE_CHAIN (label) = BLOCK_VARS (block);
1250 BLOCK_VARS (block) = label;
1253 named_labels = NULL_TREE;
1256 /* Any uses of undefined labels now operate under constraints
1257 of next binding contour. */
1259 struct binding_level *level_chain;
1260 level_chain = current_binding_level->level_chain;
1263 struct named_label_list *labels;
1264 for (labels = named_label_uses; labels; labels = labels->next)
1265 if (labels->binding_level == current_binding_level)
1267 labels->binding_level = level_chain;
1268 labels->names_in_scope = level_chain->names;
1273 tmp = current_binding_level->keep;
1275 pop_binding_level ();
1277 DECL_INITIAL (current_function_decl) = block;
1280 if (!block_previously_created)
1281 current_binding_level->blocks
1282 = chainon (current_binding_level->blocks, block);
1284 /* If we did not make a block for the level just exited,
1285 any blocks made for inner levels
1286 (since they cannot be recorded as subblocks in that level)
1287 must be carried forward so they will later become subblocks
1288 of something else. */
1292 current_binding_level->blocks
1293 = chainon (subblocks, current_binding_level->blocks);
1295 current_binding_level->blocks
1296 = chainon (current_binding_level->blocks, subblocks);
1299 /* Take care of compiler's internal binding structures. */
1302 expand_end_bindings (getdecls (), keep, 1);
1303 /* Each and every BLOCK node created here in `poplevel' is important
1304 (e.g. for proper debugging information) so if we created one
1305 earlier, mark it as "used". */
1307 TREE_USED (block) = 1;
1308 block = poplevel (keep, reverse, real_functionbody);
1311 /* Each and every BLOCK node created here in `poplevel' is important
1312 (e.g. for proper debugging information) so if we created one
1313 earlier, mark it as "used". */
1315 TREE_USED (block) = 1;
1319 /* Delete the node BLOCK from the current binding level.
1320 This is used for the block inside a stmt expr ({...})
1321 so that the block can be reinserted where appropriate. */
1324 delete_block (block)
1328 if (current_binding_level->blocks == block)
1329 current_binding_level->blocks = TREE_CHAIN (block);
1330 for (t = current_binding_level->blocks; t;)
1332 if (TREE_CHAIN (t) == block)
1333 TREE_CHAIN (t) = TREE_CHAIN (block);
1337 TREE_CHAIN (block) = NULL_TREE;
1338 /* Clear TREE_USED which is always set by poplevel.
1339 The flag is set again if insert_block is called. */
1340 TREE_USED (block) = 0;
1343 /* Insert BLOCK at the end of the list of subblocks of the
1344 current binding level. This is used when a BIND_EXPR is expanded,
1345 to handle the BLOCK node inside the BIND_EXPR. */
1348 insert_block (block)
1351 TREE_USED (block) = 1;
1352 current_binding_level->blocks
1353 = chainon (current_binding_level->blocks, block);
1356 /* Set the BLOCK node for the innermost scope
1357 (the one we are currently in). */
1361 register tree block;
1363 current_binding_level->this_block = block;
1366 /* Do a pushlevel for class declarations. */
1371 register struct binding_level *newlevel;
1373 /* Reuse or create a struct for this binding level. */
1374 #if defined(DEBUG_CP_BINDING_LEVELS)
1376 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1377 if (free_binding_level)
1378 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1380 newlevel = free_binding_level;
1381 free_binding_level = free_binding_level->level_chain;
1385 newlevel = make_binding_level ();
1388 #if defined(DEBUG_CP_BINDING_LEVELS)
1390 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1392 push_binding_level (newlevel, 0, 0);
1394 decl_stack = push_decl_level (decl_stack, &decl_obstack);
1395 class_binding_level = current_binding_level;
1396 class_binding_level->parm_flag = 2;
1397 /* We have just pushed into a new binding level. Now, fake out the rest
1398 of the compiler. Set the `current_binding_level' back to point to
1399 the most closely containing non-class binding level. */
1402 current_binding_level = current_binding_level->level_chain;
1404 while (current_binding_level->parm_flag == 2);
1407 /* ...and a poplevel for class declarations. FORCE is used to force
1408 clearing out of CLASS_VALUEs after a class definition. */
1411 poplevel_class (force)
1414 register struct binding_level *level = class_binding_level;
1415 tree block = NULL_TREE;
1418 my_friendly_assert (level != 0, 354);
1420 decl_stack = pop_stack_level (decl_stack);
1421 for (shadowed = level->shadowed; shadowed; shadowed = TREE_CHAIN (shadowed))
1422 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1423 /* If we're leaving a toplevel class, don't bother to do the setting
1424 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1425 shouldn't even be used when current_class_type isn't set, and second,
1426 if we don't touch it here, we're able to use the cache effect if the
1427 next time we're entering a class scope, it is the same class. */
1428 if (current_class_depth != 1 || force)
1429 for (shadowed = level->class_shadowed;
1431 shadowed = TREE_CHAIN (shadowed))
1432 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = TREE_VALUE (shadowed);
1434 /* Remember to save what IDENTIFIER's were bound in this scope so we
1435 can recover from cache misses. */
1437 previous_class_type = current_class_type;
1438 previous_class_values = class_binding_level->class_shadowed;
1440 for (shadowed = level->type_shadowed;
1442 shadowed = TREE_CHAIN (shadowed))
1443 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1445 GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1446 (HOST_WIDE_INT) class_binding_level->level_chain,
1447 class_binding_level->parm_flag,
1448 class_binding_level->keep);
1450 if (class_binding_level->parm_flag != 2)
1451 class_binding_level = (struct binding_level *)0;
1453 /* Now, pop out of the binding level which we created up in the
1454 `pushlevel_class' routine. */
1455 #if defined(DEBUG_CP_BINDING_LEVELS)
1457 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1459 pop_binding_level ();
1464 /* For debugging. */
1465 static int no_print_functions = 0;
1466 static int no_print_builtins = 0;
1469 print_binding_level (lvl)
1470 struct binding_level *lvl;
1474 fprintf (stderr, " blocks=");
1475 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1476 fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1477 list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1478 if (lvl->tag_transparent)
1479 fprintf (stderr, " tag-transparent");
1480 if (lvl->more_cleanups_ok)
1481 fprintf (stderr, " more-cleanups-ok");
1482 if (lvl->have_cleanups)
1483 fprintf (stderr, " have-cleanups");
1484 fprintf (stderr, "\n");
1487 fprintf (stderr, " names:\t");
1488 /* We can probably fit 3 names to a line? */
1489 for (t = lvl->names; t; t = TREE_CHAIN (t))
1491 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1493 if (no_print_builtins
1494 && (TREE_CODE (t) == TYPE_DECL)
1495 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1498 /* Function decls tend to have longer names. */
1499 if (TREE_CODE (t) == FUNCTION_DECL)
1506 fprintf (stderr, "\n\t");
1509 print_node_brief (stderr, "", t, 0);
1510 if (t == error_mark_node)
1514 fprintf (stderr, "\n");
1518 fprintf (stderr, " tags:\t");
1520 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1522 if (TREE_PURPOSE (t) == NULL_TREE)
1524 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1531 fprintf (stderr, "\n\t");
1534 if (TREE_PURPOSE (t) == NULL_TREE)
1536 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1537 fprintf (stderr, ">");
1539 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1540 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1543 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1544 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1545 fprintf (stderr, ">");
1549 fprintf (stderr, "\n");
1553 fprintf (stderr, " shadowed:");
1554 for (t = lvl->shadowed; t; t = TREE_CHAIN (t))
1556 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1558 fprintf (stderr, "\n");
1560 if (lvl->class_shadowed)
1562 fprintf (stderr, " class-shadowed:");
1563 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1565 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1567 fprintf (stderr, "\n");
1569 if (lvl->type_shadowed)
1571 fprintf (stderr, " type-shadowed:");
1572 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1574 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1576 fprintf (stderr, "\n");
1581 print_other_binding_stack (stack)
1582 struct binding_level *stack;
1584 struct binding_level *level;
1585 for (level = stack; level != global_binding_level; level = level->level_chain)
1587 fprintf (stderr, "binding level ");
1588 fprintf (stderr, HOST_PTR_PRINTF, level);
1589 fprintf (stderr, "\n");
1590 print_binding_level (level);
1595 print_binding_stack ()
1597 struct binding_level *b;
1598 fprintf (stderr, "current_binding_level=");
1599 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1600 fprintf (stderr, "\nclass_binding_level=");
1601 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1602 fprintf (stderr, "\nglobal_binding_level=");
1603 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1604 fprintf (stderr, "\n");
1605 if (class_binding_level)
1607 for (b = class_binding_level; b; b = b->level_chain)
1608 if (b == current_binding_level)
1611 b = class_binding_level;
1613 b = current_binding_level;
1616 b = current_binding_level;
1617 print_other_binding_stack (b);
1618 fprintf (stderr, "global:\n");
1619 print_binding_level (global_binding_level);
1622 /* Namespace binding access routines: The namespace_bindings field of
1623 the identifier is polymorphic, with three possible values:
1624 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1625 indicating the BINDING_VALUE of global_namespace. */
1627 /* Check whether the a binding for the name to scope is known.
1628 Assumes that the bindings of the name are already a list
1629 of bindings. Returns the binding found, or NULL_TREE. */
1632 find_binding (name, scope)
1636 tree iter, prev = NULL_TREE;
1637 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
1638 iter = TREE_CHAIN (iter))
1640 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
1641 if (BINDING_SCOPE (iter) == scope)
1643 /* Move binding found to the fron of the list, so
1644 subsequent lookups will find it faster. */
1647 TREE_CHAIN (prev) = TREE_CHAIN (iter);
1648 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
1649 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
1658 /* Always returns a binding for name in scope. If the
1659 namespace_bindings is not a list, convert it to one first.
1660 If no binding is found, make a new one. */
1663 binding_for_name (name, scope)
1667 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1669 if (b && TREE_CODE (b) != CPLUS_BINDING)
1671 /* Get rid of optimization for global scope. */
1672 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
1673 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
1674 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1676 if (b && (result = find_binding (name, scope)))
1678 /* Not found, make a new permanent one. */
1679 push_obstacks (&permanent_obstack, &permanent_obstack);
1680 result = make_node (CPLUS_BINDING);
1681 TREE_CHAIN (result) = b;
1682 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1683 BINDING_SCOPE (result) = scope;
1684 BINDING_TYPE (result) = NULL_TREE;
1685 BINDING_VALUE (result) = NULL_TREE;
1690 /* Return the binding value for name in scope, considering that
1691 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
1694 namespace_binding (name, scope)
1698 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1701 if (TREE_CODE (b) != CPLUS_BINDING)
1702 return (scope == global_namespace) ? b : NULL_TREE;
1703 name = find_binding (name,scope);
1704 if (name == NULL_TREE)
1706 return BINDING_VALUE (name);
1709 /* Set the binding value for name in scope. If modifying the binding
1710 of global_namespace is attempted, try to optimize it. */
1713 set_namespace_binding (name, scope, val)
1719 if (scope == global_namespace)
1721 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1722 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
1724 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
1728 b = binding_for_name (name, scope);
1729 BINDING_VALUE (b) = val;
1732 extern char * first_global_object_name;
1734 /* Get a unique name for each call to this routine for unnamed namespaces.
1735 Mostly copied from get_file_function_name. */
1740 static int temp_name_counter = 0;
1744 if (first_global_object_name)
1745 p = first_global_object_name;
1746 else if (main_input_filename)
1747 p = main_input_filename;
1751 #define UNNAMED_NAMESPACE_FORMAT "__%s_%d"
1753 buf = (char *) alloca (sizeof (UNNAMED_NAMESPACE_FORMAT) + strlen (p));
1755 sprintf (buf, UNNAMED_NAMESPACE_FORMAT, p, temp_name_counter++);
1757 /* Don't need to pull weird characters out of global names. */
1758 if (p != first_global_object_name)
1760 for (p = buf+2; *p; p++)
1761 if (! ((*p >= '0' && *p <= '9')
1762 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
1765 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
1768 || (*p >= 'A' && *p <= 'Z')
1769 || (*p >= 'a' && *p <= 'z')))
1773 return get_identifier (buf);
1776 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
1777 select a name that is unique to this compilation unit. */
1780 push_namespace (name)
1785 int implicit_use = 0;
1787 if (!global_namespace)
1789 /* This must be ::. */
1790 my_friendly_assert (name == get_identifier ("::"), 377);
1795 name = get_unique_name ();
1798 else if (current_namespace == global_namespace
1799 && name == DECL_NAME (std_node))
1806 /* Check whether this is an extended namespace definition. */
1807 d = IDENTIFIER_NAMESPACE_VALUE (name);
1808 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
1814 /* Make a new namespace, binding the name to it. */
1815 d = build_lang_decl (NAMESPACE_DECL, name, NULL_TREE);
1816 /* The global namespace is not pushed, and the global binding
1817 level is set elsewhere. */
1822 declare_namespace_level ();
1823 NAMESPACE_LEVEL (d) = current_binding_level;
1827 resume_binding_level (NAMESPACE_LEVEL (d));
1830 do_using_directive (d);
1831 /* Enter the name space. */
1832 current_namespace = d;
1835 /* Pop from the scope of the current namespace. */
1840 if (current_namespace == global_namespace)
1842 my_friendly_assert (in_std>0, 980421);
1846 current_namespace = DECL_CONTEXT (current_namespace);
1847 /* The binding level is not popped, as it might be re-opened later. */
1848 suspend_binding_level ();
1851 /* Concatenate the binding levels of all namespaces. */
1854 cat_namespace_levels()
1858 struct binding_level *b;
1860 last = NAMESPACE_LEVEL (global_namespace) -> names;
1861 /* The nested namespaces appear in the names list of their ancestors. */
1862 for (current = last; current; current = TREE_CHAIN (current))
1864 if (TREE_CODE (current) != NAMESPACE_DECL)
1866 if (!DECL_LANG_SPECIFIC (current))
1869 my_friendly_assert (current == std_node, 393);
1872 b = NAMESPACE_LEVEL (current);
1873 while (TREE_CHAIN (last))
1874 last = TREE_CHAIN (last);
1875 TREE_CHAIN (last) = NAMESPACE_LEVEL (current) -> names;
1879 /* Subroutines for reverting temporarily to top-level for instantiation
1880 of templates and such. We actually need to clear out the class- and
1881 local-value slots of all identifiers, so that only the global values
1882 are at all visible. Simply setting current_binding_level to the global
1883 scope isn't enough, because more binding levels may be pushed. */
1884 struct saved_scope {
1885 struct binding_level *old_binding_level;
1888 struct saved_scope *prev;
1889 tree class_name, class_type, function_decl;
1890 struct binding_level *class_bindings;
1891 tree *lang_base, *lang_stack, lang_name;
1893 int minimal_parse_mode;
1894 tree last_function_parms;
1895 tree template_parms;
1896 HOST_WIDE_INT processing_template_decl;
1897 tree previous_class_type, previous_class_values;
1898 int processing_specialization;
1899 int processing_explicit_instantiation;
1901 static struct saved_scope *current_saved_scope;
1903 /* A chain of the binding vecs created by store_bindings. We create a
1904 whole bunch of these during compilation, on permanent_obstack, so we
1905 can't just throw them away. */
1906 static tree free_binding_vecs;
1909 store_bindings (names, old_bindings)
1910 tree names, old_bindings;
1913 for (t = names; t; t = TREE_CHAIN (t))
1915 tree binding, t1, id;
1917 if (TREE_CODE (t) == TREE_LIST)
1918 id = TREE_PURPOSE (t);
1923 || (!IDENTIFIER_LOCAL_VALUE (id)
1924 && !IDENTIFIER_CLASS_VALUE (id)))
1927 for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
1928 if (TREE_VEC_ELT (t1, 0) == id)
1931 if (free_binding_vecs)
1933 binding = free_binding_vecs;
1934 free_binding_vecs = TREE_CHAIN (free_binding_vecs);
1937 binding = make_tree_vec (4);
1941 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
1942 TREE_VEC_ELT (binding, 0) = id;
1943 TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
1944 TREE_VEC_ELT (binding, 2) = IDENTIFIER_LOCAL_VALUE (id);
1945 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
1946 IDENTIFIER_LOCAL_VALUE (id) = NULL_TREE;
1947 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
1949 TREE_CHAIN (binding) = old_bindings;
1950 old_bindings = binding;
1954 return old_bindings;
1958 maybe_push_to_top_level (pseudo)
1961 extern int current_lang_stacksize;
1962 struct saved_scope *s
1963 = (struct saved_scope *) xmalloc (sizeof (struct saved_scope));
1964 struct binding_level *b = inner_binding_level;
1965 tree old_bindings = NULL_TREE;
1967 if (current_function_decl)
1968 push_cp_function_context (NULL_TREE);
1970 if (previous_class_type)
1971 old_bindings = store_bindings (previous_class_values, old_bindings);
1973 /* Have to include global_binding_level, because class-level decls
1974 aren't listed anywhere useful. */
1975 for (; b; b = b->level_chain)
1979 /* Template IDs are inserted into the global level. If they were
1980 inserted into namespace level, finish_file wouldn't find them
1981 when doing pending instantiations. Therefore, don't stop at
1982 namespace level, but continue until :: . */
1983 if (b == global_binding_level || (pseudo && b->pseudo_global))
1986 old_bindings = store_bindings (b->names, old_bindings);
1987 /* We also need to check class_shadowed to save class-level type
1988 bindings, since pushclass doesn't fill in b->names. */
1989 if (b->parm_flag == 2)
1990 old_bindings = store_bindings (b->class_shadowed, old_bindings);
1992 /* Unwind type-value slots back to top level. */
1993 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
1994 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
1997 s->old_binding_level = current_binding_level;
1998 current_binding_level = b;
2000 s->old_namespace = current_namespace;
2001 s->class_name = current_class_name;
2002 s->class_type = current_class_type;
2003 s->function_decl = current_function_decl;
2004 s->class_bindings = class_binding_level;
2005 s->lang_stack = current_lang_stack;
2006 s->lang_base = current_lang_base;
2007 s->lang_stacksize = current_lang_stacksize;
2008 s->lang_name = current_lang_name;
2009 s->minimal_parse_mode = minimal_parse_mode;
2010 s->last_function_parms = last_function_parms;
2011 s->template_parms = current_template_parms;
2012 s->processing_template_decl = processing_template_decl;
2013 s->previous_class_type = previous_class_type;
2014 s->previous_class_values = previous_class_values;
2015 s->processing_specialization = processing_specialization;
2016 s->processing_explicit_instantiation = processing_explicit_instantiation;
2018 current_class_name = current_class_type = NULL_TREE;
2019 current_function_decl = NULL_TREE;
2020 class_binding_level = (struct binding_level *)0;
2021 current_lang_stacksize = 10;
2022 current_lang_stack = current_lang_base
2023 = (tree *) xmalloc (current_lang_stacksize * sizeof (tree));
2024 current_lang_name = lang_name_cplusplus;
2025 strict_prototype = strict_prototypes_lang_cplusplus;
2026 named_labels = NULL_TREE;
2027 minimal_parse_mode = 0;
2028 previous_class_type = previous_class_values = NULL_TREE;
2029 processing_specialization = 0;
2030 processing_explicit_instantiation = 0;
2031 current_template_parms = NULL_TREE;
2032 processing_template_decl = 0;
2033 current_namespace = global_namespace;
2035 s->prev = current_saved_scope;
2036 s->old_bindings = old_bindings;
2037 current_saved_scope = s;
2039 push_obstacks (&permanent_obstack, &permanent_obstack);
2043 push_to_top_level ()
2045 maybe_push_to_top_level (0);
2049 pop_from_top_level ()
2051 extern int current_lang_stacksize;
2052 struct saved_scope *s = current_saved_scope;
2055 /* Clear out class-level bindings cache. */
2056 if (previous_class_type)
2059 previous_class_type = NULL_TREE;
2064 current_binding_level = s->old_binding_level;
2065 current_saved_scope = s->prev;
2066 for (t = s->old_bindings; t; )
2069 tree id = TREE_VEC_ELT (t, 0);
2072 SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2073 IDENTIFIER_LOCAL_VALUE (id) = TREE_VEC_ELT (t, 2);
2074 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2077 TREE_CHAIN (save) = free_binding_vecs;
2078 free_binding_vecs = save;
2080 current_namespace = s->old_namespace;
2081 current_class_name = s->class_name;
2082 current_class_type = s->class_type;
2083 current_function_decl = s->function_decl;
2084 class_binding_level = s->class_bindings;
2085 free (current_lang_base);
2086 current_lang_base = s->lang_base;
2087 current_lang_stack = s->lang_stack;
2088 current_lang_name = s->lang_name;
2089 current_lang_stacksize = s->lang_stacksize;
2090 if (current_lang_name == lang_name_cplusplus)
2091 strict_prototype = strict_prototypes_lang_cplusplus;
2092 else if (current_lang_name == lang_name_c)
2093 strict_prototype = strict_prototypes_lang_c;
2094 minimal_parse_mode = s->minimal_parse_mode;
2095 last_function_parms = s->last_function_parms;
2096 current_template_parms = s->template_parms;
2097 processing_template_decl = s->processing_template_decl;
2098 previous_class_type = s->previous_class_type;
2099 previous_class_values = s->previous_class_values;
2100 processing_specialization = s->processing_specialization;
2101 processing_explicit_instantiation = s->processing_explicit_instantiation;
2105 if (current_function_decl)
2106 pop_cp_function_context (NULL_TREE);
2109 /* Push a definition of struct, union or enum tag "name".
2110 into binding_level "b". "type" should be the type node,
2111 We assume that the tag "name" is not already defined.
2113 Note that the definition may really be just a forward reference.
2114 In that case, the TYPE_SIZE will be a NULL_TREE.
2116 C++ gratuitously puts all these tags in the name space. */
2118 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2119 record the shadowed value for this binding contour. TYPE is
2120 the type that ID maps to. */
2123 set_identifier_type_value_with_scope (id, type, b)
2126 struct binding_level *b;
2128 if (!b->namespace_p)
2130 /* Shadow the marker, not the real thing, so that the marker
2131 gets restored later. */
2132 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2134 = tree_cons (id, old_type_value, b->type_shadowed);
2138 tree binding = binding_for_name (id, current_namespace);
2139 BINDING_TYPE (binding) = type;
2140 /* Store marker instead of real type. */
2141 type = global_type_node;
2143 SET_IDENTIFIER_TYPE_VALUE (id, type);
2146 /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
2149 set_identifier_type_value (id, type)
2153 set_identifier_type_value_with_scope (id, type, inner_binding_level);
2156 /* Return the type associated with id. */
2159 identifier_type_value (id)
2162 /* There is no type with that name, anywhere. */
2163 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2165 /* This is not the type marker, but the real thing. */
2166 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2167 return REAL_IDENTIFIER_TYPE_VALUE (id);
2168 /* Have to search for it. It must be on the global level, now.
2169 Ask lookup_name not to return non-types. */
2170 id = lookup_name_real (id, 2, 1);
2172 return TREE_TYPE (id);
2176 /* Pop off extraneous binding levels left over due to syntax errors.
2178 We don't pop past namespaces, as they might be valid. */
2183 #ifdef DEBUG_CP_BINDING_LEVELS
2184 fprintf (stderr, "XXX entering pop_everything ()\n");
2186 while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
2188 if (class_binding_level)
2189 pop_nested_class (1);
2193 #ifdef DEBUG_CP_BINDING_LEVELS
2194 fprintf (stderr, "XXX leaving pop_everything ()\n");
2198 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2199 Normally put it into the inner-most non-tag-transparent scope,
2200 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2201 The latter is needed for implicit declarations. */
2204 pushtag (name, type, globalize)
2208 register struct binding_level *b;
2212 b = inner_binding_level;
2213 while (b->tag_transparent
2214 || (globalize && b->parm_flag == 2))
2217 if (toplevel_bindings_p ())
2218 b->tags = perm_tree_cons (name, type, b->tags);
2220 b->tags = saveable_tree_cons (name, type, b->tags);
2224 context = type ? TYPE_CONTEXT (type) : NULL_TREE;
2227 tree cs = current_scope ();
2231 else if (cs != NULL_TREE
2232 && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2233 /* When declaring a friend class of a local class, we want
2234 to inject the newly named class into the scope
2235 containing the local class, not the namespace scope. */
2236 context = hack_decl_function_context (get_type_decl (cs));
2239 c_decl = TREE_CODE (context) == FUNCTION_DECL
2240 ? context : TYPE_MAIN_DECL (context);
2243 context = current_namespace;
2245 /* Do C++ gratuitous typedefing. */
2246 if (IDENTIFIER_TYPE_VALUE (name) != type)
2248 register tree d = NULL_TREE;
2249 int newdecl = 0, in_class = 0;
2251 if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2252 || b->parm_flag == 2)
2255 d = lookup_nested_type (type, c_decl);
2260 d = build_decl (TYPE_DECL, name, type);
2261 SET_DECL_ARTIFICIAL (d);
2263 set_identifier_type_value_with_scope (name, type, b);
2266 d = TYPE_MAIN_DECL (d);
2268 TYPE_NAME (type) = d;
2269 DECL_CONTEXT (d) = context;
2271 if (IS_AGGR_TYPE (type)
2272 && (/* If !GLOBALIZE then we are looking at a
2273 definition. It may not be a primary template.
2277 struct S1 { class S2 {}; }
2279 we have to push_template_decl for S2.) */
2280 (processing_template_decl && !globalize)
2281 /* If we are declaring a friend template class, we
2282 will have GLOBALIZE set, since something like:
2290 declares S2 to be at global scope. */
2291 || (processing_template_decl >
2292 template_class_depth (current_class_type))))
2294 d = push_template_decl_real (d, globalize);
2295 /* If the current binding level is the binding level for
2296 the template parameters (see the comment in
2297 begin_template_parm_list) and the enclosing level is
2298 a class scope, and we're not looking at a friend,
2299 push the declaration of the member class into the
2300 class scope. In the friend case, push_template_decl
2301 will already have put the friend into global scope,
2303 if (!globalize && b->pseudo_global &&
2304 b->level_chain->parm_flag == 2)
2305 pushdecl_with_scope (CLASSTYPE_TI_TEMPLATE (type),
2309 if (b->parm_flag == 2)
2310 d = pushdecl_class_level (d);
2312 d = pushdecl_with_scope (d, b);
2316 if (ANON_AGGRNAME_P (name))
2317 DECL_IGNORED_P (d) = 1;
2319 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2320 DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2321 DECL_ASSEMBLER_NAME (d)
2322 = get_identifier (build_overload_name (type, 1, 1));
2325 if (b->parm_flag == 2)
2327 TREE_NONLOCAL_FLAG (type) = 1;
2328 if (TYPE_SIZE (current_class_type) == NULL_TREE)
2329 CLASSTYPE_TAGS (current_class_type) = b->tags;
2333 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2334 /* Use the canonical TYPE_DECL for this node. */
2335 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2338 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2339 will be the tagged type we just added to the current
2340 binding level. This fake NULL-named TYPE_DECL node helps
2341 dwarfout.c to know when it needs to output a
2342 representation of a tagged type, and it also gives us a
2343 convenient place to record the "scope start" address for
2346 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2347 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2351 /* Counter used to create anonymous type names. */
2353 static int anon_cnt = 0;
2355 /* Return an IDENTIFIER which can be used as a name for
2356 anonymous structs and unions. */
2363 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2364 return get_identifier (buf);
2367 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2368 This keeps dbxout from getting confused. */
2373 register struct binding_level *b;
2375 static int last_cnt = 0;
2377 /* Fast out if no new anon names were declared. */
2378 if (last_cnt == anon_cnt)
2381 b = current_binding_level;
2382 while (b->tag_transparent)
2387 /* A NULL purpose means we have already processed all tags
2388 from here to the end of the list. */
2389 if (TREE_PURPOSE (tags) == NULL_TREE)
2391 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2392 TREE_PURPOSE (tags) = NULL_TREE;
2393 tags = TREE_CHAIN (tags);
2395 last_cnt = anon_cnt;
2398 /* Subroutine of duplicate_decls: return truthvalue of whether
2399 or not types of these decls match.
2401 For C++, we must compare the parameter list so that `int' can match
2402 `int&' in a parameter position, but `int&' is not confused with
2406 decls_match (newdecl, olddecl)
2407 tree newdecl, olddecl;
2411 if (TREE_CODE (newdecl) == FUNCTION_DECL
2412 && TREE_CODE (olddecl) == FUNCTION_DECL)
2414 tree f1 = TREE_TYPE (newdecl);
2415 tree f2 = TREE_TYPE (olddecl);
2416 tree p1 = TYPE_ARG_TYPES (f1);
2417 tree p2 = TYPE_ARG_TYPES (f2);
2419 /* When we parse a static member function definition,
2420 we put together a FUNCTION_DECL which thinks its type
2421 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2423 if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2424 revert_static_member_fn (&newdecl, &f1, &p1);
2425 else if (TREE_CODE (f2) == METHOD_TYPE
2426 && DECL_STATIC_FUNCTION_P (newdecl))
2427 revert_static_member_fn (&olddecl, &f2, &p2);
2429 /* Here we must take care of the case where new default
2430 parameters are specified. Also, warn if an old
2431 declaration becomes ambiguous because default
2432 parameters may cause the two to be ambiguous. */
2433 if (TREE_CODE (f1) != TREE_CODE (f2))
2435 if (TREE_CODE (f1) == OFFSET_TYPE)
2436 cp_compiler_error ("`%D' redeclared as member function", newdecl);
2438 cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2442 if (comptypes (TREE_TYPE (f1), TREE_TYPE (f2), 1))
2444 if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2447 types_match = self_promoting_args_p (p1);
2448 if (p1 == void_list_node)
2449 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2451 else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2452 && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2454 types_match = self_promoting_args_p (p2);
2455 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2458 types_match = compparms (p1, p2, 3);
2463 else if (TREE_CODE (newdecl) == TEMPLATE_DECL
2464 && TREE_CODE (olddecl) == TEMPLATE_DECL)
2466 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2467 DECL_TEMPLATE_PARMS (olddecl)))
2470 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2473 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2474 DECL_TEMPLATE_RESULT (newdecl));
2478 if (TREE_TYPE (newdecl) == error_mark_node)
2479 types_match = TREE_TYPE (olddecl) == error_mark_node;
2480 else if (TREE_TYPE (olddecl) == NULL_TREE)
2481 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2482 else if (TREE_TYPE (newdecl) == NULL_TREE)
2484 /* Qualifiers must match, and they may be present on either, the type
2486 else if ((TREE_READONLY (newdecl)
2487 || TYPE_READONLY (TREE_TYPE (newdecl)))
2488 == (TREE_READONLY (olddecl)
2489 || TYPE_READONLY (TREE_TYPE (olddecl)))
2490 && (TREE_THIS_VOLATILE (newdecl)
2491 || TYPE_VOLATILE (TREE_TYPE (newdecl)))
2492 == (TREE_THIS_VOLATILE (olddecl)
2493 || TYPE_VOLATILE (TREE_TYPE (olddecl))))
2494 types_match = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (newdecl)),
2495 TYPE_MAIN_VARIANT (TREE_TYPE (olddecl)), 1);
2503 /* If NEWDECL is `static' and an `extern' was seen previously,
2504 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2505 information about previous usage as an `extern'.)
2507 Note that this does not apply to the C++ case of declaring
2508 a variable `extern const' and then later `const'.
2510 Don't complain about built-in functions, since they are beyond
2511 the user's control. */
2514 warn_extern_redeclared_static (newdecl, olddecl)
2515 tree newdecl, olddecl;
2519 static char *explicit_extern_static_warning
2520 = "`%D' was declared `extern' and later `static'";
2521 static char *implicit_extern_static_warning
2522 = "`%D' was declared implicitly `extern' and later `static'";
2524 if (TREE_CODE (newdecl) == TYPE_DECL)
2527 name = DECL_ASSEMBLER_NAME (newdecl);
2528 if (TREE_PUBLIC (name) && DECL_THIS_STATIC (newdecl))
2530 /* It's okay to redeclare an ANSI built-in function as static,
2531 or to declare a non-ANSI built-in function as anything. */
2532 if (! (TREE_CODE (newdecl) == FUNCTION_DECL
2533 && olddecl != NULL_TREE
2534 && TREE_CODE (olddecl) == FUNCTION_DECL
2535 && (DECL_BUILT_IN (olddecl)
2536 || DECL_BUILT_IN_NONANSI (olddecl))))
2538 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2539 ? implicit_extern_static_warning
2540 : explicit_extern_static_warning, newdecl);
2541 if (olddecl != NULL_TREE)
2542 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2547 /* Handle when a new declaration NEWDECL has the same name as an old
2548 one OLDDECL in the same binding contour. Prints an error message
2551 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2552 Otherwise, return 0. */
2555 duplicate_decls (newdecl, olddecl)
2556 tree newdecl, olddecl;
2558 extern struct obstack permanent_obstack;
2559 unsigned olddecl_uid = DECL_UID (olddecl);
2560 int olddecl_friend = 0, types_match = 0;
2561 int new_defines_function = 0;
2563 if (newdecl == olddecl)
2566 types_match = decls_match (newdecl, olddecl);
2568 /* If either the type of the new decl or the type of the old decl is an
2569 error_mark_node, then that implies that we have already issued an
2570 error (earlier) for some bogus type specification, and in that case,
2571 it is rather pointless to harass the user with yet more error message
2572 about the same declaration, so just pretend the types match here. */
2573 if (TREE_TYPE (newdecl) == error_mark_node
2574 || TREE_TYPE (olddecl) == error_mark_node)
2577 /* Check for redeclaration and other discrepancies. */
2578 if (TREE_CODE (olddecl) == FUNCTION_DECL
2579 && DECL_ARTIFICIAL (olddecl)
2580 && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
2582 /* If you declare a built-in or predefined function name as static,
2583 the old definition is overridden, but optionally warn this was a
2584 bad choice of name. Ditto for overloads. */
2585 if (! TREE_PUBLIC (newdecl)
2586 || (TREE_CODE (newdecl) == FUNCTION_DECL
2587 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl)))
2590 cp_warning ("shadowing %s function `%#D'",
2591 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2593 /* Discard the old built-in function. */
2596 else if (! types_match)
2598 if (TREE_CODE (newdecl) != FUNCTION_DECL)
2600 /* If the built-in is not ansi, then programs can override
2601 it even globally without an error. */
2602 if (! DECL_BUILT_IN (olddecl))
2603 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2607 cp_error ("declaration of `%#D'", newdecl);
2608 cp_error ("conflicts with built-in declaration `%#D'",
2614 cp_warning ("declaration of `%#D'", newdecl);
2615 cp_warning ("conflicts with built-in declaration `%#D'",
2619 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
2621 if ((TREE_CODE (newdecl) == FUNCTION_DECL
2622 && DECL_FUNCTION_TEMPLATE_P (olddecl))
2623 || (TREE_CODE (olddecl) == FUNCTION_DECL
2624 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
2627 cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
2628 if (TREE_CODE (olddecl) == TREE_LIST)
2629 olddecl = TREE_VALUE (olddecl);
2630 cp_error_at ("previous declaration of `%#D'", olddecl);
2632 /* New decl is completely inconsistent with the old one =>
2633 tell caller to replace the old one. */
2637 else if (!types_match)
2639 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2641 /* The name of a class template may not be declared to refer to
2642 any other template, class, function, object, namespace, value,
2643 or type in the same scope. */
2644 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
2645 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2647 cp_error ("declaration of template `%#D'", newdecl);
2648 cp_error_at ("conflicts with previous declaration `%#D'",
2651 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
2652 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
2653 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
2654 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))), 3)
2655 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2656 DECL_TEMPLATE_PARMS (olddecl)))
2658 cp_error ("new declaration `%#D'", newdecl);
2659 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2663 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2665 if (DECL_LANGUAGE (newdecl) == lang_c
2666 && DECL_LANGUAGE (olddecl) == lang_c)
2668 cp_error ("declaration of C function `%#D' conflicts with",
2670 cp_error_at ("previous declaration `%#D' here", olddecl);
2672 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2673 TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 3))
2675 cp_error ("new declaration `%#D'", newdecl);
2676 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
2682 /* Already complained about this, so don't do so again. */
2683 else if (current_class_type == NULL_TREE
2684 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
2686 cp_error ("conflicting types for `%#D'", newdecl);
2687 cp_error_at ("previous declaration as `%#D'", olddecl);
2690 else if (TREE_CODE (newdecl) == FUNCTION_DECL
2691 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
2692 && (!DECL_TEMPLATE_INFO (newdecl)
2693 || (DECL_TI_TEMPLATE (newdecl)
2694 != DECL_TI_TEMPLATE (olddecl))))
2695 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
2696 && (!DECL_TEMPLATE_INFO (olddecl)
2697 || (DECL_TI_TEMPLATE (olddecl)
2698 != DECL_TI_TEMPLATE (newdecl))))))
2699 /* It's OK to have a template specialization and a non-template
2700 with the same type, or to have specializations of two
2701 different templates with the same type. Note that if one is a
2702 specialization, and the other is an instantiation of the same
2703 template, that we do not exit at this point. That situation
2704 can occur if we instantiate a template class, and then
2705 specialize one of its methods. This situation is legal, but
2706 the declarations must be merged in the usual way. */
2708 else if (TREE_CODE (newdecl) == FUNCTION_DECL
2709 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
2710 && !DECL_USE_TEMPLATE (newdecl))
2711 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
2712 && !DECL_USE_TEMPLATE (olddecl))))
2713 /* One of the declarations is a template instantiation, and the
2714 other is not a template at all. That's OK. */
2718 char *errmsg = redeclaration_error_message (newdecl, olddecl);
2721 cp_error (errmsg, newdecl);
2722 if (DECL_NAME (olddecl) != NULL_TREE)
2723 cp_error_at ((DECL_INITIAL (olddecl)
2724 && namespace_bindings_p ())
2725 ? "`%#D' previously defined here"
2726 : "`%#D' previously declared here", olddecl);
2728 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2729 && DECL_INITIAL (olddecl) != NULL_TREE
2730 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
2731 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
2733 /* Prototype decl follows defn w/o prototype. */
2734 cp_warning_at ("prototype for `%#D'", newdecl);
2735 cp_warning_at ("follows non-prototype definition here", olddecl);
2737 else if (TREE_CODE (olddecl) == FUNCTION_DECL
2738 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
2740 /* extern "C" int foo ();
2741 int foo () { bar (); }
2743 if (current_lang_stack == current_lang_base)
2744 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
2747 cp_error_at ("previous declaration of `%#D' with %L linkage",
2748 olddecl, DECL_LANGUAGE (olddecl));
2749 cp_error ("conflicts with new declaration with %L linkage",
2750 DECL_LANGUAGE (newdecl));
2754 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
2756 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
2758 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
2759 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
2762 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
2763 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
2765 for (; t1 && t1 != void_list_node;
2766 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
2767 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
2769 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
2774 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2776 cp_pedwarn_at ("after previous specification in `%#D'",
2782 cp_error ("default argument given for parameter %d of `%#D'",
2784 cp_error_at ("after previous specification in `%#D'",
2789 if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
2790 && TREE_ADDRESSABLE (olddecl) && warn_inline)
2792 cp_warning ("`%#D' was used before it was declared inline",
2794 cp_warning_at ("previous non-inline declaration here",
2798 /* These bits are logically part of the type for non-functions. */
2799 else if (TREE_READONLY (newdecl) != TREE_READONLY (olddecl)
2800 || TREE_THIS_VOLATILE (newdecl) != TREE_THIS_VOLATILE (olddecl))
2802 cp_pedwarn ("type qualifiers for `%#D'", newdecl);
2803 cp_pedwarn_at ("conflict with previous decl `%#D'", olddecl);
2807 /* If new decl is `static' and an `extern' was seen previously,
2809 warn_extern_redeclared_static (newdecl, olddecl);
2811 /* We have committed to returning 1 at this point. */
2812 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2814 /* Now that functions must hold information normally held
2815 by field decls, there is extra work to do so that
2816 declaration information does not get destroyed during
2818 if (DECL_VINDEX (olddecl))
2819 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
2820 if (DECL_CONTEXT (olddecl))
2821 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
2822 if (DECL_CLASS_CONTEXT (olddecl))
2823 DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
2824 if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
2825 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2826 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
2827 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
2828 DECL_ABSTRACT_VIRTUAL_P (newdecl) |= DECL_ABSTRACT_VIRTUAL_P (olddecl);
2829 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
2830 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
2831 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
2833 /* Optionally warn about more than one declaration for the same
2834 name, but don't warn about a function declaration followed by a
2836 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
2837 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
2838 /* Don't warn about extern decl followed by definition. */
2839 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
2840 /* Don't warn about friends, let add_friend take care of it. */
2841 && ! DECL_FRIEND_P (newdecl))
2843 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
2844 cp_warning_at ("previous declaration of `%D'", olddecl);
2848 /* Deal with C++: must preserve virtual function table size. */
2849 if (TREE_CODE (olddecl) == TYPE_DECL)
2851 register tree newtype = TREE_TYPE (newdecl);
2852 register tree oldtype = TREE_TYPE (olddecl);
2854 if (newtype != error_mark_node && oldtype != error_mark_node
2855 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
2857 CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
2858 CLASSTYPE_FRIEND_CLASSES (newtype)
2859 = CLASSTYPE_FRIEND_CLASSES (oldtype);
2863 /* Copy all the DECL_... slots specified in the new decl
2864 except for any that we copy here from the old type. */
2865 DECL_MACHINE_ATTRIBUTES (newdecl)
2866 = merge_machine_decl_attributes (olddecl, newdecl);
2868 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2870 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE)
2872 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
2873 DECL_TEMPLATE_RESULT (olddecl)))
2874 cp_error ("invalid redeclaration of %D", newdecl);
2875 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
2876 DECL_TEMPLATE_PARMS (olddecl) = DECL_TEMPLATE_PARMS (newdecl);
2877 DECL_TEMPLATE_INFO (olddecl) = DECL_TEMPLATE_INFO (newdecl);
2879 DECL_TEMPLATE_SPECIALIZATIONS (newdecl)
2880 = DECL_TEMPLATE_SPECIALIZATIONS (olddecl);
2887 /* Automatically handles default parameters. */
2888 tree oldtype = TREE_TYPE (olddecl);
2891 /* Make sure we put the new type in the same obstack as the old one. */
2893 push_obstacks (TYPE_OBSTACK (oldtype), TYPE_OBSTACK (oldtype));
2896 push_obstacks_nochange ();
2897 end_temporary_allocation ();
2900 /* Merge the data types specified in the two decls. */
2901 newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
2903 if (TREE_CODE (newdecl) == VAR_DECL)
2904 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
2905 /* Do this after calling `common_type' so that default
2906 parameters don't confuse us. */
2907 else if (TREE_CODE (newdecl) == FUNCTION_DECL
2908 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
2909 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
2911 TREE_TYPE (newdecl) = build_exception_variant (newtype,
2912 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
2913 TREE_TYPE (olddecl) = build_exception_variant (newtype,
2914 TYPE_RAISES_EXCEPTIONS (oldtype));
2916 if ((pedantic || (! DECL_IN_SYSTEM_HEADER (olddecl)
2917 && DECL_SOURCE_LINE (olddecl) != 0))
2919 && ! compexcepttypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2921 cp_pedwarn ("declaration of `%D' throws different exceptions",
2923 cp_pedwarn_at ("previous declaration here", olddecl);
2926 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
2928 /* Lay the type out, unless already done. */
2929 if (newtype != CANONICAL_TYPE_VARIANT (oldtype)
2930 && TREE_TYPE (newdecl) != error_mark_node
2931 && !(processing_template_decl && uses_template_parms (newdecl)))
2932 layout_type (TREE_TYPE (newdecl));
2934 if ((TREE_CODE (newdecl) == VAR_DECL
2935 || TREE_CODE (newdecl) == PARM_DECL
2936 || TREE_CODE (newdecl) == RESULT_DECL
2937 || TREE_CODE (newdecl) == FIELD_DECL
2938 || TREE_CODE (newdecl) == TYPE_DECL)
2939 && !(processing_template_decl && uses_template_parms (newdecl)))
2940 layout_decl (newdecl, 0);
2942 /* Merge the type qualifiers. */
2943 if (TREE_READONLY (newdecl))
2944 TREE_READONLY (olddecl) = 1;
2945 if (TREE_THIS_VOLATILE (newdecl))
2946 TREE_THIS_VOLATILE (olddecl) = 1;
2948 /* Merge the initialization information. */
2949 if (DECL_INITIAL (newdecl) == NULL_TREE
2950 && DECL_INITIAL (olddecl) != NULL_TREE)
2952 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2953 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
2954 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
2957 /* Merge the section attribute.
2958 We want to issue an error if the sections conflict but that must be
2959 done later in decl_attributes since we are called before attributes
2961 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
2962 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
2964 /* Keep the old rtl since we can safely use it, unless it's the
2965 call to abort() used for abstract virtuals. */
2966 if ((DECL_LANG_SPECIFIC (olddecl)
2967 && !DECL_ABSTRACT_VIRTUAL_P (olddecl))
2968 || DECL_RTL (olddecl) != DECL_RTL (abort_fndecl))
2969 DECL_RTL (newdecl) = DECL_RTL (olddecl);
2973 /* If cannot merge, then use the new type and qualifiers,
2974 and don't preserve the old rtl. */
2977 /* Clean out any memory we had of the old declaration. */
2978 tree oldstatic = value_member (olddecl, static_aggregates);
2980 TREE_VALUE (oldstatic) = error_mark_node;
2982 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2983 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2984 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2985 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2988 /* Merge the storage class information. */
2989 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
2990 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
2991 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2992 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
2993 if (! DECL_EXTERNAL (olddecl))
2994 DECL_EXTERNAL (newdecl) = 0;
2996 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
2998 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2999 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3000 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3001 /* Don't really know how much of the language-specific
3002 values we should copy from old to new. */
3003 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3004 DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3005 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3006 if (DECL_TEMPLATE_INFO (newdecl) == NULL_TREE)
3008 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3009 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
3011 olddecl_friend = DECL_FRIEND_P (olddecl);
3014 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3016 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3017 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3019 /* If newdecl is not a specialization, then it is not a
3020 template-related function at all. And that means that we
3021 shoud have exited above, returning 0. */
3022 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3025 if (TREE_USED (olddecl))
3026 /* From [temp.expl.spec]:
3028 If a template, a member template or the member of a class
3029 template is explicitly specialized then that
3030 specialization shall be declared before the first use of
3031 that specialization that would cause an implicit
3032 instantiation to take place, in every translation unit in
3033 which such a use occurs. */
3034 cp_error ("explicit specialization of %D after first use",
3037 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3039 DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3041 /* If either decl says `inline', this fn is inline, unless its
3042 definition was passed already. */
3043 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3044 DECL_INLINE (olddecl) = 1;
3045 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3049 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3050 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3051 DECL_RTL (olddecl) = DECL_RTL (newdecl);
3053 if (! types_match || new_defines_function)
3055 /* These need to be copied so that the names are available. */
3056 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3057 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3059 if (new_defines_function)
3060 /* If defining a function declared with other language
3061 linkage, use the previously declared language linkage. */
3062 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3065 /* If redeclaring a builtin function, and not a definition,
3066 it stays built in. */
3067 if (DECL_BUILT_IN (olddecl))
3069 DECL_BUILT_IN (newdecl) = 1;
3070 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3071 /* If we're keeping the built-in definition, keep the rtl,
3072 regardless of declaration matches. */
3073 DECL_RTL (newdecl) = DECL_RTL (olddecl);
3076 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3078 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3079 if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3080 /* Previously saved insns go together with
3081 the function's previous definition. */
3082 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3083 /* Don't clear out the arguments if we're redefining a function. */
3084 if (DECL_ARGUMENTS (olddecl))
3085 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3087 if (DECL_LANG_SPECIFIC (olddecl))
3088 DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3091 if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3093 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3096 /* Now preserve various other info from the definition. */
3097 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3098 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3099 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3100 DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3102 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3105 struct lang_decl *ol = DECL_LANG_SPECIFIC (olddecl);
3106 struct lang_decl *nl = DECL_LANG_SPECIFIC (newdecl);
3108 function_size = sizeof (struct tree_decl);
3110 bcopy ((char *) newdecl + sizeof (struct tree_common),
3111 (char *) olddecl + sizeof (struct tree_common),
3112 function_size - sizeof (struct tree_common));
3114 /* Can we safely free the storage used by newdecl? */
3116 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3117 & ~ obstack_alignment_mask (&permanent_obstack))
3119 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3121 /* If newdecl is a template instantiation, it is possible that
3122 the following sequence of events has occurred:
3124 o A friend function was declared in a class template. The
3125 class template was instantiated.
3127 o The instantiation of the friend declaration was
3128 recorded on the instantiation list, and is newdecl.
3130 o Later, however, instantiate_class_template called pushdecl
3131 on the newdecl to perform name injection. But, pushdecl in
3132 turn called duplicate_decls when it discovered that another
3133 declaration of a global function with the same name already
3136 o Here, in duplicate_decls, we decided to clobber newdecl.
3138 If we're going to do that, we'd better make sure that
3139 olddecl, and not newdecl, is on the list of
3140 instantiations so that if we try to do the instantiation
3141 again we won't get the clobbered declaration. */
3143 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3144 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3146 for (; decls; decls = TREE_CHAIN (decls))
3147 if (TREE_VALUE (decls) == newdecl)
3148 TREE_VALUE (decls) = olddecl;
3151 if (((char *)newdecl + ROUND (function_size) == (char *)nl
3152 && ((char *)newdecl + ROUND (function_size)
3153 + ROUND (sizeof (struct lang_decl))
3154 == obstack_next_free (&permanent_obstack)))
3155 || ((char *)newdecl + ROUND (function_size)
3156 == obstack_next_free (&permanent_obstack)))
3158 DECL_MAIN_VARIANT (newdecl) = olddecl;
3159 DECL_LANG_SPECIFIC (olddecl) = ol;
3160 bcopy ((char *)nl, (char *)ol, sizeof (struct lang_decl));
3162 obstack_free (&permanent_obstack, newdecl);
3164 else if (LANG_DECL_PERMANENT (ol) && ol != nl)
3166 if (DECL_MAIN_VARIANT (olddecl) == olddecl)
3168 /* Save these lang_decls that would otherwise be lost. */
3169 extern tree free_lang_decl_chain;
3170 tree free_lang_decl = (tree) ol;
3172 if (DECL_LANG_SPECIFIC (olddecl) == ol)
3175 TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
3176 free_lang_decl_chain = free_lang_decl;
3180 /* Storage leak. */;
3186 bcopy ((char *) newdecl + sizeof (struct tree_common),
3187 (char *) olddecl + sizeof (struct tree_common),
3188 sizeof (struct tree_decl) - sizeof (struct tree_common)
3189 + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3192 DECL_UID (olddecl) = olddecl_uid;
3194 DECL_FRIEND_P (olddecl) = 1;
3196 /* NEWDECL contains the merged attribute lists.
3197 Update OLDDECL to be the same. */
3198 DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3203 /* Record a decl-node X as belonging to the current lexical scope.
3204 Check for errors (such as an incompatible declaration for the same
3205 name already seen in the same scope).
3207 Returns either X or an old decl for the same name.
3208 If an old decl is returned, it may have been smashed
3209 to agree with what X says. */
3216 register tree name = DECL_ASSEMBLER_NAME (x);
3217 register struct binding_level *b = current_binding_level;
3219 if (current_function_decl && x != current_function_decl
3220 /* A local declaration for a function doesn't constitute nesting. */
3221 && (TREE_CODE (x) != FUNCTION_DECL || DECL_INITIAL (x))
3222 /* Don't change DECL_CONTEXT of virtual methods. */
3223 && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3224 && ! DECL_CONTEXT (x))
3225 DECL_CONTEXT (x) = current_function_decl;
3226 if (!DECL_CONTEXT (x))
3227 DECL_CONTEXT (x) = current_namespace;
3229 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3230 compiler wants to use. */
3231 if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3232 || TREE_CODE (x) == NAMESPACE_DECL || TREE_CODE (x) == TEMPLATE_TYPE_PARM
3233 || TREE_CODE (x) == TEMPLATE_TEMPLATE_PARM)
3234 name = DECL_NAME (x);
3239 /* Not needed...see below. */
3243 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3244 name = TREE_OPERAND (name, 0);
3246 /* Namespace-scoped variables are not found in the current level. */
3247 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3248 t = namespace_binding (name, DECL_CONTEXT (x));
3250 t = lookup_name_current_level (name);
3251 if (t == error_mark_node)
3253 /* error_mark_node is 0 for a while during initialization! */
3255 cp_error_at ("`%#D' used prior to declaration", x);
3258 else if (t != NULL_TREE)
3261 /* This is turned off until I have time to do it right (bpk). */
3262 /* With the code below that uses it... */
3263 file = DECL_SOURCE_FILE (t);
3264 line = DECL_SOURCE_LINE (t);
3266 if (TREE_CODE (t) == PARM_DECL)
3268 if (DECL_CONTEXT (t) == NULL_TREE)
3269 fatal ("parse errors have confused me too much");
3271 /* Check for duplicate params. */
3272 if (duplicate_decls (x, t))
3275 else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3276 || DECL_FUNCTION_TEMPLATE_P (x))
3277 && is_overloaded_fn (t))
3278 /* Don't do anything just yet. */;
3279 else if (t == wchar_decl_node)
3281 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3282 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3284 /* Throw away the redeclaration. */
3287 else if (TREE_CODE (t) != TREE_CODE (x))
3289 if ((TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)
3290 && TREE_CODE (x) != TYPE_DECL
3291 && ! (TREE_CODE (x) == TEMPLATE_DECL
3292 && TREE_CODE (DECL_TEMPLATE_RESULT (x)) == TYPE_DECL))
3293 || (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3294 && TREE_CODE (t) != TYPE_DECL
3295 && ! (TREE_CODE (t) == TEMPLATE_DECL
3296 && (TREE_CODE (DECL_TEMPLATE_RESULT (t))
3299 /* We do nothing special here, because C++ does such nasty
3300 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3301 get shadowed, and know that if we need to find a TYPE_DECL
3302 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3303 slot of the identifier. */
3306 else if (duplicate_decls (x, t))
3309 else if (duplicate_decls (x, t))
3312 /* This is turned off until I have time to do it right (bpk). */
3314 /* Also warn if they did a prototype with `static' on it, but
3315 then later left the `static' off. */
3316 if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3318 if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3323 cp_warning ("`static' missing from declaration of `%D'",
3325 warning_with_file_and_line (file, line,
3326 "previous declaration of `%s'",
3327 decl_as_string (t, 0));
3330 /* Now fix things so it'll do what they expect. */
3331 if (current_function_decl)
3332 TREE_PUBLIC (current_function_decl) = 0;
3334 /* Due to interference in memory reclamation (X may be
3335 obstack-deallocated at this point), we must guard against
3336 one really special case. [jason: This should be handled
3337 by start_function] */
3338 if (current_function_decl == x)
3339 current_function_decl = t;
3341 if (TREE_CODE (t) == TYPE_DECL)
3342 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3343 else if (TREE_CODE (t) == FUNCTION_DECL)
3344 check_default_args (t);
3350 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3352 t = push_overloaded_decl (x, 1);
3353 if (t != x || DECL_LANGUAGE (x) == lang_c)
3356 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3357 return push_overloaded_decl (x, 0);
3359 /* If declaring a type as a typedef, copy the type (unless we're
3360 at line 0), and install this TYPE_DECL as the new type's typedef
3361 name. See the extensive comment in ../c-decl.c (pushdecl). */
3362 if (TREE_CODE (x) == TYPE_DECL)
3364 tree type = TREE_TYPE (x);
3365 if (DECL_SOURCE_LINE (x) == 0)
3367 if (TYPE_NAME (type) == 0)
3368 TYPE_NAME (type) = x;
3370 else if (type != error_mark_node && TYPE_NAME (type) != x)
3372 DECL_ORIGINAL_TYPE (x) = type;
3373 type = build_type_copy (type);
3374 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3375 TYPE_NAME (type) = x;
3376 TREE_TYPE (x) = type;
3379 if (type != error_mark_node
3381 && TYPE_IDENTIFIER (type))
3382 set_identifier_type_value_with_scope (DECL_NAME (x), type, b);
3385 /* Multiple external decls of the same identifier ought to match.
3387 We get warnings about inline functions where they are defined.
3388 We get warnings about other functions from push_overloaded_decl.
3390 Avoid duplicate warnings where they are used. */
3391 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3394 tree bindings = binding_for_name (name, current_namespace);
3396 if (BINDING_VALUE (bindings) != NULL_TREE
3397 && (DECL_EXTERNAL (BINDING_VALUE (bindings))
3398 || TREE_PUBLIC (BINDING_VALUE (bindings))))
3399 decl = BINDING_VALUE (bindings);
3404 /* If different sort of thing, we already gave an error. */
3405 && TREE_CODE (decl) == TREE_CODE (x)
3406 && ! comptypes (TREE_TYPE (x), TREE_TYPE (decl), 1))
3408 cp_pedwarn ("type mismatch with previous external decl", x);
3409 cp_pedwarn_at ("previous external decl of `%#D'", decl);
3413 /* This name is new in its binding level.
3414 Install the new declaration and return it. */
3415 if (namespace_bindings_p ())
3417 /* Install a global value. */
3418 tree bindings = binding_for_name (name, current_namespace);
3420 /* If the first global decl has external linkage,
3421 warn if we later see static one. */
3422 if (BINDING_VALUE (bindings) == NULL_TREE && TREE_PUBLIC (x))
3423 TREE_PUBLIC (name) = 1;
3425 /* Don't install an artificial TYPE_DECL if we already have
3426 another _DECL with that name. */
3427 if (TREE_CODE (x) != TYPE_DECL
3429 || ! DECL_ARTIFICIAL (x))
3431 if (TREE_CODE (x) == FUNCTION_DECL)
3432 my_friendly_assert ((BINDING_VALUE (bindings) == NULL_TREE)
3433 || BINDING_VALUE (bindings) == x, 378);
3434 BINDING_VALUE (bindings) = x;
3437 /* Don't forget if the function was used via an implicit decl. */
3438 if (IDENTIFIER_IMPLICIT_DECL (name)
3439 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3442 /* Don't forget if its address was taken in that way. */
3443 if (IDENTIFIER_IMPLICIT_DECL (name)
3444 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3445 TREE_ADDRESSABLE (x) = 1;
3447 /* Warn about mismatches against previous implicit decl. */
3448 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3449 /* If this real decl matches the implicit, don't complain. */
3450 && ! (TREE_CODE (x) == FUNCTION_DECL
3451 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3453 ("`%D' was previously implicitly declared to return `int'", x);
3455 /* If new decl is `static' and an `extern' was seen previously,
3457 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3458 warn_extern_redeclared_static (x, t);
3462 /* Here to install a non-global value. */
3463 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
3464 tree oldglobal = binding_for_name (name, current_namespace);
3466 /* Don't install an artificial TYPE_DECL if we already have
3467 another _DECL with that name. */
3468 if (TREE_CODE (x) != TYPE_DECL
3470 || ! DECL_ARTIFICIAL (x))
3472 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
3473 IDENTIFIER_LOCAL_VALUE (name) = x;
3476 /* If this is a TYPE_DECL, push it into the type value slot. */
3477 if (TREE_CODE (x) == TYPE_DECL)
3478 set_identifier_type_value_with_scope (name, TREE_TYPE (x), b);
3480 /* Clear out any TYPE_DECL shadowed by a namespace so that
3481 we won't think this is a type. The C struct hack doesn't
3482 go through namespaces. */
3483 if (TREE_CODE (x) == NAMESPACE_DECL)
3484 set_identifier_type_value_with_scope (name, NULL_TREE, b);
3486 /* If this is an extern function declaration, see if we
3487 have a global definition or declaration for the function. */
3488 if (oldlocal == NULL_TREE
3489 && DECL_EXTERNAL (x)
3490 && BINDING_VALUE (oldglobal) != NULL_TREE
3491 && TREE_CODE (x) == FUNCTION_DECL
3492 && TREE_CODE (BINDING_VALUE (oldglobal)) == FUNCTION_DECL)
3494 /* We have one. Their types must agree. */
3495 if (decls_match (x, BINDING_VALUE (oldglobal)))
3499 cp_warning ("extern declaration of `%#D' doesn't match", x);
3500 cp_warning_at ("global declaration `%#D'", BINDING_VALUE (oldglobal));
3503 /* If we have a local external declaration,
3504 and no file-scope declaration has yet been seen,
3505 then if we later have a file-scope decl it must not be static. */
3506 if (oldlocal == NULL_TREE
3507 && BINDING_VALUE (oldglobal) == NULL_TREE
3508 && DECL_EXTERNAL (x)
3511 TREE_PUBLIC (name) = 1;
3514 if (DECL_FROM_INLINE (x))
3515 /* Inline decls shadow nothing. */;
3517 /* Warn if shadowing an argument at the top level of the body. */
3518 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3519 && TREE_CODE (oldlocal) == PARM_DECL
3520 && TREE_CODE (x) != PARM_DECL)
3522 /* Go to where the parms should be and see if we
3524 struct binding_level *b = current_binding_level->level_chain;
3530 if (b->parm_flag == 1)
3531 cp_error ("declaration of `%#D' shadows a parameter", name);
3533 else if (warn_shadow && oldlocal != NULL_TREE && b->is_for_scope
3534 && !DECL_DEAD_FOR_LOCAL (oldlocal))
3536 warning ("variable `%s' shadows local",
3537 IDENTIFIER_POINTER (name));
3538 cp_warning_at (" this is the shadowed declaration", oldlocal);
3540 /* Maybe warn if shadowing something else. */
3541 else if (warn_shadow && !DECL_EXTERNAL (x)
3542 /* No shadow warnings for internally generated vars. */
3543 && ! DECL_ARTIFICIAL (x)
3544 /* No shadow warnings for vars made for inlining. */
3545 && ! DECL_FROM_INLINE (x))
3547 char *warnstring = NULL;
3549 if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3550 warnstring = "declaration of `%s' shadows a parameter";
3551 else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
3552 && current_class_ptr
3553 && !TREE_STATIC (name))
3554 warnstring = "declaration of `%s' shadows a member of `this'";
3555 else if (oldlocal != NULL_TREE)
3556 warnstring = "declaration of `%s' shadows previous local";
3557 else if (BINDING_VALUE (oldglobal) != NULL_TREE)
3558 /* XXX shadow warnings in outer-more namespaces */
3559 warnstring = "declaration of `%s' shadows global declaration";
3562 warning (warnstring, IDENTIFIER_POINTER (name));
3566 if (TREE_CODE (x) == FUNCTION_DECL)
3567 check_default_args (x);
3569 /* Keep count of variables in this level with incomplete type. */
3570 if (TREE_CODE (x) == VAR_DECL
3571 && TREE_TYPE (x) != error_mark_node
3572 && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
3573 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
3574 /* RTTI TD entries are created while defining the type_info. */
3575 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
3576 && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
3577 b->incomplete = tree_cons (NULL_TREE, x, b->incomplete);
3580 /* Put decls on list in reverse order.
3581 We will reverse them later if necessary. */
3582 TREE_CHAIN (x) = b->names;
3584 if (! (b != global_binding_level || TREE_PERMANENT (x)))
3585 my_friendly_abort (124);
3590 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3591 caller to set DECL_CONTEXT properly. */
3594 pushdecl_with_scope (x, level)
3596 struct binding_level *level;
3598 register struct binding_level *b;
3599 tree function_decl = current_function_decl;
3601 current_function_decl = NULL_TREE;
3602 if (level->parm_flag == 2)
3604 b = class_binding_level;
3605 class_binding_level = level;
3606 pushdecl_class_level (x);
3607 class_binding_level = b;
3611 b = current_binding_level;
3612 current_binding_level = level;
3614 current_binding_level = b;
3616 current_function_decl = function_decl;
3620 /* Like pushdecl, only it places X in the current namespace,
3624 pushdecl_namespace_level (x)
3627 register struct binding_level *b = inner_binding_level;
3630 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3632 /* Now, the type_shadowed stack may screw us. Munge it so it does
3634 if (TREE_CODE (x) == TYPE_DECL)
3636 tree name = DECL_NAME (x);
3638 tree *ptr = (tree *)0;
3639 for (; b != global_binding_level; b = b->level_chain)
3641 tree shadowed = b->type_shadowed;
3642 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3643 if (TREE_PURPOSE (shadowed) == name)
3645 ptr = &TREE_VALUE (shadowed);
3646 /* Can't break out of the loop here because sometimes
3647 a binding level will have duplicate bindings for
3648 PT names. It's gross, but I haven't time to fix it. */
3651 newval = TREE_TYPE (x);
3652 if (ptr == (tree *)0)
3654 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3655 up here if this is changed to an assertion. --KR */
3656 SET_IDENTIFIER_TYPE_VALUE (name, newval);
3666 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3670 pushdecl_top_level (x)
3673 tree cur_namespace = current_namespace;
3674 current_namespace = global_namespace;
3675 x = pushdecl_namespace_level (x);
3676 current_namespace = cur_namespace;
3680 /* Like push_overloaded_decl, only it places X in GLOBAL_BINDING_LEVEL,
3684 push_overloaded_decl_top_level (x, forget)
3688 struct binding_level *b = current_binding_level;
3690 current_binding_level = global_binding_level;
3691 push_overloaded_decl (x, forget);
3692 current_binding_level = b;
3695 /* Make the declaration of X appear in CLASS scope. */
3698 pushdecl_class_level (x)
3701 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3702 scope looks for the pre-mangled name. */
3703 register tree name = DECL_NAME (x);
3707 if (TYPE_BEING_DEFINED (current_class_type))
3709 /* Check for inconsistent use of this name in the class body.
3710 Types, enums, and static vars are checked here; other
3711 members are checked in finish_struct. */
3712 tree icv = IDENTIFIER_CLASS_VALUE (name);
3715 /* Don't complain about inherited names. */
3716 && id_in_current_class (name)
3717 /* Or shadowed tags. */
3718 && !(TREE_CODE (icv) == TYPE_DECL
3719 && DECL_CONTEXT (icv) == current_class_type))
3721 cp_error ("declaration of identifier `%D' as `%#D'", name, x);
3722 cp_error_at ("conflicts with previous use in class as `%#D'",
3727 push_class_level_binding (name, x);
3728 if (TREE_CODE (x) == TYPE_DECL)
3730 set_identifier_type_value (name, TREE_TYPE (x));
3737 /* This function is used to push the mangled decls for nested types into
3738 the appropriate scope. Previously pushdecl_top_level was used, but that
3739 is incorrect for members of local classes. */
3742 pushdecl_nonclass_level (x)
3745 struct binding_level *b = current_binding_level;
3747 my_friendly_assert (b->parm_flag != 2, 180);
3750 /* Get out of template binding levels */
3751 while (b->pseudo_global)
3755 pushdecl_with_scope (x, b);
3759 /* Make the declaration(s) of X appear in CLASS scope
3760 under the name NAME. */
3763 push_class_level_binding (name, x)
3767 /* The class_binding_level will be NULL if x is a template
3768 parameter name in a member template. */
3769 if (!class_binding_level)
3772 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3773 && purpose_member (name, class_binding_level->class_shadowed))
3776 maybe_push_cache_obstack ();
3777 class_binding_level->class_shadowed
3778 = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
3779 class_binding_level->class_shadowed);
3781 IDENTIFIER_CLASS_VALUE (name) = x;
3782 obstack_ptr_grow (&decl_obstack, x);
3785 /* Insert another USING_DECL into the current binding level,
3786 returning this declaration. If this is a redeclaration,
3787 do nothing and return NULL_TREE. */
3790 push_using_decl (scope, name)
3796 if (!toplevel_bindings_p ())
3798 sorry ("using declaration inside function");
3802 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
3803 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
3804 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
3805 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
3809 decl = build_lang_decl (USING_DECL, name, void_type_node);
3810 DECL_INITIAL (decl) = scope;
3811 TREE_CHAIN (decl) = current_binding_level->usings;
3812 current_binding_level->usings = decl;
3816 /* DECL is a FUNCTION_DECL which may have other definitions already in
3817 place. We get around this by making the value of the identifier point
3818 to a list of all the things that want to be referenced by that name. It
3819 is then up to the users of that name to decide what to do with that
3822 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3823 slot. It is dealt with the same way.
3825 The value returned may be a previous declaration if we guessed wrong
3826 about what language DECL should belong to (C or C++). Otherwise,
3827 it's always DECL (and never something that's not a _DECL). */
3830 push_overloaded_decl (decl, forgettable)
3834 tree orig_name = DECL_NAME (decl);
3836 int doing_global = (namespace_bindings_p () || ! forgettable);
3840 old = namespace_binding (orig_name, DECL_CONTEXT (decl));
3841 if (old && TREE_CODE (old) == FUNCTION_DECL
3842 && DECL_ARTIFICIAL (old)
3843 && (DECL_BUILT_IN (old) || DECL_BUILT_IN_NONANSI (old)))
3845 if (duplicate_decls (decl, old))
3852 old = IDENTIFIER_LOCAL_VALUE (orig_name);
3854 if (! purpose_member (orig_name, current_binding_level->shadowed))
3856 current_binding_level->shadowed
3857 = tree_cons (orig_name, old, current_binding_level->shadowed);
3864 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
3866 tree t = TREE_TYPE (old);
3867 if (IS_AGGR_TYPE (t) && warn_shadow
3868 && (! DECL_IN_SYSTEM_HEADER (decl)
3869 || ! DECL_IN_SYSTEM_HEADER (old)))
3870 cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
3873 else if (is_overloaded_fn (old))
3877 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
3878 if (decl == OVL_CURRENT (tmp)
3879 || duplicate_decls (decl, OVL_CURRENT (tmp)))
3880 return OVL_CURRENT (tmp);
3884 cp_error_at ("previous non-function declaration `%#D'", old);
3885 cp_error ("conflicts with function declaration `%#D'", decl);
3890 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
3892 if (old && TREE_CODE (old) != OVERLOAD)
3893 old = ovl_cons (old, NULL_TREE);
3894 old = ovl_cons (decl, old);
3897 /* orig_name is not ambiguous. */
3901 set_namespace_binding (orig_name, DECL_CONTEXT (decl), old);
3903 IDENTIFIER_LOCAL_VALUE (orig_name) = old;
3908 /* Generate an implicit declaration for identifier FUNCTIONID
3909 as a function of type int (). Print a warning if appropriate. */
3912 implicitly_declare (functionid)
3916 int temp = allocation_temporary_p ();
3918 push_obstacks_nochange ();
3920 /* Save the decl permanently so we can warn if definition follows.
3921 In ANSI C, warn_implicit is usually false, so the saves little space.
3922 But in C++, it's usually true, hence the extra code. */
3923 if (temp && (! warn_implicit || toplevel_bindings_p ()))
3924 end_temporary_allocation ();
3926 /* We used to reuse an old implicit decl here,
3927 but this loses with inline functions because it can clobber
3928 the saved decl chains. */
3929 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
3931 DECL_EXTERNAL (decl) = 1;
3932 TREE_PUBLIC (decl) = 1;
3934 /* ANSI standard says implicit declarations are in the innermost block.
3935 So we record the decl in the standard fashion. */
3937 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
3940 /* Only one warning per identifier. */
3941 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
3943 cp_pedwarn ("implicit declaration of function `%#D'", decl);
3946 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
3953 /* Return zero if the declaration NEWDECL is valid
3954 when the declaration OLDDECL (assumed to be for the same name)
3955 has already been seen.
3956 Otherwise return an error message format string with a %s
3957 where the identifier should go. */
3960 redeclaration_error_message (newdecl, olddecl)
3961 tree newdecl, olddecl;
3963 if (TREE_CODE (newdecl) == TYPE_DECL)
3965 /* Because C++ can put things into name space for free,
3966 constructs like "typedef struct foo { ... } foo"
3967 would look like an erroneous redeclaration. */
3968 if (comptypes (TREE_TYPE (newdecl), TREE_TYPE (olddecl), 0))
3971 return "redefinition of `%#D'";
3973 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
3975 /* If this is a pure function, its olddecl will actually be
3976 the original initialization to `0' (which we force to call
3977 abort()). Don't complain about redefinition in this case. */
3978 if (DECL_LANG_SPECIFIC (olddecl) && DECL_ABSTRACT_VIRTUAL_P (olddecl))
3981 /* If both functions come from different namespaces, this is not
3982 a redeclaration - this is a conflict with a used function. */
3983 if (DECL_NAMESPACE_SCOPE_P (olddecl)
3984 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
3985 return "`%D' conflicts with used function";
3987 /* We'll complain about linkage mismatches in
3988 warn_extern_redeclared_static. */
3990 /* Defining the same name twice is no good. */
3991 if (DECL_INITIAL (olddecl) != NULL_TREE
3992 && DECL_INITIAL (newdecl) != NULL_TREE)
3994 if (DECL_NAME (olddecl) == NULL_TREE)
3995 return "`%#D' not declared in class";
3997 return "redefinition of `%#D'";
4001 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4003 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4004 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4005 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4006 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4007 && TYPE_SIZE (TREE_TYPE (newdecl))
4008 && TYPE_SIZE (TREE_TYPE (olddecl))))
4009 return "redefinition of `%#D'";
4012 else if (toplevel_bindings_p ())
4014 /* Objects declared at top level: */
4015 /* If at least one is a reference, it's ok. */
4016 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4018 /* Reject two definitions. */
4019 return "redefinition of `%#D'";
4023 /* Objects declared with block scope: */
4024 /* Reject two definitions, and reject a definition
4025 together with an external reference. */
4026 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4027 return "redeclaration of `%#D'";
4032 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4033 Create one if none exists so far for the current function.
4034 This function is called for both label definitions and label references. */
4040 register tree decl = IDENTIFIER_LABEL_VALUE (id);
4042 if (current_function_decl == NULL_TREE)
4044 error ("label `%s' referenced outside of any function",
4045 IDENTIFIER_POINTER (id));
4049 if ((decl == NULL_TREE
4050 || DECL_SOURCE_LINE (decl) == 0)
4051 && (named_label_uses == NULL
4052 || named_label_uses->names_in_scope != current_binding_level->names
4053 || named_label_uses->label_decl != decl))
4055 struct named_label_list *new_ent;
4057 = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4058 new_ent->label_decl = decl;
4059 new_ent->names_in_scope = current_binding_level->names;
4060 new_ent->binding_level = current_binding_level;
4061 new_ent->lineno_o_goto = lineno;
4062 new_ent->filename_o_goto = input_filename;
4063 new_ent->next = named_label_uses;
4064 named_label_uses = new_ent;
4067 /* Use a label already defined or ref'd with this name. */
4068 if (decl != NULL_TREE)
4070 /* But not if it is inherited and wasn't declared to be inheritable. */
4071 if (DECL_CONTEXT (decl) != current_function_decl
4072 && ! C_DECLARED_LABEL_FLAG (decl))
4073 return shadow_label (id);
4077 decl = build_decl (LABEL_DECL, id, void_type_node);
4079 /* Make sure every label has an rtx. */
4082 /* A label not explicitly declared must be local to where it's ref'd. */
4083 DECL_CONTEXT (decl) = current_function_decl;
4085 DECL_MODE (decl) = VOIDmode;
4087 /* Say where one reference is to the label,
4088 for the sake of the error if it is not defined. */
4089 DECL_SOURCE_LINE (decl) = lineno;
4090 DECL_SOURCE_FILE (decl) = input_filename;
4092 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4094 named_labels = tree_cons (NULL_TREE, decl, named_labels);
4095 named_label_uses->label_decl = decl;
4100 /* Make a label named NAME in the current function,
4101 shadowing silently any that may be inherited from containing functions
4102 or containing scopes.
4104 Note that valid use, if the label being shadowed
4105 comes from another scope in the same function,
4106 requires calling declare_nonlocal_label right away. */
4112 register tree decl = IDENTIFIER_LABEL_VALUE (name);
4114 if (decl != NULL_TREE)
4116 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4117 SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4118 SET_IDENTIFIER_LABEL_VALUE (decl, NULL_TREE);
4121 return lookup_label (name);
4124 /* Define a label, specifying the location in the source file.
4125 Return the LABEL_DECL node for the label, if the definition is valid.
4126 Otherwise return 0. */
4129 define_label (filename, line, name)
4136 if (minimal_parse_mode)
4138 push_obstacks (&permanent_obstack, &permanent_obstack);
4139 decl = build_decl (LABEL_DECL, name, void_type_node);
4141 DECL_SOURCE_LINE (decl) = line;
4142 DECL_SOURCE_FILE (decl) = filename;
4147 decl = lookup_label (name);
4149 /* After labels, make any new cleanups go into their
4150 own new (temporary) binding contour. */
4151 current_binding_level->more_cleanups_ok = 0;
4153 /* If label with this name is known from an outer context, shadow it. */
4154 if (decl != NULL_TREE && DECL_CONTEXT (decl) != current_function_decl)
4156 shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels);
4157 SET_IDENTIFIER_LABEL_VALUE (name, NULL_TREE);
4158 decl = lookup_label (name);
4161 if (name == get_identifier ("wchar_t"))
4162 cp_pedwarn ("label named wchar_t");
4164 if (DECL_INITIAL (decl) != NULL_TREE)
4166 cp_error ("duplicate label `%D'", decl);
4171 struct named_label_list *uses, *prev;
4174 /* Mark label as having been defined. */
4175 DECL_INITIAL (decl) = error_mark_node;
4176 /* Say where in the source. */
4177 DECL_SOURCE_FILE (decl) = filename;
4178 DECL_SOURCE_LINE (decl) = line;
4181 uses = named_label_uses;
4182 while (uses != NULL)
4183 if (uses->label_decl == decl)
4185 struct binding_level *b = current_binding_level;
4188 tree new_decls = b->names;
4189 tree old_decls = (b == uses->binding_level)
4190 ? uses->names_in_scope : NULL_TREE;
4191 while (new_decls != old_decls)
4193 if (TREE_CODE (new_decls) == VAR_DECL
4194 /* Don't complain about crossing initialization
4195 of internal entities. They can't be accessed,
4196 and they should be cleaned up
4197 by the time we get to the label. */
4198 && ! DECL_ARTIFICIAL (new_decls)
4199 && ((DECL_INITIAL (new_decls) != NULL_TREE
4200 && DECL_INITIAL (new_decls) != error_mark_node)
4201 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4205 cp_error ("jump to label `%D'", decl);
4206 error_with_file_and_line (uses->filename_o_goto,
4207 uses->lineno_o_goto,
4211 cp_error_at (" crosses initialization of `%#D'",
4214 new_decls = TREE_CHAIN (new_decls);
4216 if (b == uses->binding_level)
4222 prev->next = uses->next;
4224 named_label_uses = uses->next;
4233 current_function_return_value = NULL_TREE;
4240 struct binding_level *level;
4241 struct cp_switch *next;
4244 static struct cp_switch *switch_stack;
4250 = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4251 p->level = current_binding_level;
4252 p->next = switch_stack;
4259 switch_stack = switch_stack->next;
4262 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4263 /* XXX Note decl is never actually used. (bpk) */
4266 define_case_label (decl)
4269 tree cleanup = last_cleanup_this_contour ();
4270 struct binding_level *b = current_binding_level;
4275 static int explained = 0;
4276 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4277 warning ("where case label appears here");
4280 warning ("(enclose actions of previous case statements requiring");
4281 warning ("destructors in their own binding contours.)");
4286 for (; b && b != switch_stack->level; b = b->level_chain)
4288 tree new_decls = b->names;
4289 for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4291 if (TREE_CODE (new_decls) == VAR_DECL
4292 /* Don't complain about crossing initialization
4293 of internal entities. They can't be accessed,
4294 and they should be cleaned up
4295 by the time we get to the label. */
4296 && ! DECL_ARTIFICIAL (new_decls)
4297 && ((DECL_INITIAL (new_decls) != NULL_TREE
4298 && DECL_INITIAL (new_decls) != error_mark_node)
4299 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4302 error ("jump to case label");
4304 cp_error_at (" crosses initialization of `%#D'",
4310 /* After labels, make any new cleanups go into their
4311 own new (temporary) binding contour. */
4313 current_binding_level->more_cleanups_ok = 0;
4314 current_function_return_value = NULL_TREE;
4317 /* Return the list of declarations of the current level.
4318 Note that this list is in reverse order unless/until
4319 you nreverse it; and when you do nreverse it, you must
4320 store the result back using `storedecls' or you will lose. */
4325 return current_binding_level->names;
4328 /* Return the list of type-tags (for structs, etc) of the current level. */
4333 return current_binding_level->tags;
4336 /* Store the list of declarations of the current level.
4337 This is done for the parameter declarations of a function being defined,
4338 after they are modified in the light of any missing parameters. */
4344 current_binding_level->names = decls;
4347 /* Similarly, store the list of tags of the current level. */
4353 current_binding_level->tags = tags;
4356 /* Given NAME, an IDENTIFIER_NODE,
4357 return the structure (or union or enum) definition for that name.
4358 Searches binding levels from BINDING_LEVEL up to the global level.
4359 If THISLEVEL_ONLY is nonzero, searches only the specified context
4360 (but skips any tag-transparent contexts to find one that is
4361 meaningful for tags).
4362 FORM says which kind of type the caller wants;
4363 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4364 If the wrong kind of type is found, and it's not a template, an error is
4368 lookup_tag (form, name, binding_level, thislevel_only)
4369 enum tree_code form;
4371 struct binding_level *binding_level;
4374 register struct binding_level *level;
4376 for (level = binding_level; level; level = level->level_chain)
4379 if (ANON_AGGRNAME_P (name))
4380 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4382 /* There's no need for error checking here, because
4383 anon names are unique throughout the compilation. */
4384 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4385 return TREE_VALUE (tail);
4387 else if (level->namespace_p)
4388 /* Do namespace lookup. */
4389 /* XXX: is this a real lookup, considering using-directives etc. ??? */
4390 for (tail = current_namespace; 1; tail = DECL_CONTEXT (tail))
4392 tree old = BINDING_TYPE (binding_for_name (name, tail));
4393 /* If it has an original type, it is a typedef, and we
4394 should not return it. */
4395 if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
4397 if (old && TREE_CODE (old) != form
4398 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
4400 cp_error ("`%#D' redeclared as %C", old, form);
4405 if (thislevel_only || tail == global_namespace)
4409 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4411 if (TREE_PURPOSE (tail) == name)
4413 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
4414 /* Should tighten this up; it'll probably permit
4415 UNION_TYPE and a struct template, for example. */
4417 && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
4419 /* Definition isn't the kind we were looking for. */
4420 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
4424 return TREE_VALUE (tail);
4427 if (thislevel_only && ! level->tag_transparent)
4429 if (level->pseudo_global)
4431 tree t = IDENTIFIER_NAMESPACE_VALUE (name);
4432 if (t && TREE_CODE (t) == TEMPLATE_DECL
4433 && TREE_CODE (DECL_TEMPLATE_RESULT (t)) == TYPE_DECL)
4434 return TREE_TYPE (t);
4438 if (current_class_type && level->level_chain->namespace_p)
4440 /* Try looking in this class's tags before heading into
4441 global binding level. */
4442 tree context = current_class_type;
4445 switch (TREE_CODE_CLASS (TREE_CODE (context)))
4449 these_tags = CLASSTYPE_TAGS (context);
4450 if (ANON_AGGRNAME_P (name))
4453 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags))
4455 return TREE_VALUE (tail);
4456 these_tags = TREE_CHAIN (these_tags);
4461 if (TREE_PURPOSE (these_tags) == name)
4463 if (TREE_CODE (TREE_VALUE (these_tags)) != form)
4465 cp_error ("`%#D' redeclared as %C in class scope",
4466 TREE_VALUE (tail), form);
4469 return TREE_VALUE (tail);
4471 these_tags = TREE_CHAIN (these_tags);
4473 /* If this type is not yet complete, then don't
4474 look at its context. */
4475 if (TYPE_SIZE (context) == NULL_TREE)
4477 /* Go to next enclosing type, if any. */
4478 context = DECL_CONTEXT (TYPE_MAIN_DECL (context));
4481 context = DECL_CONTEXT (context);
4484 my_friendly_abort (10);
4497 set_current_level_tags_transparency (tags_transparent)
4498 int tags_transparent;
4500 current_binding_level->tag_transparent = tags_transparent;
4504 /* Given a type, find the tag that was defined for it and return the tag name.
4505 Otherwise return 0. However, the value can never be 0
4506 in the cases in which this is used.
4508 C++: If NAME is non-zero, this is the new name to install. This is
4509 done when replacing anonymous tags with real tag names. */
4512 lookup_tag_reverse (type, name)
4516 register struct binding_level *level;
4518 for (level = current_binding_level; level; level = level->level_chain)
4521 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4523 if (TREE_VALUE (tail) == type)
4526 TREE_PURPOSE (tail) = name;
4527 return TREE_PURPOSE (tail);
4534 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4535 Return the type value, or NULL_TREE if not found. */
4538 lookup_nested_type (type, context)
4542 if (context == NULL_TREE)
4546 switch (TREE_CODE (context))
4550 tree ctype = TREE_TYPE (context);
4551 tree match = value_member (type, CLASSTYPE_TAGS (ctype));
4553 return TREE_VALUE (match);
4554 context = DECL_CONTEXT (context);
4556 /* When we have a nested class whose member functions have
4557 local types (e.g., a set of enums), we'll arrive here
4558 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4559 the enclosing class. Instead, we want to make sure we
4560 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4561 if (context && TREE_CODE (context) == RECORD_TYPE)
4562 context = TREE_CHAIN (context);
4566 if (TYPE_NAME (type) && TYPE_IDENTIFIER (type))
4567 return lookup_name (TYPE_IDENTIFIER (type), 1);
4570 my_friendly_abort (12);
4576 /* Look up NAME in the NAMESPACE. */
4579 lookup_namespace_name (namespace, name)
4580 tree namespace, name;
4582 struct tree_binding _b;
4585 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
4586 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
4588 val = binding_init (&_b);
4589 if (!qualified_lookup_using_namespace (name, namespace, val))
4590 return error_mark_node;
4592 if (BINDING_VALUE (val))
4593 return BINDING_VALUE (val);
4594 cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
4595 return error_mark_node;
4599 make_typename_type (context, name)
4605 if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
4606 name = TYPE_IDENTIFIER (name);
4607 else if (TREE_CODE (name) == TYPE_DECL)
4608 name = DECL_NAME (name);
4612 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
4614 name = TREE_OPERAND (name, 0);
4615 if (TREE_CODE (name) == TEMPLATE_DECL)
4616 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
4618 if (TREE_CODE (name) != IDENTIFIER_NODE)
4619 my_friendly_abort (2000);
4621 if (! uses_template_parms (context)
4622 || currently_open_class (context))
4624 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
4626 if (IS_AGGR_TYPE (context))
4627 t = lookup_field (context, name, 0, 0);
4631 if (t == NULL_TREE || TREE_CODE (t) != TEMPLATE_DECL
4632 || TREE_CODE (DECL_RESULT (t)) != TYPE_DECL)
4634 cp_error ("no class template named `%#T' in `%#T'",
4636 return error_mark_node;
4639 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
4640 NULL_TREE, context);
4644 if (IS_AGGR_TYPE (context))
4645 t = lookup_field (context, name, 0, 1);
4651 cp_error ("no type named `%#T' in `%#T'", name, context);
4652 return error_mark_node;
4655 return TREE_TYPE (t);
4659 if (processing_template_decl)
4660 push_obstacks (&permanent_obstack, &permanent_obstack);
4661 t = make_lang_type (TYPENAME_TYPE);
4662 TYPENAME_TYPE_FULLNAME (t) = fullname;
4663 d = build_decl (TYPE_DECL, name, t);
4664 if (processing_template_decl)
4667 TYPE_CONTEXT (t) = context;
4668 TYPE_NAME (TREE_TYPE (d)) = d;
4669 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
4670 DECL_CONTEXT (d) = context;
4671 CLASSTYPE_GOT_SEMICOLON (t) = 1;
4676 /* Select the right _DECL from multiple choices. */
4679 select_decl (binding, prefer_type)
4684 val = BINDING_VALUE (binding);
4685 /* If we could have a type and
4686 we have nothing or we need a type and have none. */
4687 if (BINDING_TYPE (binding)
4688 && (!val || (prefer_type && TREE_CODE (val) != TYPE_DECL)))
4689 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
4690 /* Don't return non-types if we really prefer types. */
4691 else if (val && prefer_type > 1 && TREE_CODE (val) != TYPE_DECL
4692 && (!looking_for_template || TREE_CODE (val) != TEMPLATE_DECL))
4697 /* Look up NAME in the current binding level and its superiors in the
4698 namespace of variables, functions and typedefs. Return a ..._DECL
4699 node of some kind representing its definition if there is only one
4700 such declaration, or return a TREE_LIST with all the overloaded
4701 definitions if there are many, or return 0 if it is undefined.
4703 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4704 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4705 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
4706 Otherwise we prefer non-TYPE_DECLs.
4708 If NONCLASS is non-zero, we don't look for the NAME in class scope,
4709 using IDENTIFIER_CLASS_VALUE. */
4712 lookup_name_real (name, prefer_type, nonclass)
4714 int prefer_type, nonclass;
4718 tree from_obj = NULL_TREE;
4719 tree locval, classval;
4721 if (prefer_type == -2)
4723 extern int looking_for_typename;
4724 tree type = NULL_TREE;
4727 prefer_type = looking_for_typename;
4729 /* std:: becomes :: for now. */
4730 if (got_scope == std_node)
4731 got_scope = void_type_node;
4735 else if (got_object != error_mark_node)
4740 if (type == error_mark_node)
4741 return error_mark_node;
4742 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
4743 type = TREE_TYPE (type);
4745 type = complete_type (type);
4747 if (TREE_CODE (type) == VOID_TYPE)
4748 type = global_namespace;
4749 if (TREE_CODE (type) == NAMESPACE_DECL)
4751 struct tree_binding b;
4752 val = binding_init (&b);
4753 if (!qualified_lookup_using_namespace (name, type, val))
4755 val = select_decl (val, prefer_type);
4757 else if (! IS_AGGR_TYPE (type)
4758 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
4759 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
4760 || TREE_CODE (type) == TYPENAME_TYPE)
4761 /* Someone else will give an error about this if needed. */
4763 else if (TYPE_BEING_DEFINED (type))
4765 val = IDENTIFIER_CLASS_VALUE (name);
4766 if (val && DECL_CONTEXT (val) != type)
4768 struct binding_level *b = class_binding_level;
4769 for (val = NULL_TREE; b; b = b->level_chain)
4771 tree t = purpose_member (name, b->class_shadowed);
4772 if (t && TREE_VALUE (t)
4773 && DECL_CONTEXT (TREE_VALUE (t)) == type)
4775 val = TREE_VALUE (t);
4780 if (val == NULL_TREE)
4781 val = lookup_field (type, name, 0, 1);
4783 else if (type == current_class_type)
4784 val = IDENTIFIER_CLASS_VALUE (name);
4786 val = lookup_field (type, name, 0, prefer_type);
4793 else if (got_object && val)
4797 locval = classval = NULL_TREE;
4799 if (!current_binding_level->namespace_p
4800 && IDENTIFIER_LOCAL_VALUE (name)
4801 /* Kludge to avoid infinite recursion with identifier_type_value. */
4802 && (prefer_type <= 0
4803 || TREE_CODE (IDENTIFIER_LOCAL_VALUE (name)) == TYPE_DECL))
4804 locval = IDENTIFIER_LOCAL_VALUE (name);
4806 /* In C++ class fields are between local and global scope,
4807 just before the global scope. */
4808 if (current_class_type && ! nonclass)
4810 classval = IDENTIFIER_CLASS_VALUE (name);
4811 if (classval == NULL_TREE && TYPE_BEING_DEFINED (current_class_type))
4812 /* Try to find values from base classes if we are presently
4813 defining a type. We are presently only interested in
4815 classval = lookup_field (current_class_type, name, 0, 1);
4817 /* Add implicit 'typename' to types from template bases. lookup_field
4818 will do this for us. If classval is actually from an enclosing
4819 scope, lookup_nested_field will get it for us. */
4820 if (processing_template_decl
4821 && classval && TREE_CODE (classval) == TYPE_DECL
4822 && ! currently_open_class (DECL_CONTEXT (classval))
4823 && uses_template_parms (current_class_type)
4824 && ! DECL_ARTIFICIAL (classval))
4825 classval = lookup_field (current_class_type, name, 0, 1);
4827 /* yylex() calls this with -2, since we should never start digging for
4828 the nested name at the point where we haven't even, for example,
4829 created the COMPONENT_REF or anything like that. */
4830 if (classval == NULL_TREE)
4831 classval = lookup_nested_field (name, ! yylex);
4834 if (locval && classval)
4836 if (current_scope () == current_function_decl
4837 && ! hack_decl_function_context (current_function_decl))
4838 /* Not in a nested function. */
4842 /* This is incredibly horrible. The whole concept of
4843 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
4844 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
4846 tree lctx = hack_decl_function_context (locval);
4847 tree cctx = hack_decl_function_context (classval);
4849 if (lctx == current_scope ())
4851 else if (lctx == cctx)
4854 /* I don't know which is right; let's just guess for now. */
4864 /* Unscoped lookup of a global, iterate over namespaces,
4865 considering using namespace statements. */
4866 struct tree_binding _binding;
4867 tree b = binding_init (&_binding);
4868 tree initial = current_decl_namespace();
4869 tree scope = initial;
4873 val = binding_for_name (name, scope);
4874 /* Initialize binding for this context. */
4875 BINDING_VALUE (b) = BINDING_VALUE (val);
4876 BINDING_TYPE (b) = BINDING_TYPE (val);
4877 /* Add all _DECLs seen through using-directives. */
4878 if (!lookup_using_namespace (name, b, initial, scope))
4880 /* Give up because of error. */
4884 val = select_decl (b, prefer_type);
4885 if (scope == global_namespace)
4887 scope = DECL_CONTEXT (scope);
4894 /* This should only warn about types used in qualified-ids. */
4895 if (from_obj && from_obj != val)
4897 if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
4898 && TREE_CODE (val) == TYPE_DECL
4899 && TREE_TYPE (from_obj) != TREE_TYPE (val))
4901 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
4902 name, got_object, TREE_TYPE (from_obj));
4903 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
4910 if ((TREE_CODE (val) == TEMPLATE_DECL && looking_for_template)
4911 || TREE_CODE (val) == TYPE_DECL || prefer_type <= 0)
4913 /* Caller wants a class-or-namespace-name. */
4914 else if (prefer_type == 1 && TREE_CODE (val) == NAMESPACE_DECL)
4916 else if (IDENTIFIER_HAS_TYPE_VALUE (name))
4917 val = TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name));
4918 else if (TREE_TYPE (val) == error_mark_node)
4919 val = error_mark_node;
4928 lookup_name_nonclass (name)
4931 return lookup_name_real (name, 0, 1);
4935 lookup_function_nonclass (name, args)
4939 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
4943 lookup_name (name, prefer_type)
4947 return lookup_name_real (name, prefer_type, 0);
4950 /* Similar to `lookup_name' but look only at current binding level. */
4953 lookup_name_current_level (name)
4956 register tree t = NULL_TREE;
4958 if (current_binding_level->namespace_p)
4960 t = IDENTIFIER_NAMESPACE_VALUE (name);
4962 /* extern "C" function() */
4963 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4966 else if (IDENTIFIER_LOCAL_VALUE (name) != NULL_TREE)
4968 struct binding_level *b = current_binding_level;
4971 for (t = b->names; t; t = TREE_CHAIN (t))
4972 if (DECL_NAME (t) == name || DECL_ASSEMBLER_NAME (t) == name)
4986 /* Arrange for the user to get a source line number, even when the
4987 compiler is going down in flames, so that she at least has a
4988 chance of working around problems in the compiler. We used to
4989 call error(), but that let the segmentation fault continue
4990 through; now, it's much more passive by asking them to send the
4991 maintainers mail about the problem. */
4995 int sig ATTRIBUTE_UNUSED;
4997 signal (SIGSEGV, SIG_DFL);
4999 signal (SIGIOT, SIG_DFL);
5002 signal (SIGILL, SIG_DFL);
5005 signal (SIGABRT, SIG_DFL);
5008 signal (SIGBUS, SIG_DFL);
5010 my_friendly_abort (0);
5014 /* Unused -- brendan 970107 */
5015 /* Array for holding types considered "built-in". These types
5016 are output in the module in which `main' is defined. */
5017 static tree *builtin_type_tdescs_arr;
5018 static int builtin_type_tdescs_len, builtin_type_tdescs_max;
5021 /* Push the declarations of builtin types into the namespace.
5022 RID_INDEX, if < RID_MAX is the index of the builtin type
5023 in the array RID_POINTERS. NAME is the name used when looking
5024 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5027 record_builtin_type (rid_index, name, type)
5032 tree rname = NULL_TREE, tname = NULL_TREE;
5033 tree tdecl = NULL_TREE;
5035 if ((int) rid_index < (int) RID_MAX)
5036 rname = ridpointers[(int) rid_index];
5038 tname = get_identifier (name);
5040 TYPE_BUILT_IN (type) = 1;
5044 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5045 set_identifier_type_value (tname, NULL_TREE);
5046 if ((int) rid_index < (int) RID_MAX)
5047 /* Built-in types live in the global namespace. */
5048 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5050 if (rname != NULL_TREE)
5052 if (tname != NULL_TREE)
5054 set_identifier_type_value (rname, NULL_TREE);
5055 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5059 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5060 set_identifier_type_value (rname, NULL_TREE);
5065 /* Push overloaded decl, in global scope, with one argument so it
5066 can be used as a callback from define_function. */
5069 push_overloaded_decl_1 (x)
5072 push_overloaded_decl (x, 0);
5079 auto_function (name, type, code)
5081 enum built_in_function code;
5083 return define_function
5084 (IDENTIFIER_POINTER (name), type, code, push_overloaded_decl_1,
5085 IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5089 /* Create the predefined scalar types of C,
5090 and some nodes representing standard constants (0, 1, (void *)0).
5091 Initialize the global binding level.
5092 Make definitions for built-in primitive functions. */
5095 init_decl_processing ()
5098 register tree endlink, int_endlink, double_endlink, unsigned_endlink;
5100 /* Data type of memcpy. */
5101 tree memcpy_ftype, strlen_ftype;
5102 int wchar_type_size;
5104 tree array_domain_type;
5105 extern int flag_strict_prototype;
5106 tree vb_off_identifier = NULL_TREE;
5107 /* Function type `char *(char *, char *)' and similar ones */
5108 tree string_ftype_ptr_ptr, int_ftype_string_string;
5109 tree sizetype_endlink;
5110 tree ptr_ftype, ptr_ftype_unsigned, ptr_ftype_sizetype;
5111 tree void_ftype, void_ftype_int, void_ftype_ptr, ptr_ftype_void;
5113 /* Have to make these distinct before we try using them. */
5114 lang_name_cplusplus = get_identifier ("C++");
5115 lang_name_c = get_identifier ("C");
5116 lang_name_java = get_identifier ("Java");
5118 /* Enter the global namespace. */
5119 my_friendly_assert (global_namespace == NULL_TREE, 375);
5120 my_friendly_assert (current_lang_name == NULL_TREE, 375);
5121 current_lang_name = lang_name_cplusplus;
5122 push_namespace (get_identifier ("::"));
5123 global_namespace = current_namespace;
5124 current_lang_name = NULL_TREE;
5126 if (flag_strict_prototype == 2)
5129 strict_prototypes_lang_c = strict_prototypes_lang_cplusplus;
5132 strict_prototypes_lang_c = flag_strict_prototype;
5135 current_lang_name = lang_name_c;
5137 current_function_decl = NULL_TREE;
5138 named_labels = NULL_TREE;
5139 named_label_uses = NULL;
5140 current_binding_level = NULL_BINDING_LEVEL;
5141 free_binding_level = NULL_BINDING_LEVEL;
5143 #ifndef __CYGWIN32__
5144 /* Because most segmentation signals can be traced back into user
5145 code, catch them and at least give the user a chance of working
5146 around compiler bugs. */
5147 signal (SIGSEGV, signal_catch);
5149 /* We will also catch aborts in the back-end through signal_catch and
5150 give the user a chance to see where the error might be, and to defeat
5151 aborts in the back-end when there have been errors previously in their
5154 signal (SIGIOT, signal_catch);
5157 signal (SIGILL, signal_catch);
5160 signal (SIGABRT, signal_catch);
5163 signal (SIGBUS, signal_catch);
5165 #else /* ndef __CYGWIN32__ */
5166 /* Cygwin32 cannot handle catching signals other than
5167 SIGABRT yet. We hope this will cease to be the case soon. */
5169 signal (SIGABRT, signal_catch);
5171 #endif /* ndef __CYGWIN32__ */
5173 gcc_obstack_init (&decl_obstack);
5175 /* Must lay these out before anything else gets laid out. */
5176 error_mark_node = make_node (ERROR_MARK);
5177 TREE_PERMANENT (error_mark_node) = 1;
5178 TREE_TYPE (error_mark_node) = error_mark_node;
5179 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
5180 TREE_TYPE (error_mark_list) = error_mark_node;
5182 /* Make the binding_level structure for global names. */
5184 global_binding_level = current_binding_level;
5185 /* The global level is the namespace level of ::. */
5186 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
5187 declare_namespace_level ();
5189 this_identifier = get_identifier (THIS_NAME);
5190 in_charge_identifier = get_identifier (IN_CHARGE_NAME);
5191 ctor_identifier = get_identifier (CTOR_NAME);
5192 dtor_identifier = get_identifier (DTOR_NAME);
5193 pfn_identifier = get_identifier (VTABLE_PFN_NAME);
5194 index_identifier = get_identifier (VTABLE_INDEX_NAME);
5195 delta_identifier = get_identifier (VTABLE_DELTA_NAME);
5196 delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
5197 pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
5198 if (flag_handle_signatures)
5200 tag_identifier = get_identifier (SIGTABLE_TAG_NAME);
5201 vb_off_identifier = get_identifier (SIGTABLE_VB_OFF_NAME);
5202 vt_off_identifier = get_identifier (SIGTABLE_VT_OFF_NAME);
5205 /* Define `int' and `char' first so that dbx will output them first. */
5207 integer_type_node = make_signed_type (INT_TYPE_SIZE);
5208 record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
5210 /* Define `char', which is like either `signed char' or `unsigned char'
5211 but not the same as either. */
5215 ? make_signed_type (CHAR_TYPE_SIZE)
5216 : make_unsigned_type (CHAR_TYPE_SIZE));
5217 record_builtin_type (RID_CHAR, "char", char_type_node);
5219 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
5220 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
5222 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
5223 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
5225 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
5226 record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
5227 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
5229 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
5230 record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
5232 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
5233 record_builtin_type (RID_MAX, "long long unsigned int",
5234 long_long_unsigned_type_node);
5235 record_builtin_type (RID_MAX, "long long unsigned",
5236 long_long_unsigned_type_node);
5238 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
5239 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
5240 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
5241 record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
5242 record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
5244 /* `unsigned long' is the standard type for sizeof.
5245 Note that stddef.h uses `unsigned long',
5246 and this must agree, even if long and int are the same size. */
5248 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
5251 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
5253 /* Define both `signed char' and `unsigned char'. */
5254 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
5255 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
5256 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
5257 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
5259 /* These are types that type_for_size and type_for_mode use. */
5260 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
5261 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
5262 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
5263 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
5264 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
5265 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
5266 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
5267 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
5268 intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
5269 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intTI_type_node));
5270 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
5271 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
5272 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
5273 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
5274 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
5275 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
5276 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
5277 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
5278 unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
5279 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intTI_type_node));
5281 float_type_node = make_node (REAL_TYPE);
5282 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
5283 record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
5284 layout_type (float_type_node);
5286 double_type_node = make_node (REAL_TYPE);
5287 if (flag_short_double)
5288 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
5290 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
5291 record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
5292 layout_type (double_type_node);
5294 long_double_type_node = make_node (REAL_TYPE);
5295 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
5296 record_builtin_type (RID_MAX, "long double", long_double_type_node);
5297 layout_type (long_double_type_node);
5299 complex_integer_type_node = make_node (COMPLEX_TYPE);
5300 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
5301 complex_integer_type_node));
5302 TREE_TYPE (complex_integer_type_node) = integer_type_node;
5303 layout_type (complex_integer_type_node);
5305 complex_float_type_node = make_node (COMPLEX_TYPE);
5306 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
5307 complex_float_type_node));
5308 TREE_TYPE (complex_float_type_node) = float_type_node;
5309 layout_type (complex_float_type_node);
5311 complex_double_type_node = make_node (COMPLEX_TYPE);
5312 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
5313 complex_double_type_node));
5314 TREE_TYPE (complex_double_type_node) = double_type_node;
5315 layout_type (complex_double_type_node);
5317 complex_long_double_type_node = make_node (COMPLEX_TYPE);
5318 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
5319 complex_long_double_type_node));
5320 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
5321 layout_type (complex_long_double_type_node);
5323 integer_zero_node = build_int_2 (0, 0);
5324 TREE_TYPE (integer_zero_node) = integer_type_node;
5325 integer_one_node = build_int_2 (1, 0);
5326 TREE_TYPE (integer_one_node) = integer_type_node;
5327 integer_two_node = build_int_2 (2, 0);
5328 TREE_TYPE (integer_two_node) = integer_type_node;
5329 integer_three_node = build_int_2 (3, 0);
5330 TREE_TYPE (integer_three_node) = integer_type_node;
5332 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
5333 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
5334 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
5335 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
5336 TYPE_PRECISION (boolean_type_node) = 1;
5337 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
5338 boolean_false_node = build_int_2 (0, 0);
5339 TREE_TYPE (boolean_false_node) = boolean_type_node;
5340 boolean_true_node = build_int_2 (1, 0);
5341 TREE_TYPE (boolean_true_node) = boolean_type_node;
5343 /* These are needed by stor-layout.c. */
5344 size_zero_node = size_int (0);
5345 size_one_node = size_int (1);
5347 signed_size_zero_node = build_int_2 (0, 0);
5348 TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
5350 void_type_node = make_node (VOID_TYPE);
5351 record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
5352 layout_type (void_type_node); /* Uses integer_zero_node. */
5353 void_list_node = build_tree_list (NULL_TREE, void_type_node);
5354 TREE_PARMLIST (void_list_node) = 1;
5356 null_pointer_node = build_int_2 (0, 0);
5357 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
5358 layout_type (TREE_TYPE (null_pointer_node));
5360 /* Used for expressions that do nothing, but are not errors. */
5361 void_zero_node = build_int_2 (0, 0);
5362 TREE_TYPE (void_zero_node) = void_type_node;
5364 string_type_node = build_pointer_type (char_type_node);
5365 const_string_type_node
5366 = build_pointer_type (build_type_variant (char_type_node, 1, 0));
5368 record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
5371 /* Make a type to be the domain of a few array types
5372 whose domains don't really matter.
5373 200 is small enough that it always fits in size_t
5374 and large enough that it can hold most function names for the
5375 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5376 array_domain_type = build_index_type (build_int_2 (200, 0));
5378 /* Make a type for arrays of characters.
5379 With luck nothing will ever really depend on the length of this
5381 char_array_type_node
5382 = build_array_type (char_type_node, array_domain_type);
5383 /* Likewise for arrays of ints. */
5385 = build_array_type (integer_type_node, array_domain_type);
5387 /* This is just some anonymous class type. Nobody should ever
5388 need to look inside this envelope. */
5389 class_star_type_node = build_pointer_type (make_lang_type (RECORD_TYPE));
5391 default_function_type
5392 = build_function_type (integer_type_node, NULL_TREE);
5394 ptr_type_node = build_pointer_type (void_type_node);
5396 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
5398 record_builtin_type (RID_MAX, NULL_PTR, ptr_type_node);
5400 endlink = void_list_node;
5401 int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
5402 double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
5403 unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
5405 ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
5406 ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
5407 sizetype_endlink = tree_cons (NULL_TREE, sizetype, endlink);
5408 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5409 ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
5411 void_ftype = build_function_type (void_type_node, endlink);
5412 void_ftype_int = build_function_type (void_type_node, int_endlink);
5414 = build_function_type (void_type_node,
5415 tree_cons (NULL_TREE, ptr_type_node, endlink));
5417 = build_exception_variant (void_ftype_ptr,
5418 tree_cons (NULL_TREE, NULL_TREE, NULL_TREE));
5421 = build_function_type (float_type_node,
5422 tree_cons (NULL_TREE, float_type_node, endlink));
5425 = build_function_type (double_type_node, double_endlink);
5427 ldouble_ftype_ldouble
5428 = build_function_type (long_double_type_node,
5429 tree_cons (NULL_TREE, long_double_type_node,
5432 double_ftype_double_double
5433 = build_function_type (double_type_node,
5434 tree_cons (NULL_TREE, double_type_node,
5438 = build_function_type (integer_type_node, int_endlink);
5441 = build_function_type (long_integer_type_node,
5442 tree_cons (NULL_TREE, long_integer_type_node,
5445 int_ftype_cptr_cptr_sizet
5446 = build_function_type (integer_type_node,
5447 tree_cons (NULL_TREE, const_ptr_type_node,
5448 tree_cons (NULL_TREE, const_ptr_type_node,
5449 tree_cons (NULL_TREE,
5453 string_ftype_ptr_ptr /* strcpy prototype */
5454 = build_function_type (string_type_node,
5455 tree_cons (NULL_TREE, string_type_node,
5456 tree_cons (NULL_TREE,
5457 const_string_type_node,
5460 int_ftype_string_string /* strcmp prototype */
5461 = build_function_type (integer_type_node,
5462 tree_cons (NULL_TREE, const_string_type_node,
5463 tree_cons (NULL_TREE,
5464 const_string_type_node,
5467 strlen_ftype /* strlen prototype */
5468 = build_function_type (sizetype,
5469 tree_cons (NULL_TREE, const_string_type_node,
5472 memcpy_ftype /* memcpy prototype */
5473 = build_function_type (ptr_type_node,
5474 tree_cons (NULL_TREE, ptr_type_node,
5475 tree_cons (NULL_TREE, const_ptr_type_node,
5476 sizetype_endlink)));
5478 if (flag_huge_objects)
5479 delta_type_node = long_integer_type_node;
5481 delta_type_node = short_integer_type_node;
5483 builtin_function ("__builtin_constant_p", default_function_type,
5484 BUILT_IN_CONSTANT_P, NULL_PTR);
5486 builtin_return_address_fndecl
5487 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
5488 BUILT_IN_RETURN_ADDRESS, NULL_PTR);
5490 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
5491 BUILT_IN_FRAME_ADDRESS, NULL_PTR);
5493 ptr_ftype_void = build_function_type (ptr_type_node, endlink);
5494 builtin_function ("__builtin_fp", ptr_ftype_void, BUILT_IN_FP, NULL_PTR);
5495 builtin_function ("__builtin_sp", ptr_ftype_void, BUILT_IN_SP, NULL_PTR);
5497 builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
5498 BUILT_IN_ALLOCA, "alloca");
5499 builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
5500 /* Define alloca, ffs as builtins.
5501 Declare _exit just to mark it as volatile. */
5502 if (! flag_no_builtin && !flag_no_nonansi_builtin)
5504 temp = builtin_function ("alloca", ptr_ftype_sizetype,
5505 BUILT_IN_ALLOCA, NULL_PTR);
5506 /* Suppress error if redefined as a non-function. */
5507 DECL_BUILT_IN_NONANSI (temp) = 1;
5508 temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR);
5509 /* Suppress error if redefined as a non-function. */
5510 DECL_BUILT_IN_NONANSI (temp) = 1;
5511 temp = builtin_function ("_exit", void_ftype_int,
5512 NOT_BUILT_IN, NULL_PTR);
5513 TREE_THIS_VOLATILE (temp) = 1;
5514 TREE_SIDE_EFFECTS (temp) = 1;
5515 /* Suppress error if redefined as a non-function. */
5516 DECL_BUILT_IN_NONANSI (temp) = 1;
5519 builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
5520 builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
5522 builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
5524 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5526 builtin_function ("__builtin_labs", long_ftype_long,
5527 BUILT_IN_LABS, NULL_PTR);
5528 builtin_function ("__builtin_saveregs", ptr_ftype,
5529 BUILT_IN_SAVEREGS, NULL_PTR);
5530 builtin_function ("__builtin_classify_type", default_function_type,
5531 BUILT_IN_CLASSIFY_TYPE, NULL_PTR);
5532 builtin_function ("__builtin_next_arg", ptr_ftype,
5533 BUILT_IN_NEXT_ARG, NULL_PTR);
5534 builtin_function ("__builtin_args_info", int_ftype_int,
5535 BUILT_IN_ARGS_INFO, NULL_PTR);
5536 builtin_function ("__builtin_setjmp",
5537 build_function_type (integer_type_node,
5538 tree_cons (NULL_TREE, ptr_type_node,
5540 BUILT_IN_SETJMP, NULL_PTR);
5541 builtin_function ("__builtin_longjmp",
5542 build_function_type (integer_type_node,
5543 tree_cons (NULL_TREE, ptr_type_node,
5544 tree_cons (NULL_TREE,
5547 BUILT_IN_LONGJMP, NULL_PTR);
5549 /* Untyped call and return. */
5550 builtin_function ("__builtin_apply_args", ptr_ftype,
5551 BUILT_IN_APPLY_ARGS, NULL_PTR);
5553 temp = tree_cons (NULL_TREE,
5554 build_pointer_type (build_function_type (void_type_node,
5556 tree_cons (NULL_TREE, ptr_ftype_sizetype, NULL_TREE));
5557 builtin_function ("__builtin_apply",
5558 build_function_type (ptr_type_node, temp),
5559 BUILT_IN_APPLY, NULL_PTR);
5560 builtin_function ("__builtin_return", void_ftype_ptr,
5561 BUILT_IN_RETURN, NULL_PTR);
5563 /* Currently under experimentation. */
5564 builtin_function ("__builtin_memcpy", memcpy_ftype,
5565 BUILT_IN_MEMCPY, "memcpy");
5566 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
5567 BUILT_IN_MEMCMP, "memcmp");
5568 builtin_function ("__builtin_strcmp", int_ftype_string_string,
5569 BUILT_IN_STRCMP, "strcmp");
5570 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
5571 BUILT_IN_STRCPY, "strcpy");
5572 builtin_function ("__builtin_strlen", strlen_ftype,
5573 BUILT_IN_STRLEN, "strlen");
5574 builtin_function ("__builtin_sqrtf", float_ftype_float,
5575 BUILT_IN_FSQRT, "sqrtf");
5576 builtin_function ("__builtin_fsqrt", double_ftype_double,
5577 BUILT_IN_FSQRT, NULL_PTR);
5578 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
5579 BUILT_IN_FSQRT, "sqrtl");
5580 builtin_function ("__builtin_sinf", float_ftype_float,
5581 BUILT_IN_SIN, "sinf");
5582 builtin_function ("__builtin_sin", double_ftype_double,
5583 BUILT_IN_SIN, "sin");
5584 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
5585 BUILT_IN_SIN, "sinl");
5586 builtin_function ("__builtin_cosf", float_ftype_float,
5587 BUILT_IN_COS, "cosf");
5588 builtin_function ("__builtin_cos", double_ftype_double,
5589 BUILT_IN_COS, "cos");
5590 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
5591 BUILT_IN_COS, "cosl");
5593 if (!flag_no_builtin)
5595 builtin_function ("abs", int_ftype_int, BUILT_IN_ABS, NULL_PTR);
5596 builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS, NULL_PTR);
5597 builtin_function ("labs", long_ftype_long, BUILT_IN_LABS, NULL_PTR);
5598 builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS, NULL_PTR);
5599 builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5601 builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY, NULL_PTR);
5602 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
5604 builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
5606 builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
5608 builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN, NULL_PTR);
5609 builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT, NULL_PTR);
5610 builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT, NULL_PTR);
5611 builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
5613 builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN, NULL_PTR);
5614 builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR);
5615 builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN, NULL_PTR);
5616 builtin_function ("cosf", float_ftype_float, BUILT_IN_COS, NULL_PTR);
5617 builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR);
5618 builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS, NULL_PTR);
5620 /* Declare these functions volatile
5621 to avoid spurious "control drops through" warnings. */
5622 temp = builtin_function ("abort", void_ftype,
5623 NOT_BUILT_IN, NULL_PTR);
5624 TREE_THIS_VOLATILE (temp) = 1;
5625 TREE_SIDE_EFFECTS (temp) = 1;
5626 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
5628 DECL_BUILT_IN_NONANSI (temp) = 1;
5629 temp = builtin_function ("exit", void_ftype_int,
5630 NOT_BUILT_IN, NULL_PTR);
5631 TREE_THIS_VOLATILE (temp) = 1;
5632 TREE_SIDE_EFFECTS (temp) = 1;
5633 DECL_BUILT_IN_NONANSI (temp) = 1;
5637 /* Support for these has not been written in either expand_builtin
5638 or build_function_call. */
5639 builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV, NULL_PTR);
5640 builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV, NULL_PTR);
5641 builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
5643 builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
5645 builtin_function ("__builtin_fmod", double_ftype_double_double,
5646 BUILT_IN_FMOD, NULL_PTR);
5647 builtin_function ("__builtin_frem", double_ftype_double_double,
5648 BUILT_IN_FREM, NULL_PTR);
5649 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int,
5650 BUILT_IN_MEMSET, NULL_PTR);
5651 builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
5653 builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
5657 /* C++ extensions */
5659 unknown_type_node = make_node (UNKNOWN_TYPE);
5660 decl = pushdecl (build_decl (TYPE_DECL, get_identifier ("unknown type"),
5661 unknown_type_node));
5662 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5663 DECL_IGNORED_P (decl) = 1;
5664 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5665 TYPE_SIZE (unknown_type_node) = TYPE_SIZE (void_type_node);
5666 TYPE_ALIGN (unknown_type_node) = 1;
5667 TYPE_MODE (unknown_type_node) = TYPE_MODE (void_type_node);
5668 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
5669 TREE_TYPE (unknown_type_node) = unknown_type_node;
5672 TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
5674 TREE_TYPE (null_node) = build_pointer_type (unknown_type_node);
5676 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
5678 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
5679 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
5681 /* This is for handling opaque types in signatures. */
5682 opaque_type_node = copy_node (ptr_type_node);
5683 TYPE_MAIN_VARIANT (opaque_type_node) = opaque_type_node;
5684 record_builtin_type (RID_MAX, 0, opaque_type_node);
5686 /* This is special for C++ so functions can be overloaded. */
5688 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE)));
5689 wchar_type_size = TYPE_PRECISION (wchar_type_node);
5690 signed_wchar_type_node = make_signed_type (wchar_type_size);
5691 unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
5693 = TREE_UNSIGNED (wchar_type_node)
5694 ? unsigned_wchar_type_node
5695 : signed_wchar_type_node;
5696 record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
5698 /* Artificial declaration of wchar_t -- can be bashed */
5699 wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
5701 pushdecl (wchar_decl_node);
5703 /* This is for wide string constants. */
5704 wchar_array_type_node
5705 = build_array_type (wchar_type_node, array_domain_type);
5707 if (flag_vtable_thunks)
5709 /* Make sure we get a unique function type, so we can give
5710 its pointer type a name. (This wins for gdb.) */
5711 tree vfunc_type = make_node (FUNCTION_TYPE);
5712 TREE_TYPE (vfunc_type) = integer_type_node;
5713 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
5714 layout_type (vfunc_type);
5716 vtable_entry_type = build_pointer_type (vfunc_type);
5720 vtable_entry_type = make_lang_type (RECORD_TYPE);
5721 fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
5723 fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
5725 fields[2] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
5727 finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
5730 /* Make this part of an invisible union. */
5731 fields[3] = copy_node (fields[2]);
5732 TREE_TYPE (fields[3]) = delta_type_node;
5733 DECL_NAME (fields[3]) = delta2_identifier;
5734 DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
5735 DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
5736 TREE_UNSIGNED (fields[3]) = 0;
5737 TREE_CHAIN (fields[2]) = fields[3];
5738 vtable_entry_type = build_type_variant (vtable_entry_type, 1, 0);
5740 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
5743 = build_array_type (vtable_entry_type, NULL_TREE);
5744 layout_type (vtbl_type_node);
5745 vtbl_type_node = cp_build_type_variant (vtbl_type_node, 1, 0);
5746 record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
5748 /* Simplify life by making a "sigtable_entry_type". Give its
5749 fields names so that the debugger can use them. */
5751 if (flag_handle_signatures)
5753 sigtable_entry_type = make_lang_type (RECORD_TYPE);
5754 fields[0] = build_lang_field_decl (FIELD_DECL, tag_identifier,
5756 fields[1] = build_lang_field_decl (FIELD_DECL, vb_off_identifier,
5758 fields[2] = build_lang_field_decl (FIELD_DECL, delta_identifier,
5760 fields[3] = build_lang_field_decl (FIELD_DECL, index_identifier,
5762 fields[4] = build_lang_field_decl (FIELD_DECL, pfn_identifier,
5765 /* Set the alignment to the max of the alignment of ptr_type_node and
5766 delta_type_node. Double alignment wastes a word on the Sparc. */
5767 finish_builtin_type (sigtable_entry_type, SIGTABLE_PTR_TYPE, fields, 4,
5768 (TYPE_ALIGN (ptr_type_node) > TYPE_ALIGN (delta_type_node))
5772 /* Make this part of an invisible union. */
5773 fields[5] = copy_node (fields[4]);
5774 TREE_TYPE (fields[5]) = delta_type_node;
5775 DECL_NAME (fields[5]) = vt_off_identifier;
5776 DECL_MODE (fields[5]) = TYPE_MODE (delta_type_node);
5777 DECL_SIZE (fields[5]) = TYPE_SIZE (delta_type_node);
5778 TREE_UNSIGNED (fields[5]) = 0;
5779 TREE_CHAIN (fields[4]) = fields[5];
5781 sigtable_entry_type = build_type_variant (sigtable_entry_type, 1, 0);
5782 record_builtin_type (RID_MAX, SIGTABLE_PTR_TYPE, sigtable_entry_type);
5785 std_node = build_decl (NAMESPACE_DECL,
5786 get_identifier (flag_honor_std ? "fake std":"std"),
5788 pushdecl (std_node);
5790 global_type_node = make_node (LANG_TYPE);
5791 record_builtin_type (RID_MAX, "global type", global_type_node);
5794 current_lang_name = lang_name_cplusplus;
5797 tree bad_alloc_type_node, newtype, deltype;
5799 push_namespace (get_identifier ("std"));
5800 bad_alloc_type_node = xref_tag
5801 (class_type_node, get_identifier ("bad_alloc"), NULL_TREE, 1);
5804 newtype = build_exception_variant
5805 (ptr_ftype_sizetype, build_tree_list (NULL_TREE, bad_alloc_type_node));
5806 deltype = build_exception_variant
5807 (void_ftype_ptr, build_tree_list (NULL_TREE, NULL_TREE));
5808 auto_function (ansi_opname[(int) NEW_EXPR], newtype, NOT_BUILT_IN);
5809 auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype, NOT_BUILT_IN);
5810 auto_function (ansi_opname[(int) DELETE_EXPR], deltype, NOT_BUILT_IN);
5811 auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype, NOT_BUILT_IN);
5815 = define_function ("__pure_virtual", void_ftype,
5816 NOT_BUILT_IN, 0, 0);
5818 /* Perform other language dependent initializations. */
5819 init_class_processing ();
5820 init_init_processing ();
5821 init_search_processing ();
5823 init_rtti_processing ();
5825 if (flag_exceptions)
5826 init_exception_processing ();
5829 flag_inline_functions = 0;
5832 if (! supports_one_only ())
5835 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
5836 declare_function_name ();
5838 /* Prepare to check format strings against argument lists. */
5839 init_function_format_info ();
5841 /* Show we use EH for cleanups. */
5842 using_eh_for_cleanups ();
5845 /* Make a definition for a builtin function named NAME and whose data type
5846 is TYPE. TYPE should be a function type with argument types.
5847 FUNCTION_CODE tells later passes how to compile calls to this function.
5848 See tree.h for its possible values.
5850 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
5851 the name to be called if we can't opencode the function. */
5854 define_function (name, type, function_code, pfn, library_name)
5857 enum built_in_function function_code;
5858 void (*pfn) PROTO((tree));
5861 tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
5862 DECL_EXTERNAL (decl) = 1;
5863 TREE_PUBLIC (decl) = 1;
5864 DECL_ARTIFICIAL (decl) = 1;
5866 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
5867 DECL_CONTEXT (decl) = current_namespace;
5869 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
5870 we cannot change DECL_ASSEMBLER_NAME until we have installed this
5871 function in the namespace. */
5872 if (pfn) (*pfn) (decl);
5874 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
5875 make_function_rtl (decl);
5876 if (function_code != NOT_BUILT_IN)
5878 DECL_BUILT_IN (decl) = 1;
5879 DECL_FUNCTION_CODE (decl) = function_code;
5884 /* Called when a declaration is seen that contains no names to declare.
5885 If its type is a reference to a structure, union or enum inherited
5886 from a containing scope, shadow that tag name for the current scope
5887 with a forward reference.
5888 If its type defines a new named structure or union
5889 or defines an enum, it is valid but we need not do anything here.
5890 Otherwise, it is an error.
5892 C++: may have to grok the declspecs to learn about static,
5893 complain for anonymous unions. */
5896 shadow_tag (declspecs)
5900 tree ob_modifier = NULL_TREE;
5902 register enum tree_code code, ok_code = ERROR_MARK;
5903 register tree t = NULL_TREE;
5905 for (link = declspecs; link; link = TREE_CHAIN (link))
5907 register tree value = TREE_VALUE (link);
5909 code = TREE_CODE (value);
5910 if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE)
5912 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
5914 if (IS_AGGR_TYPE (value) && CLASSTYPE_USE_TEMPLATE (value))
5916 if (CLASSTYPE_IMPLICIT_INSTANTIATION (value)
5917 && TYPE_SIZE (value) == NULL_TREE)
5919 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (value);
5920 if (processing_template_decl)
5921 push_template_decl (TYPE_MAIN_DECL (value));
5923 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (value))
5924 cp_error ("specialization after instantiation of `%T'", value);
5931 else if (value == ridpointers[(int) RID_STATIC]
5932 || value == ridpointers[(int) RID_EXTERN]
5933 || value == ridpointers[(int) RID_AUTO]
5934 || value == ridpointers[(int) RID_REGISTER]
5935 || value == ridpointers[(int) RID_INLINE]
5936 || value == ridpointers[(int) RID_VIRTUAL]
5937 || value == ridpointers[(int) RID_EXPLICIT])
5938 ob_modifier = value;
5941 /* This is where the variables in an anonymous union are
5942 declared. An anonymous union declaration looks like:
5944 because there is no declarator after the union, the parser
5945 sends that declaration here. */
5946 if (ok_code == UNION_TYPE
5948 && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
5949 && ANON_AGGRNAME_P (TYPE_NAME (t)))
5950 || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
5951 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))))
5953 /* See also grok_x_components. */
5956 /* Wipe out memory of synthesized methods */
5957 TYPE_HAS_CONSTRUCTOR (t) = 0;
5958 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
5959 TYPE_HAS_INIT_REF (t) = 0;
5960 TYPE_HAS_CONST_INIT_REF (t) = 0;
5961 TYPE_HAS_ASSIGN_REF (t) = 0;
5962 TYPE_HAS_ASSIGNMENT (t) = 0;
5963 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
5965 q = &TYPE_METHODS (t);
5968 if (DECL_ARTIFICIAL (*q))
5969 *q = TREE_CHAIN (*q);
5971 q = &TREE_CHAIN (*q);
5974 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
5975 function members. */
5976 if (TYPE_METHODS (t))
5977 error ("an anonymous union cannot have function members");
5979 if (TYPE_FIELDS (t))
5981 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
5983 finish_anon_union (decl);
5988 /* Anonymous unions are objects, that's why we only check for
5989 inappropriate specifiers in this branch. */
5993 if (ob_modifier == ridpointers[(int) RID_INLINE]
5994 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
5995 cp_error ("`%D' can only be specified for functions", ob_modifier);
5996 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
5997 cp_error ("`%D' can only be specified for constructors",
6000 cp_error ("`%D' can only be specified for objects and functions",
6005 cp_error ("abstract declarator used as declaration");
6006 else if (found_tag > 1)
6007 pedwarn ("multiple types in one declaration");
6011 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6014 groktypename (typename)
6017 if (TREE_CODE (typename) != TREE_LIST)
6019 return grokdeclarator (TREE_VALUE (typename),
6020 TREE_PURPOSE (typename),
6021 TYPENAME, 0, NULL_TREE);
6024 /* Decode a declarator in an ordinary declaration or data definition.
6025 This is called as soon as the type information and variable name
6026 have been parsed, before parsing the initializer if any.
6027 Here we create the ..._DECL node, fill in its type,
6028 and put it on the list of decls for the current context.
6029 The ..._DECL node is returned as the value.
6031 Exception: for arrays where the length is not specified,
6032 the type is left null, to be filled in by `cp_finish_decl'.
6034 Function definitions do not come here; they go to start_function
6035 instead. However, external and forward declarations of functions
6036 do go through here. Structure field declarations are done by
6037 grokfield and not through here. */
6039 /* Set this to zero to debug not using the temporary obstack
6040 to parse initializers. */
6041 int debug_temp_inits = 1;
6044 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6045 tree declarator, declspecs;
6047 tree attributes, prefix_attributes;
6050 register tree type, tem;
6052 extern int have_extern_spec;
6053 extern int used_extern_spec;
6056 /* See code below that used this. */
6057 int init_written = initialized;
6060 /* This should only be done once on the top most decl. */
6061 if (have_extern_spec && !used_extern_spec)
6063 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6065 used_extern_spec = 1;
6068 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6070 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6073 type = TREE_TYPE (decl);
6075 /* Don't lose if destructors must be executed at file-level. */
6076 if (! processing_template_decl && TREE_STATIC (decl)
6077 && TYPE_NEEDS_DESTRUCTOR (complete_type (type))
6078 && !TREE_PERMANENT (decl))
6080 push_obstacks (&permanent_obstack, &permanent_obstack);
6081 decl = copy_node (decl);
6082 if (TREE_CODE (type) == ARRAY_TYPE)
6084 tree itype = TYPE_DOMAIN (type);
6085 if (itype && ! TREE_PERMANENT (itype))
6087 itype = build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype)));
6088 type = build_cplus_array_type (TREE_TYPE (type), itype);
6089 TREE_TYPE (decl) = type;
6096 = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6097 ? DECL_CLASS_CONTEXT (decl)
6098 : DECL_CONTEXT (decl);
6100 /* We are only interested in class contexts, later. */
6101 if (context && TREE_CODE (context) == NAMESPACE_DECL)
6102 context = NULL_TREE;
6105 /* Is it valid for this decl to have an initializer at all?
6106 If not, set INITIALIZED to zero, which will indirectly
6107 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6108 switch (TREE_CODE (decl))
6111 /* typedef foo = bar means give foo the same type as bar.
6112 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6113 Any other case of an initialization in a TYPE_DECL is an error. */
6114 if (pedantic || list_length (declspecs) > 1)
6116 cp_error ("typedef `%D' is initialized", decl);
6122 cp_error ("function `%#D' is initialized like a variable", decl);
6127 if (! processing_template_decl)
6129 if (type != error_mark_node)
6131 if (TYPE_SIZE (type) != NULL_TREE
6132 && ! TREE_CONSTANT (TYPE_SIZE (type)))
6135 ("variable-sized object `%D' may not be initialized",
6140 if (TREE_CODE (type) == ARRAY_TYPE
6141 && TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6144 ("elements of array `%#D' have incomplete type", decl);
6153 if (! toplevel_bindings_p ()
6154 && DECL_EXTERNAL (decl))
6155 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6157 DECL_EXTERNAL (decl) = 0;
6158 if (toplevel_bindings_p ())
6159 TREE_STATIC (decl) = 1;
6161 /* Tell `pushdecl' this is an initialized decl
6162 even though we don't yet have the initializer expression.
6163 Also tell `cp_finish_decl' it may store the real initializer. */
6164 DECL_INITIAL (decl) = error_mark_node;
6167 if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6169 if (TREE_CODE (decl) == VAR_DECL)
6171 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6172 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6173 cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6176 if (DECL_CONTEXT (field) != context)
6178 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6179 DECL_CONTEXT (field), DECL_NAME (decl),
6180 context, DECL_NAME (decl));
6181 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6183 /* Static data member are tricky; an in-class initialization
6184 still doesn't provide a definition, so the in-class
6185 declaration will have DECL_EXTERNAL set, but will have an
6186 initialization. Thus, duplicate_decls won't warn
6187 about this situation, and so we check here. */
6188 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6189 cp_error ("duplicate initialization of %D", decl);
6190 if (duplicate_decls (decl, field))
6196 tree field = check_classfn (context, decl);
6197 if (field && duplicate_decls (decl, field))
6201 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6202 if (DECL_LANG_SPECIFIC (decl))
6203 DECL_IN_AGGR_P (decl) = 0;
6204 if (DECL_USE_TEMPLATE (decl) || CLASSTYPE_USE_TEMPLATE (context))
6205 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6207 /* Stupid stupid stupid stupid (jason 7/21/95) */
6208 if (pedantic && DECL_EXTERNAL (decl)
6209 && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6210 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6213 pushclass (context, 2);
6216 /* Set attributes here so if duplicate decl, will have proper attributes. */
6217 cplus_decl_attributes (decl, attributes, prefix_attributes);
6219 /* Add this decl to the current binding level, but not if it
6220 comes from another scope, e.g. a static member variable.
6221 TEM may equal DECL or it may be a previous decl of the same name. */
6223 if ((TREE_CODE (decl) != PARM_DECL && DECL_CONTEXT (decl) != NULL_TREE
6224 /* Definitions of namespace members outside their namespace are
6226 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
6227 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
6228 || TREE_CODE (type) == LANG_TYPE
6229 /* The declaration of template specializations does not affect
6230 the functions available for overload resolution, so we do not
6232 || (TREE_CODE (decl) == FUNCTION_DECL
6233 && DECL_TEMPLATE_SPECIALIZATION (decl)))
6236 tem = pushdecl (decl);
6238 if (processing_template_decl)
6240 if (! current_function_decl)
6241 tem = push_template_decl (tem);
6242 else if (minimal_parse_mode)
6244 = build_min_nt (DECL_STMT, copy_to_permanent (declarator),
6245 copy_to_permanent (declspecs),
6250 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6251 /* Tell the back-end to use or not use .common as appropriate. If we say
6252 -fconserve-space, we want this to save .data space, at the expense of
6253 wrong semantics. If we say -fno-conserve-space, we want this to
6254 produce errors about redefs; to do this we force variables into the
6256 DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6259 if (! processing_template_decl)
6262 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6263 push_obstacks_nochange ();
6266 /* We have no way of knowing whether the initializer will need to be
6267 evaluated at run-time or not until we've parsed it, so let's just put
6268 it in the permanent obstack. (jason) */
6270 && ! (TREE_CODE (tem) == PARM_DECL
6271 || (TREE_READONLY (tem)
6272 && (TREE_CODE (tem) == VAR_DECL
6273 || TREE_CODE (tem) == FIELD_DECL))))
6275 /* When parsing and digesting the initializer,
6276 use temporary storage. Do this even if we will ignore the value. */
6277 if (toplevel_bindings_p () && debug_temp_inits)
6279 if (processing_template_decl
6280 || TYPE_NEEDS_CONSTRUCTING (type)
6281 || TREE_CODE (type) == REFERENCE_TYPE)
6282 /* In this case, the initializer must lay down in permanent
6283 storage, since it will be saved until `finish_file' is run. */
6286 temporary_allocation ();
6298 tree type = TREE_TYPE (decl);
6299 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6301 /* If this type of object needs a cleanup, and control may
6302 jump past it, make a new binding level so that it is cleaned
6303 up only when it is initialized first. */
6304 if (TYPE_NEEDS_DESTRUCTOR (type)
6305 && current_binding_level->more_cleanups_ok == 0)
6306 pushlevel_temporary (1);
6309 /* Is it valid for this decl to have an initializer at all?
6310 If not, set INITIALIZED to zero, which will indirectly
6311 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6313 /* Don't allow initializations for incomplete types except for
6314 arrays which might be completed by the initialization. */
6315 if (type == error_mark_node)
6316 ; /* Don't complain again. */
6317 else if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6318 ; /* A complete type is ok. */
6319 else if (TREE_CODE (type) != ARRAY_TYPE)
6321 cp_error ("variable `%#D' has initializer but incomplete type",
6325 else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6327 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6328 cp_error ("elements of array `%#D' have incomplete type", decl);
6329 /* else we already gave an error in start_decl. */
6335 && TREE_CODE (decl) != TYPE_DECL
6336 && TREE_CODE (decl) != TEMPLATE_DECL
6337 && IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
6339 if ((! processing_template_decl || ! uses_template_parms (type))
6340 && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6342 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6344 /* Change the type so that assemble_variable will give
6345 DECL an rtl we can live with: (mem (const_int 0)). */
6346 TREE_TYPE (decl) = error_mark_node;
6347 type = error_mark_node;
6351 /* If any base type in the hierarchy of TYPE needs a constructor,
6352 then we set initialized to 1. This way any nodes which are
6353 created for the purposes of initializing this aggregate
6354 will live as long as it does. This is necessary for global
6355 aggregates which do not have their initializers processed until
6356 the end of the file. */
6357 initialized = TYPE_NEEDS_CONSTRUCTING (type);
6362 /* We don't do this yet for GNU C++. */
6363 /* For a local variable, define the RTL now. */
6364 if (! toplevel_bindings_p ()
6365 /* But not if this is a duplicate decl
6366 and we preserved the rtl from the previous one
6367 (which may or may not happen). */
6368 && DECL_RTL (tem) == NULL_RTX)
6370 if (TYPE_SIZE (TREE_TYPE (tem)) != NULL_TREE)
6372 else if (TREE_CODE (TREE_TYPE (tem)) == ARRAY_TYPE
6373 && DECL_INITIAL (tem) != NULL_TREE)
6379 DECL_INITIAL (decl) = NULL_TREE;
6382 /* Handle initialization of references.
6383 These three arguments are from `cp_finish_decl', and have the
6384 same meaning here that they do there.
6386 Quotes on semantics can be found in ARM 8.4.3. */
6389 grok_reference_init (decl, type, init)
6390 tree decl, type, init;
6394 if (init == NULL_TREE)
6396 if ((DECL_LANG_SPECIFIC (decl) == 0
6397 || DECL_IN_AGGR_P (decl) == 0)
6398 && ! DECL_THIS_EXTERN (decl))
6400 cp_error ("`%D' declared as reference but not initialized", decl);
6401 if (TREE_CODE (decl) == VAR_DECL)
6402 SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
6407 if (init == error_mark_node)
6410 if (TREE_CODE (type) == REFERENCE_TYPE
6411 && TREE_CODE (init) == CONSTRUCTOR)
6413 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
6417 if (TREE_TYPE (init) && TREE_CODE (TREE_TYPE (init)) == UNKNOWN_TYPE)
6418 /* decay_conversion is probably wrong for references to functions. */
6419 init = decay_conversion (instantiate_type (TREE_TYPE (type), init, 1));
6421 if (TREE_CODE (init) == TREE_LIST)
6422 init = build_compound_expr (init);
6424 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6425 init = convert_from_reference (init);
6427 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6428 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6430 /* Note: default conversion is only called in very special cases. */
6431 init = default_conversion (init);
6434 tmp = convert_to_reference
6435 (type, init, CONV_IMPLICIT,
6436 LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6438 if (tmp == error_mark_node)
6440 else if (tmp != NULL_TREE)
6443 DECL_INITIAL (decl) = save_expr (init);
6447 cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6451 /* ?? Can this be optimized in some cases to
6452 hand back the DECL_INITIAL slot?? */
6453 if (TYPE_SIZE (TREE_TYPE (type)))
6455 init = convert_from_reference (decl);
6456 if (TREE_PERMANENT (decl))
6457 init = copy_to_permanent (init);
6458 SET_DECL_REFERENCE_SLOT (decl, init);
6461 if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6463 expand_static_init (decl, DECL_INITIAL (decl));
6464 DECL_INITIAL (decl) = NULL_TREE;
6469 if (TREE_CODE (decl) == VAR_DECL)
6470 SET_DECL_REFERENCE_SLOT (decl, error_mark_node);
6474 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6475 mucking with forces it does not comprehend (i.e. initialization with a
6476 constructor). If we are at global scope and won't go into COMMON, fill
6477 it in with a dummy CONSTRUCTOR to force the variable into .data;
6478 otherwise we can use error_mark_node. */
6481 obscure_complex_init (decl, init)
6484 if (! flag_no_inline && TREE_STATIC (decl))
6486 if (extract_init (decl, init))
6490 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6491 if (toplevel_bindings_p () && ! DECL_COMMON (decl))
6492 DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
6496 DECL_INITIAL (decl) = error_mark_node;
6501 /* Finish processing of a declaration;
6502 install its line number and initial value.
6503 If the length of an array type is not known before,
6504 it must be determined now, from the initial value, or it is an error.
6506 Call `pop_obstacks' iff NEED_POP is nonzero.
6508 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
6509 for aggregates that have constructors alive on the permanent obstack,
6510 so that the global initializing functions can be written at the end.
6512 INIT0 holds the value of an initializer that should be allowed to escape
6515 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
6516 if the (init) syntax was used.
6518 For functions that take default parameters, DECL points to its
6519 "maximal" instantiation. `cp_finish_decl' must then also declared its
6520 subsequently lower and lower forms of instantiation, checking for
6521 ambiguity as it goes. This can be sped up later. */
6524 cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
6531 tree cleanup = NULL_TREE, ttype = NULL_TREE;
6533 int temporary = allocation_temporary_p ();
6534 char *asmspec = NULL;
6535 int was_readonly = 0;
6536 int already_used = 0;
6538 /* If this is 0, then we did not change obstacks. */
6542 error ("assignment (not initialization) in declaration");
6546 /* If a name was specified, get the string. */
6548 asmspec = TREE_STRING_POINTER (asmspec_tree);
6550 if (init && TREE_CODE (init) == NAMESPACE_DECL)
6552 cp_error ("Cannot initialize `%D' to namespace `%D'",
6557 /* If the type of the thing we are declaring either has
6558 a constructor, or has a virtual function table pointer,
6559 AND its initialization was accepted by `start_decl',
6560 then we stayed on the permanent obstack through the
6561 declaration, otherwise, changed obstacks as GCC would. */
6563 type = TREE_TYPE (decl);
6565 if (type == error_mark_node)
6567 if (toplevel_bindings_p () && temporary)
6568 end_temporary_allocation ();
6573 if (processing_template_decl)
6575 if (init && DECL_INITIAL (decl))
6576 DECL_INITIAL (decl) = init;
6577 if (minimal_parse_mode && ! DECL_ARTIFICIAL (decl))
6579 tree stmt = DECL_VINDEX (decl);
6580 /* If the decl is declaring a member of a local class (in a
6581 template function), the DECL_VINDEX will either be NULL,
6582 or it will be an actual virtual function index, not a
6584 if (stmt != NULL_TREE && TREE_CODE (stmt) == DECL_STMT)
6586 DECL_VINDEX (decl) = NULL_TREE;
6587 TREE_OPERAND (stmt, 2) = copy_to_permanent (init);
6594 /* Take care of TYPE_DECLs up front. */
6595 if (TREE_CODE (decl) == TYPE_DECL)
6597 if (init && DECL_INITIAL (decl))
6599 /* typedef foo = bar; store the type of bar as the type of foo. */
6600 TREE_TYPE (decl) = type = TREE_TYPE (init);
6601 DECL_INITIAL (decl) = init = NULL_TREE;
6603 if (type != error_mark_node
6604 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
6606 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6607 cp_warning ("shadowing previous type declaration of `%#D'", decl);
6608 set_identifier_type_value (DECL_NAME (decl), type);
6609 CLASSTYPE_GOT_SEMICOLON (type) = 1;
6611 GNU_xref_decl (current_function_decl, decl);
6613 /* If we have installed this as the canonical typedef for this
6614 type, and that type has not been defined yet, delay emitting
6615 the debug information for it, as we will emit it later. */
6616 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6617 && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
6618 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6620 rest_of_decl_compilation (decl, NULL_PTR,
6621 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
6624 if (TREE_CODE (decl) != FUNCTION_DECL)
6626 ttype = target_type (type);
6629 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
6630 && TYPE_NEEDS_CONSTRUCTING (type))
6633 /* Currently, GNU C++ puts constants in text space, making them
6634 impossible to initialize. In the future, one would hope for
6635 an operating system which understood the difference between
6636 initialization and the running of a program. */
6638 TREE_READONLY (decl) = 0;
6641 if (TREE_CODE (decl) == FIELD_DECL)
6643 if (init && init != error_mark_node)
6644 my_friendly_assert (TREE_PERMANENT (init), 147);
6648 /* This must override the asm specifier which was placed
6649 by grokclassfn. Lay this out fresh. */
6650 DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
6651 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
6652 make_decl_rtl (decl, asmspec, 0);
6655 /* If `start_decl' didn't like having an initialization, ignore it now. */
6656 else if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
6658 else if (DECL_EXTERNAL (decl))
6660 else if (TREE_CODE (type) == REFERENCE_TYPE
6661 || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type)))
6663 if (TREE_STATIC (decl))
6664 make_decl_rtl (decl, NULL_PTR,
6665 toplevel_bindings_p ()
6666 || pseudo_global_level_p ());
6667 grok_reference_init (decl, type, init);
6671 GNU_xref_decl (current_function_decl, decl);
6673 if (TREE_CODE (decl) == FIELD_DECL)
6675 else if (TREE_CODE (decl) == CONST_DECL)
6677 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
6679 DECL_INITIAL (decl) = init;
6681 /* This will keep us from needing to worry about our obstacks. */
6682 my_friendly_assert (init != NULL_TREE, 149);
6687 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
6689 if (TREE_CODE (type) == ARRAY_TYPE)
6690 init = digest_init (type, init, (tree *) 0);
6691 else if (TREE_CODE (init) == CONSTRUCTOR)
6693 if (TYPE_NON_AGGREGATE_CLASS (type))
6695 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
6697 init = error_mark_node;
6700 goto dont_use_constructor;
6705 dont_use_constructor:
6706 if (TREE_CODE (init) != TREE_VEC)
6707 init = store_init_value (decl, init);
6711 /* We must hide the initializer so that expand_decl
6712 won't try to do something it does not understand. */
6713 init = obscure_complex_init (decl, init);
6715 else if (DECL_EXTERNAL (decl))
6717 else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
6718 && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
6721 while (TREE_CODE (ctype) == ARRAY_TYPE)
6722 ctype = TREE_TYPE (ctype);
6723 if (! TYPE_NEEDS_CONSTRUCTING (ctype))
6725 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype))
6726 cp_error ("structure `%D' with uninitialized const members", decl);
6727 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype))
6728 cp_error ("structure `%D' with uninitialized reference members",
6732 if (TREE_CODE (decl) == VAR_DECL
6733 && !DECL_INITIAL (decl)
6734 && !TYPE_NEEDS_CONSTRUCTING (type)
6735 && (TYPE_READONLY (type) || TREE_READONLY (decl)))
6736 cp_error ("uninitialized const `%D'", decl);
6738 if (TYPE_SIZE (type) != NULL_TREE
6739 && TYPE_NEEDS_CONSTRUCTING (type))
6740 init = obscure_complex_init (decl, NULL_TREE);
6742 else if (TREE_CODE (decl) == VAR_DECL
6743 && TREE_CODE (type) != REFERENCE_TYPE
6744 && (TYPE_READONLY (type) || TREE_READONLY (decl)))
6746 /* ``Unless explicitly declared extern, a const object does not have
6747 external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
6748 However, if it's `const int foo = 1; const int foo;', don't complain
6749 about the second decl, since it does have an initializer before.
6750 We deliberately don't complain about arrays, because they're
6751 supposed to be initialized by a constructor. */
6752 if (! DECL_INITIAL (decl)
6753 && TREE_CODE (type) != ARRAY_TYPE
6754 && (!pedantic || !current_class_type))
6755 cp_error ("uninitialized const `%#D'", decl);
6758 /* For top-level declaration, the initial value was read in
6759 the temporary obstack. MAXINDEX, rtl, etc. to be made below
6760 must go in the permanent obstack; but don't discard the
6761 temporary data yet. */
6763 if (toplevel_bindings_p () && temporary)
6764 end_temporary_allocation ();
6766 /* Deduce size of array from initialization, if not already known. */
6768 if (TREE_CODE (type) == ARRAY_TYPE
6769 && TYPE_DOMAIN (type) == NULL_TREE
6770 && TREE_CODE (decl) != TYPE_DECL)
6773 = (TREE_STATIC (decl)
6774 /* Even if pedantic, an external linkage array
6775 may have incomplete type at first. */
6776 ? pedantic && ! DECL_EXTERNAL (decl)
6777 : !DECL_EXTERNAL (decl));
6778 tree initializer = init ? init : DECL_INITIAL (decl);
6779 int failure = complete_array_type (type, initializer, do_default);
6782 cp_error ("initializer fails to determine size of `%D'", decl);
6787 cp_error ("array size missing in `%D'", decl);
6788 /* If a `static' var's size isn't known, make it extern as
6789 well as static, so it does not get allocated. If it's not
6790 `static', then don't mark it extern; finish_incomplete_decl
6791 will give it a default size and it will get allocated. */
6792 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
6793 DECL_EXTERNAL (decl) = 1;
6796 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
6797 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
6799 cp_error ("zero-size array `%D'", decl);
6801 layout_decl (decl, 0);
6804 if (TREE_CODE (decl) == VAR_DECL)
6806 if (DECL_SIZE (decl) == NULL_TREE
6807 && TYPE_SIZE (complete_type (TREE_TYPE (decl))) != NULL_TREE)
6808 layout_decl (decl, 0);
6810 if (TREE_STATIC (decl) && DECL_SIZE (decl) == NULL_TREE)
6812 /* A static variable with an incomplete type:
6813 that is an error if it is initialized.
6814 Otherwise, let it through, but if it is not `extern'
6815 then it may cause an error message later. */
6816 if (DECL_INITIAL (decl) != NULL_TREE)
6817 cp_error ("storage size of `%D' isn't known", decl);
6820 else if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
6822 /* An automatic variable with an incomplete type: that is an error.
6823 Don't talk about array types here, since we took care of that
6824 message in grokdeclarator. */
6825 cp_error ("storage size of `%D' isn't known", decl);
6826 TREE_TYPE (decl) = error_mark_node;
6828 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
6829 /* Let debugger know it should output info for this type. */
6830 note_debug_info_needed (ttype);
6832 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
6833 note_debug_info_needed (DECL_CONTEXT (decl));
6835 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
6836 && DECL_SIZE (decl) != NULL_TREE
6837 && ! TREE_CONSTANT (DECL_SIZE (decl)))
6839 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
6840 constant_expression_warning (DECL_SIZE (decl));
6842 cp_error ("storage size of `%D' isn't constant", decl);
6845 if (! DECL_EXTERNAL (decl) && TYPE_NEEDS_DESTRUCTOR (type)
6846 /* Cleanups for static variables are handled by `finish_file'. */
6847 && ! TREE_STATIC (decl))
6849 int yes = suspend_momentary ();
6850 cleanup = maybe_build_cleanup (decl);
6851 resume_momentary (yes);
6854 /* PARM_DECLs get cleanups, too. */
6855 else if (TREE_CODE (decl) == PARM_DECL && TYPE_NEEDS_DESTRUCTOR (type))
6858 end_temporary_allocation ();
6859 cleanup = maybe_build_cleanup (decl);
6861 resume_temporary_allocation ();
6864 /* Output the assembler code and/or RTL code for variables and functions,
6865 unless the type is an undefined structure or union.
6866 If not, it will get done when the type is completed. */
6868 was_incomplete = (DECL_SIZE (decl) == NULL_TREE);
6870 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
6871 || TREE_CODE (decl) == RESULT_DECL)
6873 /* ??? FIXME: What about nested classes? */
6874 int toplev = toplevel_bindings_p () || pseudo_global_level_p ();
6876 = (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)
6877 && allocation_temporary_p ());
6880 end_temporary_allocation ();
6882 /* Extern inline function static data has external linkage. */
6883 if (TREE_CODE (decl) == VAR_DECL
6884 && TREE_STATIC (decl)
6885 && current_function_decl
6886 && DECL_CONTEXT (decl) == current_function_decl
6887 && DECL_THIS_INLINE (current_function_decl)
6888 && TREE_PUBLIC (current_function_decl))
6890 if (DECL_INTERFACE_KNOWN (current_function_decl))
6892 TREE_PUBLIC (decl) = 1;
6893 DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
6895 /* We can only do this if we can use common or weak, and we
6896 can't if it has been initialized and we don't support weak. */
6897 else if (DECL_INITIAL (decl) == NULL_TREE
6898 || DECL_INITIAL (decl) == error_mark_node)
6900 TREE_PUBLIC (decl) = 1;
6901 DECL_COMMON (decl) = 1;
6904 make_decl_one_only (decl);
6906 if (TREE_PUBLIC (decl))
6907 DECL_ASSEMBLER_NAME (decl)
6908 = build_static_name (current_function_decl, DECL_NAME (decl));
6909 else if (! DECL_ARTIFICIAL (decl))
6910 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
6913 else if (TREE_CODE (decl) == VAR_DECL
6914 && DECL_LANG_SPECIFIC (decl)
6915 && DECL_COMDAT (decl))
6917 /* Dynamically initialized vars go into common. */
6918 if (DECL_INITIAL (decl) == NULL_TREE
6919 || DECL_INITIAL (decl) == error_mark_node)
6920 DECL_COMMON (decl) = 1;
6921 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
6923 DECL_COMMON (decl) = 1;
6924 DECL_INITIAL (decl) = error_mark_node;
6928 /* Statically initialized vars are weak or comdat, if
6931 make_decl_one_only (decl);
6934 /* We can't do anything useful; leave vars for explicit
6936 DECL_EXTERNAL (decl) = 1;
6937 DECL_NOT_REALLY_EXTERN (decl) = 0;
6942 if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
6943 make_decl_rtl (decl, NULL_PTR, toplev);
6944 else if (TREE_CODE (decl) == VAR_DECL
6945 && TREE_READONLY (decl)
6946 && DECL_INITIAL (decl) != NULL_TREE
6947 && DECL_INITIAL (decl) != error_mark_node
6948 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
6950 DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
6953 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
6956 && TREE_STATIC (decl)
6957 && ! TREE_SIDE_EFFECTS (decl)
6958 && ! TREE_PUBLIC (decl)
6959 && ! DECL_EXTERNAL (decl)
6960 && ! TYPE_NEEDS_DESTRUCTOR (type)
6961 && DECL_MODE (decl) != BLKmode)
6963 /* If this variable is really a constant, then fill its DECL_RTL
6964 slot with something which won't take up storage.
6965 If something later should take its address, we can always give
6966 it legitimate RTL at that time. */
6967 DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
6968 store_expr (DECL_INITIAL (decl), DECL_RTL (decl), 0);
6969 TREE_ASM_WRITTEN (decl) = 1;
6971 else if (toplev && ! TREE_PUBLIC (decl))
6973 /* If this is a static const, change its apparent linkage
6974 if it belongs to a #pragma interface. */
6975 if (!interface_unknown)
6977 TREE_PUBLIC (decl) = 1;
6978 DECL_EXTERNAL (decl) = interface_only;
6980 make_decl_rtl (decl, asmspec, toplev);
6983 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
6985 else if (TREE_CODE (decl) == VAR_DECL
6986 && DECL_LANG_SPECIFIC (decl)
6987 && DECL_IN_AGGR_P (decl))
6989 if (TREE_STATIC (decl))
6991 if (init == NULL_TREE
6992 #ifdef DEFAULT_STATIC_DEFS
6993 /* If this code is dead, then users must
6994 explicitly declare static member variables
6995 outside the class def'n as well. */
6996 && TYPE_NEEDS_CONSTRUCTING (type)
7000 DECL_EXTERNAL (decl) = 1;
7001 make_decl_rtl (decl, asmspec, 1);
7004 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7007 /* Just a constant field. Should not need any rtl. */
7011 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7014 resume_temporary_allocation ();
7016 if (type != error_mark_node
7017 && TYPE_LANG_SPECIFIC (type)
7018 && CLASSTYPE_ABSTRACT_VIRTUALS (type))
7019 abstract_virtuals_error (decl, type);
7020 else if ((TREE_CODE (type) == FUNCTION_TYPE
7021 || TREE_CODE (type) == METHOD_TYPE)
7022 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
7023 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type)))
7024 abstract_virtuals_error (decl, TREE_TYPE (type));
7026 if (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE (type))
7027 signature_error (decl, type);
7028 else if ((TREE_CODE (type) == FUNCTION_TYPE
7029 || TREE_CODE (type) == METHOD_TYPE)
7030 && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
7031 && IS_SIGNATURE (TREE_TYPE (type)))
7032 signature_error (decl, TREE_TYPE (type));
7034 if (TREE_CODE (decl) == FUNCTION_DECL)
7036 else if (DECL_EXTERNAL (decl)
7037 && ! (DECL_LANG_SPECIFIC (decl)
7038 && DECL_NOT_REALLY_EXTERN (decl)))
7041 DECL_INITIAL (decl) = init;
7043 else if (TREE_STATIC (decl) && type != error_mark_node)
7045 /* Cleanups for static variables are handled by `finish_file'. */
7046 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7047 || TYPE_NEEDS_DESTRUCTOR (type))
7048 expand_static_init (decl, init);
7052 /* This is a declared decl which must live until the
7053 end of the binding contour. It may need a cleanup. */
7055 /* Recompute the RTL of a local array now
7056 if it used to be an incomplete type. */
7057 if (was_incomplete && ! TREE_STATIC (decl))
7059 /* If we used it already as memory, it must stay in memory. */
7060 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7061 /* If it's still incomplete now, no init will save it. */
7062 if (DECL_SIZE (decl) == NULL_TREE)
7063 DECL_INITIAL (decl) = NULL_TREE;
7066 else if (! TREE_ASM_WRITTEN (decl)
7067 && (TYPE_SIZE (type) != NULL_TREE
7068 || TREE_CODE (type) == ARRAY_TYPE))
7070 /* Do this here, because we did not expand this decl's
7071 rtl in start_decl. */
7072 if (DECL_RTL (decl) == NULL_RTX)
7076 /* XXX: Why don't we use decl here? */
7077 /* Ans: Because it was already expanded? */
7078 if (! expand_decl_cleanup (NULL_TREE, cleanup))
7079 cp_error ("parser lost in parsing declaration of `%D'",
7081 /* Cleanup used up here. */
7082 cleanup = NULL_TREE;
7086 if (current_binding_level->is_for_scope)
7088 struct binding_level *outer = current_binding_level->level_chain;
7090 /* Check to see if the same name is already bound at
7091 the outer level, either because it was directly declared,
7092 or because a dead for-decl got preserved. In either case,
7093 the code would not have been valid under the ARM
7094 scope rules, so clear is_for_scope for the
7095 current_binding_level.
7097 Otherwise, we need to preserve the temp slot for decl
7098 to last into the outer binding level. */
7100 int handling_dead_for_vars = 0;
7101 tree link = outer->names;
7102 for (; ; link = TREE_CHAIN (link))
7104 if (link == NULL && handling_dead_for_vars == 0)
7106 link = outer->dead_vars_from_for;
7107 handling_dead_for_vars = 1;
7111 if (DECL_IN_MEMORY_P (decl))
7112 preserve_temp_slots (DECL_RTL (decl));
7115 if (DECL_NAME (link) == DECL_NAME (decl))
7117 if (handling_dead_for_vars)
7120 = purpose_member (DECL_NAME (decl),
7121 current_binding_level->shadowed);
7122 if (shadowing && TREE_VALUE (shadowing) == link)
7123 TREE_VALUE (shadowing)
7124 = DECL_SHADOWED_FOR_VAR (link);
7126 current_binding_level->is_for_scope = 0;
7132 expand_start_target_temps ();
7134 if (DECL_SIZE (decl) && type != error_mark_node)
7136 /* Compute and store the initial value. */
7137 expand_decl_init (decl);
7138 already_used = TREE_USED (decl) || TREE_USED (type);
7140 if (init || TYPE_NEEDS_CONSTRUCTING (type))
7142 emit_line_note (DECL_SOURCE_FILE (decl),
7143 DECL_SOURCE_LINE (decl));
7144 expand_aggr_init (decl, init, 0, flags);
7147 /* Set this to 0 so we can tell whether an aggregate which
7148 was initialized was ever used. Don't do this if it has a
7149 destructor, so we don't complain about the 'resource
7150 allocation is initialization' idiom. */
7151 /* Now set attribute((unused)) on types so decls of
7152 that type will be marked used. (see TREE_USED, above.)
7153 This avoids the warning problems this particular code
7154 tried to work around. */
7156 if (TYPE_NEEDS_CONSTRUCTING (type)
7158 && cleanup == NULL_TREE
7159 && DECL_NAME (decl))
7160 TREE_USED (decl) = 0;
7163 TREE_USED (decl) = 1;
7166 /* Cleanup any temporaries needed for the initial value. */
7167 expand_end_target_temps ();
7169 if (DECL_SIZE (decl) && type != error_mark_node)
7171 /* Store the cleanup, if there was one. */
7174 if (! expand_decl_cleanup (decl, cleanup))
7175 cp_error ("parser lost in parsing declaration of `%D'",
7182 /* Undo call to `pushclass' that was done in `start_decl'
7183 due to initialization of qualified member variable.
7184 I.e., Foo::x = 10; */
7186 tree context = DECL_REAL_CONTEXT (decl);
7188 && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7189 && (TREE_CODE (decl) == VAR_DECL
7190 /* We also have a pushclass done that we need to undo here
7191 if we're at top level and declare a method. */
7192 || TREE_CODE (decl) == FUNCTION_DECL)
7193 /* If size hasn't been set, we're still defining it,
7194 and therefore inside the class body; don't pop
7195 the binding level.. */
7196 && TYPE_SIZE (context) != NULL_TREE
7197 && context == current_class_type)
7204 /* If requested, warn about definitions of large data objects. */
7206 if (warn_larger_than
7207 && ! processing_template_decl
7208 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7209 && !DECL_EXTERNAL (decl))
7211 register tree decl_size = DECL_SIZE (decl);
7213 if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7215 unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7217 if (units > larger_than_size)
7218 warning_with_decl (decl, "size of `%s' is %u bytes", units);
7224 /* Resume permanent allocation, if not within a function. */
7225 /* The corresponding push_obstacks_nochange is in start_decl,
7226 start_method, groktypename, and in grokfield. */
7231 TREE_READONLY (decl) = 1;
7234 /* This is here for a midend callback from c-common.c */
7237 finish_decl (decl, init, asmspec_tree)
7241 cp_finish_decl (decl, init, asmspec_tree, 1, 0);
7245 expand_static_init (decl, init)
7249 tree oldstatic = value_member (decl, static_aggregates);
7253 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
7254 cp_error ("multiple initializations given for `%D'", decl);
7256 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7258 /* Emit code to perform this initialization but once. */
7261 /* Remember this information until end of file. */
7262 push_obstacks (&permanent_obstack, &permanent_obstack);
7264 /* Emit code to perform this initialization but once. */
7265 temp = get_temp_name (integer_type_node, 1);
7266 rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
7267 expand_start_cond (build_binary_op (EQ_EXPR, temp,
7268 integer_zero_node, 1), 0);
7269 expand_start_target_temps ();
7271 expand_assignment (temp, integer_one_node, 0, 0);
7272 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
7273 || (init && TREE_CODE (init) == TREE_LIST))
7275 expand_aggr_init (decl, init, 0, 0);
7276 do_pending_stack_adjust ();
7279 expand_assignment (decl, init, 0, 0);
7281 /* Cleanup any temporaries needed for the initial value. */
7282 expand_end_target_temps ();
7284 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
7286 tree cleanup, fcall;
7287 static tree Atexit = 0;
7290 tree atexit_fndecl, PFV, pfvlist;
7291 /* Remember this information until end of file. */
7292 push_obstacks (&permanent_obstack, &permanent_obstack);
7293 PFV = build_pointer_type (build_function_type
7294 (void_type_node, void_list_node));
7296 pfvlist = tree_cons (NULL_TREE, PFV, void_list_node);
7298 push_lang_context (lang_name_c);
7300 = builtin_function ("atexit",
7301 build_function_type (void_type_node,
7303 NOT_BUILT_IN, NULL_PTR);
7304 assemble_external (atexit_fndecl);
7305 Atexit = default_conversion (atexit_fndecl);
7306 pop_lang_context ();
7310 cleanup = start_anon_func ();
7311 expand_expr_stmt (build_cleanup (decl));
7313 mark_addressable (cleanup);
7314 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
7315 fcall = build_function_call (Atexit, expr_tree_cons (NULL_TREE, cleanup, NULL_TREE));
7316 expand_expr_stmt (fcall);
7320 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
7322 static_aggregates = perm_tree_cons (temp, decl, static_aggregates);
7323 TREE_STATIC (static_aggregates) = 1;
7326 /* Resume old (possibly temporary) allocation. */
7331 /* This code takes into account memory allocation
7332 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7333 does not hold for this object, then we must make permanent
7334 the storage currently in the temporary obstack. */
7335 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
7336 preserve_initializer ();
7337 static_aggregates = perm_tree_cons (init, decl, static_aggregates);
7341 /* Make TYPE a complete type based on INITIAL_VALUE.
7342 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7343 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7346 complete_array_type (type, initial_value, do_default)
7347 tree type, initial_value;
7350 register tree maxindex = NULL_TREE;
7355 /* Note MAXINDEX is really the maximum index,
7356 one less than the size. */
7357 if (TREE_CODE (initial_value) == STRING_CST)
7360 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7361 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
7364 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7366 tree elts = CONSTRUCTOR_ELTS (initial_value);
7367 maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
7368 for (; elts; elts = TREE_CHAIN (elts))
7370 if (TREE_PURPOSE (elts))
7371 maxindex = TREE_PURPOSE (elts);
7373 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
7375 maxindex = copy_node (maxindex);
7379 /* Make an error message unless that happened already. */
7380 if (initial_value != error_mark_node)
7383 /* Prevent further error messages. */
7384 maxindex = build_int_2 (0, 0);
7391 maxindex = build_int_2 (0, 0);
7399 TYPE_DOMAIN (type) = build_index_type (maxindex);
7400 if (! TREE_TYPE (maxindex))
7401 TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
7403 itype = TREE_TYPE (initial_value);
7406 if (itype && !TYPE_DOMAIN (itype))
7407 TYPE_DOMAIN (itype) = TYPE_DOMAIN (type);
7408 /* The type of the main variant should never be used for arrays
7409 of different sizes. It should only ever be completed with the
7410 size of the array. */
7411 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
7412 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = TYPE_DOMAIN (type);
7415 /* Lay out the type now that we can get the real answer. */
7422 /* Return zero if something is declared to be a member of type
7423 CTYPE when in the context of CUR_TYPE. STRING is the error
7424 message to print in that case. Otherwise, quietly return 1. */
7427 member_function_or_else (ctype, cur_type, string)
7428 tree ctype, cur_type;
7431 if (ctype && ctype != cur_type)
7433 error (string, TYPE_NAME_STRING (ctype));
7439 /* Subroutine of `grokdeclarator'. */
7441 /* Generate errors possibly applicable for a given set of specifiers.
7442 This is for ARM $7.1.2. */
7445 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
7448 int virtualp, quals, friendp, raises, inlinep;
7451 cp_error ("`%D' declared as a `virtual' %s", object, type);
7453 cp_error ("`%D' declared as an `inline' %s", object, type);
7455 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7458 cp_error_at ("invalid friend declaration", object);
7460 cp_error_at ("invalid exception specifications", object);
7463 /* CTYPE is class type, or null if non-class.
7464 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7466 DECLARATOR is the function's name.
7467 VIRTUALP is truthvalue of whether the function is virtual or not.
7468 FLAGS are to be passed through to `grokclassfn'.
7469 QUALS are qualifiers indicating whether the function is `const'
7471 RAISES is a list of exceptions that this function can raise.
7472 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7473 not look, and -1 if we should not call `grokclassfn' at all. */
7476 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
7477 raises, attrlist, check, friendp, publicp, inlinep, funcdef_flag,
7478 template_count, in_namespace)
7481 tree orig_declarator;
7483 enum overload_flags flags;
7484 tree quals, raises, attrlist;
7485 int check, friendp, publicp, inlinep, funcdef_flag, template_count;
7489 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7493 cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
7494 ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
7500 type = build_exception_variant (type, raises);
7503 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7504 /* Propagate volatile out from type to decl. */
7505 if (TYPE_VOLATILE (type))
7506 TREE_THIS_VOLATILE (decl) = 1;
7508 /* This decl is not from the current namespace. */
7510 set_decl_namespace (decl, in_namespace);
7512 /* Should probably propagate const out from type to decl I bet (mrs). */
7515 DECL_STATIC_FUNCTION_P (decl) = 1;
7516 DECL_CONTEXT (decl) = ctype;
7520 DECL_CLASS_CONTEXT (decl) = ctype;
7522 if (ctype == NULL_TREE && ! strcmp (IDENTIFIER_POINTER (declarator), "main"))
7525 error ("cannot declare `main' to be inline");
7527 error ("cannot declare `main' to be static");
7532 TREE_PUBLIC (decl) = publicp;
7535 DECL_INTERFACE_KNOWN (decl) = 1;
7536 DECL_NOT_REALLY_EXTERN (decl) = 1;
7540 DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
7542 DECL_EXTERNAL (decl) = 1;
7543 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
7545 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
7546 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
7550 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
7551 grok_op_properties (decl, virtualp, check < 0);
7553 if (ctype && hack_decl_function_context (decl))
7554 DECL_NO_STATIC_CHAIN (decl) = 1;
7556 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7557 if (TREE_PURPOSE (t)
7558 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7560 add_defarg_fn (decl);
7565 TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7567 /* A friend declaration of the form friend void f<>(). Record
7568 the information in the TEMPLATE_ID_EXPR. */
7569 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7570 DECL_TEMPLATE_INFO (decl)
7571 = perm_tree_cons (TREE_OPERAND (orig_declarator, 0),
7572 TREE_OPERAND (orig_declarator, 1),
7576 /* Caller will do the rest of this. */
7580 if (check && funcdef_flag)
7581 DECL_INITIAL (decl) = error_mark_node;
7583 if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
7586 /* Just handle constructors here. We could do this
7587 inside the following if stmt, but I think
7588 that the code is more legible by breaking this
7589 case out. See comments below for what each of
7590 the following calls is supposed to do. */
7591 DECL_CONSTRUCTOR_P (decl) = 1;
7593 grokclassfn (ctype, declarator, decl, flags, quals);
7595 decl = check_explicit_specialization (orig_declarator, decl,
7597 2 * (funcdef_flag != 0) +
7598 4 * (friendp != 0));
7602 tmp = check_classfn (ctype, decl);
7604 if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
7605 tmp = DECL_TEMPLATE_RESULT(tmp);
7607 if (tmp && DECL_ARTIFICIAL (tmp))
7608 cp_error ("definition of implicitly-declared `%D'", tmp);
7609 if (tmp && duplicate_decls (decl, tmp))
7612 if (! grok_ctor_properties (ctype, decl))
7615 if (check == 0 && ! current_function_decl)
7617 /* Assembler names live in the global namespace. */
7618 tmp = IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl));
7619 if (tmp == NULL_TREE)
7620 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl), decl);
7621 else if (TREE_CODE (tmp) != TREE_CODE (decl))
7622 cp_error ("inconsistent declarations for `%D'", decl);
7625 duplicate_decls (decl, tmp);
7628 make_decl_rtl (decl, NULL_PTR, 1);
7635 /* Function gets the ugly name, field gets the nice one.
7636 This call may change the type of the function (because
7637 of default parameters)! */
7638 if (ctype != NULL_TREE)
7639 grokclassfn (ctype, cname, decl, flags, quals);
7641 decl = check_explicit_specialization (orig_declarator, decl,
7643 2 * (funcdef_flag != 0) +
7644 4 * (friendp != 0));
7646 if (ctype != NULL_TREE && check)
7648 tmp = check_classfn (ctype, decl);
7650 if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
7651 tmp = DECL_TEMPLATE_RESULT (tmp);
7653 if (tmp && DECL_STATIC_FUNCTION_P (tmp)
7654 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7656 /* Remove the `this' parm added by grokclassfn.
7657 XXX Isn't this done in start_function, too? */
7658 revert_static_member_fn (&decl, NULL, NULL);
7659 last_function_parms = TREE_CHAIN (last_function_parms);
7661 if (tmp && DECL_ARTIFICIAL (tmp))
7662 cp_error ("definition of implicitly-declared `%D'", tmp);
7665 if (!duplicate_decls (decl, tmp))
7666 my_friendly_abort (892);
7671 if (ctype == NULL_TREE || check)
7674 /* Now install the declaration of this function so that others may
7675 find it (esp. its DECL_FRIENDLIST). Don't do this for local class
7677 if (! current_function_decl)
7679 if (!DECL_TEMPLATE_SPECIALIZATION (decl))
7681 /* We don't do this for specializations since the
7682 equivalent checks will be done later. Also, at this
7683 point the DECL_ASSEMBLER_NAME is not yet fully
7686 /* FIXME: this should only need to look at
7687 IDENTIFIER_GLOBAL_VALUE. */
7688 tmp = lookup_name (DECL_ASSEMBLER_NAME (decl), 0);
7689 if (tmp == NULL_TREE)
7690 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl), decl);
7691 else if (TREE_CODE (tmp) != TREE_CODE (decl))
7692 cp_error ("inconsistent declarations for `%D'", decl);
7695 duplicate_decls (decl, tmp);
7701 cplus_decl_attributes (decl, TREE_PURPOSE (attrlist),
7702 TREE_VALUE (attrlist));
7703 make_decl_rtl (decl, NULL_PTR, 1);
7707 DECL_VIRTUAL_P (decl) = 1;
7708 if (DECL_VINDEX (decl) == NULL_TREE)
7709 DECL_VINDEX (decl) = error_mark_node;
7710 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
7717 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
7720 RID_BIT_TYPE *specbits_in;
7726 RID_BIT_TYPE specbits;
7728 specbits = *specbits_in;
7730 if (TREE_CODE (type) == OFFSET_TYPE)
7732 /* If you declare a static member so that it
7733 can be initialized, the code will reach here. */
7734 tree basetype = TYPE_OFFSET_BASETYPE (type);
7735 type = TREE_TYPE (type);
7736 decl = build_lang_field_decl (VAR_DECL, declarator, type);
7737 DECL_CONTEXT (decl) = basetype;
7738 DECL_CLASS_CONTEXT (decl) = basetype;
7739 DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
7743 tree context = in_namespace ? in_namespace : current_namespace;
7744 decl = build_decl (VAR_DECL, declarator, complete_type (type));
7745 if (context != global_namespace)
7746 DECL_ASSEMBLER_NAME (decl) = build_static_name (context,
7751 set_decl_namespace (decl, in_namespace);
7753 if (RIDBIT_SETP (RID_EXTERN, specbits))
7755 DECL_THIS_EXTERN (decl) = 1;
7756 DECL_EXTERNAL (decl) = !initialized;
7759 /* In class context, static means one per class,
7760 public access, and static storage. */
7761 if (DECL_FIELD_CONTEXT (decl) != NULL_TREE
7762 && IS_AGGR_TYPE (DECL_FIELD_CONTEXT (decl)))
7764 TREE_PUBLIC (decl) = 1;
7765 TREE_STATIC (decl) = 1;
7766 DECL_EXTERNAL (decl) = 0;
7768 /* At top level, either `static' or no s.c. makes a definition
7769 (perhaps tentative), and absence of `static' makes it public. */
7770 else if (toplevel_bindings_p ())
7772 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
7773 && (DECL_THIS_EXTERN (decl) || ! constp));
7774 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
7776 /* Not at top level, only `static' makes a static definition. */
7779 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
7780 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7785 /* Create a canonical pointer to member function type. */
7788 build_ptrmemfunc_type (type)
7795 /* If a canonical type already exists for this type, use it. We use
7796 this method instead of type_hash_canon, because it only does a
7797 simple equality check on the list of field members. */
7799 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7802 push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
7804 u = make_lang_type (UNION_TYPE);
7805 IS_AGGR_TYPE (u) = 0;
7806 fields[0] = build_lang_field_decl (FIELD_DECL, pfn_identifier, type);
7807 fields[1] = build_lang_field_decl (FIELD_DECL, delta2_identifier,
7809 finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
7810 TYPE_NAME (u) = NULL_TREE;
7812 t = make_lang_type (RECORD_TYPE);
7814 /* Let the front-end know this is a pointer to member function... */
7815 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7816 /* ... and not really an aggregate. */
7817 IS_AGGR_TYPE (t) = 0;
7819 fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier,
7821 fields[1] = build_lang_field_decl (FIELD_DECL, index_identifier,
7823 fields[2] = build_lang_field_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
7824 finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
7828 /* Zap out the name so that the back-end will give us the debugging
7829 information for this anonymous RECORD_TYPE. */
7830 TYPE_NAME (t) = NULL_TREE;
7832 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7834 /* Seems to be wanted. */
7835 CLASSTYPE_GOT_SEMICOLON (t) = 1;
7839 /* Given declspecs and a declarator,
7840 determine the name and type of the object declared
7841 and construct a ..._DECL node for it.
7842 (In one case we can return a ..._TYPE node instead.
7843 For invalid input we sometimes return 0.)
7845 DECLSPECS is a chain of tree_list nodes whose value fields
7846 are the storage classes and type specifiers.
7848 DECL_CONTEXT says which syntactic context this declaration is in:
7849 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7850 FUNCDEF for a function definition. Like NORMAL but a few different
7851 error messages in each case. Return value may be zero meaning
7852 this definition is too screwy to try to parse.
7853 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7854 handle member functions (which have FIELD context).
7855 Return value may be zero meaning this definition is too screwy to
7857 PARM for a parameter declaration (either within a function prototype
7858 or before a function body). Make a PARM_DECL, or return void_type_node.
7859 CATCHPARM for a parameter declaration before a catch clause.
7860 TYPENAME if for a typename (in a cast or sizeof).
7861 Don't make a DECL node; just return the ..._TYPE node.
7862 FIELD for a struct or union field; make a FIELD_DECL.
7863 BITFIELD for a field with specified width.
7864 INITIALIZED is 1 if the decl has an initializer.
7866 In the TYPENAME case, DECLARATOR is really an absolute declarator.
7867 It may also be so in the PARM case, for a prototype where the
7868 argument type is specified but not the name.
7870 This function is where the complicated C meanings of `static'
7871 and `extern' are interpreted.
7873 For C++, if there is any monkey business to do, the function which
7874 calls this one must do it, i.e., prepending instance variables,
7875 renaming overloaded function names, etc.
7877 Note that for this C++, it is an error to define a method within a class
7878 which does not belong to that class.
7880 Except in the case where SCOPE_REFs are implicitly known (such as
7881 methods within a class being redundantly qualified),
7882 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
7883 (class_name::decl_name). The caller must also deal with this.
7885 If a constructor or destructor is seen, and the context is FIELD,
7886 then the type gains the attribute TREE_HAS_x. If such a declaration
7887 is erroneous, NULL_TREE is returned.
7889 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
7890 function, these are the qualifiers to give to the `this' pointer.
7892 May return void_type_node if the declarator turned out to be a friend.
7893 See grokfield for details. */
7895 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
7898 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
7901 enum decl_context decl_context;
7905 RID_BIT_TYPE specbits;
7908 tree type = NULL_TREE;
7912 int virtualp, explicitp, friendp, inlinep, staticp;
7913 int explicit_int = 0;
7914 int explicit_char = 0;
7915 int defaulted_int = 0;
7916 int opaque_typedef = 0;
7917 tree typedef_decl = NULL_TREE;
7919 tree typedef_type = NULL_TREE;
7920 int funcdef_flag = 0;
7921 enum tree_code innermost_code = ERROR_MARK;
7924 /* See the code below that used this. */
7925 tree decl_machine_attr = NULL_TREE;
7927 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
7928 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
7929 tree init = NULL_TREE;
7931 /* Keep track of what sort of function is being processed
7932 so that we can warn about default return values, or explicit
7933 return values which do not match prescribed defaults. */
7934 enum return_types return_type = return_normal;
7936 tree dname = NULL_TREE;
7937 tree ctype = current_class_type;
7938 tree ctor_return_type = NULL_TREE;
7939 enum overload_flags flags = NO_SPECIAL;
7940 tree quals = NULL_TREE;
7941 tree raises = NULL_TREE;
7942 int template_count = 0;
7943 tree in_namespace = NULL_TREE;
7945 RIDBIT_RESET_ALL (specbits);
7946 if (decl_context == FUNCDEF)
7947 funcdef_flag = 1, decl_context = NORMAL;
7948 else if (decl_context == MEMFUNCDEF)
7949 funcdef_flag = -1, decl_context = FIELD;
7950 else if (decl_context == BITFIELD)
7951 bitfield = 1, decl_context = FIELD;
7953 /* Look inside a declarator for the name being declared
7954 and get it as a string, for an error message. */
7956 tree *next = &declarator;
7960 while (next && *next)
7963 switch (TREE_CODE (decl))
7967 next = &TREE_OPERAND (decl, 0);
7970 case BIT_NOT_EXPR: /* For C++ destructors! */
7972 tree name = TREE_OPERAND (decl, 0);
7973 tree rename = NULL_TREE;
7975 my_friendly_assert (flags == NO_SPECIAL, 152);
7977 return_type = return_dtor;
7978 if (TREE_CODE (name) == TYPE_DECL)
7979 TREE_OPERAND (decl, 0) = name = constructor_name (name);
7980 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
7981 if (ctype == NULL_TREE)
7983 if (current_class_type == NULL_TREE)
7985 error ("destructors must be member functions");
7990 tree t = constructor_name (current_class_name);
7997 tree t = constructor_name (ctype);
8004 cp_error ("destructor `%T' must match class name `%T'",
8006 TREE_OPERAND (decl, 0) = rename;
8012 case ADDR_EXPR: /* C++ reference declaration */
8017 innermost_code = TREE_CODE (decl);
8018 next = &TREE_OPERAND (decl, 0);
8022 if (parmlist_is_exprlist (TREE_OPERAND (decl, 1)))
8024 /* This is actually a variable declaration using constructor
8025 syntax. We need to call start_decl and cp_finish_decl so we
8026 can get the variable initialized... */
8028 *next = TREE_OPERAND (decl, 0);
8029 init = TREE_OPERAND (decl, 1);
8031 decl = start_decl (declarator, declspecs, 1, NULL_TREE, NULL_TREE);
8032 /* Look for __unused__ attribute */
8033 if (TREE_USED (TREE_TYPE (decl)))
8034 TREE_USED (decl) = 1;
8035 finish_decl (decl, init, NULL_TREE);
8038 innermost_code = TREE_CODE (decl);
8039 if (decl_context == FIELD && ctype == NULL_TREE)
8040 ctype = current_class_type;
8042 && TREE_OPERAND (decl, 0)
8043 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
8044 && ((DECL_NAME (TREE_OPERAND (decl, 0))
8045 == constructor_name_full (ctype))
8046 || (DECL_NAME (TREE_OPERAND (decl, 0))
8047 == constructor_name (ctype)))))
8048 TREE_OPERAND (decl, 0) = constructor_name (ctype);
8049 next = &TREE_OPERAND (decl, 0);
8051 if (ctype != NULL_TREE
8052 && decl != NULL_TREE && flags != DTOR_FLAG
8053 && decl == constructor_name (ctype))
8055 return_type = return_ctor;
8056 ctor_return_type = ctype;
8061 case TEMPLATE_ID_EXPR:
8063 tree fns = TREE_OPERAND (decl, 0);
8065 if (TREE_CODE (fns) == LOOKUP_EXPR)
8066 fns = TREE_OPERAND (fns, 0);
8068 if (TREE_CODE (fns) == IDENTIFIER_NODE)
8070 else if (is_overloaded_fn (fns))
8071 dname = DECL_NAME (get_first_fn (fns));
8073 my_friendly_abort (0);
8077 case IDENTIFIER_NODE:
8078 if (TREE_CODE (decl) == IDENTIFIER_NODE)
8085 cp_error ("declarator-id missing; using reserved word `%D'",
8087 name = IDENTIFIER_POINTER (dname);
8089 if (! IDENTIFIER_OPNAME_P (dname)
8090 /* GNU/Linux headers use '__op'. Arrgh. */
8091 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
8092 name = IDENTIFIER_POINTER (dname);
8095 if (IDENTIFIER_TYPENAME_P (dname))
8097 my_friendly_assert (flags == NO_SPECIAL, 154);
8098 flags = TYPENAME_FLAG;
8099 ctor_return_type = TREE_TYPE (dname);
8100 return_type = return_conversion;
8102 name = operator_name_string (dname);
8109 /* Perform error checking, and decide on a ctype. */
8110 tree cname = TREE_OPERAND (decl, 0);
8111 if (cname == NULL_TREE)
8113 else if (TREE_CODE (cname) == NAMESPACE_DECL)
8116 in_namespace = TREE_OPERAND (decl, 0);
8117 TREE_OPERAND (decl, 0) = NULL_TREE;
8119 else if (! is_aggr_type (cname, 1))
8120 TREE_OPERAND (decl, 0) = NULL_TREE;
8121 /* Must test TREE_OPERAND (decl, 1), in case user gives
8122 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8123 else if (TREE_OPERAND (decl, 1)
8124 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
8126 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
8127 || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
8129 cp_error ("`%T::%D' is not a valid declarator", cname,
8130 TREE_OPERAND (decl, 1));
8131 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8132 cname, TREE_OPERAND (decl, 1));
8133 return void_type_node;
8135 else if (ctype == NULL_TREE)
8137 else if (TREE_COMPLEXITY (decl) == current_class_depth)
8138 TREE_OPERAND (decl, 0) = ctype;
8141 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
8143 cp_error ("type `%T' is not derived from type `%T'",
8145 TREE_OPERAND (decl, 0) = NULL_TREE;
8151 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
8152 && ((DECL_NAME (TREE_OPERAND (decl, 1))
8153 == constructor_name_full (ctype))
8154 || (DECL_NAME (TREE_OPERAND (decl, 1))
8155 == constructor_name (ctype))))
8156 TREE_OPERAND (decl, 1) = constructor_name (ctype);
8157 next = &TREE_OPERAND (decl, 1);
8161 if (TREE_CODE (decl) == IDENTIFIER_NODE
8162 && constructor_name (ctype) == decl)
8164 return_type = return_ctor;
8165 ctor_return_type = ctype;
8167 else if (TREE_CODE (decl) == BIT_NOT_EXPR
8168 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
8169 && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
8170 || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
8172 return_type = return_dtor;
8173 ctor_return_type = ctype;
8175 TREE_OPERAND (decl, 0) = constructor_name (ctype);
8176 next = &TREE_OPERAND (decl, 0);
8187 /* Parse error puts this typespec where
8188 a declarator should go. */
8189 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
8190 if (TREE_TYPE (decl) == current_class_type)
8191 cp_error (" perhaps you want `%T' for a constructor",
8192 current_class_name);
8193 dname = DECL_NAME (decl);
8194 name = IDENTIFIER_POINTER (dname);
8196 /* Avoid giving two errors for this. */
8197 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
8199 declspecs = temp_tree_cons (NULL_TREE, integer_type_node,
8206 cp_compiler_error ("`%D' as declarator", decl);
8207 return 0; /* We used to do a 155 abort here. */
8214 /* A function definition's declarator must have the form of
8215 a function declarator. */
8217 if (funcdef_flag && innermost_code != CALL_EXPR)
8220 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8221 && innermost_code != CALL_EXPR
8222 && ! (ctype && declspecs == NULL_TREE))
8224 cp_error ("declaration of `%D' as non-function", dname);
8225 return void_type_node;
8228 /* Anything declared one level down from the top level
8229 must be one of the parameters of a function
8230 (because the body is at least two levels down). */
8232 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8233 by not allowing C++ class definitions to specify their parameters
8234 with xdecls (must be spec.d in the parmlist).
8236 Since we now wait to push a class scope until we are sure that
8237 we are in a legitimate method context, we must set oldcname
8238 explicitly (since current_class_name is not yet alive).
8240 We also want to avoid calling this a PARM if it is in a namespace. */
8242 if (decl_context == NORMAL && ! namespace_bindings_p ()
8243 && ! pseudo_global_level_p ())
8245 struct binding_level *b = current_binding_level;
8246 current_binding_level = b->level_chain;
8247 if (current_binding_level != 0 && toplevel_bindings_p ())
8248 decl_context = PARM;
8249 current_binding_level = b;
8252 /* Look through the decl specs and record which ones appear.
8253 Some typespecs are defined as built-in typenames.
8254 Others, the ones that are modifiers of other types,
8255 are represented by bits in SPECBITS: set the bits for
8256 the modifiers that appear. Storage class keywords are also in SPECBITS.
8258 If there is a typedef name or a type, store the type in TYPE.
8259 This includes builtin typedefs such as `int'.
8261 Set EXPLICIT_INT if the type is `int' or `char' and did not
8262 come from a user typedef.
8264 Set LONGLONG if `long' is mentioned twice.
8266 For C++, constructors and destructors have their own fast treatment. */
8268 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
8273 /* Certain parse errors slip through. For example,
8274 `int class;' is not caught by the parser. Try
8275 weakly to recover here. */
8276 if (TREE_CODE (spec) != TREE_LIST)
8279 id = TREE_VALUE (spec);
8281 if (TREE_CODE (id) == IDENTIFIER_NODE)
8283 if (id == ridpointers[(int) RID_INT]
8284 || id == ridpointers[(int) RID_CHAR]
8285 || id == ridpointers[(int) RID_BOOL]
8286 || id == ridpointers[(int) RID_WCHAR])
8290 if (id == ridpointers[(int) RID_BOOL])
8291 error ("`bool' is now a keyword");
8293 cp_error ("extraneous `%T' ignored", id);
8297 if (id == ridpointers[(int) RID_INT])
8299 else if (id == ridpointers[(int) RID_CHAR])
8301 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
8305 /* C++ aggregate types. */
8306 if (IDENTIFIER_HAS_TYPE_VALUE (id))
8309 cp_error ("multiple declarations `%T' and `%T'", type, id);
8311 type = IDENTIFIER_TYPE_VALUE (id);
8315 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
8317 if (ridpointers[i] == id)
8319 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
8321 if (pedantic && ! in_system_header)
8322 pedwarn ("ANSI C++ does not support `long long'");
8324 error ("`long long long' is too long for GCC");
8328 else if (RIDBIT_SETP (i, specbits))
8329 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
8330 RIDBIT_SET (i, specbits);
8335 /* C++ aggregate types. */
8336 else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
8339 cp_error ("multiple declarations `%T' and `%T'", type,
8343 type = TREE_TYPE (id);
8344 TREE_VALUE (spec) = type;
8349 error ("two or more data types in declaration of `%s'", name);
8350 else if (TREE_CODE (id) == IDENTIFIER_NODE)
8352 register tree t = lookup_name (id, 1);
8353 if (!t || TREE_CODE (t) != TYPE_DECL)
8354 error ("`%s' fails to be a typedef or built in type",
8355 IDENTIFIER_POINTER (id));
8358 type = TREE_TYPE (t);
8360 /* See the code below that used this. */
8361 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
8366 else if (id != error_mark_node)
8367 /* Can't change CLASS nodes into RECORD nodes here! */
8373 typedef_type = type;
8375 /* No type at all: default to `int', and set DEFAULTED_INT
8376 because it was not a user-defined typedef.
8377 Except when we have a `typedef' inside a signature, in
8378 which case the type defaults to `unknown type' and is
8379 instantiated when assigning to a signature pointer or ref. */
8381 if (type == NULL_TREE
8382 && (RIDBIT_SETP (RID_SIGNED, specbits)
8383 || RIDBIT_SETP (RID_UNSIGNED, specbits)
8384 || RIDBIT_SETP (RID_LONG, specbits)
8385 || RIDBIT_SETP (RID_SHORT, specbits)))
8387 /* These imply 'int'. */
8388 type = integer_type_node;
8392 if (type == NULL_TREE)
8395 if (return_type == return_dtor)
8396 type = void_type_node;
8397 else if (return_type == return_ctor)
8398 type = build_pointer_type (ctor_return_type);
8399 else if (return_type == return_conversion)
8400 type = ctor_return_type;
8401 else if (current_class_type
8402 && IS_SIGNATURE (current_class_type)
8403 && RIDBIT_SETP (RID_TYPEDEF, specbits)
8404 && (decl_context == FIELD || decl_context == NORMAL))
8408 type = copy_node (opaque_type_node);
8414 if (warn_return_type
8415 && return_type == return_normal)
8416 /* Save warning until we know what is really going on. */
8417 warn_about_return_type = 1;
8419 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8420 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
8421 else if (innermost_code != CALL_EXPR || pedantic
8422 || (warn_return_type && return_type == return_normal))
8424 if (innermost_code == CALL_EXPR)
8425 cp_pedwarn ("return-type of `%D' defaults to `int'", dname);
8427 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
8430 type = integer_type_node;
8433 else if (return_type == return_dtor)
8435 error ("return type specification for destructor invalid");
8436 type = void_type_node;
8438 else if (return_type == return_ctor)
8440 error ("return type specification for constructor invalid");
8441 type = build_pointer_type (ctor_return_type);
8443 else if (return_type == return_conversion)
8445 if (comptypes (type, ctor_return_type, 1) == 0)
8446 cp_error ("operator `%T' declared to return `%T'",
8447 ctor_return_type, type);
8449 cp_pedwarn ("return type specified for `operator %T'",
8452 type = ctor_return_type;
8457 /* Now process the modifiers that were specified
8458 and check for invalid combinations. */
8460 /* Long double is a special combination. */
8462 if (RIDBIT_SETP (RID_LONG, specbits)
8463 && TYPE_MAIN_VARIANT (type) == double_type_node)
8465 RIDBIT_RESET (RID_LONG, specbits);
8466 type = build_type_variant (long_double_type_node, TYPE_READONLY (type),
8467 TYPE_VOLATILE (type));
8470 /* Check all other uses of type modifiers. */
8472 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
8473 || RIDBIT_SETP (RID_SIGNED, specbits)
8474 || RIDBIT_SETP (RID_LONG, specbits)
8475 || RIDBIT_SETP (RID_SHORT, specbits))
8479 if (TREE_CODE (type) == REAL_TYPE)
8480 error ("short, signed or unsigned invalid for `%s'", name);
8481 else if (TREE_CODE (type) != INTEGER_TYPE)
8482 error ("long, short, signed or unsigned invalid for `%s'", name);
8483 else if (RIDBIT_SETP (RID_LONG, specbits)
8484 && RIDBIT_SETP (RID_SHORT, specbits))
8485 error ("long and short specified together for `%s'", name);
8486 else if ((RIDBIT_SETP (RID_LONG, specbits)
8487 || RIDBIT_SETP (RID_SHORT, specbits))
8489 error ("long or short specified with char for `%s'", name);
8490 else if ((RIDBIT_SETP (RID_LONG, specbits)
8491 || RIDBIT_SETP (RID_SHORT, specbits))
8492 && TREE_CODE (type) == REAL_TYPE)
8493 error ("long or short specified with floating type for `%s'", name);
8494 else if (RIDBIT_SETP (RID_SIGNED, specbits)
8495 && RIDBIT_SETP (RID_UNSIGNED, specbits))
8496 error ("signed and unsigned given together for `%s'", name);
8500 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
8502 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
8504 if (flag_pedantic_errors)
8509 /* Discard the type modifiers if they are invalid. */
8512 RIDBIT_RESET (RID_UNSIGNED, specbits);
8513 RIDBIT_RESET (RID_SIGNED, specbits);
8514 RIDBIT_RESET (RID_LONG, specbits);
8515 RIDBIT_RESET (RID_SHORT, specbits);
8520 if (RIDBIT_SETP (RID_COMPLEX, specbits)
8521 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8523 error ("complex invalid for `%s'", name);
8524 RIDBIT_RESET (RID_COMPLEX, specbits);
8527 /* Decide whether an integer type is signed or not.
8528 Optionally treat bitfields as signed by default. */
8529 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
8530 || (bitfield && ! flag_signed_bitfields
8531 && (explicit_int || defaulted_int || explicit_char
8532 /* A typedef for plain `int' without `signed'
8533 can be controlled just like plain `int'. */
8534 || ! (typedef_decl != NULL_TREE
8535 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8536 && TREE_CODE (type) != ENUMERAL_TYPE
8537 && RIDBIT_NOTSETP (RID_SIGNED, specbits)))
8540 type = long_long_unsigned_type_node;
8541 else if (RIDBIT_SETP (RID_LONG, specbits))
8542 type = long_unsigned_type_node;
8543 else if (RIDBIT_SETP (RID_SHORT, specbits))
8544 type = short_unsigned_type_node;
8545 else if (type == char_type_node)
8546 type = unsigned_char_type_node;
8547 else if (typedef_decl)
8548 type = unsigned_type (type);
8550 type = unsigned_type_node;
8552 else if (RIDBIT_SETP (RID_SIGNED, specbits)
8553 && type == char_type_node)
8554 type = signed_char_type_node;
8556 type = long_long_integer_type_node;
8557 else if (RIDBIT_SETP (RID_LONG, specbits))
8558 type = long_integer_type_node;
8559 else if (RIDBIT_SETP (RID_SHORT, specbits))
8560 type = short_integer_type_node;
8562 if (RIDBIT_SETP (RID_COMPLEX, specbits))
8564 /* If we just have "complex", it is equivalent to
8565 "complex double", but if any modifiers at all are specified it is
8566 the complex form of TYPE. E.g, "complex short" is
8567 "complex short int". */
8569 if (defaulted_int && ! longlong
8570 && ! (RIDBIT_SETP (RID_LONG, specbits)
8571 || RIDBIT_SETP (RID_SHORT, specbits)
8572 || RIDBIT_SETP (RID_SIGNED, specbits)
8573 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
8574 type = complex_double_type_node;
8575 else if (type == integer_type_node)
8576 type = complex_integer_type_node;
8577 else if (type == float_type_node)
8578 type = complex_float_type_node;
8579 else if (type == double_type_node)
8580 type = complex_double_type_node;
8581 else if (type == long_double_type_node)
8582 type = complex_long_double_type_node;
8584 type = build_complex_type (type);
8587 if (return_type == return_conversion
8588 && (RIDBIT_SETP (RID_CONST, specbits)
8589 || RIDBIT_SETP (RID_VOLATILE, specbits)))
8590 cp_error ("`operator %T' cannot be cv-qualified",
8593 /* Set CONSTP if this declaration is `const', whether by
8594 explicit specification or via a typedef.
8595 Likewise for VOLATILEP. */
8597 constp = !! RIDBIT_SETP (RID_CONST, specbits) + TYPE_READONLY (type);
8598 volatilep = !! RIDBIT_SETP (RID_VOLATILE, specbits) + TYPE_VOLATILE (type);
8599 type = build_type_variant (type, 0, 0);
8601 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
8602 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
8603 RIDBIT_RESET (RID_VIRTUAL, specbits);
8604 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
8605 RIDBIT_RESET (RID_EXPLICIT, specbits);
8607 if (RIDBIT_SETP (RID_STATIC, specbits))
8608 staticp = 1 + (decl_context == FIELD);
8610 if (virtualp && staticp == 2)
8612 cp_error ("member `%D' cannot be declared both virtual and static",
8616 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
8617 RIDBIT_RESET (RID_FRIEND, specbits);
8619 if (RIDBIT_SETP (RID_MUTABLE, specbits))
8621 if (decl_context == PARM)
8623 error ("non-member `%s' cannot be declared `mutable'", name);
8624 RIDBIT_RESET (RID_MUTABLE, specbits);
8626 else if (friendp || decl_context == TYPENAME)
8628 error ("non-object member `%s' cannot be declared `mutable'", name);
8629 RIDBIT_RESET (RID_MUTABLE, specbits);
8633 /* Warn if two storage classes are given. Default to `auto'. */
8635 if (RIDBIT_ANY_SET (specbits))
8637 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
8638 if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
8639 if (decl_context == PARM && nclasses > 0)
8640 error ("storage class specifiers invalid in parameter declarations");
8641 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8643 if (decl_context == PARM)
8644 error ("typedef declaration invalid in parameter declaration");
8647 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
8648 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
8651 /* Give error if `virtual' is used outside of class declaration. */
8653 && (current_class_name == NULL_TREE || decl_context != FIELD))
8655 error ("virtual outside class declaration");
8658 if (current_class_name == NULL_TREE && RIDBIT_SETP (RID_MUTABLE, specbits))
8660 error ("only members can be declared mutable");
8661 RIDBIT_RESET (RID_MUTABLE, specbits);
8664 /* Static anonymous unions are dealt with here. */
8665 if (staticp && decl_context == TYPENAME
8666 && TREE_CODE (declspecs) == TREE_LIST
8667 && TREE_CODE (TREE_VALUE (declspecs)) == UNION_TYPE
8668 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_VALUE (declspecs))))
8669 decl_context = FIELD;
8671 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
8672 is used in a signature member function declaration. */
8673 if (decl_context == FIELD
8674 && IS_SIGNATURE (current_class_type)
8675 && RIDBIT_NOTSETP (RID_TYPEDEF, specbits))
8679 error ("`const' specified for signature member function `%s'", name);
8684 error ("`volatile' specified for signature member function `%s'",
8690 error ("`inline' specified for signature member function `%s'", name);
8691 /* Later, we'll make signature member functions inline. */
8696 error ("`friend' declaration in signature definition");
8701 error ("`virtual' specified for signature member function `%s'",
8703 /* Later, we'll make signature member functions virtual. */
8708 /* Warn about storage classes that are invalid for certain
8709 kinds of declarations (parameters, typenames, etc.). */
8712 error ("multiple storage classes in declaration of `%s'", name);
8713 else if (decl_context != NORMAL && nclasses > 0)
8715 if ((decl_context == PARM || decl_context == CATCHPARM)
8716 && (RIDBIT_SETP (RID_REGISTER, specbits)
8717 || RIDBIT_SETP (RID_AUTO, specbits)))
8719 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
8721 else if (decl_context == FIELD
8722 && ! IS_SIGNATURE (current_class_type)
8723 /* C++ allows static class elements */
8724 && RIDBIT_SETP (RID_STATIC, specbits))
8725 /* C++ also allows inlines and signed and unsigned elements,
8726 but in those cases we don't come in here. */
8730 if (decl_context == FIELD)
8732 tree tmp = NULL_TREE;
8733 register int op = 0;
8737 /* Avoid trying to get an operand off an identifier node. */
8738 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
8741 tmp = TREE_OPERAND (declarator, 0);
8742 op = IDENTIFIER_OPNAME_P (tmp);
8744 error ("storage class specified for %s `%s'",
8745 IS_SIGNATURE (current_class_type)
8747 ? "signature member operator"
8748 : "signature member function")
8749 : (op ? "member operator" : "field"),
8750 op ? operator_name_string (tmp) : name);
8753 error (((decl_context == PARM || decl_context == CATCHPARM)
8754 ? "storage class specified for parameter `%s'"
8755 : "storage class specified for typename"), name);
8756 RIDBIT_RESET (RID_REGISTER, specbits);
8757 RIDBIT_RESET (RID_AUTO, specbits);
8758 RIDBIT_RESET (RID_EXTERN, specbits);
8760 if (decl_context == FIELD && IS_SIGNATURE (current_class_type))
8762 RIDBIT_RESET (RID_STATIC, specbits);
8767 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
8769 if (toplevel_bindings_p ())
8771 /* It's common practice (and completely valid) to have a const
8772 be initialized and declared extern. */
8774 warning ("`%s' initialized and declared `extern'", name);
8777 error ("`%s' has both `extern' and initializer", name);
8779 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
8780 && ! toplevel_bindings_p ())
8781 error ("nested function `%s' declared `extern'", name);
8782 else if (toplevel_bindings_p ())
8784 if (RIDBIT_SETP (RID_AUTO, specbits))
8785 error ("top-level declaration of `%s' specifies `auto'", name);
8788 if (nclasses > 0 && friendp)
8789 error ("storage class specifiers invalid in friend function declarations");
8791 /* Now figure out the structure of the declarator proper.
8792 Descend through it, creating more complex types, until we reach
8793 the declared identifier (or NULL_TREE, in an absolute declarator). */
8795 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
8796 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
8798 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
8799 an INDIRECT_REF (for *...),
8800 a CALL_EXPR (for ...(...)),
8801 an identifier (for the name being declared)
8802 or a null pointer (for the place in an absolute declarator
8803 where the name was omitted).
8804 For the last two cases, we have just exited the loop.
8806 For C++ it could also be
8807 a SCOPE_REF (for class :: ...). In this case, we have converted
8808 sensible names to types, and those are the values we use to
8809 qualify the member name.
8810 an ADDR_EXPR (for &...),
8811 a BIT_NOT_EXPR (for destructors)
8813 At this point, TYPE is the type of elements of an array,
8814 or for a function to return, or for a pointer to point to.
8815 After this sequence of ifs, TYPE is the type of the
8816 array or function or pointer, and DECLARATOR has had its
8817 outermost layer removed. */
8819 if (type == error_mark_node)
8821 if (TREE_CODE (declarator) == SCOPE_REF)
8822 declarator = TREE_OPERAND (declarator, 1);
8824 declarator = TREE_OPERAND (declarator, 0);
8827 if (quals != NULL_TREE
8828 && (declarator == NULL_TREE
8829 || TREE_CODE (declarator) != SCOPE_REF))
8831 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
8832 ctype = TYPE_METHOD_BASETYPE (type);
8833 if (ctype != NULL_TREE)
8835 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
8836 ctype = grok_method_quals (ctype, dummy, quals);
8837 type = TREE_TYPE (dummy);
8841 switch (TREE_CODE (declarator))
8845 register tree itype = NULL_TREE;
8846 register tree size = TREE_OPERAND (declarator, 1);
8847 /* The index is a signed object `sizetype' bits wide. */
8848 tree index_type = signed_type (sizetype);
8850 declarator = TREE_OPERAND (declarator, 0);
8852 /* Check for some types that there cannot be arrays of. */
8854 if (TREE_CODE (type) == VOID_TYPE)
8856 cp_error ("declaration of `%D' as array of voids", dname);
8857 type = error_mark_node;
8860 if (TREE_CODE (type) == FUNCTION_TYPE)
8862 cp_error ("declaration of `%D' as array of functions", dname);
8863 type = error_mark_node;
8866 /* ARM $8.4.3: Since you can't have a pointer to a reference,
8867 you can't have arrays of references. If we allowed them,
8868 then we'd be saying x[i] is valid for an array x, but
8869 then you'd have to ask: what does `*(x + i)' mean? */
8870 if (TREE_CODE (type) == REFERENCE_TYPE)
8872 if (decl_context == TYPENAME)
8873 cp_error ("cannot make arrays of references");
8875 cp_error ("declaration of `%D' as array of references",
8877 type = error_mark_node;
8880 if (TREE_CODE (type) == OFFSET_TYPE)
8882 cp_error ("declaration of `%D' as array of data members",
8884 type = error_mark_node;
8887 if (TREE_CODE (type) == METHOD_TYPE)
8889 cp_error ("declaration of `%D' as array of function members",
8891 type = error_mark_node;
8894 if (size == error_mark_node)
8895 type = error_mark_node;
8897 if (type == error_mark_node)
8902 /* Must suspend_momentary here because the index
8903 type may need to live until the end of the function.
8904 For example, it is used in the declaration of a
8905 variable which requires destructing at the end of
8906 the function; then build_vec_delete will need this
8908 int yes = suspend_momentary ();
8909 /* Might be a cast. */
8910 if (TREE_CODE (size) == NOP_EXPR
8911 && TREE_TYPE (size) == TREE_TYPE (TREE_OPERAND (size, 0)))
8912 size = TREE_OPERAND (size, 0);
8914 /* If this involves a template parameter, it'll be
8915 constant, but we don't know what the value is yet. */
8916 if (processing_template_decl)
8918 itype = make_node (INTEGER_TYPE);
8919 TYPE_MIN_VALUE (itype) = size_zero_node;
8920 TYPE_MAX_VALUE (itype) = build_min
8921 (MINUS_EXPR, sizetype, size, integer_one_node);
8922 goto dont_grok_size;
8925 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8926 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
8928 cp_error ("size of array `%D' has non-integer type",
8930 size = integer_one_node;
8932 if (TREE_READONLY_DECL_P (size))
8933 size = decl_constant_value (size);
8934 if (pedantic && integer_zerop (size))
8935 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname);
8936 if (TREE_CONSTANT (size))
8938 int old_flag_pedantic_errors = flag_pedantic_errors;
8939 int old_pedantic = pedantic;
8940 pedantic = flag_pedantic_errors = 1;
8941 /* Always give overflow errors on array subscripts. */
8942 constant_expression_warning (size);
8943 pedantic = old_pedantic;
8944 flag_pedantic_errors = old_flag_pedantic_errors;
8945 if (INT_CST_LT (size, integer_zero_node))
8947 cp_error ("size of array `%D' is negative", dname);
8948 size = integer_one_node;
8956 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8959 cp_pedwarn ("ANSI C++ forbids variable-size array");
8964 = fold (build_binary_op (MINUS_EXPR,
8965 cp_convert (index_type, size),
8966 cp_convert (index_type,
8967 integer_one_node), 1));
8968 if (! TREE_CONSTANT (itype))
8969 itype = variable_size (itype);
8970 else if (TREE_OVERFLOW (itype))
8972 error ("overflow in array dimension");
8973 TREE_OVERFLOW (itype) = 0;
8976 /* If we're a parm, we need to have a permanent type so
8977 mangling checks for re-use will work right. If both the
8978 element and index types are permanent, the array type
8980 if (decl_context == PARM
8981 && allocation_temporary_p () && TREE_PERMANENT (type))
8983 push_obstacks (&permanent_obstack, &permanent_obstack);
8984 itype = build_index_type (itype);
8988 itype = build_index_type (itype);
8991 resume_momentary (yes);
8994 /* Build the array type itself, then merge any constancy or
8995 volatility into the target type. We must do it in this order
8996 to ensure that the TYPE_MAIN_VARIANT field of the array type
8997 is set correctly. */
8999 type = build_cplus_array_type (type, itype);
9000 if (constp || volatilep)
9001 type = cp_build_type_variant (type, constp, volatilep);
9011 tree inner_parms = TREE_OPERAND (declarator, 1);
9012 tree inner_decl = TREE_OPERAND (declarator, 0);
9014 /* Declaring a function type.
9015 Make sure we have a valid type for the function to return. */
9017 /* Is this an error? Should they be merged into TYPE here? */
9018 if (pedantic && (constp || volatilep))
9019 pedwarn ("function declared to return const or volatile result");
9021 /* Merge any constancy or volatility into the function return
9024 if (constp || volatilep)
9026 type = cp_build_type_variant (type, constp, volatilep);
9027 if (IS_AGGR_TYPE (type))
9028 build_pointer_type (type);
9034 /* Warn about some types functions can't return. */
9036 if (TREE_CODE (type) == FUNCTION_TYPE)
9038 error ("`%s' declared as function returning a function", name);
9039 type = integer_type_node;
9041 if (TREE_CODE (type) == ARRAY_TYPE)
9043 error ("`%s' declared as function returning an array", name);
9044 type = integer_type_node;
9047 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
9048 inner_decl = TREE_OPERAND (inner_decl, 1);
9050 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
9053 /* Pick up type qualifiers which should be applied to `this'. */
9054 quals = TREE_OPERAND (declarator, 2);
9056 /* Pick up the exception specifications. */
9057 raises = TREE_TYPE (declarator);
9059 /* Say it's a definition only for the CALL_EXPR
9060 closest to the identifier. */
9063 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
9064 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
9065 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
9067 if (ctype == NULL_TREE
9068 && decl_context == FIELD
9070 && (friendp == 0 || dname == current_class_name))
9071 ctype = current_class_type;
9073 if (ctype && return_type == return_conversion)
9074 TYPE_HAS_CONVERSION (ctype) = 1;
9075 if (ctype && constructor_name (ctype) == dname)
9077 /* We are within a class's scope. If our declarator name
9078 is the same as the class name, and we are defining
9079 a function, then it is a constructor/destructor, and
9080 therefore returns a void type. */
9082 if (flags == DTOR_FLAG)
9084 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9085 not be declared const or volatile. A destructor
9086 may not be static. */
9088 error ("destructor cannot be static member function");
9091 error ("destructors cannot be declared `const' or `volatile'");
9092 return void_type_node;
9094 if (decl_context == FIELD)
9096 if (! member_function_or_else (ctype, current_class_type,
9097 "destructor for alien class `%s' cannot be a member"))
9098 return void_type_node;
9101 else /* It's a constructor. */
9105 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9106 not be declared const or volatile. A constructor may
9107 not be virtual. A constructor may not be static. */
9109 error ("constructor cannot be static member function");
9112 pedwarn ("constructors cannot be declared virtual");
9117 error ("constructors cannot be declared `const' or `volatile'");
9118 return void_type_node;
9121 RID_BIT_TYPE tmp_bits;
9122 bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
9123 RIDBIT_RESET (RID_INLINE, tmp_bits);
9124 RIDBIT_RESET (RID_STATIC, tmp_bits);
9125 if (RIDBIT_ANY_SET (tmp_bits))
9126 error ("return value type specifier for constructor ignored");
9128 type = build_pointer_type (ctype);
9129 if (decl_context == FIELD
9130 && IS_SIGNATURE (current_class_type))
9132 error ("constructor not allowed in signature");
9133 return void_type_node;
9135 else if (decl_context == FIELD)
9137 if (! member_function_or_else (ctype, current_class_type,
9138 "constructor for alien class `%s' cannot be member"))
9139 return void_type_node;
9140 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
9141 if (return_type != return_ctor)
9145 if (decl_context == FIELD)
9151 error ("can't initialize friend function `%s'", name);
9154 /* Cannot be both friend and virtual. */
9155 error ("virtual functions cannot be friends");
9156 RIDBIT_RESET (RID_FRIEND, specbits);
9159 if (decl_context == NORMAL)
9160 error ("friend declaration not in class definition");
9161 if (current_function_decl && funcdef_flag)
9162 cp_error ("can't define friend function `%s' in a local class definition",
9166 /* Construct the function type and go to the next
9167 inner layer of declarator. */
9169 declarator = TREE_OPERAND (declarator, 0);
9171 /* FIXME: This is where default args should be fully
9174 arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
9178 /* Get past destructors, etc.
9179 We know we have one because FLAGS will be non-zero.
9181 Complain about improper parameter lists here. */
9182 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
9184 declarator = TREE_OPERAND (declarator, 0);
9186 if (strict_prototype == 0 && arg_types == NULL_TREE)
9187 arg_types = void_list_node;
9188 else if (arg_types == NULL_TREE
9189 || arg_types != void_list_node)
9191 error ("destructors cannot be specified with parameters");
9192 arg_types = void_list_node;
9197 /* ANSI says that `const int foo ();'
9198 does not make the function foo const. */
9199 type = build_function_type (type, arg_types);
9203 for (t = arg_types; t; t = TREE_CHAIN (t))
9204 if (TREE_PURPOSE (t)
9205 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9207 add_defarg_fn (type);
9216 /* Filter out pointers-to-references and references-to-references.
9217 We can get these if a TYPE_DECL is used. */
9219 if (TREE_CODE (type) == REFERENCE_TYPE)
9221 error ("cannot declare %s to references",
9222 TREE_CODE (declarator) == ADDR_EXPR
9223 ? "references" : "pointers");
9224 declarator = TREE_OPERAND (declarator, 0);
9228 if (TREE_CODE (type) == OFFSET_TYPE
9229 && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
9230 || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
9232 cp_error ("cannot declare pointer to `%#T' member",
9234 type = TREE_TYPE (type);
9237 /* Merge any constancy or volatility into the target type
9240 if (constp || volatilep)
9242 /* A const or volatile signature pointer/reference is
9243 pointing to a const or volatile object, i.e., the
9244 `optr' is const or volatile, respectively, not the
9245 signature pointer/reference itself. */
9246 if (! IS_SIGNATURE (type))
9248 type = cp_build_type_variant (type, constp, volatilep);
9249 if (IS_AGGR_TYPE (type))
9250 build_pointer_type (type);
9256 if (IS_SIGNATURE (type))
9258 if (TREE_CODE (declarator) == ADDR_EXPR)
9260 if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
9261 && TYPE_SIZE (type))
9262 cp_warning ("empty signature `%T' used in signature reference declaration",
9265 type = build_signature_reference_type (type,
9268 sorry ("signature reference");
9274 if (CLASSTYPE_METHOD_VEC (type) == NULL_TREE
9275 && TYPE_SIZE (type))
9276 cp_warning ("empty signature `%T' used in signature pointer declaration",
9278 type = build_signature_pointer_type (type,
9284 else if (TREE_CODE (declarator) == ADDR_EXPR)
9286 if (TREE_CODE (type) == FUNCTION_TYPE)
9288 error ("cannot declare references to functions; use pointer to function instead");
9289 type = build_pointer_type (type);
9293 if (TREE_CODE (type) == VOID_TYPE)
9294 error ("invalid type: `void &'");
9296 type = build_reference_type (type);
9299 else if (TREE_CODE (type) == METHOD_TYPE)
9301 type = build_ptrmemfunc_type (build_pointer_type (type));
9304 type = build_pointer_type (type);
9306 /* Process a list of type modifier keywords (such as
9307 const or volatile) that were given inside the `*' or `&'. */
9309 if (TREE_TYPE (declarator))
9311 register tree typemodlist;
9313 for (typemodlist = TREE_TYPE (declarator); typemodlist;
9314 typemodlist = TREE_CHAIN (typemodlist))
9316 if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
9318 else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
9323 error ("invalid type modifier within %s declarator",
9324 TREE_CODE (declarator) == ADDR_EXPR
9325 ? "reference" : "pointer");
9329 pedwarn ("duplicate `const'");
9331 pedwarn ("duplicate `volatile'");
9332 if (TREE_CODE (declarator) == ADDR_EXPR
9333 && (constp || volatilep))
9336 pedwarn ("discarding `const' applied to a reference");
9338 pedwarn ("discarding `volatile' applied to a reference");
9339 constp = volatilep = 0;
9342 declarator = TREE_OPERAND (declarator, 0);
9348 /* We have converted type names to NULL_TREE if the
9349 name was bogus, or to a _TYPE node, if not.
9351 The variable CTYPE holds the type we will ultimately
9352 resolve to. The code here just needs to build
9353 up appropriate member types. */
9354 tree sname = TREE_OPERAND (declarator, 1);
9357 /* Destructors can have their visibilities changed as well. */
9358 if (TREE_CODE (sname) == BIT_NOT_EXPR)
9359 sname = TREE_OPERAND (sname, 0);
9361 if (TREE_COMPLEXITY (declarator) == 0)
9362 /* This needs to be here, in case we are called
9363 multiple times. */ ;
9364 else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
9365 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
9366 else if (! IS_AGGR_TYPE_CODE
9367 (TREE_CODE (TREE_OPERAND (declarator, 0))))
9369 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
9371 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9372 that refer to ctype. They couldn't be resolved earlier
9373 because we hadn't pushed into the class yet.
9374 Example: resolve 'B<T>::type' in
9375 'B<typename B<T>::type> B<T>::f () { }'. */
9376 if (current_template_parms
9377 && uses_template_parms (type)
9378 && uses_template_parms (current_class_type))
9380 tree args = current_template_args ();
9381 type = tsubst (type, args, NULL_TREE);
9384 /* This pop_nested_class corresponds to the
9385 push_nested_class used to push into class scope for
9386 parsing the argument list of a function decl, in
9388 pop_nested_class (1);
9389 TREE_COMPLEXITY (declarator) = current_class_depth;
9392 my_friendly_abort (16);
9394 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
9396 /* We had a reference to a global decl, or
9397 perhaps we were given a non-aggregate typedef,
9398 in which case we cleared this out, and should just
9399 keep going as though it wasn't there. */
9403 ctype = TREE_OPERAND (declarator, 0);
9406 while (t != NULL_TREE)
9408 if (CLASSTYPE_TEMPLATE_INFO (t) &&
9409 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
9410 template_count += 1;
9411 t = TYPE_MAIN_DECL (t);
9412 if (DECL_LANG_SPECIFIC (t))
9413 t = DECL_CLASS_CONTEXT (t);
9418 if (sname == NULL_TREE)
9421 if (TREE_CODE (sname) == IDENTIFIER_NODE)
9423 /* This is the `standard' use of the scoping operator:
9424 basetype :: member . */
9426 if (ctype == current_class_type)
9432 Is this ill-formed? */
9435 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
9438 else if (TREE_CODE (type) == FUNCTION_TYPE)
9440 if (current_class_type == NULL_TREE
9442 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9443 TREE_TYPE (type), TYPE_ARG_TYPES (type));
9446 cp_error ("cannot declare member function `%T::%s' within `%T'",
9447 ctype, name, current_class_type);
9448 return void_type_node;
9451 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
9452 || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
9454 /* Have to move this code elsewhere in this function.
9455 this code is used for i.e., typedef int A::M; M *pm;
9457 It is? How? jason 10/2/94 */
9459 if (current_class_type)
9461 cp_error ("cannot declare member `%T::%s' within `%T'",
9462 ctype, name, current_class_type);
9463 return void_type_node;
9465 type = build_offset_type (ctype, type);
9467 else if (uses_template_parms (ctype))
9469 if (TREE_CODE (type) == FUNCTION_TYPE)
9471 = build_cplus_method_type (build_type_variant (ctype,
9475 TYPE_ARG_TYPES (type));
9479 cp_error ("structure `%T' not yet defined", ctype);
9480 return error_mark_node;
9485 else if (TREE_CODE (sname) == SCOPE_REF)
9486 my_friendly_abort (17);
9490 declarator = TREE_OPERAND (declarator, 1);
9491 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
9492 /* In this case, we will deal with it later. */
9496 if (TREE_CODE (type) == FUNCTION_TYPE)
9497 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep), TREE_TYPE (type), TYPE_ARG_TYPES (type));
9499 type = build_offset_type (ctype, type);
9506 declarator = TREE_OPERAND (declarator, 0);
9512 declarator = NULL_TREE;
9516 declarator = NULL_TREE;
9520 my_friendly_abort (158);
9526 error ("only constructors can be declared `explicit'");
9530 /* Now TYPE has the actual type. */
9532 /* If this is declaring a typedef name, return a TYPE_DECL. */
9534 if (RIDBIT_SETP (RID_MUTABLE, specbits))
9538 error ("const `%s' cannot be declared `mutable'", name);
9539 RIDBIT_RESET (RID_MUTABLE, specbits);
9543 error ("static `%s' cannot be declared `mutable'", name);
9544 RIDBIT_RESET (RID_MUTABLE, specbits);
9548 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
9552 /* Note that the grammar rejects storage classes
9553 in typenames, fields or parameters. */
9554 if (constp || volatilep)
9555 type = cp_build_type_variant (type, constp, volatilep);
9557 if (decl_context == FIELD)
9559 if (declarator == current_class_name)
9560 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
9562 decl = build_lang_decl (TYPE_DECL, declarator, type);
9563 if (IS_SIGNATURE (current_class_type) && opaque_typedef)
9564 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type) = 1;
9566 else if (current_lang_name == lang_name_java)
9567 decl = build_lang_decl (TYPE_DECL, declarator, type);
9569 decl = build_decl (TYPE_DECL, declarator, type);
9571 /* If the user declares "struct {...} foo" then `foo' will have
9572 an anonymous name. Fill that name in now. Nothing can
9573 refer to it, so nothing needs know about the name change.
9574 The TYPE_NAME field was filled in by build_struct_xref. */
9575 if (type != error_mark_node
9577 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9578 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
9580 /* Replace the anonymous name with the real name everywhere. */
9581 lookup_tag_reverse (type, declarator);
9582 TYPE_NAME (type) = decl;
9584 if (TYPE_LANG_SPECIFIC (type))
9585 TYPE_WAS_ANONYMOUS (type) = 1;
9587 /* XXX Temporarily set the scope.
9588 When returning, start_decl expects it as NULL_TREE,
9589 and will then then set it using pushdecl. */
9590 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
9591 if (current_class_type)
9592 DECL_CONTEXT (decl) = current_class_type;
9594 DECL_CONTEXT (decl) = current_namespace;
9596 DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
9597 DECL_ASSEMBLER_NAME (decl)
9598 = get_identifier (build_overload_name (type, 1, 1));
9599 DECL_CONTEXT (decl) = NULL_TREE;
9602 if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
9604 cp_error_at ("typedef name may not be class-qualified", decl);
9609 if (ctype == NULL_TREE)
9611 if (TREE_CODE (type) != METHOD_TYPE)
9612 cp_error_at ("invalid type qualifier for non-method type", decl);
9614 ctype = TYPE_METHOD_BASETYPE (type);
9616 if (ctype != NULL_TREE)
9617 grok_method_quals (ctype, decl, quals);
9620 if (RIDBIT_SETP (RID_SIGNED, specbits)
9621 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
9622 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
9624 if (RIDBIT_SETP (RID_MUTABLE, specbits))
9626 error ("non-object member `%s' cannot be declared mutable", name);
9629 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
9630 inlinep, friendp, raises != NULL_TREE);
9633 error ("typedef declaration includes an initializer");
9638 /* Detect the case of an array type of unspecified size
9639 which came, as such, direct from a typedef name.
9640 We must copy the type, so that each identifier gets
9641 a distinct type, so that each identifier's size can be
9642 controlled separately by its own initializer. */
9644 if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
9645 && TYPE_DOMAIN (type) == NULL_TREE)
9647 type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
9650 /* If this is a type name (such as, in a cast or sizeof),
9651 compute the type and return it now. */
9653 if (decl_context == TYPENAME)
9655 /* Note that the grammar rejects storage classes
9656 in typenames, fields or parameters. */
9657 if (constp || volatilep)
9659 if (IS_SIGNATURE (type))
9660 error ("`const' or `volatile' specified with signature type");
9662 type = cp_build_type_variant (type, constp, volatilep);
9665 /* Special case: "friend class foo" looks like a TYPENAME context. */
9670 cp_error ("`volatile' specified for friend class declaration");
9675 cp_error ("`inline' specified for friend class declaration");
9679 /* Only try to do this stuff if we didn't already give up. */
9680 if (type != integer_type_node)
9682 /* A friendly class? */
9683 if (current_class_type)
9684 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
9686 error ("trying to make class `%s' a friend of global scope",
9687 TYPE_NAME_STRING (type));
9688 type = void_type_node;
9693 tree dummy = build_decl (TYPE_DECL, declarator, type);
9694 if (ctype == NULL_TREE)
9696 my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
9697 ctype = TYPE_METHOD_BASETYPE (type);
9699 grok_method_quals (ctype, dummy, quals);
9700 type = TREE_TYPE (dummy);
9705 else if (declarator == NULL_TREE && decl_context != PARM
9706 && decl_context != CATCHPARM
9707 && TREE_CODE (type) != UNION_TYPE
9710 cp_error ("abstract declarator `%T' used as declaration", type);
9711 declarator = make_anon_name ();
9714 /* `void' at top level (not within pointer)
9715 is allowed only in typedefs or type names.
9716 We don't complain about parms either, but that is because
9717 a better error message can be made later. */
9719 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
9722 error ("unnamed variable or field declared void");
9723 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9725 if (IDENTIFIER_OPNAME_P (declarator))
9726 my_friendly_abort (356);
9728 error ("variable or field `%s' declared void", name);
9731 error ("variable or field declared void");
9732 type = integer_type_node;
9735 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9736 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9741 if (decl_context == PARM)
9744 error ("cannot use `::' in parameter declaration");
9746 /* A parameter declared as an array of T is really a pointer to T.
9747 One declared as a function is really a pointer to a function.
9748 One declared as a member is really a pointer to member. */
9750 if (TREE_CODE (type) == ARRAY_TYPE)
9752 /* Transfer const-ness of array into that of type pointed to. */
9753 type = build_pointer_type
9754 (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
9755 volatilep = constp = 0;
9757 else if (TREE_CODE (type) == FUNCTION_TYPE)
9758 type = build_pointer_type (type);
9759 else if (TREE_CODE (type) == OFFSET_TYPE)
9760 type = build_pointer_type (type);
9761 else if (TREE_CODE (type) == VOID_TYPE && declarator)
9763 error ("declaration of `%s' as void", name);
9767 decl = build_decl (PARM_DECL, declarator, complete_type (type));
9769 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
9770 inlinep, friendp, raises != NULL_TREE);
9771 if (current_class_type
9772 && IS_SIGNATURE (current_class_type))
9775 error ("parameter of signature member function declared `inline'");
9776 if (RIDBIT_SETP (RID_AUTO, specbits))
9777 error ("parameter of signature member function declared `auto'");
9778 if (RIDBIT_SETP (RID_REGISTER, specbits))
9779 error ("parameter of signature member function declared `register'");
9782 /* Compute the type actually passed in the parmlist,
9783 for the case where there is no prototype.
9784 (For example, shorts and chars are passed as ints.)
9785 When there is a prototype, this is overridden later. */
9787 DECL_ARG_TYPE (decl) = type_promotes_to (type);
9789 else if (decl_context == FIELD)
9791 if (type == error_mark_node)
9793 /* Happens when declaring arrays of sizes which
9794 are error_mark_node, for example. */
9797 else if (TREE_CODE (type) == FUNCTION_TYPE)
9800 tree function_context;
9802 /* We catch the others as conflicts with the builtin
9804 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
9806 cp_error ("function `%D' cannot be declared friend",
9813 if (ctype == NULL_TREE)
9814 ctype = current_class_type;
9816 if (ctype == NULL_TREE)
9818 cp_error ("can't make `%D' into a method -- not in a class",
9820 return void_type_node;
9823 /* ``A union may [ ... ] not [ have ] virtual functions.''
9825 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9827 cp_error ("function `%D' declared virtual inside a union",
9829 return void_type_node;
9832 if (declarator == ansi_opname[(int) NEW_EXPR]
9833 || declarator == ansi_opname[(int) VEC_NEW_EXPR]
9834 || declarator == ansi_opname[(int) DELETE_EXPR]
9835 || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
9839 cp_error ("`%D' cannot be declared virtual, since it is always static",
9844 else if (staticp < 2)
9845 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
9846 TREE_TYPE (type), TYPE_ARG_TYPES (type));
9849 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9850 function_context = (ctype != NULL_TREE) ?
9851 hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9852 publicp = (! friendp || ! staticp)
9853 && function_context == NULL_TREE;
9854 decl = grokfndecl (ctype, type,
9855 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
9856 ? declarator : dname,
9858 virtualp, flags, quals, raises, attrlist,
9859 friendp ? -1 : 0, friendp, publicp, inlinep,
9860 funcdef_flag, template_count, in_namespace);
9861 if (decl == NULL_TREE)
9864 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9865 /* The decl and setting of decl_machine_attr is also turned off. */
9866 decl = build_decl_attribute_variant (decl, decl_machine_attr);
9870 DECL_NONCONVERTING_P (decl) = 1;
9872 else if (TREE_CODE (type) == METHOD_TYPE)
9874 /* We only get here for friend declarations of
9875 members of other classes. */
9876 /* All method decls are public, so tell grokfndecl to set
9877 TREE_PUBLIC, also. */
9878 decl = grokfndecl (ctype, type, declarator, declarator,
9879 virtualp, flags, quals, raises, attrlist,
9880 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
9881 template_count, in_namespace);
9882 if (decl == NULL_TREE)
9885 else if (!staticp && ! processing_template_decl
9886 && TYPE_SIZE (complete_type (type)) == NULL_TREE
9887 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9890 cp_error ("field `%D' has incomplete type", declarator);
9892 cp_error ("name `%T' has incomplete type", type);
9894 /* If we're instantiating a template, tell them which
9895 instantiation made the field's type be incomplete. */
9896 if (current_class_type
9897 && TYPE_NAME (current_class_type)
9898 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9899 && declspecs && TREE_VALUE (declspecs)
9900 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
9901 cp_error (" in instantiation of template `%T'",
9902 current_class_type);
9904 type = error_mark_node;
9911 error ("`%s' is neither function nor method; cannot be declared friend",
9912 IDENTIFIER_POINTER (declarator));
9920 /* Friends are treated specially. */
9921 if (ctype == current_class_type)
9922 warning ("member functions are implicitly friends of their class");
9926 if (decl && DECL_NAME (decl))
9927 t = do_friend (ctype, declarator, decl,
9928 last_function_parms, flags, quals,
9930 if (t && funcdef_flag)
9933 return void_type_node;
9937 /* Structure field. It may not be a function, except for C++ */
9939 if (decl == NULL_TREE)
9945 /* An attempt is being made to initialize a non-static
9946 member. But, from [class.mem]:
9948 4 A member-declarator can contain a
9949 constant-initializer only if it declares a static
9950 member (_class.static_) of integral or enumeration
9951 type, see _class.static.data_.
9953 This used to be relatively common practice, but
9954 the rest of the compiler does not correctly
9955 handle the initialization unless the member is
9956 static so we make it static below. */
9957 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
9958 constp ? "const member" : "member",
9960 cp_pedwarn ("making `%D' static", declarator);
9964 /* Motion 10 at San Diego: If a static const integral data
9965 member is initialized with an integral constant
9966 expression, the initializer may appear either in the
9967 declaration (within the class), or in the definition,
9968 but not both. If it appears in the class, the member is
9969 a member constant. The file-scope definition is always
9972 /* According to Mike Stump, we generate bad code for
9973 this case, so we might as well always make it an
9975 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
9978 if (pedantic && ! INTEGRAL_TYPE_P (type))
9979 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", declarator, type);
9984 /* ANSI C++ Apr '95 wp 9.2 */
9985 if (declarator == current_class_name)
9986 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
9989 /* C++ allows static class members.
9990 All other work for this is done by grokfield.
9991 This VAR_DECL is built by build_lang_field_decl.
9992 All other VAR_DECLs are built by build_decl. */
9993 decl = build_lang_field_decl (VAR_DECL, declarator, type);
9994 TREE_STATIC (decl) = 1;
9995 /* In class context, 'static' means public access. */
9996 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
10000 decl = build_lang_field_decl (FIELD_DECL, declarator, type);
10001 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10003 DECL_MUTABLE_P (decl) = 1;
10004 RIDBIT_RESET (RID_MUTABLE, specbits);
10008 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
10009 inlinep, friendp, raises != NULL_TREE);
10012 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
10014 tree original_name;
10020 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10021 original_name = dname;
10023 original_name = declarator;
10025 if (RIDBIT_SETP (RID_AUTO, specbits))
10026 error ("storage class `auto' invalid for function `%s'", name);
10027 else if (RIDBIT_SETP (RID_REGISTER, specbits))
10028 error ("storage class `register' invalid for function `%s'", name);
10030 /* Function declaration not at top level.
10031 Storage classes other than `extern' are not allowed
10032 and `extern' makes no difference. */
10033 if (! toplevel_bindings_p ()
10034 && (RIDBIT_SETP (RID_STATIC, specbits)
10035 || RIDBIT_SETP (RID_INLINE, specbits))
10038 if (RIDBIT_SETP (RID_STATIC, specbits))
10039 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
10041 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
10044 if (ctype == NULL_TREE)
10048 error ("virtual non-class function `%s'", name);
10052 if (current_lang_name == lang_name_cplusplus
10053 && ! processing_template_decl
10054 && ! (IDENTIFIER_LENGTH (original_name) == 4
10055 && IDENTIFIER_POINTER (original_name)[0] == 'm'
10056 && strcmp (IDENTIFIER_POINTER (original_name), "main") == 0)
10057 && ! (IDENTIFIER_LENGTH (original_name) > 10
10058 && IDENTIFIER_POINTER (original_name)[0] == '_'
10059 && IDENTIFIER_POINTER (original_name)[1] == '_'
10060 && strncmp (IDENTIFIER_POINTER (original_name)+2, "builtin_", 8) == 0))
10061 /* Plain overloading: will not be grok'd by grokclassfn. */
10062 if (name_mangling_version < 1
10063 || TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10064 declarator = build_decl_overload (dname, TYPE_ARG_TYPES (type), 0);
10066 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
10067 type = build_cplus_method_type (build_type_variant (ctype, constp, volatilep),
10068 TREE_TYPE (type), TYPE_ARG_TYPES (type));
10070 /* Record presence of `static'. */
10071 publicp = (ctype != NULL_TREE
10072 || RIDBIT_SETP (RID_EXTERN, specbits)
10073 || !RIDBIT_SETP (RID_STATIC, specbits));
10075 decl = grokfndecl (ctype, type, original_name, declarator,
10076 virtualp, flags, quals, raises, attrlist,
10078 publicp, inlinep, funcdef_flag,
10079 template_count, in_namespace);
10080 if (decl == NULL_TREE)
10083 if (ctype == NULL_TREE && DECL_LANGUAGE (decl) != lang_c
10084 && (! DECL_USE_TEMPLATE (decl) ||
10085 name_mangling_version < 1))
10086 DECL_ASSEMBLER_NAME (decl) = declarator;
10090 int illegal_static = 0;
10092 /* Don't allow a static member function in a class, and forbid
10093 declaring main to be static. */
10094 if (TREE_CODE (type) == METHOD_TYPE)
10096 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
10097 illegal_static = 1;
10099 else if (current_function_decl)
10101 /* FIXME need arm citation */
10102 error ("cannot declare static function inside another function");
10103 illegal_static = 1;
10106 if (illegal_static)
10109 RIDBIT_RESET (RID_STATIC, specbits);
10115 /* It's a variable. */
10117 if (decl_context == CATCHPARM)
10122 error ("cannot use `::' in parameter declaration");
10125 /* A parameter declared as an array of T is really a pointer to T.
10126 One declared as a function is really a pointer to a function.
10127 One declared as a member is really a pointer to member. */
10129 if (TREE_CODE (type) == ARRAY_TYPE)
10131 /* Transfer const-ness of array into that of type
10133 type = build_pointer_type
10134 (cp_build_type_variant (TREE_TYPE (type), constp, volatilep));
10135 volatilep = constp = 0;
10137 else if (TREE_CODE (type) == FUNCTION_TYPE)
10138 type = build_pointer_type (type);
10139 else if (TREE_CODE (type) == OFFSET_TYPE)
10140 type = build_pointer_type (type);
10143 /* An uninitialized decl with `extern' is a reference. */
10144 decl = grokvardecl (type, declarator, &specbits,
10145 initialized, constp, in_namespace);
10146 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
10147 inlinep, friendp, raises != NULL_TREE);
10151 DECL_CONTEXT (decl) = ctype;
10154 cp_pedwarn ("static member `%D' re-declared as static", decl);
10156 RIDBIT_RESET (RID_STATIC, specbits);
10158 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
10160 cp_error ("static member `%D' declared `register'", decl);
10161 RIDBIT_RESET (RID_REGISTER, specbits);
10163 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
10165 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10167 RIDBIT_RESET (RID_EXTERN, specbits);
10172 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10174 error ("`%s' cannot be declared mutable", name);
10177 /* Record `register' declaration for warnings on &
10178 and in case doing stupid register allocation. */
10180 if (RIDBIT_SETP (RID_REGISTER, specbits))
10181 DECL_REGISTER (decl) = 1;
10183 if (RIDBIT_SETP (RID_EXTERN, specbits))
10184 DECL_THIS_EXTERN (decl) = 1;
10186 if (RIDBIT_SETP (RID_STATIC, specbits))
10187 DECL_THIS_STATIC (decl) = 1;
10189 /* Record constancy and volatility. */
10192 TREE_READONLY (decl) = TREE_CODE (type) != REFERENCE_TYPE;
10195 TREE_SIDE_EFFECTS (decl) = 1;
10196 TREE_THIS_VOLATILE (decl) = 1;
10203 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10204 An empty exprlist is a parmlist. An exprlist which
10205 contains only identifiers at the global level
10206 is a parmlist. Otherwise, it is an exprlist. */
10209 parmlist_is_exprlist (exprs)
10212 if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
10215 if (toplevel_bindings_p ())
10217 /* At the global level, if these are all identifiers,
10218 then it is a parmlist. */
10221 if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
10223 exprs = TREE_CHAIN (exprs);
10230 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10233 C++: also subroutine of `start_function'. */
10236 require_complete_types_for_parms (parms)
10239 if (processing_template_decl)
10244 tree type = TREE_TYPE (parms);
10245 if (TYPE_SIZE (complete_type (type)) == NULL_TREE)
10247 if (DECL_NAME (parms))
10248 error ("parameter `%s' has incomplete type",
10249 IDENTIFIER_POINTER (DECL_NAME (parms)));
10251 error ("parameter has incomplete type");
10252 TREE_TYPE (parms) = error_mark_node;
10255 /* If the arg types are incomplete in a declaration,
10256 they must include undefined tags.
10257 These tags can never be defined in the scope of the declaration,
10258 so the types can never be completed,
10259 and no call can be compiled successfully. */
10260 /* This is not the right behavior for C++, but not having
10261 it is also probably wrong. */
10264 /* Now warn if is a pointer to an incomplete type. */
10265 while (TREE_CODE (type) == POINTER_TYPE
10266 || TREE_CODE (type) == REFERENCE_TYPE)
10267 type = TREE_TYPE (type);
10268 type = TYPE_MAIN_VARIANT (type);
10269 if (TYPE_SIZE (type) == NULL_TREE)
10271 if (DECL_NAME (parm) != NULL_TREE)
10272 warning ("parameter `%s' points to incomplete type",
10273 IDENTIFIER_POINTER (DECL_NAME (parm)));
10275 warning ("parameter points to incomplete type");
10279 parms = TREE_CHAIN (parms);
10283 /* Decode the list of parameter types for a function type.
10284 Given the list of things declared inside the parens,
10285 return a list of types.
10287 The list we receive can have three kinds of elements:
10288 an IDENTIFIER_NODE for names given without types,
10289 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10290 or void_type_node, to mark the end of an argument list
10291 when additional arguments are not permitted (... was not used).
10293 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10294 a mere declaration. A nonempty identifier-list gets an error message
10295 when FUNCDEF_FLAG is zero.
10296 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10297 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10299 If all elements of the input list contain types,
10300 we return a list of the types.
10301 If all elements contain no type (except perhaps a void_type_node
10302 at the end), we return a null list.
10303 If some have types and some do not, it is an error, and we
10304 return a null list.
10306 Also set last_function_parms to either
10307 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10308 A list of names is converted to a chain of PARM_DECLs
10309 by store_parm_decls so that ultimately it is always a chain of decls.
10311 Note that in C++, parameters can take default values. These default
10312 values are in the TREE_PURPOSE field of the TREE_LIST. It is
10313 an error to specify default values which are followed by parameters
10314 that have no default values, or an ELLIPSES. For simplicities sake,
10315 only parameters which are specified with their types can take on
10319 grokparms (first_parm, funcdef_flag)
10323 tree result = NULL_TREE;
10324 tree decls = NULL_TREE;
10326 if (first_parm != NULL_TREE
10327 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
10329 if (! funcdef_flag)
10330 pedwarn ("parameter names (without types) in function declaration");
10331 last_function_parms = first_parm;
10334 else if (first_parm != NULL_TREE
10335 && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
10336 && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
10337 my_friendly_abort (145);
10340 /* Types were specified. This is a list of declarators
10341 each represented as a TREE_LIST node. */
10342 register tree parm, chain;
10343 int any_init = 0, any_error = 0;
10345 if (first_parm != NULL_TREE)
10347 tree last_result = NULL_TREE;
10348 tree last_decl = NULL_TREE;
10350 for (parm = first_parm; parm != NULL_TREE; parm = chain)
10352 tree type = NULL_TREE, list_node = parm;
10353 register tree decl = TREE_VALUE (parm);
10354 tree init = TREE_PURPOSE (parm);
10356 chain = TREE_CHAIN (parm);
10357 /* @@ weak defense against parse errors. */
10358 if (TREE_CODE (decl) != VOID_TYPE
10359 && TREE_CODE (decl) != TREE_LIST)
10361 /* Give various messages as the need arises. */
10362 if (TREE_CODE (decl) == STRING_CST)
10363 cp_error ("invalid string constant `%E'", decl);
10364 else if (TREE_CODE (decl) == INTEGER_CST)
10365 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
10369 if (TREE_CODE (decl) != VOID_TYPE)
10371 decl = grokdeclarator (TREE_VALUE (decl),
10372 TREE_PURPOSE (decl),
10373 PARM, init != NULL_TREE,
10377 type = TREE_TYPE (decl);
10378 if (TREE_CODE (type) == VOID_TYPE)
10379 decl = void_type_node;
10380 else if (TREE_CODE (type) == METHOD_TYPE)
10382 if (DECL_NAME (decl))
10383 /* Cannot use the decl here because
10384 we don't have DECL_CONTEXT set up yet. */
10385 cp_error ("parameter `%D' invalidly declared method type",
10388 error ("parameter invalidly declared method type");
10389 type = build_pointer_type (type);
10390 TREE_TYPE (decl) = type;
10392 else if (TREE_CODE (type) == OFFSET_TYPE)
10394 if (DECL_NAME (decl))
10395 cp_error ("parameter `%D' invalidly declared offset type",
10398 error ("parameter invalidly declared offset type");
10399 type = build_pointer_type (type);
10400 TREE_TYPE (decl) = type;
10402 else if (TREE_CODE (type) == RECORD_TYPE
10403 && TYPE_LANG_SPECIFIC (type)
10404 && CLASSTYPE_ABSTRACT_VIRTUALS (type))
10406 abstract_virtuals_error (decl, type);
10407 any_error = 1; /* Seems like a good idea. */
10409 else if (TREE_CODE (type) == RECORD_TYPE
10410 && TYPE_LANG_SPECIFIC (type)
10411 && IS_SIGNATURE (type))
10413 signature_error (decl, type);
10414 any_error = 1; /* Seems like a good idea. */
10418 if (TREE_CODE (decl) == VOID_TYPE)
10420 if (result == NULL_TREE)
10422 result = void_list_node;
10423 last_result = result;
10427 TREE_CHAIN (last_result) = void_list_node;
10428 last_result = void_list_node;
10431 && (chain != void_list_node || TREE_CHAIN (chain)))
10432 error ("`void' in parameter list must be entire list");
10436 /* Since there is a prototype, args are passed in their own types. */
10437 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
10438 #ifdef PROMOTE_PROTOTYPES
10439 if ((TREE_CODE (type) == INTEGER_TYPE
10440 || TREE_CODE (type) == ENUMERAL_TYPE)
10441 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
10442 DECL_ARG_TYPE (decl) = integer_type_node;
10449 if (TREE_CODE (init) == SAVE_EXPR)
10450 PARM_DECL_EXPR (init) = 1;
10451 else if (processing_template_decl)
10453 /* Unparsed default arg from in-class decl. */
10454 else if (TREE_CODE (init) == DEFAULT_ARG)
10456 else if (TREE_CODE (init) == VAR_DECL
10457 || TREE_CODE (init) == PARM_DECL)
10459 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init)))
10461 /* ``Local variables may not be used in default
10462 argument expressions.'' dpANSI C++ 8.2.6 */
10463 /* If extern int i; within a function is not
10464 considered a local variable, then this code is
10466 cp_error ("local variable `%D' may not be used as a default argument", init);
10469 else if (TREE_READONLY_DECL_P (init))
10470 init = decl_constant_value (init);
10473 init = require_instantiated_type (type, init, integer_zero_node);
10474 if (! processing_template_decl
10475 && TREE_CODE (init) != DEFAULT_ARG
10476 && ! can_convert_arg (type, TREE_TYPE (init), init))
10477 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
10478 TREE_TYPE (init), decl);
10484 if (decls == NULL_TREE)
10491 TREE_CHAIN (last_decl) = decl;
10494 if (! current_function_decl && TREE_PERMANENT (list_node))
10496 TREE_PURPOSE (list_node) = init;
10497 TREE_VALUE (list_node) = type;
10498 TREE_CHAIN (list_node) = NULL_TREE;
10501 list_node = saveable_tree_cons (init, type, NULL_TREE);
10502 if (result == NULL_TREE)
10504 result = list_node;
10505 last_result = result;
10509 TREE_CHAIN (last_result) = list_node;
10510 last_result = list_node;
10514 TREE_CHAIN (last_result) = NULL_TREE;
10515 /* If there are no parameters, and the function does not end
10516 with `...', then last_decl will be NULL_TREE. */
10517 if (last_decl != NULL_TREE)
10518 TREE_CHAIN (last_decl) = NULL_TREE;
10522 last_function_parms = decls;
10524 /* In a fcn definition, arg types must be complete. */
10525 if (funcdef_flag > 0)
10526 require_complete_types_for_parms (last_function_parms);
10531 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
10532 FUNCTION_TYPE with the newly parsed version of its default argument, which
10533 was previously digested as text. See snarf_defarg et al in lex.c. */
10536 replace_defarg (arg, init)
10539 if (! processing_template_decl
10540 && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
10541 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
10542 TREE_TYPE (init), TREE_VALUE (arg));
10543 TREE_PURPOSE (arg) = init;
10550 tree t = FUNCTION_ARG_CHAIN (d);
10551 if (DECL_CONSTRUCTOR_P (d)
10552 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
10553 t = TREE_CHAIN (t);
10554 if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
10555 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
10556 == DECL_CLASS_CONTEXT (d))
10557 && (TREE_CHAIN (t) == NULL_TREE
10558 || TREE_CHAIN (t) == void_list_node
10559 || TREE_PURPOSE (TREE_CHAIN (t))))
10564 /* These memoizing functions keep track of special properties which
10565 a class may have. `grok_ctor_properties' notices whether a class
10566 has a constructor of the form X(X&), and also complains
10567 if the class has a constructor of the form X(X).
10568 `grok_op_properties' takes notice of the various forms of
10569 operator= which are defined, as well as what sorts of type conversion
10570 may apply. Both functions take a FUNCTION_DECL as an argument. */
10573 grok_ctor_properties (ctype, decl)
10576 tree parmtypes = FUNCTION_ARG_CHAIN (decl);
10577 tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
10579 /* When a type has virtual baseclasses, a magical first int argument is
10580 added to any ctor so we can tell if the class has been initialized
10581 yet. This could screw things up in this function, so we deliberately
10582 ignore the leading int if we're in that situation. */
10584 && TREE_VALUE (parmtypes) == integer_type_node
10585 && TYPE_USES_VIRTUAL_BASECLASSES (ctype))
10587 parmtypes = TREE_CHAIN (parmtypes);
10588 parmtype = TREE_VALUE (parmtypes);
10591 if (TREE_CODE (parmtype) == REFERENCE_TYPE
10592 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
10593 && (TREE_CHAIN (parmtypes) == NULL_TREE
10594 || TREE_CHAIN (parmtypes) == void_list_node
10595 || TREE_PURPOSE (TREE_CHAIN (parmtypes))))
10597 TYPE_HAS_INIT_REF (ctype) = 1;
10598 if (TYPE_READONLY (TREE_TYPE (parmtype)))
10599 TYPE_HAS_CONST_INIT_REF (ctype) = 1;
10601 else if (TYPE_MAIN_VARIANT (parmtype) == ctype
10602 && TREE_CHAIN (parmtypes) != NULL_TREE
10603 && TREE_CHAIN (parmtypes) == void_list_node)
10605 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
10607 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
10610 else if (TREE_CODE (parmtype) == VOID_TYPE
10611 || TREE_PURPOSE (parmtypes) != NULL_TREE)
10612 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
10617 /* An operator with this name can be either unary or binary. */
10623 return (name == ansi_opname [(int) INDIRECT_REF]
10624 || name == ansi_opname [(int) ADDR_EXPR]
10625 || name == ansi_opname [(int) NEGATE_EXPR]
10626 || name == ansi_opname[(int) POSTINCREMENT_EXPR]
10627 || name == ansi_opname[(int) POSTDECREMENT_EXPR]
10628 || name == ansi_opname [(int) CONVERT_EXPR]);
10631 /* An operator with this name can only be unary. */
10637 return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
10638 || name == ansi_opname [(int) BIT_NOT_EXPR]
10639 || name == ansi_opname [(int) COMPONENT_REF]
10640 || OPERATOR_TYPENAME_P (name));
10643 /* Do a little sanity-checking on how they declared their operator. */
10646 grok_op_properties (decl, virtualp, friendp)
10648 int virtualp, friendp;
10650 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10651 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10652 tree name = DECL_NAME (decl);
10654 if (current_class_type == NULL_TREE)
10659 if (name == ansi_opname[(int) MODIFY_EXPR])
10660 TYPE_HAS_ASSIGNMENT (current_class_type) = 1;
10661 else if (name == ansi_opname[(int) CALL_EXPR])
10662 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
10663 else if (name == ansi_opname[(int) ARRAY_REF])
10664 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
10665 else if (name == ansi_opname[(int) COMPONENT_REF]
10666 || name == ansi_opname[(int) MEMBER_REF])
10667 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
10668 else if (name == ansi_opname[(int) NEW_EXPR])
10669 TYPE_GETS_NEW (current_class_type) |= 1;
10670 else if (name == ansi_opname[(int) DELETE_EXPR])
10671 TYPE_GETS_DELETE (current_class_type) |= 1;
10672 else if (name == ansi_opname[(int) VEC_NEW_EXPR])
10673 TYPE_GETS_NEW (current_class_type) |= 2;
10674 else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
10675 TYPE_GETS_DELETE (current_class_type) |= 2;
10678 if (name == ansi_opname[(int) NEW_EXPR]
10679 || name == ansi_opname[(int) VEC_NEW_EXPR])
10681 /* When the compiler encounters the definition of A::operator new, it
10682 doesn't look at the class declaration to find out if it's static. */
10684 revert_static_member_fn (&decl, NULL, NULL);
10686 /* Take care of function decl if we had syntax errors. */
10687 if (argtypes == NULL_TREE)
10689 = build_function_type (ptr_type_node,
10690 hash_tree_chain (integer_type_node,
10693 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10695 else if (name == ansi_opname[(int) DELETE_EXPR]
10696 || name == ansi_opname[(int) VEC_DELETE_EXPR])
10699 revert_static_member_fn (&decl, NULL, NULL);
10701 if (argtypes == NULL_TREE)
10703 = build_function_type (void_type_node,
10704 hash_tree_chain (ptr_type_node,
10708 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10710 if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
10711 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
10712 != void_list_node))
10713 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
10718 /* An operator function must either be a non-static member function
10719 or have at least one parameter of a class, a reference to a class,
10720 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10721 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10723 if (OPERATOR_TYPENAME_P (name)
10724 || name == ansi_opname[(int) CALL_EXPR]
10725 || name == ansi_opname[(int) MODIFY_EXPR]
10726 || name == ansi_opname[(int) COMPONENT_REF]
10727 || name == ansi_opname[(int) ARRAY_REF])
10728 cp_error ("`%D' must be a nonstatic member function", decl);
10733 if (DECL_STATIC_FUNCTION_P (decl))
10734 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
10737 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
10739 tree arg = TREE_VALUE (p);
10740 if (TREE_CODE (arg) == REFERENCE_TYPE)
10741 arg = TREE_TYPE (arg);
10743 /* This lets bad template code slip through. */
10744 if (IS_AGGR_TYPE (arg)
10745 || TREE_CODE (arg) == ENUMERAL_TYPE
10746 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
10747 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
10751 ("`%D' must have an argument of class or enumerated type",
10758 if (name == ansi_opname[(int) CALL_EXPR])
10759 return; /* No restrictions on args. */
10761 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
10763 tree t = TREE_TYPE (name);
10764 if (TREE_CODE (t) == VOID_TYPE)
10765 pedwarn ("void is not a valid type conversion operator");
10766 else if (! friendp)
10768 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10771 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10773 if (t == current_class_type)
10774 what = "the same type";
10775 /* Don't force t to be complete here. */
10776 else if (IS_AGGR_TYPE (t)
10778 && DERIVED_FROM_P (t, current_class_type))
10779 what = "a base class";
10782 warning ("conversion to %s%s will never use a type conversion operator",
10783 ref ? "a reference to " : "", what);
10787 if (name == ansi_opname[(int) MODIFY_EXPR])
10791 if (list_length (argtypes) != 3 && methodp)
10793 cp_error ("`%D' must take exactly one argument", decl);
10796 parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
10798 if (copy_assignment_arg_p (parmtype, virtualp)
10801 TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
10802 if (TREE_CODE (parmtype) != REFERENCE_TYPE
10803 || TYPE_READONLY (TREE_TYPE (parmtype)))
10804 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
10807 else if (name == ansi_opname[(int) COND_EXPR])
10810 pedwarn ("ANSI C++ prohibits overloading operator ?:");
10811 if (list_length (argtypes) != 4)
10812 cp_error ("`%D' must take exactly three arguments", decl);
10814 else if (ambi_op_p (name))
10816 if (list_length (argtypes) == 2)
10818 else if (list_length (argtypes) == 3)
10820 if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
10821 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
10822 && ! processing_template_decl
10823 && TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
10826 cp_error ("postfix `%D' must take `int' as its argument",
10830 ("postfix `%D' must take `int' as its second argument",
10837 cp_error ("`%D' must take either zero or one argument", decl);
10839 cp_error ("`%D' must take either one or two arguments", decl);
10842 /* More Effective C++ rule 6. */
10844 && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
10845 || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
10847 tree arg = TREE_VALUE (argtypes);
10848 tree ret = TREE_TYPE (TREE_TYPE (decl));
10849 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10850 arg = TREE_TYPE (arg);
10851 arg = TYPE_MAIN_VARIANT (arg);
10852 if (list_length (argtypes) == 2)
10854 if (TREE_CODE (ret) != REFERENCE_TYPE
10855 || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10857 cp_warning ("prefix `%D' should return `%T'", decl,
10858 build_reference_type (arg));
10862 if (!comptypes (TYPE_MAIN_VARIANT (ret), arg, 1))
10863 cp_warning ("postfix `%D' should return `%T'", decl, arg);
10867 else if (unary_op_p (name))
10869 if (list_length (argtypes) != 2)
10872 cp_error ("`%D' must take `void'", decl);
10874 cp_error ("`%D' must take exactly one argument", decl);
10877 else /* if (binary_op_p (name)) */
10879 if (list_length (argtypes) != 3)
10882 cp_error ("`%D' must take exactly one argument", decl);
10884 cp_error ("`%D' must take exactly two arguments", decl);
10887 /* More Effective C++ rule 7. */
10889 && (name == ansi_opname [TRUTH_ANDIF_EXPR]
10890 || name == ansi_opname [TRUTH_ORIF_EXPR]
10891 || name == ansi_opname [COMPOUND_EXPR]))
10892 cp_warning ("user-defined `%D' always evaluates both arguments",
10896 /* Effective C++ rule 23. */
10898 && list_length (argtypes) == 3
10899 && (name == ansi_opname [PLUS_EXPR]
10900 || name == ansi_opname [MINUS_EXPR]
10901 || name == ansi_opname [TRUNC_DIV_EXPR]
10902 || name == ansi_opname [MULT_EXPR])
10903 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10904 cp_warning ("`%D' should return by value", decl);
10908 for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
10909 if (TREE_PURPOSE (argtypes))
10911 TREE_PURPOSE (argtypes) = NULL_TREE;
10912 if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
10913 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
10916 cp_pedwarn ("`%D' cannot have default arguments", decl);
10919 cp_error ("`%D' cannot have default arguments", decl);
10924 /* Get the struct, enum or union (CODE says which) with tag NAME.
10925 Define the tag as a forward-reference if it is not defined.
10927 C++: If a class derivation is given, process it here, and report
10928 an error if multiple derivation declarations are not identical.
10930 If this is a definition, come in through xref_tag and only look in
10931 the current frame for the name (since C++ allows new names in any
10935 xref_tag (code_type_node, name, binfo, globalize)
10936 tree code_type_node;
10940 enum tag_types tag_code;
10941 enum tree_code code;
10943 register tree ref, t;
10944 struct binding_level *b = inner_binding_level;
10947 tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
10952 case signature_type:
10953 code = RECORD_TYPE;
10959 code = ENUMERAL_TYPE;
10962 my_friendly_abort (18);
10965 /* If a cross reference is requested, look up the type
10966 already defined for this tag and return it. */
10967 if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
10970 name = TYPE_IDENTIFIER (t);
10974 t = IDENTIFIER_TYPE_VALUE (name);
10975 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
10976 && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
10981 if (pedantic && t && (TREE_CODE (t) == TEMPLATE_TYPE_PARM
10982 || TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM))
10984 cp_pedwarn ("redeclaration of template type-parameter `%T'", name);
10985 cp_pedwarn_at (" previously declared here", t);
10987 if (t && TYPE_CONTEXT (t) && got_type)
10991 /* If we know we are defining this tag, only look it up in
10992 this scope and don't try to find it as a type. */
10993 ref = lookup_tag (code, name, b, 1);
11001 ref = lookup_tag (code, name, b, 0);
11005 /* Try finding it as a type declaration. If that wins, use it. */
11006 ref = lookup_name (name, 1);
11008 if (ref != NULL_TREE
11009 && processing_template_decl
11010 && DECL_CLASS_TEMPLATE_P (ref)
11011 && template_class_depth (current_class_type) == 0)
11012 /* Since GLOBALIZE is true, we're declaring a global
11013 template, so we want this type. */
11014 ref = DECL_RESULT (ref);
11016 if (ref && TREE_CODE (ref) == TYPE_DECL
11017 && TREE_CODE (TREE_TYPE (ref)) == code)
11018 ref = TREE_TYPE (ref);
11024 push_obstacks_nochange ();
11028 /* If no such tag is yet defined, create a forward-reference node
11029 and record it as the "definition".
11030 When a real declaration of this type is found,
11031 the forward-reference will be altered into a real type. */
11033 /* In C++, since these migrate into the global scope, we must
11034 build them on the permanent obstack. */
11036 temp = allocation_temporary_p ();
11038 end_temporary_allocation ();
11040 if (code == ENUMERAL_TYPE)
11042 cp_error ("use of enum `%#D' without previous declaration", name);
11044 ref = make_node (ENUMERAL_TYPE);
11046 /* Give the type a default layout like unsigned int
11047 to avoid crashing if it does not get defined. */
11048 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
11049 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
11050 TREE_UNSIGNED (ref) = 1;
11051 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
11052 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
11053 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
11055 /* Enable us to recognize when a type is created in class context.
11056 To do nested classes correctly, this should probably be cleared
11057 out when we leave this classes scope. Currently this in only
11058 done in `start_enum'. */
11060 pushtag (name, ref, globalize);
11064 struct binding_level *old_b = class_binding_level;
11066 ref = make_lang_type (code);
11068 if (tag_code == signature_type)
11070 SET_SIGNATURE (ref);
11071 /* Since a signature type will be turned into the type
11072 of signature tables, it's not only an interface. */
11073 CLASSTYPE_INTERFACE_ONLY (ref) = 0;
11074 SET_CLASSTYPE_INTERFACE_KNOWN (ref);
11075 /* A signature doesn't have a vtable. */
11076 CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0;
11079 #ifdef NONNESTED_CLASSES
11080 /* Class types don't nest the way enums do. */
11081 class_binding_level = (struct binding_level *)0;
11083 pushtag (name, ref, globalize);
11084 class_binding_level = old_b;
11089 /* If it no longer looks like a nested type, make sure it's
11091 If it is not an IDENTIFIER, this is not a declaration */
11092 if (b->namespace_p && !class_binding_level
11093 && TREE_CODE (name) == IDENTIFIER_NODE)
11095 if (IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
11096 SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
11099 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
11100 redeclare_class_template (ref, current_template_parms);
11104 xref_basetypes (code_type_node, name, ref, binfo);
11106 /* Until the type is defined, tentatively accept whatever
11107 structure tag the user hands us. */
11108 if (TYPE_SIZE (ref) == NULL_TREE
11109 && ref != current_class_type
11110 /* Have to check this, in case we have contradictory tag info. */
11111 && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
11113 if (tag_code == class_type)
11114 CLASSTYPE_DECLARED_CLASS (ref) = 1;
11115 else if (tag_code == record_type || tag_code == signature_type)
11116 CLASSTYPE_DECLARED_CLASS (ref) = 0;
11125 xref_tag_from_type (old, id, globalize)
11129 tree code_type_node;
11131 if (TREE_CODE (old) == RECORD_TYPE)
11132 code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
11133 ? class_type_node : record_type_node);
11135 code_type_node = union_type_node;
11137 if (id == NULL_TREE)
11138 id = TYPE_IDENTIFIER (old);
11140 return xref_tag (code_type_node, id, NULL_TREE, globalize);
11144 xref_basetypes (code_type_node, name, ref, binfo)
11145 tree code_type_node;
11149 /* In the declaration `A : X, Y, ... Z' we mark all the types
11150 (A, X, Y, ..., Z) so we can check for duplicates. */
11153 enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
11155 if (tag_code == union_type)
11157 cp_error ("derived union `%T' invalid", ref);
11161 len = list_length (binfo);
11162 push_obstacks (TYPE_OBSTACK (ref), TYPE_OBSTACK (ref));
11164 SET_CLASSTYPE_MARKED (ref);
11165 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
11167 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
11169 /* The base of a derived struct is public by default. */
11171 = (TREE_PURPOSE (binfo) == access_public_node
11172 || TREE_PURPOSE (binfo) == access_public_virtual_node
11173 || (tag_code != class_type
11174 && (TREE_PURPOSE (binfo) == access_default_node
11175 || TREE_PURPOSE (binfo) == access_default_virtual_node)));
11177 = (TREE_PURPOSE (binfo) == access_protected_node
11178 || TREE_PURPOSE (binfo) == access_protected_virtual_node);
11180 = (TREE_PURPOSE (binfo) == access_private_virtual_node
11181 || TREE_PURPOSE (binfo) == access_protected_virtual_node
11182 || TREE_PURPOSE (binfo) == access_public_virtual_node
11183 || TREE_PURPOSE (binfo) == access_default_virtual_node);
11184 tree basetype = TREE_VALUE (binfo);
11187 GNU_xref_hier (IDENTIFIER_POINTER (name),
11188 IDENTIFIER_POINTER (TREE_VALUE (binfo)),
11189 via_public, via_virtual, 0);
11191 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
11192 basetype = TREE_TYPE (basetype);
11194 || (TREE_CODE (basetype) != RECORD_TYPE
11195 && TREE_CODE (basetype) != TYPENAME_TYPE
11196 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
11197 && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
11199 cp_error ("base type `%T' fails to be a struct or class type",
11200 TREE_VALUE (binfo));
11204 /* This code replaces similar code in layout_basetypes.
11205 We put the complete_type first for implicit `typename'. */
11206 else if (TYPE_SIZE (complete_type (basetype)) == NULL_TREE
11207 && ! (current_template_parms && uses_template_parms (basetype)))
11209 cp_error ("base class `%T' has incomplete type", basetype);
11215 if (CLASSTYPE_MARKED (basetype))
11217 if (basetype == ref)
11218 cp_error ("recursive type `%T' undefined", basetype);
11220 cp_error ("duplicate base type `%T' invalid", basetype);
11224 /* Note that the BINFO records which describe individual
11225 inheritances are *not* shared in the lattice! They
11226 cannot be shared because a given baseclass may be
11227 inherited with different `accessibility' by different
11228 derived classes. (Each BINFO record describing an
11229 individual inheritance contains flags which say what
11230 the `accessibility' of that particular inheritance is.) */
11232 base_binfo = make_binfo (integer_zero_node, basetype,
11233 TYPE_BINFO_VTABLE (basetype),
11234 TYPE_BINFO_VIRTUALS (basetype), NULL_TREE);
11236 TREE_VEC_ELT (binfos, i) = base_binfo;
11237 TREE_VIA_PUBLIC (base_binfo) = via_public;
11238 TREE_VIA_PROTECTED (base_binfo) = via_protected;
11239 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
11240 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
11242 SET_CLASSTYPE_MARKED (basetype);
11244 /* We are free to modify these bits because they are meaningless
11245 at top level, and BASETYPE is a top-level type. */
11246 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
11248 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
11249 TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
11252 TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
11253 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
11254 CLASSTYPE_LOCAL_TYPEDECLS (ref) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype);
11259 TREE_VEC_LENGTH (binfos) = i;
11261 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
11264 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
11266 TYPE_USES_MULTIPLE_INHERITANCE (ref)
11267 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos, 0)));
11268 if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
11269 TYPE_USES_COMPLEX_INHERITANCE (ref) = 1;
11271 /* Unmark all the types. */
11273 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
11274 CLEAR_CLASSTYPE_MARKED (ref);
11280 tree current_local_enum = NULL_TREE;
11282 /* Begin compiling the definition of an enumeration type.
11283 NAME is its name (or null if anonymous).
11284 Returns the type object, as yet incomplete.
11285 Also records info about it so that build_enumerator
11286 may be used to declare the individual values as they are read. */
11292 register tree enumtype = NULL_TREE;
11293 struct binding_level *b = inner_binding_level;
11295 if (processing_template_decl && current_function_decl)
11296 end_temporary_allocation ();
11298 /* If this is the real definition for a previous forward reference,
11299 fill in the contents in the same object that used to be the
11300 forward reference. */
11302 if (name != NULL_TREE)
11303 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
11305 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
11306 cp_error ("multiple definition of `%#T'", enumtype);
11309 enumtype = make_node (ENUMERAL_TYPE);
11310 pushtag (name, enumtype, 0);
11313 if (b->pseudo_global)
11314 cp_error ("template declaration of `%#T'", enumtype);
11316 if (current_class_type)
11317 TREE_ADDRESSABLE (b->tags) = 1;
11319 current_local_enum = NULL_TREE;
11321 /* We don't copy this value because build_enumerator needs to do it. */
11322 enum_next_value = integer_zero_node;
11325 GNU_xref_decl (current_function_decl, enumtype);
11329 /* After processing and defining all the values of an enumeration type,
11330 install their decls in the enumeration type and finish it off.
11331 ENUMTYPE is the type object and VALUES a list of name-value pairs.
11332 Returns ENUMTYPE. */
11335 finish_enum (enumtype, values)
11336 register tree enumtype, values;
11338 register tree minnode = NULL_TREE, maxnode = NULL_TREE;
11339 /* Calculate the maximum value of any enumerator in this type. */
11343 register tree pair;
11344 register tree value = DECL_INITIAL (TREE_VALUE (values));
11346 if (! processing_template_decl)
11348 /* Speed up the main loop by performing some precalculations */
11349 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11350 TREE_TYPE (value) = enumtype;
11351 minnode = maxnode = value;
11353 TREE_VALUE (values) = value;
11355 for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
11357 value = DECL_INITIAL (TREE_VALUE (pair));
11358 if (! processing_template_decl)
11360 TREE_TYPE (TREE_VALUE (pair)) = enumtype;
11361 TREE_TYPE (value) = enumtype;
11362 if (tree_int_cst_lt (maxnode, value))
11364 else if (tree_int_cst_lt (value, minnode))
11367 TREE_VALUE (pair) = value;
11371 maxnode = minnode = integer_zero_node;
11373 TYPE_VALUES (enumtype) = nreverse (values);
11375 if (processing_template_decl)
11377 if (current_function_decl)
11379 add_tree (build_min (TAG_DEFN, enumtype));
11380 resume_temporary_allocation ();
11386 int unsignedp = tree_int_cst_sgn (minnode) >= 0;
11387 int lowprec = min_precision (minnode, unsignedp);
11388 int highprec = min_precision (maxnode, unsignedp);
11389 int precision = MAX (lowprec, highprec);
11391 TYPE_SIZE (enumtype) = NULL_TREE;
11393 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
11395 TYPE_PRECISION (enumtype) = precision;
11397 fixup_unsigned_type (enumtype);
11399 fixup_signed_type (enumtype);
11401 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
11402 /* Use the width of the narrowest normal C type which is wide enough. */
11403 TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
11406 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
11408 TYPE_SIZE (enumtype) = 0;
11409 layout_type (enumtype);
11415 /* Fix up all variant types of this enum type. */
11416 for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
11417 tem = TYPE_NEXT_VARIANT (tem))
11419 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
11420 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
11421 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
11422 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
11423 TYPE_MODE (tem) = TYPE_MODE (enumtype);
11424 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
11425 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
11426 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
11430 /* Finish debugging output for this type. */
11431 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11436 /* Build and install a CONST_DECL for one value of the
11437 current enumeration type (one that was begun with start_enum).
11438 Return a tree-list containing the name and its value.
11439 Assignment of sequential values by default is handled here. */
11442 build_enumerator (name, value)
11447 /* Remove no-op casts from the value. */
11449 STRIP_TYPE_NOPS (value);
11451 if (! processing_template_decl)
11453 /* Validate and default VALUE. */
11454 if (value != NULL_TREE)
11456 if (TREE_READONLY_DECL_P (value))
11457 value = decl_constant_value (value);
11459 if (TREE_CODE (value) == INTEGER_CST)
11461 value = default_conversion (value);
11462 constant_expression_warning (value);
11466 cp_error ("enumerator value for `%D' not integer constant", name);
11471 /* Default based on previous value. */
11472 if (value == NULL_TREE && ! processing_template_decl)
11474 value = enum_next_value;
11476 cp_error ("overflow in enumeration values at `%D'", name);
11479 /* Remove no-op casts from the value. */
11481 STRIP_TYPE_NOPS (value);
11483 /* We have to always copy here; not all INTEGER_CSTs are unshared,
11484 and there's no wedding ring. Look at size_int()...*/
11485 value = copy_node (value);
11487 /* To fix MAX_VAL enum consts. (bkoz) */
11488 TREE_TYPE (value) = integer_type_node;
11492 /* C++ associates enums with global, function, or class declarations. */
11494 decl = current_scope ();
11495 if (decl && decl == current_class_type)
11497 /* This enum declaration is local to the class, so we must put
11498 it in that class's list of decls. */
11499 decl = build_lang_field_decl (CONST_DECL, name, integer_type_node);
11500 DECL_INITIAL (decl) = value;
11501 TREE_READONLY (decl) = 1;
11502 pushdecl_class_level (decl);
11503 TREE_CHAIN (decl) = current_local_enum;
11504 current_local_enum = decl;
11508 /* It's a global enum, or it's local to a function. (Note local to
11509 a function could mean local to a class method. */
11510 decl = build_decl (CONST_DECL, name, integer_type_node);
11511 DECL_INITIAL (decl) = value;
11512 TREE_READONLY (decl) = 1;
11515 GNU_xref_decl (current_function_decl, decl);
11518 if (! processing_template_decl)
11520 /* Set basis for default for next value. */
11521 enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
11522 integer_one_node, PLUS_EXPR);
11523 enum_overflow = tree_int_cst_lt (enum_next_value, value);
11526 result = saveable_tree_cons (name, decl, NULL_TREE);
11531 grok_enum_decls (decl)
11534 tree d = current_local_enum;
11536 if (d == NULL_TREE)
11541 if (TREE_CHAIN (d) == NULL_TREE)
11543 TREE_CHAIN (d) = decl;
11546 d = TREE_CHAIN (d);
11549 decl = current_local_enum;
11550 current_local_enum = NULL_TREE;
11555 static int function_depth;
11557 /* Create the FUNCTION_DECL for a function definition.
11558 DECLSPECS and DECLARATOR are the parts of the declaration;
11559 they describe the function's name and the type it returns,
11560 but twisted together in a fashion that parallels the syntax of C.
11562 This function creates a binding context for the function body
11563 as well as setting up the FUNCTION_DECL in current_function_decl.
11565 Returns 1 on success. If the DECLARATOR is not suitable for a function
11566 (it defines a datum instead), we return 0, which tells
11567 yyparse to report a parse error.
11569 For C++, we must first check whether that datum makes any sense.
11570 For example, "class A local_a(1,2);" means that variable local_a
11571 is an aggregate of type A, which should have a constructor
11572 applied to it with the argument list [1, 2].
11574 @@ There is currently no way to retrieve the storage
11575 @@ allocated to FUNCTION (or all of its parms) if we return
11576 @@ something we had previously. */
11579 start_function (declspecs, declarator, attrs, pre_parsed_p)
11580 tree declspecs, declarator, attrs;
11584 tree ctype = NULL_TREE;
11587 extern int have_extern_spec;
11588 extern int used_extern_spec;
11589 int doing_friend = 0;
11591 /* Sanity check. */
11592 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
11593 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
11595 /* Assume, until we see it does. */
11596 current_function_returns_value = 0;
11597 current_function_returns_null = 0;
11598 warn_about_return_type = 0;
11600 shadowed_labels = 0;
11601 current_function_assigns_this = 0;
11602 current_function_just_assigned_this = 0;
11603 current_function_parms_stored = 0;
11604 original_result_rtx = NULL_RTX;
11605 base_init_expr = NULL_TREE;
11606 current_base_init_list = NULL_TREE;
11607 current_member_init_list = NULL_TREE;
11608 ctor_label = dtor_label = NULL_TREE;
11609 static_labelno = 0;
11611 clear_temp_name ();
11613 /* This should only be done once on the top most decl. */
11614 if (have_extern_spec && !used_extern_spec)
11616 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
11617 used_extern_spec = 1;
11622 decl1 = declarator;
11624 if (! DECL_ARGUMENTS (decl1)
11625 && !DECL_STATIC_FUNCTION_P (decl1)
11626 && DECL_CLASS_SCOPE_P (decl1)
11627 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1))
11628 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1))))
11630 tree binding = binding_for_name (DECL_NAME (decl1),
11631 current_namespace);
11632 cp_error ("redeclaration of `%#D'", decl1);
11633 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)))
11634 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1)));
11635 else if (BINDING_VALUE (binding))
11636 cp_error_at ("previous declaration here", BINDING_VALUE (binding));
11639 fntype = TREE_TYPE (decl1);
11640 if (TREE_CODE (fntype) == METHOD_TYPE)
11641 ctype = TYPE_METHOD_BASETYPE (fntype);
11643 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
11644 class is in the (lexical) scope of the class in which it is
11646 if (!ctype && DECL_FRIEND_P (decl1))
11648 ctype = DECL_CLASS_CONTEXT (decl1);
11650 /* CTYPE could be null here if we're dealing with a template;
11651 for example, `inline friend float foo()' inside a template
11652 will have no CTYPE set. */
11653 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11659 /* In a fcn definition, arg types must be complete. */
11660 require_complete_types_for_parms (DECL_ARGUMENTS (decl1));
11662 /* In case some arg types were completed since the declaration was
11663 parsed, fix up the decls. */
11665 tree t = DECL_ARGUMENTS (decl1);
11666 for (; t; t = TREE_CHAIN (t))
11667 layout_decl (t, 0);
11670 last_function_parms = DECL_ARGUMENTS (decl1);
11671 last_function_parm_tags = NULL_TREE;
11675 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
11676 /* If the declarator is not suitable for a function definition,
11677 cause a syntax error. */
11678 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
11680 fntype = TREE_TYPE (decl1);
11682 restype = TREE_TYPE (fntype);
11683 if (IS_AGGR_TYPE (restype) && ! TYPE_PTRMEMFUNC_P (restype)
11684 && ! CLASSTYPE_GOT_SEMICOLON (restype))
11686 cp_error ("semicolon missing after declaration of `%#T'", restype);
11687 shadow_tag (build_expr_list (NULL_TREE, restype));
11688 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
11689 if (TREE_CODE (fntype) == FUNCTION_TYPE)
11690 fntype = build_function_type (integer_type_node,
11691 TYPE_ARG_TYPES (fntype));
11693 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
11695 TYPE_ARG_TYPES (fntype));
11696 TREE_TYPE (decl1) = fntype;
11699 if (TREE_CODE (fntype) == METHOD_TYPE)
11700 ctype = TYPE_METHOD_BASETYPE (fntype);
11701 else if (IDENTIFIER_LENGTH (DECL_NAME (decl1)) == 4
11702 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (decl1)), "main")
11703 && DECL_CONTEXT (decl1) == NULL_TREE)
11705 /* If this doesn't return integer_type, complain. */
11706 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
11708 if (pedantic || warn_return_type)
11709 pedwarn ("return type for `main' changed to `int'");
11710 TREE_TYPE (decl1) = fntype = default_function_type;
11712 warn_about_return_type = 0;
11716 /* Warn if function was previously implicitly declared
11717 (but not if we warned then). */
11718 if (! warn_implicit
11719 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
11720 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
11722 current_function_decl = decl1;
11723 /* Save the parm names or decls from this function's declarator
11724 where store_parm_decls will find them. */
11725 current_function_parms = last_function_parms;
11726 current_function_parm_tags = last_function_parm_tags;
11728 announce_function (decl1);
11730 if (! processing_template_decl)
11732 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
11734 cp_error ("return-type `%#T' is an incomplete type",
11735 TREE_TYPE (fntype));
11737 /* Make it return void instead, but don't change the
11738 type of the DECL_RESULT, in case we have a named return value. */
11741 = build_cplus_method_type (build_type_variant (ctype,
11742 TREE_READONLY (decl1),
11743 TREE_SIDE_EFFECTS (decl1)),
11745 FUNCTION_ARG_CHAIN (decl1));
11748 = build_function_type (void_type_node,
11749 TYPE_ARG_TYPES (TREE_TYPE (decl1)));
11750 DECL_RESULT (decl1)
11751 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype)));
11752 TREE_READONLY (DECL_RESULT (decl1)) = TYPE_READONLY (TREE_TYPE (fntype));
11753 TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = TYPE_VOLATILE (TREE_TYPE (fntype));
11756 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype))
11757 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype)))
11758 abstract_virtuals_error (decl1, TREE_TYPE (fntype));
11761 if (warn_about_return_type)
11762 pedwarn ("return-type defaults to `int'");
11764 /* Effective C++ rule 15. See also c_expand_return. */
11766 && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
11767 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11768 cp_warning ("`operator=' should return a reference to `*this'");
11770 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11771 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11772 DECL_INITIAL (decl1) = error_mark_node;
11774 /* This function exists in static storage.
11775 (This does not mean `static' in the C sense!) */
11776 TREE_STATIC (decl1) = 1;
11778 /* Record the decl so that the function name is defined.
11779 If we already have a decl for this name, and it is a FUNCTION_DECL,
11780 use the old decl. */
11782 if (processing_template_decl)
11783 decl1 = push_template_decl (decl1);
11784 else if (pre_parsed_p == 0)
11786 /* A specialization is not used to guide overload resolution. */
11787 if ((flag_guiding_decls
11788 || !DECL_TEMPLATE_SPECIALIZATION (decl1))
11789 && ! DECL_FUNCTION_MEMBER_P (decl1))
11790 decl1 = pushdecl (decl1);
11792 /* We need to set the DECL_CONTEXT. */
11793 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11794 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11795 DECL_MAIN_VARIANT (decl1) = decl1;
11796 fntype = TREE_TYPE (decl1);
11799 current_function_decl = decl1;
11801 if (DECL_INTERFACE_KNOWN (decl1))
11803 tree ctx = hack_decl_function_context (decl1);
11805 if (DECL_NOT_REALLY_EXTERN (decl1))
11806 DECL_EXTERNAL (decl1) = 0;
11808 if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
11809 && TREE_PUBLIC (ctx))
11810 /* This is a function in a local class in an extern inline
11812 comdat_linkage (decl1);
11814 /* If this function belongs to an interface, it is public.
11815 If it belongs to someone else's interface, it is also external.
11816 It doesn't matter whether it's inline or not. */
11817 else if (interface_unknown == 0
11818 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
11819 || flag_alt_external_templates))
11821 if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
11822 || processing_template_decl)
11823 DECL_EXTERNAL (decl1)
11825 || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines));
11827 DECL_EXTERNAL (decl1) = 0;
11828 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11829 DECL_INTERFACE_KNOWN (decl1) = 1;
11833 /* This is a definition, not a reference.
11834 So clear DECL_EXTERNAL. */
11835 DECL_EXTERNAL (decl1) = 0;
11837 if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
11838 && ! DECL_INTERFACE_KNOWN (decl1)
11839 /* Don't try to defer nested functions for now. */
11840 && ! hack_decl_function_context (decl1))
11841 DECL_DEFER_OUTPUT (decl1) = 1;
11843 DECL_INTERFACE_KNOWN (decl1) = 1;
11846 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1))
11848 if (TREE_CODE (fntype) == METHOD_TYPE)
11849 TREE_TYPE (decl1) = fntype
11850 = build_function_type (TREE_TYPE (fntype),
11851 TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
11852 current_function_parms = TREE_CHAIN (current_function_parms);
11853 DECL_ARGUMENTS (decl1) = current_function_parms;
11856 restype = TREE_TYPE (fntype);
11860 push_nested_class (ctype, 1);
11862 /* If we're compiling a friend function, neither of the variables
11863 current_class_ptr nor current_class_type will have values. */
11864 if (! doing_friend)
11866 /* We know that this was set up by `grokclassfn'.
11867 We do not wait until `store_parm_decls', since evil
11868 parse errors may never get us to that point. Here
11869 we keep the consistency between `current_class_type'
11870 and `current_class_ptr'. */
11871 tree t = current_function_parms;
11873 my_friendly_assert (t != NULL_TREE
11874 && TREE_CODE (t) == PARM_DECL, 162);
11876 if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
11878 int i = suspend_momentary ();
11880 /* Fool build_indirect_ref. */
11881 current_class_ptr = NULL_TREE;
11882 current_class_ref = build_indirect_ref (t, NULL_PTR);
11883 current_class_ptr = t;
11884 resume_momentary (i);
11887 /* We're having a signature pointer here. */
11888 current_class_ref = current_class_ptr = t;
11894 if (DECL_STATIC_FUNCTION_P (decl1))
11895 push_nested_class (DECL_CONTEXT (decl1), 2);
11897 push_memoized_context (0, 1);
11898 current_class_ptr = current_class_ref = NULL_TREE;
11902 current_binding_level->parm_flag = 1;
11904 GNU_xref_function (decl1, current_function_parms);
11907 cplus_decl_attributes (decl1, NULL_TREE, attrs);
11908 make_function_rtl (decl1);
11910 /* Promote the value to int before returning it. */
11911 if (C_PROMOTING_INTEGER_TYPE_P (restype))
11912 restype = type_promotes_to (restype);
11914 /* If this fcn was already referenced via a block-scope `extern' decl
11915 (or an implicit decl), propagate certain information about the usage. */
11916 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
11917 TREE_ADDRESSABLE (decl1) = 1;
11919 if (DECL_RESULT (decl1) == NULL_TREE)
11921 DECL_RESULT (decl1)
11922 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11923 TREE_READONLY (DECL_RESULT (decl1)) = TYPE_READONLY (restype);
11924 TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = TYPE_VOLATILE (restype);
11927 /* Allocate further tree nodes temporarily during compilation
11928 of this function only. Tiemann moved up here from bottom of fn. */
11929 /* If this is a nested function, then we must continue to allocate RTL
11930 on the permanent obstack in case we need to inline it later. */
11931 if (! hack_decl_function_context (decl1))
11932 temporary_allocation ();
11934 if (processing_template_decl)
11936 ++minimal_parse_mode;
11937 last_tree = DECL_SAVED_TREE (decl1)
11938 = build_nt (EXPR_STMT, void_zero_node);
11943 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
11944 && DECL_LANGUAGE (decl1) == lang_cplusplus)
11946 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11947 ctor_label = NULL_TREE;
11951 dtor_label = NULL_TREE;
11952 if (DECL_CONSTRUCTOR_P (decl1))
11953 ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11959 /* Called after store_parm_decls for a function-try-block. We need to update
11960 last_parm_cleanup_insn so that the base initializers for a constructor
11961 are run within this block, not before it. */
11964 expand_start_early_try_stmts ()
11966 expand_start_try_stmts ();
11967 last_parm_cleanup_insn = get_last_insn ();
11970 /* Store the parameter declarations into the current function declaration.
11971 This is called after parsing the parameter declarations, before
11972 digesting the body of the function.
11974 Also install to binding contour return value identifier, if any. */
11977 store_parm_decls ()
11979 register tree fndecl = current_function_decl;
11980 register tree parm;
11981 int parms_have_cleanups = 0;
11982 tree cleanups = NULL_TREE;
11984 /* This is either a chain of PARM_DECLs (when a prototype is used). */
11985 tree specparms = current_function_parms;
11987 /* This is a list of types declared among parms in a prototype. */
11988 tree parmtags = current_function_parm_tags;
11990 /* This is a chain of any other decls that came in among the parm
11991 declarations. If a parm is declared with enum {foo, bar} x;
11992 then CONST_DECLs for foo and bar are put here. */
11993 tree nonparms = NULL_TREE;
11995 if (toplevel_bindings_p ())
11996 fatal ("parse errors have confused me too much");
11998 /* Initialize RTL machinery. */
11999 init_function_start (fndecl, input_filename, lineno);
12001 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12002 declare_function_name ();
12004 /* Create a binding level for the parms. */
12005 expand_start_bindings (0);
12007 if (specparms != NULL_TREE)
12009 /* This case is when the function was defined with an ANSI prototype.
12010 The parms already have decls, so we need not do anything here
12011 except record them as in effect
12012 and complain if any redundant old-style parm decls were written. */
12014 register tree next;
12016 /* Must clear this because it might contain TYPE_DECLs declared
12018 storedecls (NULL_TREE);
12020 for (parm = nreverse (specparms); parm; parm = next)
12022 next = TREE_CHAIN (parm);
12023 if (TREE_CODE (parm) == PARM_DECL)
12026 if (DECL_NAME (parm) == NULL_TREE)
12030 else if (TREE_CODE (TREE_TYPE (parm)) == VOID_TYPE)
12031 cp_error ("parameter `%D' declared void", parm);
12034 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12035 A parameter is assumed not to have any side effects.
12036 If this should change for any reason, then this
12037 will have to wrap the bashed reference type in a save_expr.
12039 Also, if the parameter type is declared to be an X
12040 and there is an X(X&) constructor, we cannot lay it
12041 into the stack (any more), so we make this parameter
12042 look like it is really of reference type. Functions
12043 which pass parameters to this function will know to
12044 create a temporary in their frame, and pass a reference
12047 if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE
12048 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm))))
12049 SET_DECL_REFERENCE_SLOT (parm, convert_from_reference (parm));
12053 if (! processing_template_decl
12054 && (cleanup = maybe_build_cleanup (parm), cleanup))
12056 expand_decl (parm);
12057 parms_have_cleanups = 1;
12059 /* Keep track of the cleanups. */
12060 cleanups = tree_cons (parm, cleanup, cleanups);
12065 /* If we find an enum constant or a type tag,
12066 put it aside for the moment. */
12067 TREE_CHAIN (parm) = NULL_TREE;
12068 nonparms = chainon (nonparms, parm);
12072 /* Get the decls in their original chain order
12073 and record in the function. This is all and only the
12074 PARM_DECLs that were pushed into scope by the loop above. */
12075 DECL_ARGUMENTS (fndecl) = getdecls ();
12077 storetags (chainon (parmtags, gettags ()));
12080 DECL_ARGUMENTS (fndecl) = NULL_TREE;
12082 /* Now store the final chain of decls for the arguments
12083 as the decl-chain of the current lexical scope.
12084 Put the enumerators in as well, at the front so that
12085 DECL_ARGUMENTS is not modified. */
12087 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
12089 /* Initialize the RTL code for the function. */
12090 DECL_SAVED_INSNS (fndecl) = NULL_RTX;
12091 if (! processing_template_decl)
12092 expand_function_start (fndecl, parms_have_cleanups);
12094 current_function_parms_stored = 1;
12096 /* If this function is `main', emit a call to `__main'
12097 to run global initializers, etc. */
12098 if (DECL_NAME (fndecl)
12099 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
12100 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
12101 && DECL_CONTEXT (fndecl) == global_namespace)
12103 expand_main_function ();
12106 /* Now that we have initialized the parms, we can start their
12107 cleanups. We cannot do this before, since expand_decl_cleanup
12108 should not be called before the parm can be used. */
12110 && ! processing_template_decl)
12112 for (cleanups = nreverse (cleanups); cleanups; cleanups = TREE_CHAIN (cleanups))
12114 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups), TREE_VALUE (cleanups)))
12115 cp_error ("parser lost in parsing declaration of `%D'",
12116 TREE_PURPOSE (cleanups));
12120 /* Create a binding contour which can be used to catch
12121 cleanup-generated temporaries. Also, if the return value needs or
12122 has initialization, deal with that now. */
12123 if (parms_have_cleanups)
12126 expand_start_bindings (0);
12129 if (! processing_template_decl && flag_exceptions)
12131 /* Do the starting of the exception specifications, if we have any. */
12132 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
12133 expand_start_eh_spec ();
12136 last_parm_cleanup_insn = get_last_insn ();
12137 last_dtor_insn = get_last_insn ();
12140 /* Bind a name and initialization to the return value of
12141 the current function. */
12144 store_return_init (return_id, init)
12145 tree return_id, init;
12147 tree decl = DECL_RESULT (current_function_decl);
12150 /* Give this error as many times as there are occurrences,
12151 so that users can use Emacs compilation buffers to find
12152 and fix all such places. */
12153 pedwarn ("ANSI C++ does not permit named return values");
12155 if (return_id != NULL_TREE)
12157 if (DECL_NAME (decl) == NULL_TREE)
12159 DECL_NAME (decl) = return_id;
12160 DECL_ASSEMBLER_NAME (decl) = return_id;
12163 cp_error ("return identifier `%D' already in place", decl);
12166 /* Can't let this happen for constructors. */
12167 if (DECL_CONSTRUCTOR_P (current_function_decl))
12169 error ("can't redefine default return value for constructors");
12173 /* If we have a named return value, put that in our scope as well. */
12174 if (DECL_NAME (decl) != NULL_TREE)
12176 /* If this named return value comes in a register,
12177 put it in a pseudo-register. */
12178 if (DECL_REGISTER (decl))
12180 original_result_rtx = DECL_RTL (decl);
12181 DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
12184 /* Let `cp_finish_decl' know that this initializer is ok. */
12185 DECL_INITIAL (decl) = init;
12188 if (minimal_parse_mode)
12189 add_tree (build_min_nt (RETURN_INIT, return_id,
12190 copy_to_permanent (init)));
12192 cp_finish_decl (decl, init, NULL_TREE, 0, 0);
12197 /* Finish up a function declaration and compile that function
12198 all the way to assembler language output. The free the storage
12199 for the function definition.
12201 This is called after parsing the body of the function definition.
12202 LINENO is the current line number.
12204 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12205 (and expand_end_bindings) must be made to take care of the binding
12206 contour for the base initializers. This is only relevant for
12209 NESTED is nonzero if we were in the middle of compiling another function
12210 when we started on this one. */
12213 finish_function (lineno, call_poplevel, nested)
12218 register tree fndecl = current_function_decl;
12219 tree fntype, ctype = NULL_TREE;
12220 rtx last_parm_insn, insns;
12221 /* Label to use if this function is supposed to return a value. */
12222 tree no_return_label = NULL_TREE;
12223 tree decls = NULL_TREE;
12225 /* When we get some parse errors, we can end up without a
12226 current_function_decl, so cope. */
12227 if (fndecl == NULL_TREE)
12230 if (! nested && function_depth > 1)
12233 fntype = TREE_TYPE (fndecl);
12235 /* TREE_READONLY (fndecl) = 1;
12236 This caused &foo to be of type ptr-to-const-function
12237 which then got a warning when stored in a ptr-to-function variable. */
12239 /* This happens on strange parse errors. */
12240 if (! current_function_parms_stored)
12243 store_parm_decls ();
12246 if (processing_template_decl)
12248 if (DECL_CONSTRUCTOR_P (fndecl) && call_poplevel)
12250 decls = getdecls ();
12251 expand_end_bindings (decls, decls != NULL_TREE, 0);
12252 poplevel (decls != NULL_TREE, 0, 0);
12257 if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
12259 tree ttype = target_type (fntype);
12262 if (IS_AGGR_TYPE (ttype))
12263 /* Let debugger know it should output info for this type. */
12264 note_debug_info_needed (ttype);
12266 for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
12268 ttype = target_type (TREE_TYPE (parmdecl));
12269 if (IS_AGGR_TYPE (ttype))
12270 /* Let debugger know it should output info for this type. */
12271 note_debug_info_needed (ttype);
12275 /* Clean house because we will need to reorder insns here. */
12276 do_pending_stack_adjust ();
12280 tree binfo = TYPE_BINFO (current_class_type);
12281 tree cond = integer_one_node;
12283 tree in_charge_node = lookup_name (in_charge_identifier, 0);
12285 int ok_to_optimize_dtor = 0;
12286 int empty_dtor = get_last_insn () == last_dtor_insn;
12288 if (current_function_assigns_this)
12289 cond = build (NE_EXPR, boolean_type_node,
12290 current_class_ptr, integer_zero_node);
12293 int n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
12295 /* If this destructor is empty, then we don't need to check
12296 whether `this' is NULL in some cases. */
12297 if ((flag_this_is_variable & 1) == 0)
12298 ok_to_optimize_dtor = 1;
12299 else if (empty_dtor)
12300 ok_to_optimize_dtor
12301 = (n_baseclasses == 0
12302 || (n_baseclasses == 1
12303 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type, 0))));
12306 /* These initializations might go inline. Protect
12307 the binding level of the parms. */
12309 expand_start_bindings (0);
12311 if (current_function_assigns_this)
12313 current_function_assigns_this = 0;
12314 current_function_just_assigned_this = 0;
12317 /* Generate the code to call destructor on base class.
12318 If this destructor belongs to a class with virtual
12319 functions, then set the virtual function table
12320 pointer to represent the type of our base class. */
12322 /* This side-effect makes call to `build_delete' generate the
12323 code we have to have at the end of this destructor. */
12324 TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
12326 /* These are two cases where we cannot delegate deletion. */
12327 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
12328 || TYPE_GETS_REG_DELETE (current_class_type))
12329 exprstmt = build_delete (current_class_type, current_class_ref, integer_zero_node,
12330 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
12332 exprstmt = build_delete (current_class_type, current_class_ref, in_charge_node,
12333 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 0);
12335 /* If we did not assign to this, then `this' is non-zero at
12336 the end of a destructor. As a special optimization, don't
12337 emit test if this is an empty destructor. If it does nothing,
12338 it does nothing. If it calls a base destructor, the base
12339 destructor will perform the test. */
12341 if (exprstmt != error_mark_node
12342 && (TREE_CODE (exprstmt) != NOP_EXPR
12343 || TREE_OPERAND (exprstmt, 0) != integer_zero_node
12344 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
12346 expand_label (dtor_label);
12347 if (cond != integer_one_node)
12348 expand_start_cond (cond, 0);
12349 if (exprstmt != void_zero_node)
12350 /* Don't call `expand_expr_stmt' if we're not going to do
12351 anything, since -Wall will give a diagnostic. */
12352 expand_expr_stmt (exprstmt);
12354 /* Run destructor on all virtual baseclasses. */
12355 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12357 tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
12358 expand_start_cond (build (BIT_AND_EXPR, integer_type_node,
12359 in_charge_node, integer_two_node), 0);
12362 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
12364 tree vb = get_vbase
12365 (BINFO_TYPE (vbases),
12366 TYPE_BINFO (current_class_type));
12368 (build_scoped_method_call
12369 (current_class_ref, vb, dtor_identifier,
12370 build_expr_list (NULL_TREE, integer_zero_node)));
12372 vbases = TREE_CHAIN (vbases);
12374 expand_end_cond ();
12377 do_pending_stack_adjust ();
12378 if (cond != integer_one_node)
12379 expand_end_cond ();
12382 TYPE_HAS_DESTRUCTOR (current_class_type) = 1;
12384 virtual_size = c_sizeof (current_class_type);
12386 /* At the end, call delete if that's what's requested. */
12387 if (TYPE_GETS_REG_DELETE (current_class_type))
12388 /* This NOP_EXPR means we are in a static call context. */
12390 = build_method_call (build_indirect_ref (build1 (NOP_EXPR,
12391 build_pointer_type (current_class_type),
12394 ansi_opname[(int) DELETE_EXPR],
12395 expr_tree_cons (NULL_TREE, current_class_ptr,
12396 build_expr_list (NULL_TREE, virtual_size)),
12397 NULL_TREE, LOOKUP_NORMAL);
12398 else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12399 exprstmt = build_x_delete (ptr_type_node, current_class_ptr, 0,
12402 exprstmt = NULL_TREE;
12406 cond = build (BIT_AND_EXPR, integer_type_node,
12407 in_charge_node, integer_one_node);
12408 expand_start_cond (cond, 0);
12409 expand_expr_stmt (exprstmt);
12410 expand_end_cond ();
12413 /* End of destructor. */
12414 expand_end_bindings (NULL_TREE, getdecls () != NULL_TREE, 0);
12415 poplevel (2, 0, 0); /* XXX change to 1 */
12417 /* Back to the top of destructor. */
12418 /* Don't execute destructor code if `this' is NULL. */
12422 /* If the dtor is empty, and we know there is not possible way we
12423 could use any vtable entries, before they are possibly set by
12424 a base class dtor, we don't have to setup the vtables, as we
12425 know that any base class dtoring will set up any vtables it
12426 needs. We avoid MI, because one base class dtor can do a
12427 virtual dispatch to an overridden function that would need to
12428 have a non-related vtable set up, we cannot avoid setting up
12429 vtables in that case. We could change this to see if there is
12430 just one vtable. */
12431 if (! empty_dtor || TYPE_USES_COMPLEX_INHERITANCE (current_class_type))
12433 /* Make all virtual function table pointers in non-virtual base
12434 classes point to CURRENT_CLASS_TYPE's virtual function
12436 expand_direct_vtbls_init (binfo, binfo, 1, 0, current_class_ptr);
12438 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
12439 expand_indirect_vtbls_init (binfo, current_class_ref, current_class_ptr);
12442 if (! ok_to_optimize_dtor)
12444 cond = build_binary_op (NE_EXPR,
12445 current_class_ptr, integer_zero_node, 1);
12446 expand_start_cond (cond, 0);
12449 insns = get_insns ();
12452 last_parm_insn = get_first_nonparm_insn ();
12453 if (last_parm_insn == NULL_RTX)
12454 last_parm_insn = get_last_insn ();
12456 last_parm_insn = previous_insn (last_parm_insn);
12458 emit_insns_after (insns, last_parm_insn);
12460 if (! ok_to_optimize_dtor)
12461 expand_end_cond ();
12463 else if (current_function_assigns_this)
12465 /* Does not need to call emit_base_init, because
12466 that is done (if needed) just after assignment to this
12469 if (DECL_CONSTRUCTOR_P (current_function_decl))
12471 end_protect_partials ();
12472 expand_label (ctor_label);
12473 ctor_label = NULL_TREE;
12477 decls = getdecls ();
12478 expand_end_bindings (decls, decls != NULL_TREE, 0);
12479 poplevel (decls != NULL_TREE, 0, 0);
12481 c_expand_return (current_class_ptr);
12483 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl))) != VOID_TYPE
12484 && return_label != NULL_RTX)
12485 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12487 current_function_assigns_this = 0;
12488 current_function_just_assigned_this = 0;
12489 base_init_expr = NULL_TREE;
12491 else if (DECL_CONSTRUCTOR_P (fndecl))
12493 tree cond = NULL_TREE, thenclause = NULL_TREE;
12494 /* Allow constructor for a type to get a new instance of the object
12495 using `build_new'. */
12496 tree abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type);
12497 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = NULL_TREE;
12499 DECL_RETURNS_FIRST_ARG (fndecl) = 1;
12501 if (flag_this_is_variable > 0)
12503 cond = build_binary_op (EQ_EXPR,
12504 current_class_ptr, integer_zero_node, 1);
12505 thenclause = build_modify_expr (current_class_ptr, NOP_EXPR,
12506 build_new (NULL_TREE, current_class_type, void_type_node, 0));
12509 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type) = abstract_virtuals;
12513 if (flag_this_is_variable > 0)
12515 expand_start_cond (cond, 0);
12516 expand_expr_stmt (thenclause);
12517 expand_end_cond ();
12520 /* Emit insns from `emit_base_init' which sets up virtual
12521 function table pointer(s). */
12522 if (base_init_expr)
12524 expand_expr_stmt (base_init_expr);
12525 base_init_expr = NULL_TREE;
12528 insns = get_insns ();
12531 /* This is where the body of the constructor begins. */
12533 emit_insns_after (insns, last_parm_cleanup_insn);
12535 end_protect_partials ();
12537 /* This is where the body of the constructor ends. */
12538 expand_label (ctor_label);
12539 ctor_label = NULL_TREE;
12543 decls = getdecls ();
12544 expand_end_bindings (decls, decls != NULL_TREE, 0);
12545 poplevel (decls != NULL_TREE, 1, 0);
12548 c_expand_return (current_class_ptr);
12550 current_function_assigns_this = 0;
12551 current_function_just_assigned_this = 0;
12553 else if (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 4
12554 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main")
12555 && DECL_CONTEXT (fndecl) == global_namespace)
12557 /* Make it so that `main' always returns 0 by default. */
12559 c_expand_return (integer_one_node);
12561 c_expand_return (integer_zero_node);
12564 else if (return_label != NULL_RTX
12565 && current_function_return_value == NULL_TREE
12566 && ! DECL_NAME (DECL_RESULT (current_function_decl)))
12567 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
12569 if (flag_exceptions)
12570 expand_exception_blocks ();
12572 /* If this function is supposed to return a value, ensure that
12573 we do not fall into the cleanups by mistake. The end of our
12574 function will look like this:
12576 user code (may have return stmt somewhere)
12577 goto no_return_label
12582 NOTE_INSN_FUNCTION_END
12586 If the user omits a return stmt in the USER CODE section, we
12587 will have a control path which reaches NOTE_INSN_FUNCTION_END.
12588 Otherwise, we won't. */
12589 if (no_return_label)
12591 DECL_CONTEXT (no_return_label) = fndecl;
12592 DECL_INITIAL (no_return_label) = error_mark_node;
12593 DECL_SOURCE_FILE (no_return_label) = input_filename;
12594 DECL_SOURCE_LINE (no_return_label) = lineno;
12595 expand_goto (no_return_label);
12600 /* Remove the binding contour which is used
12601 to catch cleanup-generated temporaries. */
12602 expand_end_bindings (0, 0, 0);
12603 poplevel (0, 0, 0);
12605 /* Emit label at beginning of cleanup code for parameters. */
12606 emit_label (cleanup_label);
12609 /* Get return value into register if that's where it's supposed to be. */
12610 if (original_result_rtx)
12611 fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
12613 /* Finish building code that will trigger warnings if users forget
12614 to make their functions return values. */
12615 if (no_return_label || cleanup_label)
12616 emit_jump (return_label);
12617 if (no_return_label)
12619 /* We don't need to call `expand_*_return' here because we
12620 don't need any cleanups here--this path of code is only
12621 for error checking purposes. */
12622 expand_label (no_return_label);
12625 /* Generate rtl for function exit. */
12626 expand_function_end (input_filename, lineno, 1);
12629 /* This must come after expand_function_end because cleanups might
12630 have declarations (from inline functions) that need to go into
12631 this function's blocks. */
12632 if (current_binding_level->parm_flag != 1)
12633 my_friendly_abort (122);
12634 poplevel (1, 0, 1);
12636 /* Reset scope for C++: if we were in the scope of a class,
12637 then when we finish this function, we are not longer so.
12638 This cannot be done until we know for sure that no more
12639 class members will ever be referenced in this function
12640 (i.e., calls to destructors). */
12641 if (current_class_name)
12643 ctype = current_class_type;
12644 pop_nested_class (1);
12647 pop_memoized_context (1);
12649 /* Must mark the RESULT_DECL as being in this function. */
12650 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12652 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12653 to the FUNCTION_DECL node itself. */
12654 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12656 if (! processing_template_decl)
12658 int saved_flag_keep_inline_functions =
12659 flag_keep_inline_functions;
12661 /* So we can tell if jump_optimize sets it to 1. */
12664 if (DECL_CONTEXT (fndecl) != NULL_TREE
12665 && hack_decl_function_context (fndecl))
12666 /* Trick rest_of_compilation into not deferring output of this
12667 function, even if it is inline, since the rtl_obstack for
12668 this function is the function_obstack of the enclosing
12669 function and will be deallocated when the enclosing
12670 function is gone. See save_tree_status. */
12671 flag_keep_inline_functions = 1;
12673 /* Run the optimizers and output the assembler code for this
12676 if (DECL_ARTIFICIAL (fndecl))
12678 /* Do we really *want* to inline this synthesized method? */
12680 int save_fif = flag_inline_functions;
12681 flag_inline_functions = 1;
12683 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
12684 will check our size. */
12685 DECL_INLINE (fndecl) = 0;
12687 rest_of_compilation (fndecl);
12688 flag_inline_functions = save_fif;
12691 rest_of_compilation (fndecl);
12693 flag_keep_inline_functions = saved_flag_keep_inline_functions;
12695 if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
12697 /* Set DECL_EXTERNAL so that assemble_external will be called as
12698 necessary. We'll clear it again in finish_file. */
12699 if (! DECL_EXTERNAL (fndecl))
12700 DECL_NOT_REALLY_EXTERN (fndecl) = 1;
12701 DECL_EXTERNAL (fndecl) = 1;
12702 mark_inline_for_output (fndecl);
12705 if (ctype && TREE_ASM_WRITTEN (fndecl))
12706 note_debug_info_needed (ctype);
12708 current_function_returns_null |= can_reach_end;
12710 /* Since we don't normally go through c_expand_return for constructors,
12711 this normally gets the wrong value.
12712 Also, named return values have their return codes emitted after
12713 NOTE_INSN_FUNCTION_END, confusing jump.c. */
12714 if (DECL_CONSTRUCTOR_P (fndecl)
12715 || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
12716 current_function_returns_null = 0;
12718 if (TREE_THIS_VOLATILE (fndecl) && current_function_returns_null)
12719 cp_warning ("`noreturn' function `%D' does return", fndecl);
12720 else if ((warn_return_type || pedantic)
12721 && current_function_returns_null
12722 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
12724 /* If this function returns non-void and control can drop through,
12726 cp_warning ("control reaches end of non-void function `%D'", fndecl);
12728 /* With just -W, complain only if function returns both with
12729 and without a value. */
12730 else if (extra_warnings
12731 && current_function_returns_value && current_function_returns_null)
12732 warning ("this function may return with or without a value");
12737 /* Free all the tree nodes making up this function. */
12738 /* Switch back to allocating nodes permanently
12739 until we start another function. */
12740 if (processing_template_decl)
12742 --minimal_parse_mode;
12743 DECL_SAVED_TREE (fndecl) = TREE_CHAIN (DECL_SAVED_TREE (fndecl));
12747 permanent_allocation (1);
12749 if (DECL_SAVED_INSNS (fndecl) == NULL_RTX)
12753 /* Stop pointing to the local nodes about to be freed. */
12754 /* But DECL_INITIAL must remain nonzero so we know this
12755 was an actual function definition. */
12756 DECL_INITIAL (fndecl) = error_mark_node;
12757 for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
12758 DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
12761 if (DECL_STATIC_CONSTRUCTOR (fndecl))
12762 static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
12763 if (DECL_STATIC_DESTRUCTOR (fndecl))
12764 static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
12768 /* Let the error reporting routines know that we're outside a
12769 function. For a nested function, this value is used in
12770 pop_cp_function_context and then reset via pop_function_context. */
12771 current_function_decl = NULL_TREE;
12774 named_label_uses = NULL;
12775 current_class_ptr = NULL_TREE;
12776 current_class_ref = NULL_TREE;
12779 /* Create the FUNCTION_DECL for a function definition.
12780 LINE1 is the line number that the definition absolutely begins on.
12781 LINE2 is the line number that the name of the function appears on.
12782 DECLSPECS and DECLARATOR are the parts of the declaration;
12783 they describe the return type and the name of the function,
12784 but twisted together in a fashion that parallels the syntax of C.
12786 This function creates a binding context for the function body
12787 as well as setting up the FUNCTION_DECL in current_function_decl.
12789 Returns a FUNCTION_DECL on success.
12791 If the DECLARATOR is not suitable for a function (it defines a datum
12792 instead), we return 0, which tells yyparse to report a parse error.
12794 May return void_type_node indicating that this method is actually
12795 a friend. See grokfield for more details.
12797 Came here with a `.pushlevel' .
12799 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12800 CHANGES TO CODE IN `grokfield'. */
12803 start_method (declspecs, declarator)
12804 tree declarator, declspecs;
12806 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12809 /* Something too ugly to handle. */
12810 if (fndecl == NULL_TREE)
12813 /* Pass friends other than inline friend functions back. */
12814 if (fndecl == void_type_node)
12817 if (TREE_CODE (fndecl) != FUNCTION_DECL)
12818 /* Not a function, tell parser to report parse error. */
12821 if (IS_SIGNATURE (current_class_type))
12822 IS_DEFAULT_IMPLEMENTATION (fndecl) = 1;
12824 if (DECL_IN_AGGR_P (fndecl))
12826 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
12828 if (DECL_CONTEXT (fndecl)
12829 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12830 cp_error ("`%D' is already defined in class %s", fndecl,
12831 TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
12833 return void_type_node;
12836 DECL_THIS_INLINE (fndecl) = 1;
12838 if (flag_default_inline)
12839 DECL_INLINE (fndecl) = 1;
12841 if (processing_template_decl)
12842 fndecl = push_template_decl (fndecl);
12844 /* We read in the parameters on the maybepermanent_obstack,
12845 but we won't be getting back to them until after we
12846 may have clobbered them. So the call to preserve_data
12847 will keep them safe. */
12850 if (! DECL_FRIEND_P (fndecl))
12852 if (TREE_CHAIN (fndecl))
12854 fndecl = copy_node (fndecl);
12855 TREE_CHAIN (fndecl) = NULL_TREE;
12858 if (DECL_CONSTRUCTOR_P (fndecl))
12860 if (! grok_ctor_properties (current_class_type, fndecl))
12861 return void_type_node;
12863 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
12864 grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
12867 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0, 0);
12869 /* Make a place for the parms */
12871 current_binding_level->parm_flag = 1;
12873 DECL_IN_AGGR_P (fndecl) = 1;
12877 /* Go through the motions of finishing a function definition.
12878 We don't compile this method until after the whole class has
12881 FINISH_METHOD must return something that looks as though it
12882 came from GROKFIELD (since we are defining a method, after all).
12884 This is called after parsing the body of the function definition.
12885 STMTS is the chain of statements that makes up the function body.
12887 DECL is the ..._DECL that `start_method' provided. */
12890 finish_method (decl)
12893 register tree fndecl = decl;
12896 register tree link;
12898 if (decl == void_type_node)
12901 old_initial = DECL_INITIAL (fndecl);
12903 /* Undo the level for the parms (from start_method).
12904 This is like poplevel, but it causes nothing to be
12905 saved. Saving information here confuses symbol-table
12906 output routines. Besides, this information will
12907 be correctly output when this method is actually
12910 /* Clear out the meanings of the local variables of this level;
12911 also record in each decl which block it belongs to. */
12913 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12915 if (DECL_NAME (link) != NULL_TREE)
12916 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
12917 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
12918 DECL_CONTEXT (link) = NULL_TREE;
12921 /* Restore all name-meanings of the outer levels
12922 that were shadowed by this level. */
12924 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
12925 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
12926 for (link = current_binding_level->class_shadowed;
12927 link; link = TREE_CHAIN (link))
12928 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
12929 for (link = current_binding_level->type_shadowed;
12930 link; link = TREE_CHAIN (link))
12931 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
12933 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
12934 (HOST_WIDE_INT) current_binding_level->level_chain,
12935 current_binding_level->parm_flag,
12936 current_binding_level->keep);
12938 poplevel (0, 0, 0);
12940 DECL_INITIAL (fndecl) = old_initial;
12942 /* We used to check if the context of FNDECL was different from
12943 current_class_type as another way to get inside here. This didn't work
12944 for String.cc in libg++. */
12945 if (DECL_FRIEND_P (fndecl))
12947 CLASSTYPE_INLINE_FRIENDS (current_class_type)
12948 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
12949 decl = void_type_node;
12955 /* Called when a new struct TYPE is defined.
12956 If this structure or union completes the type of any previous
12957 variable declaration, lay it out and output its rtl. */
12960 hack_incomplete_structures (type)
12965 if (current_binding_level->incomplete == NULL_TREE)
12968 if (!type) /* Don't do this for class templates. */
12971 for (list = ¤t_binding_level->incomplete; *list; )
12973 tree decl = TREE_VALUE (*list);
12974 if ((decl && TREE_TYPE (decl) == type)
12975 || (TREE_TYPE (decl)
12976 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
12977 && TREE_TYPE (TREE_TYPE (decl)) == type))
12979 int toplevel = toplevel_bindings_p ();
12980 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
12981 && TREE_TYPE (TREE_TYPE (decl)) == type)
12982 layout_type (TREE_TYPE (decl));
12983 layout_decl (decl, 0);
12984 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
12988 expand_decl (decl);
12989 cleanup = maybe_build_cleanup (decl);
12990 expand_decl_init (decl);
12991 if (! expand_decl_cleanup (decl, cleanup))
12992 cp_error ("parser lost in parsing declaration of `%D'",
12995 *list = TREE_CHAIN (*list);
12998 list = &TREE_CHAIN (*list);
13002 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13003 See build_delete for information about AUTO_DELETE.
13005 Don't build these on the momentary obstack; they must live
13006 the life of the binding contour. */
13009 maybe_build_cleanup_1 (decl, auto_delete)
13010 tree decl, auto_delete;
13012 tree type = TREE_TYPE (decl);
13013 if (TYPE_NEEDS_DESTRUCTOR (type))
13015 int temp = 0, flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
13018 if (TREE_CODE (decl) != PARM_DECL)
13019 temp = suspend_momentary ();
13021 if (TREE_CODE (type) == ARRAY_TYPE)
13025 mark_addressable (decl);
13026 rval = build_unary_op (ADDR_EXPR, decl, 0);
13029 /* Optimize for space over speed here. */
13030 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
13031 || flag_expensive_optimizations)
13032 flags |= LOOKUP_NONVIRTUAL;
13034 rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
13036 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
13037 && ! TYPE_HAS_DESTRUCTOR (type))
13038 rval = build_compound_expr (expr_tree_cons (NULL_TREE, rval,
13039 build_expr_list (NULL_TREE, build_vbase_delete (type, decl))));
13041 if (TREE_CODE (decl) != PARM_DECL)
13042 resume_momentary (temp);
13049 /* If DECL is of a type which needs a cleanup, build that cleanup
13050 here. The cleanup does free the storage with a call to delete. */
13053 maybe_build_cleanup_and_delete (decl)
13056 return maybe_build_cleanup_1 (decl, integer_three_node);
13059 /* If DECL is of a type which needs a cleanup, build that cleanup
13060 here. The cleanup does not free the storage with a call a delete. */
13063 maybe_build_cleanup (decl)
13066 return maybe_build_cleanup_1 (decl, integer_two_node);
13069 /* Expand a C++ expression at the statement level.
13070 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13071 The C++ type checker should get all of these out when
13072 expressions are combined with other, type-providing, expressions,
13073 leaving only orphan expressions, such as:
13075 &class::bar; / / takes its address, but does nothing with it. */
13078 cplus_expand_expr_stmt (exp)
13081 if (processing_template_decl)
13083 add_tree (build_min_nt (EXPR_STMT, exp));
13087 /* Arrange for all temps to disappear. */
13088 expand_start_target_temps ();
13090 if (TREE_TYPE (exp) == unknown_type_node)
13092 if (TREE_CODE (exp) == ADDR_EXPR || TREE_CODE (exp) == TREE_LIST)
13093 error ("address of overloaded function with no contextual type information");
13094 else if (TREE_CODE (exp) == COMPONENT_REF)
13095 warning ("useless reference to a member function name, did you forget the ()?");
13099 if (TREE_CODE (exp) == FUNCTION_DECL)
13101 cp_warning ("reference, not call, to function `%D'", exp);
13102 warning ("at this point in file");
13106 /* We should do this eventually, but right now this causes regex.o from
13107 libg++ to miscompile, and tString to core dump. */
13108 exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
13111 /* Strip unused implicit INDIRECT_REFs of references. */
13112 if (TREE_CODE (exp) == INDIRECT_REF
13113 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
13114 exp = TREE_OPERAND (exp, 0);
13116 /* If we don't do this, we end up down inside expand_expr
13117 trying to do TYPE_MODE on the ERROR_MARK, and really
13118 go outside the bounds of the type. */
13119 if (exp != error_mark_node)
13120 expand_expr_stmt (break_out_cleanups (exp));
13123 /* Clean up any pending cleanups. This happens when a function call
13124 returns a cleanup-needing value that nobody uses. */
13125 expand_end_target_temps ();
13128 /* When a stmt has been parsed, this function is called.
13130 Currently, this function only does something within a
13131 constructor's scope: if a stmt has just assigned to this,
13132 and we are in a derived class, we call `emit_base_init'. */
13137 extern struct nesting *cond_stack, *loop_stack, *case_stack;
13140 if (current_function_assigns_this
13141 || ! current_function_just_assigned_this)
13143 if (DECL_CONSTRUCTOR_P (current_function_decl))
13145 /* Constructors must wait until we are out of control
13146 zones before calling base constructors. */
13147 if (cond_stack || loop_stack || case_stack)
13149 expand_expr_stmt (base_init_expr);
13150 check_base_init (current_class_type);
13152 current_function_assigns_this = 1;
13155 /* Change a static member function definition into a FUNCTION_TYPE, instead
13156 of the METHOD_TYPE that we create when it's originally parsed.
13158 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13159 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13160 other decls. Either pass the addresses of local variables or NULL. */
13163 revert_static_member_fn (decl, fn, argtypes)
13164 tree *decl, *fn, *argtypes;
13167 tree function = fn ? *fn : TREE_TYPE (*decl);
13168 tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
13170 if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (args))))
13171 cp_error ("static member function `%#D' declared const", *decl);
13172 if (TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (args))))
13173 cp_error ("static member function `%#D' declared volatile", *decl);
13175 args = TREE_CHAIN (args);
13176 tmp = build_function_type (TREE_TYPE (function), args);
13177 tmp = build_type_variant (tmp, TYPE_READONLY (function),
13178 TYPE_VOLATILE (function));
13179 tmp = build_exception_variant (tmp,
13180 TYPE_RAISES_EXCEPTIONS (function));
13181 TREE_TYPE (*decl) = tmp;
13182 if (DECL_ARGUMENTS (*decl))
13183 DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
13184 DECL_STATIC_FUNCTION_P (*decl) = 1;
13192 id_in_current_class (id)
13195 return !!purpose_member (id, class_binding_level->class_shadowed);
13202 int warn_about_return_type;
13204 int just_assigned_this;
13206 int temp_name_counter;
13208 tree shadowed_labels;
13211 rtx last_dtor_insn;
13212 rtx last_parm_cleanup_insn;
13213 tree base_init_list;
13214 tree member_init_list;
13215 tree base_init_expr;
13216 tree current_class_ptr;
13217 tree current_class_ref;
13219 struct cp_function *next;
13220 struct binding_level *binding_level;
13221 int static_labelno;
13224 static struct cp_function *cp_function_chain;
13226 extern int temp_name_counter;
13228 /* Save and reinitialize the variables
13229 used during compilation of a C++ function. */
13232 push_cp_function_context (context)
13235 struct cp_function *p
13236 = (struct cp_function *) xmalloc (sizeof (struct cp_function));
13238 push_function_context_to (context);
13240 p->next = cp_function_chain;
13241 cp_function_chain = p;
13243 p->named_labels = named_labels;
13244 p->shadowed_labels = shadowed_labels;
13245 p->returns_value = current_function_returns_value;
13246 p->returns_null = current_function_returns_null;
13247 p->warn_about_return_type = warn_about_return_type;
13248 p->binding_level = current_binding_level;
13249 p->ctor_label = ctor_label;
13250 p->dtor_label = dtor_label;
13251 p->last_dtor_insn = last_dtor_insn;
13252 p->last_parm_cleanup_insn = last_parm_cleanup_insn;
13253 p->assigns_this = current_function_assigns_this;
13254 p->just_assigned_this = current_function_just_assigned_this;
13255 p->parms_stored = current_function_parms_stored;
13256 p->result_rtx = original_result_rtx;
13257 p->base_init_expr = base_init_expr;
13258 p->temp_name_counter = temp_name_counter;
13259 p->base_init_list = current_base_init_list;
13260 p->member_init_list = current_member_init_list;
13261 p->current_class_ptr = current_class_ptr;
13262 p->current_class_ref = current_class_ref;
13263 p->static_labelno = static_labelno;
13266 /* Restore the variables used during compilation of a C++ function. */
13269 pop_cp_function_context (context)
13272 struct cp_function *p = cp_function_chain;
13275 /* Bring back all the labels that were shadowed. */
13276 for (link = shadowed_labels; link; link = TREE_CHAIN (link))
13277 if (DECL_NAME (TREE_VALUE (link)) != 0)
13278 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link)),
13279 TREE_VALUE (link));
13281 pop_function_context_from (context);
13283 cp_function_chain = p->next;
13285 named_labels = p->named_labels;
13286 shadowed_labels = p->shadowed_labels;
13287 current_function_returns_value = p->returns_value;
13288 current_function_returns_null = p->returns_null;
13289 warn_about_return_type = p->warn_about_return_type;
13290 current_binding_level = p->binding_level;
13291 ctor_label = p->ctor_label;
13292 dtor_label = p->dtor_label;
13293 last_dtor_insn = p->last_dtor_insn;
13294 last_parm_cleanup_insn = p->last_parm_cleanup_insn;
13295 current_function_assigns_this = p->assigns_this;
13296 current_function_just_assigned_this = p->just_assigned_this;
13297 current_function_parms_stored = p->parms_stored;
13298 original_result_rtx = p->result_rtx;
13299 base_init_expr = p->base_init_expr;
13300 temp_name_counter = p->temp_name_counter;
13301 current_base_init_list = p->base_init_list;
13302 current_member_init_list = p->member_init_list;
13303 current_class_ptr = p->current_class_ptr;
13304 current_class_ref = p->current_class_ref;
13305 static_labelno = p->static_labelno;
13313 return function_depth != 0;