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
;
51 extern struct obstack
* saveable_obstack
;
53 extern int current_class_depth
;
55 extern tree static_ctors
, static_dtors
;
57 extern int static_labelno
;
59 extern tree current_namespace
;
60 extern tree global_namespace
;
62 extern void (*print_error_function
) PROTO((char *));
64 /* Stack of places to restore the search obstack back to. */
66 /* Obstack used for remembering local class declarations (like
67 enums and static (const) members. */
69 struct obstack decl_obstack
;
70 static struct stack_level
*decl_stack
;
72 #ifndef CHAR_TYPE_SIZE
73 #define CHAR_TYPE_SIZE BITS_PER_UNIT
76 #ifndef SHORT_TYPE_SIZE
77 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
81 #define INT_TYPE_SIZE BITS_PER_WORD
84 #ifndef LONG_TYPE_SIZE
85 #define LONG_TYPE_SIZE BITS_PER_WORD
88 #ifndef LONG_LONG_TYPE_SIZE
89 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
92 #ifndef WCHAR_UNSIGNED
93 #define WCHAR_UNSIGNED 0
96 #ifndef FLOAT_TYPE_SIZE
97 #define FLOAT_TYPE_SIZE BITS_PER_WORD
100 #ifndef DOUBLE_TYPE_SIZE
101 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
104 #ifndef LONG_DOUBLE_TYPE_SIZE
105 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
108 #ifndef BOOL_TYPE_SIZE
109 #ifdef SLOW_BYTE_ACCESS
110 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
112 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
116 /* We let tm.h override the types used here, to handle trivial differences
117 such as the choice of unsigned int or long unsigned int for size_t.
118 When machines start needing nontrivial differences in the size type,
119 it would be best to do something here to figure out automatically
120 from other information what type to use. */
123 #define SIZE_TYPE "long unsigned int"
127 #define PTRDIFF_TYPE "long int"
131 #define WCHAR_TYPE "int"
134 static tree grokparms
PROTO((tree
, int));
135 static tree lookup_nested_type
PROTO((tree
, tree
));
136 static char *redeclaration_error_message
PROTO((tree
, tree
));
137 static tree push_overloaded_decl
PROTO((tree
, int));
139 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
141 static void push_binding_level
PROTO((struct binding_level
*, int,
143 static void pop_binding_level
PROTO((void));
144 static void suspend_binding_level
PROTO((void));
145 static void resume_binding_level
PROTO((struct binding_level
*));
146 static struct binding_level
*make_binding_level
PROTO((void));
147 static int namespace_bindings_p
PROTO((void));
148 static void declare_namespace_level
PROTO((void));
149 static void signal_catch
PROTO((int)) ATTRIBUTE_NORETURN
;
150 static void storedecls
PROTO((tree
));
151 static void storetags
PROTO((tree
));
152 static void require_complete_types_for_parms
PROTO((tree
));
153 static void push_overloaded_decl_1
PROTO((tree
));
154 static int ambi_op_p
PROTO((tree
));
155 static int unary_op_p
PROTO((tree
));
156 static tree store_bindings
PROTO((tree
, tree
));
157 static tree lookup_tag_reverse
PROTO((tree
, tree
));
158 static tree obscure_complex_init
PROTO((tree
, tree
));
159 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
160 static tree lookup_name_real
PROTO((tree
, int, int, int));
161 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
162 static void grok_reference_init
PROTO((tree
, tree
, tree
));
163 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
164 enum overload_flags
, tree
,
165 tree
, tree
, int, int, int, int, int, int, tree
));
166 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
167 static tree lookup_tag
PROTO((enum tree_code
, tree
,
168 struct binding_level
*, int));
169 static void set_identifier_type_value_with_scope
170 PROTO((tree
, tree
, struct binding_level
*));
171 static void set_identifier_local_value_with_scope
172 PROTO((tree
, tree
, struct binding_level
*));
173 static void record_builtin_type
PROTO((enum rid
, char *, tree
));
174 static void record_unknown_type
PROTO((tree
, char *));
175 static int member_function_or_else
PROTO((tree
, tree
, char *));
176 static void bad_specifiers
PROTO((tree
, char *, int, int, int, int,
178 static void lang_print_error_function
PROTO((char *));
179 static tree maybe_process_template_type_declaration
PROTO((tree
, int, struct binding_level
*));
180 static void check_for_uninitialized_const_var
PROTO((tree
));
182 #if defined (DEBUG_CP_BINDING_LEVELS)
183 static void indent
PROTO((void));
186 /* A node which has tree code ERROR_MARK, and whose type is itself.
187 All erroneous expressions are replaced with this node. All functions
188 that accept nodes as arguments should avoid generating error messages
189 if this node is one of the arguments, since it is undesirable to get
190 multiple error messages from one error in the input. */
192 tree error_mark_node
;
194 /* Erroneous argument lists can use this *IFF* they do not modify it. */
195 tree error_mark_list
;
197 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
199 tree short_integer_type_node
;
200 tree integer_type_node
;
201 tree long_integer_type_node
;
202 tree long_long_integer_type_node
;
204 tree short_unsigned_type_node
;
205 tree unsigned_type_node
;
206 tree long_unsigned_type_node
;
207 tree long_long_unsigned_type_node
;
209 tree ptrdiff_type_node
;
211 tree unsigned_char_type_node
;
212 tree signed_char_type_node
;
214 tree wchar_type_node
;
215 tree signed_wchar_type_node
;
216 tree unsigned_wchar_type_node
;
218 tree wchar_decl_node
;
220 tree float_type_node
;
221 tree double_type_node
;
222 tree long_double_type_node
;
224 tree complex_integer_type_node
;
225 tree complex_float_type_node
;
226 tree complex_double_type_node
;
227 tree complex_long_double_type_node
;
229 tree intQI_type_node
;
230 tree intHI_type_node
;
231 tree intSI_type_node
;
232 tree intDI_type_node
;
233 #if HOST_BITS_PER_WIDE_INT >= 64
234 tree intTI_type_node
;
237 tree unsigned_intQI_type_node
;
238 tree unsigned_intHI_type_node
;
239 tree unsigned_intSI_type_node
;
240 tree unsigned_intDI_type_node
;
241 #if HOST_BITS_PER_WIDE_INT >= 64
242 tree unsigned_intTI_type_node
;
245 tree java_byte_type_node
;
246 tree java_short_type_node
;
247 tree java_int_type_node
;
248 tree java_long_type_node
;
249 tree java_float_type_node
;
250 tree java_double_type_node
;
251 tree java_char_type_node
;
252 tree java_boolean_type_node
;
254 /* A VOID_TYPE node, and the same, packaged in a TREE_LIST. */
256 tree void_type_node
, void_list_node
;
259 /* Nodes for types `void *' and `const void *'. */
262 tree const_ptr_type_node
;
264 /* Nodes for types `char *' and `const char *'. */
266 tree string_type_node
, const_string_type_node
;
268 /* Type `char[256]' or something like it.
269 Used when an array of char is needed and the size is irrelevant. */
271 tree char_array_type_node
;
273 /* Type `int[256]' or something like it.
274 Used when an array of int needed and the size is irrelevant. */
276 tree int_array_type_node
;
278 /* Type `wchar_t[256]' or something like it.
279 Used when a wide string literal is created. */
281 tree wchar_array_type_node
;
283 /* The bool data type, and constants */
284 tree boolean_type_node
, boolean_true_node
, boolean_false_node
;
286 /* Type `int ()' -- used for implicit declaration of functions. */
288 tree default_function_type
;
290 /* Function types `double (double)' and `double (double, double)', etc. */
292 static tree double_ftype_double
, double_ftype_double_double
;
293 static tree int_ftype_int
, long_ftype_long
;
294 static tree float_ftype_float
;
295 static tree ldouble_ftype_ldouble
;
297 /* Function type `int (const void *, const void *, size_t)' */
298 static tree int_ftype_cptr_cptr_sizet
;
301 tree vtable_entry_type
;
302 tree delta_type_node
;
304 /* Old rtti stuff. */
305 tree __baselist_desc_type_node
;
306 tree __i_desc_type_node
, __m_desc_type_node
;
307 tree __t_desc_array_type
, __i_desc_array_type
, __m_desc_array_type
;
309 tree __t_desc_type_node
;
311 tree __tp_desc_type_node
;
313 tree __access_mode_type_node
;
314 tree __bltn_desc_type_node
, __user_desc_type_node
, __class_desc_type_node
;
315 tree __ptr_desc_type_node
, __attr_desc_type_node
, __func_desc_type_node
;
316 tree __ptmf_desc_type_node
, __ptmd_desc_type_node
;
318 /* Not needed yet? May be needed one day? */
319 tree __bltn_desc_array_type
, __user_desc_array_type
, __class_desc_array_type
;
320 tree __ptr_desc_array_type
, __attr_dec_array_type
, __func_desc_array_type
;
321 tree __ptmf_desc_array_type
, __ptmd_desc_array_type
;
324 /* Indicates that there is a type value in some namespace, although
325 that is not necessarily in scope at the moment. */
327 static tree global_type_node
;
329 tree class_star_type_node
;
330 tree class_type_node
, record_type_node
, union_type_node
, enum_type_node
;
331 tree unknown_type_node
;
332 tree opaque_type_node
, signature_type_node
;
333 tree sigtable_entry_type
;
335 /* Array type `vtable_entry_type[]' */
337 tree vtbl_ptr_type_node
;
343 /* Expect only namespace names now. */
344 static int only_namespace_names
;
346 /* In a destructor, the point at which all derived class destroying
347 has been done, just before any base class destroying will be done. */
351 /* In a destructor, the last insn emitted after the start of the
352 function and the parms. */
354 static rtx last_dtor_insn
;
356 /* In a constructor, the last insn emitted after the start of the
357 function and the parms, the exception specification and any
358 function-try-block. The constructor initializers are emitted after
361 static rtx last_parm_cleanup_insn
;
363 /* In a constructor, the point at which we are ready to return
364 the pointer to the initialized object. */
368 /* A FUNCTION_DECL which can call `abort'. Not necessarily the
369 one that the user will declare, but sufficient to be called
370 by routines that want to abort the program. */
374 extern rtx cleanup_label
, return_label
;
376 /* If original DECL_RESULT of current function was a register,
377 but due to being an addressable named return value, would up
378 on the stack, this variable holds the named return value's
379 original location. */
380 static rtx original_result_rtx
;
382 /* Sequence of insns which represents base initialization. */
385 /* C++: Keep these around to reduce calls to `get_identifier'.
386 Identifiers for `this' in member functions and the auto-delete
387 parameter for destructors. */
388 tree this_identifier
, in_charge_identifier
;
389 tree ctor_identifier
, dtor_identifier
;
390 /* Used in pointer to member functions, in vtables, and in sigtables. */
391 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
392 tree pfn_or_delta2_identifier
, tag_identifier
;
393 tree vt_off_identifier
;
395 struct named_label_list
397 struct binding_level
*binding_level
;
400 char *filename_o_goto
;
402 struct named_label_list
*next
;
405 /* A list (chain of TREE_LIST nodes) of named label uses.
406 The TREE_PURPOSE field is the list of variables defined
407 in the label's scope defined at the point of use.
408 The TREE_VALUE field is the LABEL_DECL used.
409 The TREE_TYPE field holds `current_binding_level' at the
410 point of the label's use.
412 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
414 Look at the pretty struct named_label_list. See the pretty struct
415 with the pretty named fields that describe what they do. See the
416 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
418 Used only for jumps to as-yet undefined labels, since
419 jumps to defined labels can have their validity checked
422 static struct named_label_list
*named_label_uses
= NULL
;
424 /* A list of objects which have constructors or destructors
425 which reside in the global scope. The decl is stored in
426 the TREE_VALUE slot and the initializer is stored
427 in the TREE_PURPOSE slot. */
428 tree static_aggregates
;
432 /* Two expressions that are constants with value zero.
433 The first is of type `int', the second of type `void *'. */
435 tree integer_zero_node
;
436 tree null_pointer_node
;
438 /* The value for __null (NULL), namely, a zero of an integer type with
439 the same number of bits as a pointer. */
442 /* A node for the integer constants 1, 2, and 3. */
444 tree integer_one_node
, integer_two_node
, integer_three_node
;
446 /* While defining an enum type, this is 1 plus the last enumerator
449 static tree enum_next_value
;
451 /* Nonzero means that there was overflow computing enum_next_value. */
453 static int enum_overflow
;
455 /* Parsing a function declarator leaves a list of parameter names
456 or a chain or parameter decls here. */
458 tree last_function_parms
;
460 /* Parsing a function declarator leaves here a chain of structure
461 and enum types declared in the parmlist. */
463 static tree last_function_parm_tags
;
465 /* After parsing the declarator that starts a function definition,
466 `start_function' puts here the list of parameter names or chain of decls.
467 `store_parm_decls' finds it here. */
469 static tree current_function_parms
;
471 /* Similar, for last_function_parm_tags. */
472 static tree current_function_parm_tags
;
474 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
475 that have names. Here so we can clear out their names' definitions
476 at the end of the function. */
478 static tree named_labels
;
480 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
482 static tree shadowed_labels
;
484 /* The FUNCTION_DECL for the function currently being compiled,
485 or 0 if between functions. */
486 tree current_function_decl
;
488 /* Set to 0 at beginning of a function definition, set to 1 if
489 a return statement that specifies a return value is seen. */
491 int current_function_returns_value
;
493 /* Set to 0 at beginning of a function definition, set to 1 if
494 a return statement with no argument is seen. */
496 int current_function_returns_null
;
498 /* Set to 0 at beginning of a function definition, and whenever
499 a label (case or named) is defined. Set to value of expression
500 returned from function when that value can be transformed into
501 a named return value. */
503 tree current_function_return_value
;
505 /* Set to nonzero by `grokdeclarator' for a function
506 whose return type is defaulted, if warnings for this are desired. */
508 static int warn_about_return_type
;
510 /* Nonzero means give `double' the same size as `float'. */
512 extern int flag_short_double
;
514 /* Nonzero means don't recognize any builtin functions. */
516 extern int flag_no_builtin
;
518 /* Nonzero means don't recognize the non-ANSI builtin functions.
521 extern int flag_no_nonansi_builtin
;
523 /* Nonzero means enable obscure ANSI features and disable GNU extensions
524 that might cause ANSI-compliant code to be miscompiled. */
526 extern int flag_ansi
;
528 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
530 extern int flag_huge_objects
;
532 /* Nonzero if we want to conserve space in the .o files. We do this
533 by putting uninitialized data and runtime initialized data into
534 .common instead of .data at the expense of not flagging multiple
536 extern int flag_conserve_space
;
538 /* Pointers to the base and current top of the language name stack. */
540 extern tree
*current_lang_base
, *current_lang_stack
;
542 /* C and C++ flags are in decl2.c. */
544 /* Set to 0 at beginning of a constructor, set to 1
545 if that function does an allocation before referencing its
546 instance variable. */
547 static int current_function_assigns_this
;
548 int current_function_just_assigned_this
;
550 /* Set to 0 at beginning of a function. Set non-zero when
551 store_parm_decls is called. Don't call store_parm_decls
552 if this flag is non-zero! */
553 int current_function_parms_stored
;
555 /* Flag used when debugging spew.c */
557 extern int spew_debug
;
559 /* This is a copy of the class_shadowed list of the previous class binding
560 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
561 when entering another class scope (i.e. a cache miss). */
562 extern tree previous_class_values
;
564 /* A expression of value 0 with the same precision as a sizetype
566 tree signed_size_zero_node
;
568 /* The name of the anonymous namespace, throughout this translation
570 tree anonymous_namespace_name
;
573 /* Allocate a level of searching. */
577 push_decl_level (stack
, obstack
)
578 struct stack_level
*stack
;
579 struct obstack
*obstack
;
581 struct stack_level tem
;
584 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
587 /* For each binding contour we allocate a binding_level structure
588 which records the names defined in that contour.
591 1) one for each function definition,
592 where internal declarations of the parameters appear.
593 2) one for each compound statement,
594 to record its declarations.
596 The current meaning of a name can be found by searching the levels
597 from the current one out to the global one.
599 Off to the side, may be the class_binding_level. This exists only
600 to catch class-local declarations. It is otherwise nonexistent.
602 Also there may be binding levels that catch cleanups that must be
603 run when exceptions occur. */
605 /* Note that the information in the `names' component of the global contour
606 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
610 /* A chain of _DECL nodes for all variables, constants, functions,
611 and typedef types. These are in the reverse of the order
615 /* A list of structure, union and enum definitions, for looking up
617 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
618 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
619 or ENUMERAL_TYPE node.
621 C++: the TREE_VALUE nodes can be simple types for
622 component_bindings. */
625 /* A list of USING_DECL nodes. */
628 /* A list of used namespaces. PURPOSE is the namespace,
629 VALUE the common ancestor with this binding_level's namespace. */
630 tree using_directives
;
632 /* For each level, a list of shadowed outer-level local definitions
633 to be restored when this level is popped.
634 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
635 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
638 /* Same, for IDENTIFIER_CLASS_VALUE. */
641 /* Same, for IDENTIFIER_TYPE_VALUE. */
644 /* For each level (except not the global one),
645 a chain of BLOCK nodes for all the levels
646 that were entered and exited one level down. */
649 /* The BLOCK node for this level, if one has been preallocated.
650 If 0, the BLOCK is allocated (if needed) when the level is popped. */
653 /* The binding level which this one is contained in (inherits from). */
654 struct binding_level
*level_chain
;
656 /* List of decls in `names' that have incomplete
657 structure or union types. */
660 /* List of VAR_DECLS saved from a previous for statement.
661 These would be dead in ANSI-conforming code, but might
662 be referenced in ARM-era code. */
663 tree dead_vars_from_for
;
665 /* 1 for the level that holds the parameters of a function.
666 2 for the level that holds a class declaration.
667 3 for levels that hold parameter declarations. */
668 unsigned parm_flag
: 4;
670 /* 1 means make a BLOCK for this level regardless of all else.
671 2 for temporary binding contours created by the compiler. */
674 /* Nonzero if this level "doesn't exist" for tags. */
675 unsigned tag_transparent
: 1;
677 /* Nonzero if this level can safely have additional
678 cleanup-needing variables added to it. */
679 unsigned more_cleanups_ok
: 1;
680 unsigned have_cleanups
: 1;
682 /* Nonzero if this level is for storing the decls for template
683 parameters and generic decls; these decls will be discarded and
684 replaced with a TEMPLATE_DECL. */
685 unsigned pseudo_global
: 1;
687 /* This is set for a namespace binding level. */
688 unsigned namespace_p
: 1;
690 /* True if this level is that of a for-statement where we need to
691 worry about ambiguous (ARM or ANSI) scope rules. */
692 unsigned is_for_scope
: 1;
694 /* Two bits left for this word. */
696 #if defined(DEBUG_CP_BINDING_LEVELS)
697 /* Binding depth at which this level began. */
698 unsigned binding_depth
;
699 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
702 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
704 /* The (non-class) binding level currently in effect. */
706 static struct binding_level
*current_binding_level
;
708 /* The binding level of the current class, if any. */
710 static struct binding_level
*class_binding_level
;
712 /* The current (class or non-class) binding level currently in effect. */
714 #define inner_binding_level \
715 (class_binding_level ? class_binding_level : current_binding_level)
717 /* A chain of binding_level structures awaiting reuse. */
719 static struct binding_level
*free_binding_level
;
721 /* The outermost binding level, for names of file scope.
722 This is created when the compiler is started and exists
723 through the entire run. */
725 static struct binding_level
*global_binding_level
;
727 /* Binding level structures are initialized by copying this one. */
729 static struct binding_level clear_binding_level
;
731 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
733 static int keep_next_level_flag
;
735 #if defined(DEBUG_CP_BINDING_LEVELS)
736 static int binding_depth
= 0;
737 static int is_class_level
= 0;
744 for (i
= 0; i
< binding_depth
*2; i
++)
747 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
749 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
752 push_binding_level (newlevel
, tag_transparent
, keep
)
753 struct binding_level
*newlevel
;
754 int tag_transparent
, keep
;
756 /* Add this level to the front of the chain (stack) of levels that
758 *newlevel
= clear_binding_level
;
759 if (class_binding_level
)
761 newlevel
->level_chain
= class_binding_level
;
762 class_binding_level
= (struct binding_level
*)0;
766 newlevel
->level_chain
= current_binding_level
;
768 current_binding_level
= newlevel
;
769 newlevel
->tag_transparent
= tag_transparent
;
770 newlevel
->more_cleanups_ok
= 1;
771 newlevel
->keep
= keep
;
772 #if defined(DEBUG_CP_BINDING_LEVELS)
773 newlevel
->binding_depth
= binding_depth
;
775 fprintf (stderr
, "push %s level 0x%08x line %d\n",
776 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
779 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
785 if (class_binding_level
)
786 current_binding_level
= class_binding_level
;
788 if (global_binding_level
)
790 /* Cannot pop a level, if there are none left to pop. */
791 if (current_binding_level
== global_binding_level
)
792 my_friendly_abort (123);
794 /* Pop the current level, and free the structure for reuse. */
795 #if defined(DEBUG_CP_BINDING_LEVELS)
798 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
799 (is_class_level
) ? "class" : "block",
800 current_binding_level
, lineno
);
801 if (is_class_level
!= (current_binding_level
== class_binding_level
))
804 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
807 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
809 register struct binding_level
*level
= current_binding_level
;
810 current_binding_level
= current_binding_level
->level_chain
;
811 level
->level_chain
= free_binding_level
;
812 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
813 if (level
->binding_depth
!= binding_depth
)
815 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
816 free_binding_level
= level
;
818 class_binding_level
= current_binding_level
;
819 if (class_binding_level
->parm_flag
!= 2)
820 class_binding_level
= 0;
821 while (current_binding_level
->parm_flag
== 2)
822 current_binding_level
= current_binding_level
->level_chain
;
827 suspend_binding_level ()
829 if (class_binding_level
)
830 current_binding_level
= class_binding_level
;
832 if (global_binding_level
)
834 /* Cannot suspend a level, if there are none left to suspend. */
835 if (current_binding_level
== global_binding_level
)
836 my_friendly_abort (123);
838 /* Suspend the current level. */
839 #if defined(DEBUG_CP_BINDING_LEVELS)
842 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
843 (is_class_level
) ? "class" : "block",
844 current_binding_level
, lineno
);
845 if (is_class_level
!= (current_binding_level
== class_binding_level
))
848 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
851 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
853 current_binding_level
= current_binding_level
->level_chain
;
854 class_binding_level
= current_binding_level
;
855 if (class_binding_level
->parm_flag
!= 2)
856 class_binding_level
= 0;
857 while (current_binding_level
->parm_flag
== 2)
858 current_binding_level
= current_binding_level
->level_chain
;
863 resume_binding_level (b
)
864 struct binding_level
*b
;
866 /* Resuming binding levels is meant only for namespaces,
867 and those cannot nest into classes. */
868 my_friendly_assert(!class_binding_level
, 386);
869 /* Also, resuming a non-directly nested namespace is a no-no. */
870 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
871 current_binding_level
= b
;
872 #if defined(DEBUG_CP_BINDING_LEVELS)
873 b
->binding_depth
= binding_depth
;
875 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
876 (is_class_level
) ? "class" : "block", b
, lineno
);
879 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
882 /* Create a new `struct binding_level'. */
885 struct binding_level
*
886 make_binding_level ()
889 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
892 /* Nonzero if we are currently in the global binding level. */
897 return current_binding_level
== global_binding_level
;
900 /* Nonzero if we are currently in a toplevel binding level. This
901 means either the global binding level or a namespace in a toplevel
903 Since there are no non-toplevel namespace levels, this really
904 means any namespace or pseudo-global level. */
907 toplevel_bindings_p ()
909 return current_binding_level
->namespace_p
910 || current_binding_level
->pseudo_global
;
913 /* Nonzero if this is a namespace scope. */
916 namespace_bindings_p ()
918 return current_binding_level
->namespace_p
;
924 keep_next_level_flag
= 1;
927 /* Nonzero if the current level needs to have a BLOCK made. */
932 return (current_binding_level
->blocks
!= NULL_TREE
933 || current_binding_level
->keep
934 || current_binding_level
->names
!= NULL_TREE
935 || (current_binding_level
->tags
!= NULL_TREE
936 && !current_binding_level
->tag_transparent
));
939 /* Identify this binding level as a level of parameters. */
942 declare_parm_level ()
944 current_binding_level
->parm_flag
= 1;
948 declare_pseudo_global_level ()
950 current_binding_level
->pseudo_global
= 1;
954 declare_namespace_level ()
956 current_binding_level
->namespace_p
= 1;
960 pseudo_global_level_p ()
962 return current_binding_level
->pseudo_global
;
966 set_class_shadows (shadows
)
969 class_binding_level
->class_shadowed
= shadows
;
972 /* Enter a new binding level.
973 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
974 not for that of tags. */
977 pushlevel (tag_transparent
)
980 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
982 /* If this is the top level of a function,
983 just make sure that NAMED_LABELS is 0.
984 They should have been set to 0 at the end of the previous function. */
986 if (current_binding_level
== global_binding_level
)
987 my_friendly_assert (named_labels
== NULL_TREE
, 134);
989 /* Reuse or create a struct for this binding level. */
991 #if defined(DEBUG_CP_BINDING_LEVELS)
993 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
994 if (free_binding_level
)
995 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
997 newlevel
= free_binding_level
;
998 free_binding_level
= free_binding_level
->level_chain
;
1002 newlevel
= make_binding_level ();
1005 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
1006 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
1007 keep_next_level_flag
= 0;
1011 note_level_for_for ()
1013 current_binding_level
->is_for_scope
= 1;
1017 pushlevel_temporary (tag_transparent
)
1018 int tag_transparent
;
1020 pushlevel (tag_transparent
);
1021 current_binding_level
->keep
= 2;
1024 /* Note we don't call push_momentary() here. Otherwise, it would cause
1025 cleanups to be allocated on the momentary obstack, and they will be
1026 overwritten by the next statement. */
1028 expand_start_bindings (0);
1031 /* Exit a binding level.
1032 Pop the level off, and restore the state of the identifier-decl mappings
1033 that were in effect when this level was entered.
1035 If KEEP == 1, this level had explicit declarations, so
1036 and create a "block" (a BLOCK node) for the level
1037 to record its declarations and subblocks for symbol table output.
1039 If KEEP == 2, this level's subblocks go to the front,
1040 not the back of the current binding level. This happens,
1041 for instance, when code for constructors and destructors
1042 need to generate code at the end of a function which must
1043 be moved up to the front of the function.
1045 If FUNCTIONBODY is nonzero, this level is the body of a function,
1046 so create a block as if KEEP were set and also clear out all
1049 If REVERSE is nonzero, reverse the order of decls before putting
1050 them into the BLOCK. */
1053 poplevel (keep
, reverse
, functionbody
)
1059 /* The chain of decls was accumulated in reverse order.
1060 Put it into forward order, just for cleanliness. */
1062 int tmp
= functionbody
;
1063 int real_functionbody
= current_binding_level
->keep
== 2
1064 ? ((functionbody
= 0), tmp
) : functionbody
;
1065 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1066 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1067 tree block
= NULL_TREE
;
1069 int block_previously_created
;
1071 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1072 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1073 current_binding_level
->parm_flag
,
1074 current_binding_level
->keep
);
1076 if (current_binding_level
->keep
== 1)
1079 /* Get the decls in the order they were written.
1080 Usually current_binding_level->names is in reverse order.
1081 But parameter decls were previously put in forward order. */
1084 current_binding_level
->names
1085 = decls
= nreverse (current_binding_level
->names
);
1087 decls
= current_binding_level
->names
;
1089 /* Output any nested inline functions within this block
1090 if they weren't already output. */
1092 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1093 if (TREE_CODE (decl
) == FUNCTION_DECL
1094 && ! TREE_ASM_WRITTEN (decl
)
1095 && DECL_INITIAL (decl
) != NULL_TREE
1096 && TREE_ADDRESSABLE (decl
)
1097 && decl_function_context (decl
) == current_function_decl
)
1099 /* If this decl was copied from a file-scope decl
1100 on account of a block-scope extern decl,
1101 propagate TREE_ADDRESSABLE to the file-scope decl. */
1102 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1103 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1106 push_function_context ();
1107 output_inline_function (decl
);
1108 pop_function_context ();
1112 /* If there were any declarations or structure tags in that level,
1113 or if this level is a function body,
1114 create a BLOCK to record them for the life of this function. */
1117 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1118 if (block_previously_created
)
1119 block
= current_binding_level
->this_block
;
1120 else if (keep
== 1 || functionbody
)
1121 block
= make_node (BLOCK
);
1122 if (block
!= NULL_TREE
)
1124 if (block_previously_created
)
1126 if (decls
|| tags
|| subblocks
)
1128 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1130 warning ("internal compiler error: debugging info corrupted");
1132 BLOCK_VARS (block
) = decls
;
1133 BLOCK_TYPE_TAGS (block
) = tags
;
1135 /* We can have previous subblocks and new subblocks when
1136 doing fixup_gotos with complex cleanups. We chain the new
1137 subblocks onto the end of any pre-existing subblocks. */
1138 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1141 /* If we created the block earlier on, and we are just
1142 diddling it now, then it already should have a proper
1143 BLOCK_END_NOTE value associated with it. */
1147 BLOCK_VARS (block
) = decls
;
1148 BLOCK_TYPE_TAGS (block
) = tags
;
1149 BLOCK_SUBBLOCKS (block
) = subblocks
;
1150 /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
1151 remember_end_note (block
);
1155 /* In each subblock, record that this is its superior. */
1158 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1159 BLOCK_SUPERCONTEXT (link
) = block
;
1161 /* Clear out the meanings of the local variables of this level. */
1163 if (current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1)
1165 struct binding_level
*outer
= current_binding_level
->level_chain
;
1166 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1168 if (TREE_CODE (link
) == VAR_DECL
)
1169 DECL_DEAD_FOR_LOCAL (link
) = 1;
1171 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1174 /* Save declarations made in a 'for' statement so we can support pre-ANSI
1175 'for' scoping semantics. */
1177 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1179 tree id
= TREE_PURPOSE (link
);
1180 tree decl
= IDENTIFIER_LOCAL_VALUE (id
);
1182 if (decl
&& DECL_DEAD_FOR_LOCAL (decl
))
1184 /* In this case keep the dead for-decl visible,
1185 but remember what (if anything) it shadowed. */
1186 DECL_SHADOWED_FOR_VAR (decl
) = TREE_VALUE (link
);
1187 TREE_CHAIN (decl
) = outer
->dead_vars_from_for
;
1188 outer
->dead_vars_from_for
= decl
;
1191 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VALUE (link
);
1194 else /* Not special for scope. */
1196 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1198 if (DECL_NAME (link
) != NULL_TREE
)
1200 /* If the ident. was used or addressed via a local extern decl,
1201 don't forget that fact. */
1202 if (DECL_EXTERNAL (link
))
1204 if (TREE_USED (link
))
1205 TREE_USED (DECL_ASSEMBLER_NAME (link
)) = 1;
1206 if (TREE_ADDRESSABLE (link
))
1207 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1209 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1213 /* Restore all name-meanings of the outer levels
1214 that were shadowed by this level. */
1216 for (link
= current_binding_level
->shadowed
;
1217 link
; link
= TREE_CHAIN (link
))
1218 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1220 /* We first restore the regular decls and *then* the dead_vars_from_for
1221 to handle this case:
1225 for (int i; ; ) { ...} // i#2
1229 In this case, we want remove the binding for i#3, restoring
1230 that of i#2. Then we want to remove the binding for i#2,
1231 and restore that of i#1. */
1233 link
= current_binding_level
->dead_vars_from_for
;
1234 for (; link
!= NULL_TREE
; link
= TREE_CHAIN (link
))
1236 tree id
= DECL_NAME (link
);
1237 if (IDENTIFIER_LOCAL_VALUE (id
) == link
)
1238 IDENTIFIER_LOCAL_VALUE (id
) = DECL_SHADOWED_FOR_VAR (link
);
1241 for (link
= current_binding_level
->class_shadowed
;
1242 link
; link
= TREE_CHAIN (link
))
1243 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1244 for (link
= current_binding_level
->type_shadowed
;
1245 link
; link
= TREE_CHAIN (link
))
1246 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1249 /* If the level being exited is the top level of a function,
1250 check over all the labels. */
1254 /* If this is the top level block of a function,
1255 the vars are the function's parameters.
1256 Don't leave them in the BLOCK because they are
1257 found in the FUNCTION_DECL instead. */
1259 BLOCK_VARS (block
) = 0;
1261 /* Clear out the definitions of all label names,
1262 since their scopes end here. */
1264 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1266 register tree label
= TREE_VALUE (link
);
1268 if (DECL_INITIAL (label
) == NULL_TREE
)
1270 cp_error_at ("label `%D' used but not defined", label
);
1271 /* Avoid crashing later. */
1272 define_label (input_filename
, 1, DECL_NAME (label
));
1274 else if (warn_unused
&& !TREE_USED (label
))
1275 cp_warning_at ("label `%D' defined but not used", label
);
1276 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), NULL_TREE
);
1278 /* Put the labels into the "variables" of the
1279 top-level block, so debugger can see them. */
1280 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1281 BLOCK_VARS (block
) = label
;
1284 named_labels
= NULL_TREE
;
1287 /* Any uses of undefined labels now operate under constraints
1288 of next binding contour. */
1290 struct binding_level
*level_chain
;
1291 level_chain
= current_binding_level
->level_chain
;
1294 struct named_label_list
*labels
;
1295 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1296 if (labels
->binding_level
== current_binding_level
)
1298 labels
->binding_level
= level_chain
;
1299 labels
->names_in_scope
= level_chain
->names
;
1304 tmp
= current_binding_level
->keep
;
1306 pop_binding_level ();
1308 DECL_INITIAL (current_function_decl
) = block
;
1311 if (!block_previously_created
)
1312 current_binding_level
->blocks
1313 = chainon (current_binding_level
->blocks
, block
);
1315 /* If we did not make a block for the level just exited,
1316 any blocks made for inner levels
1317 (since they cannot be recorded as subblocks in that level)
1318 must be carried forward so they will later become subblocks
1319 of something else. */
1323 current_binding_level
->blocks
1324 = chainon (subblocks
, current_binding_level
->blocks
);
1326 current_binding_level
->blocks
1327 = chainon (current_binding_level
->blocks
, subblocks
);
1330 /* Take care of compiler's internal binding structures. */
1333 expand_end_bindings (getdecls (), keep
, 1);
1334 /* Each and every BLOCK node created here in `poplevel' is important
1335 (e.g. for proper debugging information) so if we created one
1336 earlier, mark it as "used". */
1338 TREE_USED (block
) = 1;
1339 block
= poplevel (keep
, reverse
, real_functionbody
);
1342 /* Each and every BLOCK node created here in `poplevel' is important
1343 (e.g. for proper debugging information) so if we created one
1344 earlier, mark it as "used". */
1346 TREE_USED (block
) = 1;
1350 /* Delete the node BLOCK from the current binding level.
1351 This is used for the block inside a stmt expr ({...})
1352 so that the block can be reinserted where appropriate. */
1355 delete_block (block
)
1359 if (current_binding_level
->blocks
== block
)
1360 current_binding_level
->blocks
= TREE_CHAIN (block
);
1361 for (t
= current_binding_level
->blocks
; t
;)
1363 if (TREE_CHAIN (t
) == block
)
1364 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1368 TREE_CHAIN (block
) = NULL_TREE
;
1369 /* Clear TREE_USED which is always set by poplevel.
1370 The flag is set again if insert_block is called. */
1371 TREE_USED (block
) = 0;
1374 /* Insert BLOCK at the end of the list of subblocks of the
1375 current binding level. This is used when a BIND_EXPR is expanded,
1376 to handle the BLOCK node inside the BIND_EXPR. */
1379 insert_block (block
)
1382 TREE_USED (block
) = 1;
1383 current_binding_level
->blocks
1384 = chainon (current_binding_level
->blocks
, block
);
1387 /* Set the BLOCK node for the innermost scope
1388 (the one we are currently in). */
1392 register tree block
;
1394 current_binding_level
->this_block
= block
;
1397 /* Do a pushlevel for class declarations. */
1402 register struct binding_level
*newlevel
;
1404 /* Reuse or create a struct for this binding level. */
1405 #if defined(DEBUG_CP_BINDING_LEVELS)
1407 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1408 if (free_binding_level
)
1409 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1411 newlevel
= free_binding_level
;
1412 free_binding_level
= free_binding_level
->level_chain
;
1416 newlevel
= make_binding_level ();
1419 #if defined(DEBUG_CP_BINDING_LEVELS)
1421 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1423 push_binding_level (newlevel
, 0, 0);
1425 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1426 class_binding_level
= current_binding_level
;
1427 class_binding_level
->parm_flag
= 2;
1428 /* We have just pushed into a new binding level. Now, fake out the rest
1429 of the compiler. Set the `current_binding_level' back to point to
1430 the most closely containing non-class binding level. */
1433 current_binding_level
= current_binding_level
->level_chain
;
1435 while (current_binding_level
->parm_flag
== 2);
1438 /* ...and a poplevel for class declarations. FORCE is used to force
1439 clearing out of CLASS_VALUEs after a class definition. */
1442 poplevel_class (force
)
1445 register struct binding_level
*level
= class_binding_level
;
1446 tree block
= NULL_TREE
;
1449 my_friendly_assert (level
!= 0, 354);
1451 decl_stack
= pop_stack_level (decl_stack
);
1452 for (shadowed
= level
->shadowed
; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
1453 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1454 /* If we're leaving a toplevel class, don't bother to do the setting
1455 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1456 shouldn't even be used when current_class_type isn't set, and second,
1457 if we don't touch it here, we're able to use the cache effect if the
1458 next time we're entering a class scope, it is the same class. */
1459 if (current_class_depth
!= 1 || force
)
1460 for (shadowed
= level
->class_shadowed
;
1462 shadowed
= TREE_CHAIN (shadowed
))
1463 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1465 /* Remember to save what IDENTIFIER's were bound in this scope so we
1466 can recover from cache misses. */
1468 previous_class_type
= current_class_type
;
1469 previous_class_values
= class_binding_level
->class_shadowed
;
1471 for (shadowed
= level
->type_shadowed
;
1473 shadowed
= TREE_CHAIN (shadowed
))
1474 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1476 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1477 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1478 class_binding_level
->parm_flag
,
1479 class_binding_level
->keep
);
1481 if (class_binding_level
->parm_flag
!= 2)
1482 class_binding_level
= (struct binding_level
*)0;
1484 /* Now, pop out of the binding level which we created up in the
1485 `pushlevel_class' routine. */
1486 #if defined(DEBUG_CP_BINDING_LEVELS)
1488 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1490 pop_binding_level ();
1495 /* For debugging. */
1496 static int no_print_functions
= 0;
1497 static int no_print_builtins
= 0;
1500 print_binding_level (lvl
)
1501 struct binding_level
*lvl
;
1505 fprintf (stderr
, " blocks=");
1506 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
1507 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
1508 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
1509 if (lvl
->tag_transparent
)
1510 fprintf (stderr
, " tag-transparent");
1511 if (lvl
->more_cleanups_ok
)
1512 fprintf (stderr
, " more-cleanups-ok");
1513 if (lvl
->have_cleanups
)
1514 fprintf (stderr
, " have-cleanups");
1515 fprintf (stderr
, "\n");
1518 fprintf (stderr
, " names:\t");
1519 /* We can probably fit 3 names to a line? */
1520 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1522 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1524 if (no_print_builtins
1525 && (TREE_CODE (t
) == TYPE_DECL
)
1526 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
1529 /* Function decls tend to have longer names. */
1530 if (TREE_CODE (t
) == FUNCTION_DECL
)
1537 fprintf (stderr
, "\n\t");
1540 print_node_brief (stderr
, "", t
, 0);
1541 if (t
== error_mark_node
)
1545 fprintf (stderr
, "\n");
1549 fprintf (stderr
, " tags:\t");
1551 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
1553 if (TREE_PURPOSE (t
) == NULL_TREE
)
1555 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1562 fprintf (stderr
, "\n\t");
1565 if (TREE_PURPOSE (t
) == NULL_TREE
)
1567 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
1568 fprintf (stderr
, ">");
1570 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1571 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1574 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
1575 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1576 fprintf (stderr
, ">");
1580 fprintf (stderr
, "\n");
1584 fprintf (stderr
, " shadowed:");
1585 for (t
= lvl
->shadowed
; t
; t
= TREE_CHAIN (t
))
1587 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1589 fprintf (stderr
, "\n");
1591 if (lvl
->class_shadowed
)
1593 fprintf (stderr
, " class-shadowed:");
1594 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
1596 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1598 fprintf (stderr
, "\n");
1600 if (lvl
->type_shadowed
)
1602 fprintf (stderr
, " type-shadowed:");
1603 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1605 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1607 fprintf (stderr
, "\n");
1612 print_other_binding_stack (stack
)
1613 struct binding_level
*stack
;
1615 struct binding_level
*level
;
1616 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
1618 fprintf (stderr
, "binding level ");
1619 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
1620 fprintf (stderr
, "\n");
1621 print_binding_level (level
);
1626 print_binding_stack ()
1628 struct binding_level
*b
;
1629 fprintf (stderr
, "current_binding_level=");
1630 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
1631 fprintf (stderr
, "\nclass_binding_level=");
1632 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
1633 fprintf (stderr
, "\nglobal_binding_level=");
1634 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
1635 fprintf (stderr
, "\n");
1636 if (class_binding_level
)
1638 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1639 if (b
== current_binding_level
)
1642 b
= class_binding_level
;
1644 b
= current_binding_level
;
1647 b
= current_binding_level
;
1648 print_other_binding_stack (b
);
1649 fprintf (stderr
, "global:\n");
1650 print_binding_level (global_binding_level
);
1653 /* Namespace binding access routines: The namespace_bindings field of
1654 the identifier is polymorphic, with three possible values:
1655 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1656 indicating the BINDING_VALUE of global_namespace. */
1658 /* Check whether the a binding for the name to scope is known.
1659 Assumes that the bindings of the name are already a list
1660 of bindings. Returns the binding found, or NULL_TREE. */
1663 find_binding (name
, scope
)
1667 tree iter
, prev
= NULL_TREE
;
1669 scope
= ORIGINAL_NAMESPACE (scope
);
1671 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
1672 iter
= TREE_CHAIN (iter
))
1674 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
1675 if (BINDING_SCOPE (iter
) == scope
)
1677 /* Move binding found to the fron of the list, so
1678 subsequent lookups will find it faster. */
1681 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
1682 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
1683 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
1692 /* Always returns a binding for name in scope. If the
1693 namespace_bindings is not a list, convert it to one first.
1694 If no binding is found, make a new one. */
1697 binding_for_name (name
, scope
)
1701 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1704 scope
= ORIGINAL_NAMESPACE (scope
);
1706 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
1708 /* Get rid of optimization for global scope. */
1709 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
1710 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
1711 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1713 if (b
&& (result
= find_binding (name
, scope
)))
1715 /* Not found, make a new permanent one. */
1716 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1717 result
= make_node (CPLUS_BINDING
);
1718 TREE_CHAIN (result
) = b
;
1719 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
1720 BINDING_SCOPE (result
) = scope
;
1721 BINDING_TYPE (result
) = NULL_TREE
;
1722 BINDING_VALUE (result
) = NULL_TREE
;
1727 /* Return the binding value for name in scope, considering that
1728 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
1731 namespace_binding (name
, scope
)
1735 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1738 if (scope
== NULL_TREE
)
1739 scope
= global_namespace
;
1740 if (TREE_CODE (b
) != CPLUS_BINDING
)
1741 return (scope
== global_namespace
) ? b
: NULL_TREE
;
1742 name
= find_binding (name
,scope
);
1743 if (name
== NULL_TREE
)
1745 return BINDING_VALUE (name
);
1748 /* Set the binding value for name in scope. If modifying the binding
1749 of global_namespace is attempted, try to optimize it. */
1752 set_namespace_binding (name
, scope
, val
)
1759 if (scope
== NULL_TREE
)
1760 scope
= global_namespace
;
1762 if (scope
== global_namespace
)
1764 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
1765 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
1767 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
1771 b
= binding_for_name (name
, scope
);
1772 BINDING_VALUE (b
) = val
;
1775 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
1776 select a name that is unique to this compilation unit. */
1779 push_namespace (name
)
1784 int implicit_use
= 0;
1786 if (!global_namespace
)
1788 /* This must be ::. */
1789 my_friendly_assert (name
== get_identifier ("::"), 377);
1794 /* The name of anonymous namespace is unique for the translation
1796 if (!anonymous_namespace_name
)
1797 anonymous_namespace_name
= get_file_function_name ('N');
1798 name
= anonymous_namespace_name
;
1799 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
1801 /* Reopening anonymous namespace. */
1805 else if (current_namespace
== global_namespace
1806 && name
== DECL_NAME (std_node
))
1813 /* Check whether this is an extended namespace definition. */
1814 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
1815 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
1818 if (DECL_NAMESPACE_ALIAS (d
))
1820 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
1821 d
, DECL_NAMESPACE_ALIAS (d
));
1822 d
= DECL_NAMESPACE_ALIAS (d
);
1829 /* Make a new namespace, binding the name to it. */
1830 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
1831 /* The global namespace is not pushed, and the global binding
1832 level is set elsewhere. */
1837 declare_namespace_level ();
1838 NAMESPACE_LEVEL (d
) = current_binding_level
;
1842 resume_binding_level (NAMESPACE_LEVEL (d
));
1845 do_using_directive (d
);
1846 /* Enter the name space. */
1847 current_namespace
= d
;
1850 /* Pop from the scope of the current namespace. */
1855 if (current_namespace
== global_namespace
)
1857 my_friendly_assert (in_std
>0, 980421);
1861 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
1862 /* The binding level is not popped, as it might be re-opened later. */
1863 suspend_binding_level ();
1866 /* Concatenate the binding levels of all namespaces. */
1869 cat_namespace_levels()
1873 struct binding_level
*b
;
1875 last
= NAMESPACE_LEVEL (global_namespace
) -> names
;
1876 /* The nested namespaces appear in the names list of their ancestors. */
1877 for (current
= last
; current
; current
= TREE_CHAIN (current
))
1879 if (TREE_CODE (current
) != NAMESPACE_DECL
1880 || DECL_NAMESPACE_ALIAS (current
))
1882 if (!DECL_LANG_SPECIFIC (current
))
1885 my_friendly_assert (current
== std_node
, 393);
1888 b
= NAMESPACE_LEVEL (current
);
1889 while (TREE_CHAIN (last
))
1890 last
= TREE_CHAIN (last
);
1891 TREE_CHAIN (last
) = NAMESPACE_LEVEL (current
) -> names
;
1895 /* Subroutines for reverting temporarily to top-level for instantiation
1896 of templates and such. We actually need to clear out the class- and
1897 local-value slots of all identifiers, so that only the global values
1898 are at all visible. Simply setting current_binding_level to the global
1899 scope isn't enough, because more binding levels may be pushed. */
1900 struct saved_scope
{
1901 struct binding_level
*old_binding_level
;
1904 struct saved_scope
*prev
;
1905 tree class_name
, class_type
;
1906 tree access_specifier
;
1908 struct binding_level
*class_bindings
;
1909 tree
*lang_base
, *lang_stack
, lang_name
;
1911 int minimal_parse_mode
;
1912 tree last_function_parms
;
1913 tree template_parms
;
1914 HOST_WIDE_INT processing_template_decl
;
1915 tree previous_class_type
, previous_class_values
;
1916 int processing_specialization
;
1917 int processing_explicit_instantiation
;
1919 static struct saved_scope
*current_saved_scope
;
1921 /* A chain of the binding vecs created by store_bindings. We create a
1922 whole bunch of these during compilation, on permanent_obstack, so we
1923 can't just throw them away. */
1924 static tree free_binding_vecs
;
1927 store_bindings (names
, old_bindings
)
1928 tree names
, old_bindings
;
1931 for (t
= names
; t
; t
= TREE_CHAIN (t
))
1933 tree binding
, t1
, id
;
1935 if (TREE_CODE (t
) == TREE_LIST
)
1936 id
= TREE_PURPOSE (t
);
1941 || (!IDENTIFIER_LOCAL_VALUE (id
)
1942 && !IDENTIFIER_CLASS_VALUE (id
)))
1945 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
1946 if (TREE_VEC_ELT (t1
, 0) == id
)
1949 if (free_binding_vecs
)
1951 binding
= free_binding_vecs
;
1952 free_binding_vecs
= TREE_CHAIN (free_binding_vecs
);
1955 binding
= make_tree_vec (4);
1959 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
1960 TREE_VEC_ELT (binding
, 0) = id
;
1961 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
1962 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_LOCAL_VALUE (id
);
1963 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
1964 IDENTIFIER_LOCAL_VALUE (id
) = NULL_TREE
;
1965 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
1967 TREE_CHAIN (binding
) = old_bindings
;
1968 old_bindings
= binding
;
1972 return old_bindings
;
1976 maybe_push_to_top_level (pseudo
)
1979 extern int current_lang_stacksize
;
1980 struct saved_scope
*s
1981 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
1982 struct binding_level
*b
= inner_binding_level
;
1983 tree old_bindings
= NULL_TREE
;
1985 if (current_function_decl
)
1986 push_cp_function_context (NULL_TREE
);
1988 if (previous_class_type
)
1989 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
1991 /* Have to include global_binding_level, because class-level decls
1992 aren't listed anywhere useful. */
1993 for (; b
; b
= b
->level_chain
)
1997 /* Template IDs are inserted into the global level. If they were
1998 inserted into namespace level, finish_file wouldn't find them
1999 when doing pending instantiations. Therefore, don't stop at
2000 namespace level, but continue until :: . */
2001 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
2004 old_bindings
= store_bindings (b
->names
, old_bindings
);
2005 /* We also need to check class_shadowed to save class-level type
2006 bindings, since pushclass doesn't fill in b->names. */
2007 if (b
->parm_flag
== 2)
2008 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2010 /* Unwind type-value slots back to top level. */
2011 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2012 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2015 s
->old_binding_level
= current_binding_level
;
2016 current_binding_level
= b
;
2018 s
->old_namespace
= current_namespace
;
2019 s
->class_name
= current_class_name
;
2020 s
->class_type
= current_class_type
;
2021 s
->access_specifier
= current_access_specifier
;
2022 s
->function_decl
= current_function_decl
;
2023 s
->class_bindings
= class_binding_level
;
2024 s
->lang_stack
= current_lang_stack
;
2025 s
->lang_base
= current_lang_base
;
2026 s
->lang_stacksize
= current_lang_stacksize
;
2027 s
->lang_name
= current_lang_name
;
2028 s
->minimal_parse_mode
= minimal_parse_mode
;
2029 s
->last_function_parms
= last_function_parms
;
2030 s
->template_parms
= current_template_parms
;
2031 s
->processing_template_decl
= processing_template_decl
;
2032 s
->previous_class_type
= previous_class_type
;
2033 s
->previous_class_values
= previous_class_values
;
2034 s
->processing_specialization
= processing_specialization
;
2035 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
2037 current_class_name
= current_class_type
= NULL_TREE
;
2038 current_function_decl
= NULL_TREE
;
2039 class_binding_level
= (struct binding_level
*)0;
2040 current_lang_stacksize
= 10;
2041 current_lang_stack
= current_lang_base
2042 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
2043 current_lang_name
= lang_name_cplusplus
;
2044 strict_prototype
= strict_prototypes_lang_cplusplus
;
2045 named_labels
= NULL_TREE
;
2046 shadowed_labels
= NULL_TREE
;
2047 minimal_parse_mode
= 0;
2048 previous_class_type
= previous_class_values
= NULL_TREE
;
2049 processing_specialization
= 0;
2050 processing_explicit_instantiation
= 0;
2051 current_template_parms
= NULL_TREE
;
2052 processing_template_decl
= 0;
2053 current_namespace
= global_namespace
;
2055 s
->prev
= current_saved_scope
;
2056 s
->old_bindings
= old_bindings
;
2057 current_saved_scope
= s
;
2059 push_obstacks (&permanent_obstack
, &permanent_obstack
);
2063 push_to_top_level ()
2065 maybe_push_to_top_level (0);
2069 pop_from_top_level ()
2071 extern int current_lang_stacksize
;
2072 struct saved_scope
*s
= current_saved_scope
;
2075 /* Clear out class-level bindings cache. */
2076 if (previous_class_type
)
2079 previous_class_type
= NULL_TREE
;
2084 current_binding_level
= s
->old_binding_level
;
2085 current_saved_scope
= s
->prev
;
2086 for (t
= s
->old_bindings
; t
; )
2089 tree id
= TREE_VEC_ELT (t
, 0);
2092 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2093 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VEC_ELT (t
, 2);
2094 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2097 TREE_CHAIN (save
) = free_binding_vecs
;
2098 free_binding_vecs
= save
;
2100 current_namespace
= s
->old_namespace
;
2101 current_class_name
= s
->class_name
;
2102 current_class_type
= s
->class_type
;
2103 current_access_specifier
= s
->access_specifier
;
2104 current_function_decl
= s
->function_decl
;
2105 class_binding_level
= s
->class_bindings
;
2106 free (current_lang_base
);
2107 current_lang_base
= s
->lang_base
;
2108 current_lang_stack
= s
->lang_stack
;
2109 current_lang_name
= s
->lang_name
;
2110 current_lang_stacksize
= s
->lang_stacksize
;
2111 if (current_lang_name
== lang_name_cplusplus
)
2112 strict_prototype
= strict_prototypes_lang_cplusplus
;
2113 else if (current_lang_name
== lang_name_c
)
2114 strict_prototype
= strict_prototypes_lang_c
;
2115 minimal_parse_mode
= s
->minimal_parse_mode
;
2116 last_function_parms
= s
->last_function_parms
;
2117 current_template_parms
= s
->template_parms
;
2118 processing_template_decl
= s
->processing_template_decl
;
2119 previous_class_type
= s
->previous_class_type
;
2120 previous_class_values
= s
->previous_class_values
;
2121 processing_specialization
= s
->processing_specialization
;
2122 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2126 if (current_function_decl
)
2127 pop_cp_function_context (NULL_TREE
);
2130 /* Push a definition of struct, union or enum tag "name".
2131 into binding_level "b". "type" should be the type node,
2132 We assume that the tag "name" is not already defined.
2134 Note that the definition may really be just a forward reference.
2135 In that case, the TYPE_SIZE will be a NULL_TREE.
2137 C++ gratuitously puts all these tags in the name space. */
2139 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2140 record the shadowed value for this binding contour. TYPE is
2141 the type that ID maps to. */
2144 set_identifier_type_value_with_scope (id
, type
, b
)
2147 struct binding_level
*b
;
2149 if (!b
->namespace_p
)
2151 /* Shadow the marker, not the real thing, so that the marker
2152 gets restored later. */
2153 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2155 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2159 tree binding
= binding_for_name (id
, current_namespace
);
2160 BINDING_TYPE (binding
) = type
;
2161 /* Store marker instead of real type. */
2162 type
= global_type_node
;
2164 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2167 /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
2170 set_identifier_type_value (id
, type
)
2174 set_identifier_type_value_with_scope (id
, type
, inner_binding_level
);
2178 set_identifier_local_value_with_scope (id
, val
, b
)
2180 struct binding_level
*b
;
2183 my_friendly_assert (! b
->namespace_p
, 980716);
2185 oldlocal
= IDENTIFIER_LOCAL_VALUE (id
);
2186 b
->shadowed
= tree_cons (id
, oldlocal
, b
->shadowed
);
2187 IDENTIFIER_LOCAL_VALUE (id
) = val
;
2191 set_identifier_local_value (id
, val
)
2194 set_identifier_local_value_with_scope (id
, val
, current_binding_level
);
2197 /* Return the type associated with id. */
2200 identifier_type_value (id
)
2203 /* There is no type with that name, anywhere. */
2204 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2206 /* This is not the type marker, but the real thing. */
2207 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2208 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2209 /* Have to search for it. It must be on the global level, now.
2210 Ask lookup_name not to return non-types. */
2211 id
= lookup_name_real (id
, 2, 1, 0);
2213 return TREE_TYPE (id
);
2217 /* Pop off extraneous binding levels left over due to syntax errors.
2219 We don't pop past namespaces, as they might be valid. */
2224 #ifdef DEBUG_CP_BINDING_LEVELS
2225 fprintf (stderr
, "XXX entering pop_everything ()\n");
2227 while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
2229 if (class_binding_level
)
2230 pop_nested_class (1);
2234 #ifdef DEBUG_CP_BINDING_LEVELS
2235 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2239 /* The type TYPE is being declared. If it is a class template, or a
2240 specialization of a class template, do any processing required and
2241 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2242 being declared a friend. B is the binding level at which this TYPE
2245 Returns the TYPE_DECL for TYPE, which may have been altered by this
2249 maybe_process_template_type_declaration (type
, globalize
, b
)
2252 struct binding_level
* b
;
2254 tree decl
= TYPE_NAME (type
);
2256 if (processing_template_parmlist
)
2257 /* You can't declare a new template type in a template parameter
2258 list. But, you can declare a non-template type:
2260 template <class A*> struct S;
2262 is a forward-declaration of `A'. */
2266 maybe_check_template_type (type
);
2268 my_friendly_assert (IS_AGGR_TYPE (type
)
2269 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2272 if (/* If !GLOBALIZE then we are looking at a definition.
2273 It may not be a primary template. (For example, in:
2276 struct S1 { class S2 {}; }
2278 we have to push_template_decl for S2.) */
2279 (processing_template_decl
&& !globalize
)
2280 /* If we are declaring a friend template class, we will
2281 have GLOBALIZE set, since something like:
2289 declares S2 to be at global scope. */
2290 || PROCESSING_REAL_TEMPLATE_DECL_P ())
2292 /* This may change after the call to
2293 push_template_decl_real, but we want the original value. */
2294 tree name
= DECL_NAME (decl
);
2296 decl
= push_template_decl_real (decl
, globalize
);
2297 /* If the current binding level is the binding level for the
2298 template parameters (see the comment in
2299 begin_template_parm_list) and the enclosing level is a class
2300 scope, and we're not looking at a friend, push the
2301 declaration of the member class into the class scope. In the
2302 friend case, push_template_decl will already have put the
2303 friend into global scope, if appropriate. */
2304 if (TREE_CODE (type
) != ENUMERAL_TYPE
2305 && !globalize
&& b
->pseudo_global
2306 && b
->level_chain
->parm_flag
== 2)
2308 pushdecl_with_scope (CLASSTYPE_TI_TEMPLATE (type
),
2310 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2311 /* Put this tag on the list of tags for the class, since
2312 that won't happen below because B is not the class
2313 binding level, but is instead the pseudo-global level. */
2314 b
->level_chain
->tags
=
2315 saveable_tree_cons (name
, type
, b
->level_chain
->tags
);
2316 TREE_NONLOCAL_FLAG (type
) = 1;
2317 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2318 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2326 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2327 Normally put it into the inner-most non-tag-transparent scope,
2328 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2329 The latter is needed for implicit declarations. */
2332 pushtag (name
, type
, globalize
)
2336 register struct binding_level
*b
;
2340 b
= inner_binding_level
;
2341 while (b
->tag_transparent
2342 || (globalize
&& b
->parm_flag
== 2))
2345 if (toplevel_bindings_p ())
2346 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2348 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2352 context
= type
? TYPE_CONTEXT (type
) : NULL_TREE
;
2355 tree cs
= current_scope ();
2359 else if (cs
!= NULL_TREE
2360 && TREE_CODE_CLASS (TREE_CODE (cs
)) == 't')
2361 /* When declaring a friend class of a local class, we want
2362 to inject the newly named class into the scope
2363 containing the local class, not the namespace scope. */
2364 context
= hack_decl_function_context (get_type_decl (cs
));
2367 c_decl
= TREE_CODE (context
) == FUNCTION_DECL
2368 ? context
: TYPE_MAIN_DECL (context
);
2371 context
= current_namespace
;
2373 /* Do C++ gratuitous typedefing. */
2374 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2376 register tree d
= NULL_TREE
;
2377 int newdecl
= 0, in_class
= 0;
2379 if ((b
->pseudo_global
&& b
->level_chain
->parm_flag
== 2)
2380 || b
->parm_flag
== 2)
2383 d
= lookup_nested_type (type
, c_decl
);
2388 d
= build_decl (TYPE_DECL
, name
, type
);
2389 if (current_lang_name
== lang_name_java
)
2390 TYPE_FOR_JAVA (type
) = 1;
2391 SET_DECL_ARTIFICIAL (d
);
2393 set_identifier_type_value_with_scope (name
, type
, b
);
2396 d
= TYPE_MAIN_DECL (d
);
2398 TYPE_NAME (type
) = d
;
2399 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2401 d
= maybe_process_template_type_declaration (type
,
2404 if (b
->parm_flag
== 2)
2406 pushdecl_class_level (d
);
2407 if (newdecl
&& !PROCESSING_REAL_TEMPLATE_DECL_P ())
2408 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2409 class. But if it's a member template class, we
2410 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2412 finish_member_declaration (d
);
2415 d
= pushdecl_with_scope (d
, b
);
2419 if (ANON_AGGRNAME_P (name
))
2420 DECL_IGNORED_P (d
) = 1;
2422 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2423 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2424 if (!uses_template_parms (type
))
2425 DECL_ASSEMBLER_NAME (d
)
2426 = get_identifier (build_overload_name (type
, 1, 1));
2429 if (b
->parm_flag
== 2)
2431 TREE_NONLOCAL_FLAG (type
) = 1;
2432 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2433 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2437 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2438 /* Use the canonical TYPE_DECL for this node. */
2439 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2442 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2443 will be the tagged type we just added to the current
2444 binding level. This fake NULL-named TYPE_DECL node helps
2445 dwarfout.c to know when it needs to output a
2446 representation of a tagged type, and it also gives us a
2447 convenient place to record the "scope start" address for
2450 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2451 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2455 /* Counter used to create anonymous type names. */
2457 static int anon_cnt
= 0;
2459 /* Return an IDENTIFIER which can be used as a name for
2460 anonymous structs and unions. */
2467 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2468 return get_identifier (buf
);
2471 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2472 This keeps dbxout from getting confused. */
2477 register struct binding_level
*b
;
2479 static int last_cnt
= 0;
2481 /* Fast out if no new anon names were declared. */
2482 if (last_cnt
== anon_cnt
)
2485 b
= current_binding_level
;
2486 while (b
->tag_transparent
)
2491 /* A NULL purpose means we have already processed all tags
2492 from here to the end of the list. */
2493 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2495 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2496 TREE_PURPOSE (tags
) = NULL_TREE
;
2497 tags
= TREE_CHAIN (tags
);
2499 last_cnt
= anon_cnt
;
2502 /* Subroutine of duplicate_decls: return truthvalue of whether
2503 or not types of these decls match.
2505 For C++, we must compare the parameter list so that `int' can match
2506 `int&' in a parameter position, but `int&' is not confused with
2510 decls_match (newdecl
, olddecl
)
2511 tree newdecl
, olddecl
;
2515 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2516 /* If the two DECLs are not even the same kind of thing, we're not
2517 interested in their types. */
2520 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2522 tree f1
= TREE_TYPE (newdecl
);
2523 tree f2
= TREE_TYPE (olddecl
);
2524 tree p1
= TYPE_ARG_TYPES (f1
);
2525 tree p2
= TYPE_ARG_TYPES (f2
);
2527 if (DECL_REAL_CONTEXT (newdecl
) != DECL_REAL_CONTEXT (olddecl
)
2528 && ! (DECL_LANGUAGE (newdecl
) == lang_c
2529 && DECL_LANGUAGE (olddecl
) == lang_c
))
2532 /* When we parse a static member function definition,
2533 we put together a FUNCTION_DECL which thinks its type
2534 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2536 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
2537 revert_static_member_fn (&newdecl
, &f1
, &p1
);
2538 else if (TREE_CODE (f2
) == METHOD_TYPE
2539 && DECL_STATIC_FUNCTION_P (newdecl
))
2540 revert_static_member_fn (&olddecl
, &f2
, &p2
);
2542 /* Here we must take care of the case where new default
2543 parameters are specified. Also, warn if an old
2544 declaration becomes ambiguous because default
2545 parameters may cause the two to be ambiguous. */
2546 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2548 if (TREE_CODE (f1
) == OFFSET_TYPE
)
2549 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
2551 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
2555 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2557 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
2560 types_match
= self_promoting_args_p (p1
);
2561 if (p1
== void_list_node
)
2562 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2564 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
2565 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
2567 types_match
= self_promoting_args_p (p2
);
2568 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2571 types_match
= compparms (p1
, p2
);
2576 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2578 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2579 DECL_TEMPLATE_PARMS (olddecl
)))
2582 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2585 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
2586 DECL_TEMPLATE_RESULT (newdecl
));
2590 if (TREE_TYPE (newdecl
) == error_mark_node
)
2591 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
2592 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
2593 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
2594 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
2597 types_match
= comptypes (TREE_TYPE (newdecl
),
2598 TREE_TYPE (olddecl
),
2599 COMPARE_REDECLARATION
);
2605 /* If NEWDECL is `static' and an `extern' was seen previously,
2606 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2607 information about previous usage as an `extern'.)
2609 Note that this does not apply to the C++ case of declaring
2610 a variable `extern const' and then later `const'.
2612 Don't complain about built-in functions, since they are beyond
2613 the user's control. */
2616 warn_extern_redeclared_static (newdecl
, olddecl
)
2617 tree newdecl
, olddecl
;
2621 static char *explicit_extern_static_warning
2622 = "`%D' was declared `extern' and later `static'";
2623 static char *implicit_extern_static_warning
2624 = "`%D' was declared implicitly `extern' and later `static'";
2626 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2629 name
= DECL_ASSEMBLER_NAME (newdecl
);
2630 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
2632 /* It's okay to redeclare an ANSI built-in function as static,
2633 or to declare a non-ANSI built-in function as anything. */
2634 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
2635 && olddecl
!= NULL_TREE
2636 && TREE_CODE (olddecl
) == FUNCTION_DECL
2637 && (DECL_BUILT_IN (olddecl
)
2638 || DECL_BUILT_IN_NONANSI (olddecl
))))
2640 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
2641 ? implicit_extern_static_warning
2642 : explicit_extern_static_warning
, newdecl
);
2643 if (olddecl
!= NULL_TREE
)
2644 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
2649 /* Handle when a new declaration NEWDECL has the same name as an old
2650 one OLDDECL in the same binding contour. Prints an error message
2653 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2654 Otherwise, return 0. */
2657 duplicate_decls (newdecl
, olddecl
)
2658 tree newdecl
, olddecl
;
2660 extern struct obstack permanent_obstack
;
2661 unsigned olddecl_uid
= DECL_UID (olddecl
);
2662 int olddecl_friend
= 0, types_match
= 0;
2663 int new_defines_function
= 0;
2665 if (newdecl
== olddecl
)
2668 types_match
= decls_match (newdecl
, olddecl
);
2670 /* If either the type of the new decl or the type of the old decl is an
2671 error_mark_node, then that implies that we have already issued an
2672 error (earlier) for some bogus type specification, and in that case,
2673 it is rather pointless to harass the user with yet more error message
2674 about the same declaration, so just pretend the types match here. */
2675 if (TREE_TYPE (newdecl
) == error_mark_node
2676 || TREE_TYPE (olddecl
) == error_mark_node
)
2679 /* Check for redeclaration and other discrepancies. */
2680 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2681 && DECL_ARTIFICIAL (olddecl
)
2682 && (DECL_BUILT_IN (olddecl
) || DECL_BUILT_IN_NONANSI (olddecl
)))
2684 /* If you declare a built-in or predefined function name as static,
2685 the old definition is overridden, but optionally warn this was a
2686 bad choice of name. Ditto for overloads. */
2687 if (! TREE_PUBLIC (newdecl
)
2688 || (TREE_CODE (newdecl
) == FUNCTION_DECL
2689 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
)))
2692 cp_warning ("shadowing %s function `%#D'",
2693 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2695 /* Discard the old built-in function. */
2698 else if (! types_match
)
2700 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
2702 /* If the built-in is not ansi, then programs can override
2703 it even globally without an error. */
2704 if (! DECL_BUILT_IN (olddecl
))
2705 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2709 cp_error ("declaration of `%#D'", newdecl
);
2710 cp_error ("conflicts with built-in declaration `%#D'",
2716 cp_warning ("declaration of `%#D'", newdecl
);
2717 cp_warning ("conflicts with built-in declaration `%#D'",
2721 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
2723 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
2724 && TREE_CODE (newdecl
) != TYPE_DECL
2725 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
2726 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
2727 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
2728 && TREE_CODE (olddecl
) != TYPE_DECL
2729 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
2730 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2733 /* We do nothing special here, because C++ does such nasty
2734 things with TYPE_DECLs. Instead, just let the TYPE_DECL
2735 get shadowed, and know that if we need to find a TYPE_DECL
2736 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
2737 slot of the identifier. */
2741 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
2742 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
2743 || (TREE_CODE (olddecl
) == FUNCTION_DECL
2744 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
2747 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
2748 if (TREE_CODE (olddecl
) == TREE_LIST
)
2749 olddecl
= TREE_VALUE (olddecl
);
2750 cp_error_at ("previous declaration of `%#D'", olddecl
);
2752 /* New decl is completely inconsistent with the old one =>
2753 tell caller to replace the old one. */
2757 else if (!types_match
)
2759 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2761 /* The name of a class template may not be declared to refer to
2762 any other template, class, function, object, namespace, value,
2763 or type in the same scope. */
2764 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
2765 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2767 cp_error ("declaration of template `%#D'", newdecl
);
2768 cp_error_at ("conflicts with previous declaration `%#D'",
2771 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
2772 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
2773 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
2774 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
2775 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2776 DECL_TEMPLATE_PARMS (olddecl
)))
2778 cp_error ("new declaration `%#D'", newdecl
);
2779 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2783 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2785 if (DECL_LANGUAGE (newdecl
) == lang_c
2786 && DECL_LANGUAGE (olddecl
) == lang_c
)
2788 cp_error ("declaration of C function `%#D' conflicts with",
2790 cp_error_at ("previous declaration `%#D' here", olddecl
);
2792 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
2793 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
2795 cp_error ("new declaration `%#D'", newdecl
);
2796 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2802 /* Already complained about this, so don't do so again. */
2803 else if (current_class_type
== NULL_TREE
2804 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
2806 cp_error ("conflicting types for `%#D'", newdecl
);
2807 cp_error_at ("previous declaration as `%#D'", olddecl
);
2810 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2811 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
2812 && (!DECL_TEMPLATE_INFO (newdecl
)
2813 || (DECL_TI_TEMPLATE (newdecl
)
2814 != DECL_TI_TEMPLATE (olddecl
))))
2815 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2816 && (!DECL_TEMPLATE_INFO (olddecl
)
2817 || (DECL_TI_TEMPLATE (olddecl
)
2818 != DECL_TI_TEMPLATE (newdecl
))))))
2819 /* It's OK to have a template specialization and a non-template
2820 with the same type, or to have specializations of two
2821 different templates with the same type. Note that if one is a
2822 specialization, and the other is an instantiation of the same
2823 template, that we do not exit at this point. That situation
2824 can occur if we instantiate a template class, and then
2825 specialize one of its methods. This situation is legal, but
2826 the declarations must be merged in the usual way. */
2828 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2829 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
2830 && !DECL_USE_TEMPLATE (newdecl
))
2831 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
2832 && !DECL_USE_TEMPLATE (olddecl
))))
2833 /* One of the declarations is a template instantiation, and the
2834 other is not a template at all. That's OK. */
2836 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
2837 && DECL_NAMESPACE_ALIAS (newdecl
)
2838 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
2839 /* Redeclaration of namespace alias, ignore it. */
2843 char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
2846 cp_error (errmsg
, newdecl
);
2847 if (DECL_NAME (olddecl
) != NULL_TREE
)
2848 cp_error_at ((DECL_INITIAL (olddecl
)
2849 && namespace_bindings_p ())
2850 ? "`%#D' previously defined here"
2851 : "`%#D' previously declared here", olddecl
);
2853 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2854 && DECL_INITIAL (olddecl
) != NULL_TREE
2855 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
2856 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
2858 /* Prototype decl follows defn w/o prototype. */
2859 cp_warning_at ("prototype for `%#D'", newdecl
);
2860 cp_warning_at ("follows non-prototype definition here", olddecl
);
2862 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2863 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
2865 /* extern "C" int foo ();
2866 int foo () { bar (); }
2868 if (current_lang_stack
== current_lang_base
)
2869 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
2872 cp_error_at ("previous declaration of `%#D' with %L linkage",
2873 olddecl
, DECL_LANGUAGE (olddecl
));
2874 cp_error ("conflicts with new declaration with %L linkage",
2875 DECL_LANGUAGE (newdecl
));
2879 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
2881 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2883 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
2884 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
2887 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
2888 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
2890 for (; t1
&& t1
!= void_list_node
;
2891 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
2892 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
2894 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
2899 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2901 cp_pedwarn_at ("after previous specification in `%#D'",
2907 cp_error ("default argument given for parameter %d of `%#D'",
2909 cp_error_at ("after previous specification in `%#D'",
2914 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
2915 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
2917 cp_warning ("`%#D' was used before it was declared inline",
2919 cp_warning_at ("previous non-inline declaration here",
2925 /* If new decl is `static' and an `extern' was seen previously,
2927 warn_extern_redeclared_static (newdecl
, olddecl
);
2929 /* We have committed to returning 1 at this point. */
2930 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2932 /* Now that functions must hold information normally held
2933 by field decls, there is extra work to do so that
2934 declaration information does not get destroyed during
2936 if (DECL_VINDEX (olddecl
))
2937 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
2938 if (DECL_CONTEXT (olddecl
))
2939 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2940 if (DECL_CLASS_CONTEXT (olddecl
))
2941 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
2942 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
2943 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2944 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
2945 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2946 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
2947 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
2948 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
2949 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
2951 /* Optionally warn about more than one declaration for the same
2952 name, but don't warn about a function declaration followed by a
2954 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
2955 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
2956 /* Don't warn about extern decl followed by definition. */
2957 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
2958 /* Don't warn about friends, let add_friend take care of it. */
2959 && ! DECL_FRIEND_P (newdecl
))
2961 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
2962 cp_warning_at ("previous declaration of `%D'", olddecl
);
2966 /* Deal with C++: must preserve virtual function table size. */
2967 if (TREE_CODE (olddecl
) == TYPE_DECL
)
2969 register tree newtype
= TREE_TYPE (newdecl
);
2970 register tree oldtype
= TREE_TYPE (olddecl
);
2972 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
2973 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
2975 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
2976 CLASSTYPE_FRIEND_CLASSES (newtype
)
2977 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
2981 /* Copy all the DECL_... slots specified in the new decl
2982 except for any that we copy here from the old type. */
2983 DECL_MACHINE_ATTRIBUTES (newdecl
)
2984 = merge_machine_decl_attributes (olddecl
, newdecl
);
2986 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2988 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl
),
2989 DECL_TEMPLATE_RESULT (olddecl
)))
2990 cp_error ("invalid redeclaration of %D", newdecl
);
2991 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
2992 DECL_TEMPLATE_PARMS (olddecl
) = DECL_TEMPLATE_PARMS (newdecl
);
2993 if (DECL_TEMPLATE_INFO (newdecl
))
2994 DECL_TEMPLATE_INFO (olddecl
) = DECL_TEMPLATE_INFO (newdecl
);
2995 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
2996 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
2997 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3004 /* Automatically handles default parameters. */
3005 tree oldtype
= TREE_TYPE (olddecl
);
3008 /* Make sure we put the new type in the same obstack as the old one. */
3010 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
3013 push_obstacks_nochange ();
3014 end_temporary_allocation ();
3017 /* Merge the data types specified in the two decls. */
3018 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3020 if (TREE_CODE (newdecl
) == VAR_DECL
)
3021 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3022 /* Do this after calling `common_type' so that default
3023 parameters don't confuse us. */
3024 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3025 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3026 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3028 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3029 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3030 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3031 TYPE_RAISES_EXCEPTIONS (oldtype
));
3033 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3034 && DECL_SOURCE_LINE (olddecl
) != 0
3036 && ! compexcepttypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
3038 cp_pedwarn ("declaration of `%D' throws different exceptions",
3040 cp_pedwarn_at ("previous declaration here", olddecl
);
3043 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3045 /* Lay the type out, unless already done. */
3046 if (newtype
!= canonical_type_variant (oldtype
)
3047 && TREE_TYPE (newdecl
) != error_mark_node
3048 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3049 layout_type (TREE_TYPE (newdecl
));
3051 if ((TREE_CODE (newdecl
) == VAR_DECL
3052 || TREE_CODE (newdecl
) == PARM_DECL
3053 || TREE_CODE (newdecl
) == RESULT_DECL
3054 || TREE_CODE (newdecl
) == FIELD_DECL
3055 || TREE_CODE (newdecl
) == TYPE_DECL
)
3056 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3057 layout_decl (newdecl
, 0);
3059 /* Merge the type qualifiers. */
3060 if (TREE_READONLY (newdecl
))
3061 TREE_READONLY (olddecl
) = 1;
3062 if (TREE_THIS_VOLATILE (newdecl
))
3063 TREE_THIS_VOLATILE (olddecl
) = 1;
3065 /* Merge the initialization information. */
3066 if (DECL_INITIAL (newdecl
) == NULL_TREE
3067 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3069 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3070 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3071 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3072 if (DECL_LANG_SPECIFIC (newdecl
)
3073 && DECL_LANG_SPECIFIC (olddecl
))
3074 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3077 /* Merge the section attribute.
3078 We want to issue an error if the sections conflict but that must be
3079 done later in decl_attributes since we are called before attributes
3081 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3082 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3084 /* Keep the old rtl since we can safely use it, unless it's the
3085 call to abort() used for abstract virtuals. */
3086 if ((DECL_LANG_SPECIFIC (olddecl
)
3087 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3088 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
3089 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3093 /* If cannot merge, then use the new type and qualifiers,
3094 and don't preserve the old rtl. */
3097 /* Clean out any memory we had of the old declaration. */
3098 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3100 TREE_VALUE (oldstatic
) = error_mark_node
;
3102 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3103 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3104 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3105 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3108 /* Merge the storage class information. */
3109 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3110 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3111 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3112 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3113 if (! DECL_EXTERNAL (olddecl
))
3114 DECL_EXTERNAL (newdecl
) = 0;
3116 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3118 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3119 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3120 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3121 /* Don't really know how much of the language-specific
3122 values we should copy from old to new. */
3123 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3124 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3125 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3126 if (DECL_TEMPLATE_INFO (newdecl
) == NULL_TREE
)
3128 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3129 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
3131 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3134 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3136 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3137 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3139 /* If newdecl is not a specialization, then it is not a
3140 template-related function at all. And that means that we
3141 shoud have exited above, returning 0. */
3142 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3145 if (TREE_USED (olddecl
))
3146 /* From [temp.expl.spec]:
3148 If a template, a member template or the member of a class
3149 template is explicitly specialized then that
3150 specialization shall be declared before the first use of
3151 that specialization that would cause an implicit
3152 instantiation to take place, in every translation unit in
3153 which such a use occurs. */
3154 cp_error ("explicit specialization of %D after first use",
3157 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3159 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3161 /* If either decl says `inline', this fn is inline, unless its
3162 definition was passed already. */
3163 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3164 DECL_INLINE (olddecl
) = 1;
3165 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3169 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3170 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3171 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3173 if (! types_match
|| new_defines_function
)
3175 /* These need to be copied so that the names are available. */
3176 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3177 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3179 if (new_defines_function
)
3180 /* If defining a function declared with other language
3181 linkage, use the previously declared language linkage. */
3182 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3185 /* If redeclaring a builtin function, and not a definition,
3186 it stays built in. */
3187 if (DECL_BUILT_IN (olddecl
))
3189 DECL_BUILT_IN (newdecl
) = 1;
3190 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3191 /* If we're keeping the built-in definition, keep the rtl,
3192 regardless of declaration matches. */
3193 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3196 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3198 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3199 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3200 /* Previously saved insns go together with
3201 the function's previous definition. */
3202 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3203 /* Don't clear out the arguments if we're redefining a function. */
3204 if (DECL_ARGUMENTS (olddecl
))
3205 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3207 if (DECL_LANG_SPECIFIC (olddecl
))
3208 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
3211 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3213 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3216 /* Now preserve various other info from the definition. */
3217 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3218 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3219 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3220 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3222 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3225 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3226 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3228 function_size
= sizeof (struct tree_decl
);
3230 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3231 (char *) olddecl
+ sizeof (struct tree_common
),
3232 function_size
- sizeof (struct tree_common
));
3234 /* Can we safely free the storage used by newdecl? */
3236 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3237 & ~ obstack_alignment_mask (&permanent_obstack))
3239 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3241 /* If newdecl is a template instantiation, it is possible that
3242 the following sequence of events has occurred:
3244 o A friend function was declared in a class template. The
3245 class template was instantiated.
3247 o The instantiation of the friend declaration was
3248 recorded on the instantiation list, and is newdecl.
3250 o Later, however, instantiate_class_template called pushdecl
3251 on the newdecl to perform name injection. But, pushdecl in
3252 turn called duplicate_decls when it discovered that another
3253 declaration of a global function with the same name already
3256 o Here, in duplicate_decls, we decided to clobber newdecl.
3258 If we're going to do that, we'd better make sure that
3259 olddecl, and not newdecl, is on the list of
3260 instantiations so that if we try to do the instantiation
3261 again we won't get the clobbered declaration. */
3263 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3264 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3266 for (; decls
; decls
= TREE_CHAIN (decls
))
3267 if (TREE_VALUE (decls
) == newdecl
)
3268 TREE_VALUE (decls
) = olddecl
;
3271 if (((char *)newdecl
+ ROUND (function_size
) == (char *)nl
3272 && ((char *)newdecl
+ ROUND (function_size
)
3273 + ROUND (sizeof (struct lang_decl
))
3274 == obstack_next_free (&permanent_obstack
)))
3275 || ((char *)newdecl
+ ROUND (function_size
)
3276 == obstack_next_free (&permanent_obstack
)))
3278 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3279 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3280 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3282 obstack_free (&permanent_obstack
, newdecl
);
3284 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3286 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3288 /* Save these lang_decls that would otherwise be lost. */
3289 extern tree free_lang_decl_chain
;
3290 tree free_lang_decl
= (tree
) ol
;
3292 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3295 TREE_CHAIN (free_lang_decl
) = free_lang_decl_chain
;
3296 free_lang_decl_chain
= free_lang_decl
;
3300 /* Storage leak. */;
3306 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3307 (char *) olddecl
+ sizeof (struct tree_common
),
3308 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3309 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3312 DECL_UID (olddecl
) = olddecl_uid
;
3314 DECL_FRIEND_P (olddecl
) = 1;
3316 /* NEWDECL contains the merged attribute lists.
3317 Update OLDDECL to be the same. */
3318 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3323 /* Record a decl-node X as belonging to the current lexical scope.
3324 Check for errors (such as an incompatible declaration for the same
3325 name already seen in the same scope).
3327 Returns either X or an old decl for the same name.
3328 If an old decl is returned, it may have been smashed
3329 to agree with what X says. */
3336 register tree name
= DECL_ASSEMBLER_NAME (x
);
3337 register struct binding_level
*b
= current_binding_level
;
3339 if (current_function_decl
&& x
!= current_function_decl
3340 /* A local declaration for a function doesn't constitute nesting. */
3341 && (TREE_CODE (x
) != FUNCTION_DECL
|| DECL_INITIAL (x
))
3342 /* Don't change DECL_CONTEXT of virtual methods. */
3343 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3344 && ! DECL_CONTEXT (x
))
3345 DECL_CONTEXT (x
) = current_function_decl
;
3346 if (!DECL_CONTEXT (x
))
3347 DECL_CONTEXT (x
) = FROB_CONTEXT (current_namespace
);
3349 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3350 compiler wants to use. */
3351 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3352 || TREE_CODE (x
) == NAMESPACE_DECL
|| TREE_CODE (x
) == TEMPLATE_TYPE_PARM
3353 || TREE_CODE (x
) == TEMPLATE_TEMPLATE_PARM
)
3354 name
= DECL_NAME (x
);
3359 /* Not needed...see below. */
3363 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3364 name
= TREE_OPERAND (name
, 0);
3366 /* Namespace-scoped variables are not found in the current level. */
3367 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
))
3368 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3370 t
= lookup_name_current_level (name
);
3371 if (t
== error_mark_node
)
3373 /* error_mark_node is 0 for a while during initialization! */
3375 cp_error_at ("`%#D' used prior to declaration", x
);
3378 else if (t
!= NULL_TREE
)
3381 /* This is turned off until I have time to do it right (bpk). */
3382 /* With the code below that uses it... */
3383 file
= DECL_SOURCE_FILE (t
);
3384 line
= DECL_SOURCE_LINE (t
);
3386 if (TREE_CODE (t
) == PARM_DECL
)
3388 if (DECL_CONTEXT (t
) == NULL_TREE
)
3389 fatal ("parse errors have confused me too much");
3391 /* Check for duplicate params. */
3392 if (duplicate_decls (x
, t
))
3395 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3396 || DECL_FUNCTION_TEMPLATE_P (x
))
3397 && is_overloaded_fn (t
))
3398 /* Don't do anything just yet. */;
3399 else if (t
== wchar_decl_node
)
3401 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3402 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3404 /* Throw away the redeclaration. */
3407 else if (TREE_CODE (t
) != TREE_CODE (x
))
3409 if (duplicate_decls (x
, t
))
3412 else if (duplicate_decls (x
, t
))
3415 /* This is turned off until I have time to do it right (bpk). */
3417 /* Also warn if they did a prototype with `static' on it, but
3418 then later left the `static' off. */
3419 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3421 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3426 cp_warning ("`static' missing from declaration of `%D'",
3428 warning_with_file_and_line (file
, line
,
3429 "previous declaration of `%s'",
3430 decl_as_string (t
, 0));
3433 /* Now fix things so it'll do what they expect. */
3434 if (current_function_decl
)
3435 TREE_PUBLIC (current_function_decl
) = 0;
3437 /* Due to interference in memory reclamation (X may be
3438 obstack-deallocated at this point), we must guard against
3439 one really special case. [jason: This should be handled
3440 by start_function] */
3441 if (current_function_decl
== x
)
3442 current_function_decl
= t
;
3444 if (TREE_CODE (t
) == TYPE_DECL
)
3445 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3446 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3447 check_default_args (t
);
3451 else if (DECL_MAIN_P (x
))
3453 /* A redeclaration of main, but not a duplicate of the
3458 This function shall not be overloaded. */
3459 cp_error_at ("invalid redeclaration of `%D'", t
);
3460 cp_error ("as `%D'", x
);
3461 /* We don't try to push this declaration since that
3467 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3469 t
= push_overloaded_decl (x
, 1);
3470 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3473 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3474 return push_overloaded_decl (x
, 0);
3476 /* If declaring a type as a typedef, copy the type (unless we're
3477 at line 0), and install this TYPE_DECL as the new type's typedef
3478 name. See the extensive comment in ../c-decl.c (pushdecl). */
3479 if (TREE_CODE (x
) == TYPE_DECL
)
3481 tree type
= TREE_TYPE (x
);
3482 if (DECL_SOURCE_LINE (x
) == 0)
3484 if (TYPE_NAME (type
) == 0)
3485 TYPE_NAME (type
) = x
;
3487 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3488 /* We don't want to copy the type when all we're
3489 doing is making a TYPE_DECL for the purposes of
3491 && (!TYPE_NAME (type
)
3492 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3494 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
3496 DECL_ORIGINAL_TYPE (x
) = type
;
3497 type
= build_type_copy (type
);
3498 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3499 TYPE_NAME (type
) = x
;
3500 TREE_TYPE (x
) = type
;
3505 if (type
!= error_mark_node
3507 && TYPE_IDENTIFIER (type
))
3508 set_identifier_type_value_with_scope (DECL_NAME (x
), type
, b
);
3511 /* Multiple external decls of the same identifier ought to match.
3513 We get warnings about inline functions where they are defined.
3514 We get warnings about other functions from push_overloaded_decl.
3516 Avoid duplicate warnings where they are used. */
3517 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3521 if (IDENTIFIER_NAMESPACE_VALUE (name
) != NULL_TREE
3522 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name
))
3523 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name
))))
3524 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
3529 /* If different sort of thing, we already gave an error. */
3530 && TREE_CODE (decl
) == TREE_CODE (x
)
3531 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
3533 cp_pedwarn ("type mismatch with previous external decl", x
);
3534 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
3538 /* This name is new in its binding level.
3539 Install the new declaration and return it. */
3540 if (namespace_bindings_p ())
3542 /* Install a global value. */
3544 /* If the first global decl has external linkage,
3545 warn if we later see static one. */
3546 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
3547 TREE_PUBLIC (name
) = 1;
3549 /* Don't install an artificial TYPE_DECL if we already have
3550 another _DECL with that name. */
3551 if (TREE_CODE (x
) != TYPE_DECL
3553 || ! DECL_ARTIFICIAL (x
))
3555 if (TREE_CODE (x
) == FUNCTION_DECL
)
3557 ((IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
3558 || (IDENTIFIER_GLOBAL_VALUE (name
) == x
), 378);
3559 SET_IDENTIFIER_NAMESPACE_VALUE (name
, x
);
3562 /* Don't forget if the function was used via an implicit decl. */
3563 if (IDENTIFIER_IMPLICIT_DECL (name
)
3564 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
3567 /* Don't forget if its address was taken in that way. */
3568 if (IDENTIFIER_IMPLICIT_DECL (name
)
3569 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
3570 TREE_ADDRESSABLE (x
) = 1;
3572 /* Warn about mismatches against previous implicit decl. */
3573 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
3574 /* If this real decl matches the implicit, don't complain. */
3575 && ! (TREE_CODE (x
) == FUNCTION_DECL
3576 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
3578 ("`%D' was previously implicitly declared to return `int'", x
);
3580 /* If new decl is `static' and an `extern' was seen previously,
3582 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
3583 warn_extern_redeclared_static (x
, t
);
3587 /* Here to install a non-global value. */
3588 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
3589 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
3591 /* Don't install an artificial TYPE_DECL if we already have
3592 another _DECL with that name. */
3593 if (TREE_CODE (x
) != TYPE_DECL
3595 || ! DECL_ARTIFICIAL (x
))
3596 set_identifier_local_value_with_scope (name
, x
, b
);
3598 /* If this is a TYPE_DECL, push it into the type value slot. */
3599 if (TREE_CODE (x
) == TYPE_DECL
)
3600 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
), b
);
3602 /* Clear out any TYPE_DECL shadowed by a namespace so that
3603 we won't think this is a type. The C struct hack doesn't
3604 go through namespaces. */
3605 if (TREE_CODE (x
) == NAMESPACE_DECL
)
3606 set_identifier_type_value_with_scope (name
, NULL_TREE
, b
);
3608 /* If this is an extern function declaration, see if we
3609 have a global definition or declaration for the function. */
3610 if (oldlocal
== NULL_TREE
3611 && DECL_EXTERNAL (x
)
3612 && oldglobal
!= NULL_TREE
3613 && TREE_CODE (x
) == FUNCTION_DECL
3614 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
3616 /* We have one. Their types must agree. */
3617 if (decls_match (x
, oldglobal
))
3621 cp_warning ("extern declaration of `%#D' doesn't match", x
);
3622 cp_warning_at ("global declaration `%#D'", oldglobal
);
3625 /* If we have a local external declaration,
3626 and no file-scope declaration has yet been seen,
3627 then if we later have a file-scope decl it must not be static. */
3628 if (oldlocal
== NULL_TREE
3629 && oldglobal
== NULL_TREE
3630 && DECL_EXTERNAL (x
)
3633 TREE_PUBLIC (name
) = 1;
3636 if (DECL_FROM_INLINE (x
))
3637 /* Inline decls shadow nothing. */;
3639 /* Warn if shadowing an argument at the top level of the body. */
3640 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
3641 && TREE_CODE (oldlocal
) == PARM_DECL
3642 && TREE_CODE (x
) != PARM_DECL
)
3644 /* Go to where the parms should be and see if we
3646 struct binding_level
*b
= current_binding_level
->level_chain
;
3652 if (b
->parm_flag
== 1)
3653 cp_error ("declaration of `%#D' shadows a parameter", name
);
3655 else if (warn_shadow
&& oldlocal
!= NULL_TREE
&& b
->is_for_scope
3656 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
3658 warning ("variable `%s' shadows local",
3659 IDENTIFIER_POINTER (name
));
3660 cp_warning_at (" this is the shadowed declaration", oldlocal
);
3662 /* Maybe warn if shadowing something else. */
3663 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
3664 /* No shadow warnings for internally generated vars. */
3665 && ! DECL_ARTIFICIAL (x
)
3666 /* No shadow warnings for vars made for inlining. */
3667 && ! DECL_FROM_INLINE (x
))
3669 char *warnstring
= NULL
;
3671 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
3672 warnstring
= "declaration of `%s' shadows a parameter";
3673 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
3674 && current_class_ptr
3675 && !TREE_STATIC (name
))
3676 warnstring
= "declaration of `%s' shadows a member of `this'";
3677 else if (oldlocal
!= NULL_TREE
)
3678 warnstring
= "declaration of `%s' shadows previous local";
3679 else if (oldglobal
!= NULL_TREE
)
3680 /* XXX shadow warnings in outer-more namespaces */
3681 warnstring
= "declaration of `%s' shadows global declaration";
3684 warning (warnstring
, IDENTIFIER_POINTER (name
));
3686 /* Check to see if decl redeclares a template parameter. */
3687 if (oldlocal
&& (current_class_type
|| current_function_decl
)
3688 && current_template_parms
)
3690 if (decl_template_parm_p (oldlocal
))
3692 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3693 cp_error_at (" previously declared here `%#D'", oldlocal
);
3698 if (TREE_CODE (x
) == FUNCTION_DECL
)
3699 check_default_args (x
);
3701 /* Keep count of variables in this level with incomplete type. */
3702 if (TREE_CODE (x
) == VAR_DECL
3703 && TREE_TYPE (x
) != error_mark_node
3704 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3705 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
3706 /* RTTI TD entries are created while defining the type_info. */
3707 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
3708 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
3709 b
->incomplete
= tree_cons (NULL_TREE
, x
, b
->incomplete
);
3712 /* Put decls on list in reverse order.
3713 We will reverse them later if necessary. */
3714 TREE_CHAIN (x
) = b
->names
;
3716 if (! (b
!= global_binding_level
|| TREE_PERMANENT (x
)))
3717 my_friendly_abort (124);
3722 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3723 caller to set DECL_CONTEXT properly. */
3726 pushdecl_with_scope (x
, level
)
3728 struct binding_level
*level
;
3730 register struct binding_level
*b
;
3731 tree function_decl
= current_function_decl
;
3733 current_function_decl
= NULL_TREE
;
3734 if (level
->parm_flag
== 2)
3736 b
= class_binding_level
;
3737 class_binding_level
= level
;
3738 pushdecl_class_level (x
);
3739 class_binding_level
= b
;
3743 b
= current_binding_level
;
3744 current_binding_level
= level
;
3746 current_binding_level
= b
;
3748 current_function_decl
= function_decl
;
3752 /* Like pushdecl, only it places X in the current namespace,
3756 pushdecl_namespace_level (x
)
3759 register struct binding_level
*b
= inner_binding_level
;
3762 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
3764 /* Now, the type_shadowed stack may screw us. Munge it so it does
3766 if (TREE_CODE (x
) == TYPE_DECL
)
3768 tree name
= DECL_NAME (x
);
3770 tree
*ptr
= (tree
*)0;
3771 for (; b
!= global_binding_level
; b
= b
->level_chain
)
3773 tree shadowed
= b
->type_shadowed
;
3774 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3775 if (TREE_PURPOSE (shadowed
) == name
)
3777 ptr
= &TREE_VALUE (shadowed
);
3778 /* Can't break out of the loop here because sometimes
3779 a binding level will have duplicate bindings for
3780 PT names. It's gross, but I haven't time to fix it. */
3783 newval
= TREE_TYPE (x
);
3784 if (ptr
== (tree
*)0)
3786 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3787 up here if this is changed to an assertion. --KR */
3788 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
3798 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3802 pushdecl_top_level (x
)
3805 tree cur_namespace
= current_namespace
;
3806 current_namespace
= global_namespace
;
3807 x
= pushdecl_namespace_level (x
);
3808 current_namespace
= cur_namespace
;
3812 /* Make the declaration of X appear in CLASS scope. */
3815 pushdecl_class_level (x
)
3818 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3819 scope looks for the pre-mangled name. */
3820 register tree name
= DECL_NAME (x
);
3824 if (TYPE_BEING_DEFINED (current_class_type
))
3826 /* A name N used in a class S shall refer to the same declaration
3827 in its context and when re-evaluated in the completed scope of S.
3828 Types, enums, and static vars are checked here; other
3829 members are checked in finish_struct. */
3830 tree icv
= IDENTIFIER_CLASS_VALUE (name
);
3831 tree ilv
= IDENTIFIER_LOCAL_VALUE (name
);
3834 && flag_optional_diags
3835 /* Don't complain about inherited names. */
3836 && id_in_current_class (name
)
3837 /* Or shadowed tags. */
3838 && !(DECL_DECLARES_TYPE_P (icv
)
3839 && DECL_CONTEXT (icv
) == current_class_type
))
3841 cp_pedwarn ("declaration of identifier `%D' as `%#D'", name
, x
);
3842 cp_pedwarn_at ("conflicts with previous use in class as `%#D'",
3846 /* Check to see if decl redeclares a template parameter. */
3847 if (ilv
&& ! decls_match (ilv
, x
)
3848 && (current_class_type
|| current_function_decl
)
3849 && current_template_parms
)
3851 if (decl_template_parm_p (ilv
))
3853 cp_error ("re-using name of template parameter `%T' in this scope", name
);
3854 cp_error_at (" previously declared here `%#D'", ilv
);
3859 push_class_level_binding (name
, x
);
3860 if (TREE_CODE (x
) == TYPE_DECL
)
3862 set_identifier_type_value (name
, TREE_TYPE (x
));
3868 /* This function is used to push the mangled decls for nested types into
3869 the appropriate scope. Previously pushdecl_top_level was used, but that
3870 is incorrect for members of local classes. */
3873 pushdecl_nonclass_level (x
)
3876 struct binding_level
*b
= current_binding_level
;
3878 my_friendly_assert (b
->parm_flag
!= 2, 180);
3881 /* Get out of template binding levels */
3882 while (b
->pseudo_global
)
3886 pushdecl_with_scope (x
, b
);
3890 /* Make the declaration(s) of X appear in CLASS scope
3891 under the name NAME. */
3894 push_class_level_binding (name
, x
)
3898 /* The class_binding_level will be NULL if x is a template
3899 parameter name in a member template. */
3900 if (!class_binding_level
)
3903 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3904 && purpose_member (name
, class_binding_level
->class_shadowed
))
3907 maybe_push_cache_obstack ();
3908 class_binding_level
->class_shadowed
3909 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
3910 class_binding_level
->class_shadowed
);
3912 IDENTIFIER_CLASS_VALUE (name
) = x
;
3913 obstack_ptr_grow (&decl_obstack
, x
);
3916 /* Insert another USING_DECL into the current binding level,
3917 returning this declaration. If this is a redeclaration,
3918 do nothing and return NULL_TREE. */
3921 push_using_decl (scope
, name
)
3927 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
3928 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
3929 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
3930 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
3934 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
3935 DECL_INITIAL (decl
) = scope
;
3936 TREE_CHAIN (decl
) = current_binding_level
->usings
;
3937 current_binding_level
->usings
= decl
;
3941 /* Add namespace to using_directives. Return NULL_TREE if nothing was
3942 changed (i.e. there was already a directive), or the fresh
3943 TREE_LIST otherwise. */
3946 push_using_directive (used
)
3949 tree ud
= current_binding_level
->using_directives
;
3950 tree iter
, ancestor
;
3952 /* Check if we already have this. */
3953 if (purpose_member (used
, ud
) != NULL_TREE
)
3956 /* Recursively add all namespaces used. */
3957 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
3958 push_using_directive (TREE_PURPOSE (iter
));
3960 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
3961 ud
= current_binding_level
->using_directives
;
3962 ud
= perm_tree_cons (used
, ancestor
, ud
);
3963 current_binding_level
->using_directives
= ud
;
3967 /* DECL is a FUNCTION_DECL which may have other definitions already in
3968 place. We get around this by making the value of the identifier point
3969 to a list of all the things that want to be referenced by that name. It
3970 is then up to the users of that name to decide what to do with that
3973 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3974 slot. It is dealt with the same way.
3976 The value returned may be a previous declaration if we guessed wrong
3977 about what language DECL should belong to (C or C++). Otherwise,
3978 it's always DECL (and never something that's not a _DECL). */
3981 push_overloaded_decl (decl
, forgettable
)
3985 tree orig_name
= DECL_NAME (decl
);
3987 int doing_global
= (namespace_bindings_p () || ! forgettable
);
3991 old
= namespace_binding (orig_name
, DECL_CONTEXT (decl
));
3992 if (old
&& TREE_CODE (old
) == FUNCTION_DECL
3993 && DECL_ARTIFICIAL (old
)
3994 && (DECL_BUILT_IN (old
) || DECL_BUILT_IN_NONANSI (old
)))
3996 if (duplicate_decls (decl
, old
))
4003 old
= IDENTIFIER_LOCAL_VALUE (orig_name
);
4005 if (! purpose_member (orig_name
, current_binding_level
->shadowed
))
4007 current_binding_level
->shadowed
4008 = tree_cons (orig_name
, old
, current_binding_level
->shadowed
);
4015 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4017 tree t
= TREE_TYPE (old
);
4018 if (IS_AGGR_TYPE (t
) && warn_shadow
4019 && (! DECL_IN_SYSTEM_HEADER (decl
)
4020 || ! DECL_IN_SYSTEM_HEADER (old
)))
4021 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4024 else if (is_overloaded_fn (old
))
4028 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4029 if (decl
== OVL_CURRENT (tmp
)
4030 || duplicate_decls (decl
, OVL_CURRENT (tmp
)))
4031 return OVL_CURRENT (tmp
);
4035 cp_error_at ("previous non-function declaration `%#D'", old
);
4036 cp_error ("conflicts with function declaration `%#D'", decl
);
4041 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4043 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4044 old
= ovl_cons (old
, NULL_TREE
);
4045 old
= ovl_cons (decl
, old
);
4048 /* orig_name is not ambiguous. */
4052 set_namespace_binding (orig_name
, current_namespace
, old
);
4054 IDENTIFIER_LOCAL_VALUE (orig_name
) = old
;
4059 /* Generate an implicit declaration for identifier FUNCTIONID
4060 as a function of type int (). Print a warning if appropriate. */
4063 implicitly_declare (functionid
)
4067 int temp
= allocation_temporary_p ();
4069 push_obstacks_nochange ();
4071 /* Save the decl permanently so we can warn if definition follows.
4072 In ANSI C, warn_implicit is usually false, so the saves little space.
4073 But in C++, it's usually true, hence the extra code. */
4074 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
4075 end_temporary_allocation ();
4077 /* We used to reuse an old implicit decl here,
4078 but this loses with inline functions because it can clobber
4079 the saved decl chains. */
4080 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4082 DECL_EXTERNAL (decl
) = 1;
4083 TREE_PUBLIC (decl
) = 1;
4085 /* ANSI standard says implicit declarations are in the innermost block.
4086 So we record the decl in the standard fashion. */
4088 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4091 /* Only one warning per identifier. */
4092 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4094 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4097 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4104 /* Return zero if the declaration NEWDECL is valid
4105 when the declaration OLDDECL (assumed to be for the same name)
4106 has already been seen.
4107 Otherwise return an error message format string with a %s
4108 where the identifier should go. */
4111 redeclaration_error_message (newdecl
, olddecl
)
4112 tree newdecl
, olddecl
;
4114 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4116 /* Because C++ can put things into name space for free,
4117 constructs like "typedef struct foo { ... } foo"
4118 would look like an erroneous redeclaration. */
4119 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4122 return "redefinition of `%#D'";
4124 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4126 /* If this is a pure function, its olddecl will actually be
4127 the original initialization to `0' (which we force to call
4128 abort()). Don't complain about redefinition in this case. */
4129 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
4132 /* If both functions come from different namespaces, this is not
4133 a redeclaration - this is a conflict with a used function. */
4134 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4135 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4136 return "`%D' conflicts with used function";
4138 /* We'll complain about linkage mismatches in
4139 warn_extern_redeclared_static. */
4141 /* Defining the same name twice is no good. */
4142 if (DECL_INITIAL (olddecl
) != NULL_TREE
4143 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4145 if (DECL_NAME (olddecl
) == NULL_TREE
)
4146 return "`%#D' not declared in class";
4148 return "redefinition of `%#D'";
4152 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4154 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4155 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4156 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4157 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4158 && TYPE_SIZE (TREE_TYPE (newdecl
))
4159 && TYPE_SIZE (TREE_TYPE (olddecl
))))
4160 return "redefinition of `%#D'";
4163 else if (toplevel_bindings_p ())
4165 /* Objects declared at top level: */
4166 /* If at least one is a reference, it's ok. */
4167 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4169 /* Reject two definitions. */
4170 return "redefinition of `%#D'";
4174 /* Objects declared with block scope: */
4175 /* Reject two definitions, and reject a definition
4176 together with an external reference. */
4177 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4178 return "redeclaration of `%#D'";
4183 /* Get the LABEL_DECL corresponding to identifier ID as a label.
4184 Create one if none exists so far for the current function.
4185 This function is called for both label definitions and label references. */
4191 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
4193 if (current_function_decl
== NULL_TREE
)
4195 error ("label `%s' referenced outside of any function",
4196 IDENTIFIER_POINTER (id
));
4200 if ((decl
== NULL_TREE
4201 || DECL_SOURCE_LINE (decl
) == 0)
4202 && (named_label_uses
== NULL
4203 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4204 || named_label_uses
->label_decl
!= decl
))
4206 struct named_label_list
*new_ent
;
4208 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
4209 new_ent
->label_decl
= decl
;
4210 new_ent
->names_in_scope
= current_binding_level
->names
;
4211 new_ent
->binding_level
= current_binding_level
;
4212 new_ent
->lineno_o_goto
= lineno
;
4213 new_ent
->filename_o_goto
= input_filename
;
4214 new_ent
->next
= named_label_uses
;
4215 named_label_uses
= new_ent
;
4218 /* Use a label already defined or ref'd with this name. */
4219 if (decl
!= NULL_TREE
)
4221 /* But not if it is inherited and wasn't declared to be inheritable. */
4222 if (DECL_CONTEXT (decl
) != current_function_decl
4223 && ! C_DECLARED_LABEL_FLAG (decl
))
4224 return shadow_label (id
);
4228 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4230 /* Make sure every label has an rtx. */
4233 /* A label not explicitly declared must be local to where it's ref'd. */
4234 DECL_CONTEXT (decl
) = current_function_decl
;
4236 DECL_MODE (decl
) = VOIDmode
;
4238 /* Say where one reference is to the label,
4239 for the sake of the error if it is not defined. */
4240 DECL_SOURCE_LINE (decl
) = lineno
;
4241 DECL_SOURCE_FILE (decl
) = input_filename
;
4243 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4245 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
4246 named_label_uses
->label_decl
= decl
;
4251 /* Make a label named NAME in the current function,
4252 shadowing silently any that may be inherited from containing functions
4253 or containing scopes.
4255 Note that valid use, if the label being shadowed
4256 comes from another scope in the same function,
4257 requires calling declare_nonlocal_label right away. */
4263 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
4265 if (decl
!= NULL_TREE
)
4267 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4268 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4271 return lookup_label (name
);
4274 /* Define a label, specifying the location in the source file.
4275 Return the LABEL_DECL node for the label, if the definition is valid.
4276 Otherwise return 0. */
4279 define_label (filename
, line
, name
)
4286 if (minimal_parse_mode
)
4288 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4289 decl
= build_decl (LABEL_DECL
, name
, void_type_node
);
4291 DECL_SOURCE_LINE (decl
) = line
;
4292 DECL_SOURCE_FILE (decl
) = filename
;
4297 decl
= lookup_label (name
);
4299 /* After labels, make any new cleanups go into their
4300 own new (temporary) binding contour. */
4301 current_binding_level
->more_cleanups_ok
= 0;
4303 /* If label with this name is known from an outer context, shadow it. */
4304 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) != current_function_decl
)
4306 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
4307 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
4308 decl
= lookup_label (name
);
4311 if (name
== get_identifier ("wchar_t"))
4312 cp_pedwarn ("label named wchar_t");
4314 if (DECL_INITIAL (decl
) != NULL_TREE
)
4316 cp_error ("duplicate label `%D'", decl
);
4321 struct named_label_list
*uses
, *prev
;
4324 /* Mark label as having been defined. */
4325 DECL_INITIAL (decl
) = error_mark_node
;
4326 /* Say where in the source. */
4327 DECL_SOURCE_FILE (decl
) = filename
;
4328 DECL_SOURCE_LINE (decl
) = line
;
4331 uses
= named_label_uses
;
4332 while (uses
!= NULL
)
4333 if (uses
->label_decl
== decl
)
4335 struct binding_level
*b
= current_binding_level
;
4338 tree new_decls
= b
->names
;
4339 tree old_decls
= (b
== uses
->binding_level
)
4340 ? uses
->names_in_scope
: NULL_TREE
;
4341 while (new_decls
!= old_decls
)
4343 if (TREE_CODE (new_decls
) == VAR_DECL
4344 /* Don't complain about crossing initialization
4345 of internal entities. They can't be accessed,
4346 and they should be cleaned up
4347 by the time we get to the label. */
4348 && ! DECL_ARTIFICIAL (new_decls
)
4349 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4350 && DECL_INITIAL (new_decls
) != error_mark_node
)
4351 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4355 cp_error ("jump to label `%D'", decl
);
4356 error_with_file_and_line (uses
->filename_o_goto
,
4357 uses
->lineno_o_goto
,
4361 cp_error_at (" crosses initialization of `%#D'",
4364 new_decls
= TREE_CHAIN (new_decls
);
4366 if (b
== uses
->binding_level
)
4372 prev
->next
= uses
->next
;
4374 named_label_uses
= uses
->next
;
4383 current_function_return_value
= NULL_TREE
;
4390 struct binding_level
*level
;
4391 struct cp_switch
*next
;
4394 static struct cp_switch
*switch_stack
;
4400 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4401 p
->level
= current_binding_level
;
4402 p
->next
= switch_stack
;
4409 switch_stack
= switch_stack
->next
;
4412 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4413 /* XXX Note decl is never actually used. (bpk) */
4416 define_case_label ()
4418 tree cleanup
= last_cleanup_this_contour ();
4419 struct binding_level
*b
= current_binding_level
;
4424 static int explained
= 0;
4425 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4426 warning ("where case label appears here");
4429 warning ("(enclose actions of previous case statements requiring");
4430 warning ("destructors in their own binding contours.)");
4435 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4437 tree new_decls
= b
->names
;
4438 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4440 if (TREE_CODE (new_decls
) == VAR_DECL
4441 /* Don't complain about crossing initialization
4442 of internal entities. They can't be accessed,
4443 and they should be cleaned up
4444 by the time we get to the label. */
4445 && ! DECL_ARTIFICIAL (new_decls
)
4446 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4447 && DECL_INITIAL (new_decls
) != error_mark_node
)
4448 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4451 error ("jump to case label");
4453 cp_error_at (" crosses initialization of `%#D'",
4459 /* After labels, make any new cleanups go into their
4460 own new (temporary) binding contour. */
4462 current_binding_level
->more_cleanups_ok
= 0;
4463 current_function_return_value
= NULL_TREE
;
4466 /* Return the list of declarations of the current level.
4467 Note that this list is in reverse order unless/until
4468 you nreverse it; and when you do nreverse it, you must
4469 store the result back using `storedecls' or you will lose. */
4474 return current_binding_level
->names
;
4477 /* Return the list of type-tags (for structs, etc) of the current level. */
4482 return current_binding_level
->tags
;
4485 /* Store the list of declarations of the current level.
4486 This is done for the parameter declarations of a function being defined,
4487 after they are modified in the light of any missing parameters. */
4493 current_binding_level
->names
= decls
;
4496 /* Similarly, store the list of tags of the current level. */
4502 current_binding_level
->tags
= tags
;
4505 /* Given NAME, an IDENTIFIER_NODE,
4506 return the structure (or union or enum) definition for that name.
4507 Searches binding levels from BINDING_LEVEL up to the global level.
4508 If THISLEVEL_ONLY is nonzero, searches only the specified context
4509 (but skips any tag-transparent contexts to find one that is
4510 meaningful for tags).
4511 FORM says which kind of type the caller wants;
4512 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4513 If the wrong kind of type is found, and it's not a template, an error is
4517 lookup_tag (form
, name
, binding_level
, thislevel_only
)
4518 enum tree_code form
;
4520 struct binding_level
*binding_level
;
4523 register struct binding_level
*level
;
4524 /* Non-zero if, we should look past a pseudo-global level, even if
4526 int allow_pseudo_global
= 1;
4528 for (level
= binding_level
; level
; level
= level
->level_chain
)
4531 if (ANON_AGGRNAME_P (name
))
4532 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4534 /* There's no need for error checking here, because
4535 anon names are unique throughout the compilation. */
4536 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
4537 return TREE_VALUE (tail
);
4539 else if (level
->namespace_p
)
4540 /* Do namespace lookup. */
4541 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
4543 tree old
= binding_for_name (name
, tail
);
4545 /* If we just skipped past a pseudo global level, even
4546 though THISLEVEL_ONLY, and we find a template class
4547 declaration, then we use the _TYPE node for the
4548 template. See the example below. */
4549 if (thislevel_only
&& !allow_pseudo_global
4550 && old
&& BINDING_VALUE (old
)
4551 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
4552 old
= TREE_TYPE (BINDING_VALUE (old
));
4554 old
= BINDING_TYPE (old
);
4556 /* If it has an original type, it is a typedef, and we
4557 should not return it. */
4558 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
4560 if (old
&& TREE_CODE (old
) != form
4561 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
4563 cp_error ("`%#D' redeclared as %C", old
, form
);
4568 if (thislevel_only
|| tail
== global_namespace
)
4572 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4574 if (TREE_PURPOSE (tail
) == name
)
4576 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
4577 /* Should tighten this up; it'll probably permit
4578 UNION_TYPE and a struct template, for example. */
4580 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
4582 /* Definition isn't the kind we were looking for. */
4583 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
4587 return TREE_VALUE (tail
);
4590 if (thislevel_only
&& ! level
->tag_transparent
)
4592 if (level
->pseudo_global
&& allow_pseudo_global
)
4594 /* We must deal with cases like this:
4596 template <class T> struct S;
4597 template <class T> struct S {};
4599 When looking up `S', for the second declaration, we
4600 would like to find the first declaration. But, we
4601 are in the pseudo-global level created for the
4602 template parameters, rather than the (surrounding)
4603 namespace level. Thus, we keep going one more level,
4604 even though THISLEVEL_ONLY is non-zero. */
4605 allow_pseudo_global
= 0;
4611 if (current_class_type
&& level
->level_chain
->namespace_p
)
4613 /* Try looking in this class's tags before heading into
4614 global binding level. */
4615 tree context
= current_class_type
;
4618 switch (TREE_CODE_CLASS (TREE_CODE (context
)))
4622 these_tags
= CLASSTYPE_TAGS (context
);
4623 if (ANON_AGGRNAME_P (name
))
4626 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags
))
4628 return TREE_VALUE (tail
);
4629 these_tags
= TREE_CHAIN (these_tags
);
4634 if (TREE_PURPOSE (these_tags
) == name
)
4636 if (TREE_CODE (TREE_VALUE (these_tags
)) != form
)
4638 cp_error ("`%#D' redeclared as %C in class scope",
4639 TREE_VALUE (tail
), form
);
4642 return TREE_VALUE (tail
);
4644 these_tags
= TREE_CHAIN (these_tags
);
4646 /* If this type is not yet complete, then don't
4647 look at its context. */
4648 if (TYPE_SIZE (context
) == NULL_TREE
)
4650 /* Go to next enclosing type, if any. */
4651 context
= DECL_CONTEXT (TYPE_MAIN_DECL (context
));
4654 context
= DECL_CONTEXT (context
);
4657 my_friendly_abort (10);
4670 set_current_level_tags_transparency (tags_transparent
)
4671 int tags_transparent
;
4673 current_binding_level
->tag_transparent
= tags_transparent
;
4677 /* Given a type, find the tag that was defined for it and return the tag name.
4678 Otherwise return 0. However, the value can never be 0
4679 in the cases in which this is used.
4681 C++: If NAME is non-zero, this is the new name to install. This is
4682 done when replacing anonymous tags with real tag names. */
4685 lookup_tag_reverse (type
, name
)
4689 register struct binding_level
*level
;
4691 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
4694 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4696 if (TREE_VALUE (tail
) == type
)
4699 TREE_PURPOSE (tail
) = name
;
4700 return TREE_PURPOSE (tail
);
4707 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4708 Return the type value, or NULL_TREE if not found. */
4711 lookup_nested_type (type
, context
)
4715 if (context
== NULL_TREE
)
4719 switch (TREE_CODE (context
))
4723 tree ctype
= TREE_TYPE (context
);
4724 tree match
= value_member (type
, CLASSTYPE_TAGS (ctype
));
4726 return TREE_VALUE (match
);
4727 context
= DECL_CONTEXT (context
);
4729 /* When we have a nested class whose member functions have
4730 local types (e.g., a set of enums), we'll arrive here
4731 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4732 the enclosing class. Instead, we want to make sure we
4733 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4734 if (context
&& TREE_CODE (context
) == RECORD_TYPE
)
4735 context
= TREE_CHAIN (context
);
4739 if (TYPE_NAME (type
) && TYPE_IDENTIFIER (type
))
4740 return lookup_name (TYPE_IDENTIFIER (type
), 1);
4743 my_friendly_abort (12);
4749 /* Look up NAME in the NAMESPACE. */
4752 lookup_namespace_name (namespace, name
)
4753 tree
namespace, name
;
4755 struct tree_binding _b
;
4758 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
4760 /* This happens for A::B<int> when B is a namespace. */
4761 if (TREE_CODE (name
) == NAMESPACE_DECL
)
4764 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
4766 val
= binding_init (&_b
);
4767 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
4768 return error_mark_node
;
4770 if (BINDING_VALUE (val
))
4772 val
= BINDING_VALUE (val
);
4774 /* If we have a single function from a using decl, pull it out. */
4775 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
4776 val
= OVL_FUNCTION (val
);
4780 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
4781 return error_mark_node
;
4784 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4785 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
4786 is non-NULL, this type is being created by the implicit typename
4787 extension, and BASE_TYPE is a type named `t' in some base class of
4788 `T' which depends on template parameters.
4790 Returns the new TYPENAME_TYPE. */
4793 build_typename_type (context
, name
, fullname
, base_type
)
4802 if (processing_template_decl
)
4803 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4805 /* Build the TYPENAME_TYPE. */
4806 t
= make_lang_type (TYPENAME_TYPE
);
4807 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
4808 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
4809 TREE_TYPE (t
) = base_type
;
4810 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
4812 /* Build the corresponding TYPE_DECL. */
4813 d
= build_decl (TYPE_DECL
, name
, t
);
4814 TYPE_NAME (TREE_TYPE (d
)) = d
;
4815 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
4816 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
4818 if (processing_template_decl
)
4825 make_typename_type (context
, name
)
4831 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
4832 name
= TYPE_IDENTIFIER (name
);
4833 else if (TREE_CODE (name
) == TYPE_DECL
)
4834 name
= DECL_NAME (name
);
4838 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
4840 name
= TREE_OPERAND (name
, 0);
4841 if (TREE_CODE (name
) == TEMPLATE_DECL
)
4842 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
4844 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
4845 my_friendly_abort (2000);
4847 if (TREE_CODE (context
) == NAMESPACE_DECL
)
4849 /* We can get here from typename_sub0 in the explicit_template_type
4850 expansion. Just fail. */
4851 cp_error ("no class template named `%#T' in `%#T'",
4853 return error_mark_node
;
4856 if (! uses_template_parms (context
)
4857 || currently_open_class (context
))
4859 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
4861 if (IS_AGGR_TYPE (context
))
4862 t
= lookup_field (context
, name
, 0, 0);
4866 if (t
== NULL_TREE
|| TREE_CODE (t
) != TEMPLATE_DECL
4867 || TREE_CODE (DECL_RESULT (t
)) != TYPE_DECL
)
4869 cp_error ("no class template named `%#T' in `%#T'",
4871 return error_mark_node
;
4874 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
4876 /*entering_scope=*/0);
4880 if (IS_AGGR_TYPE (context
))
4881 t
= lookup_field (context
, name
, 0, 1);
4887 cp_error ("no type named `%#T' in `%#T'", name
, context
);
4888 return error_mark_node
;
4891 return TREE_TYPE (t
);
4895 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
4898 /* Select the right _DECL from multiple choices. */
4901 select_decl (binding
, flags
)
4906 val
= BINDING_VALUE (binding
);
4907 if (LOOKUP_NAMESPACES_ONLY (flags
))
4909 /* We are not interested in types. */
4910 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
4915 /* If we could have a type and
4916 we have nothing or we need a type and have none. */
4917 if (BINDING_TYPE (binding
)
4918 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
4919 && TREE_CODE (val
) != TYPE_DECL
)))
4920 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
4921 /* Don't return non-types if we really prefer types. */
4922 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
4923 && (!looking_for_template
|| TREE_CODE (val
) != TEMPLATE_DECL
))
4929 /* Unscoped lookup of a global, iterate over namespaces, considering
4930 using namespace statements. */
4933 unqualified_namespace_lookup (name
, flags
)
4937 struct tree_binding _binding
;
4938 tree b
= binding_init (&_binding
);
4939 tree initial
= current_decl_namespace();
4940 tree scope
= initial
;
4942 struct binding_level
*level
;
4943 tree val
= NULL_TREE
;
4947 val
= binding_for_name (name
, scope
);
4949 /* Initialize binding for this context. */
4950 BINDING_VALUE (b
) = BINDING_VALUE (val
);
4951 BINDING_TYPE (b
) = BINDING_TYPE (val
);
4953 /* Add all _DECLs seen through local using-directives. */
4954 for (level
= current_binding_level
;
4955 !level
->namespace_p
;
4956 level
= level
->level_chain
)
4957 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
4959 /* Give up because of error. */
4962 /* Add all _DECLs seen through global using-directives. */
4963 /* XXX local and global using lists should work equally. */
4967 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
4969 /* Give up because of error. */
4971 if (siter
== scope
) break;
4972 siter
= CP_DECL_CONTEXT (siter
);
4975 val
= select_decl (b
, flags
);
4976 if (scope
== global_namespace
)
4978 scope
= CP_DECL_CONTEXT (scope
);
4983 /* Combine prefer_type and namespaces_only into flags. */
4986 lookup_flags (prefer_type
, namespaces_only
)
4987 int prefer_type
, namespaces_only
;
4989 if (namespaces_only
)
4990 return LOOKUP_PREFER_NAMESPACES
;
4991 if (prefer_type
> 1)
4992 return LOOKUP_PREFER_TYPES
;
4993 if (prefer_type
> 0)
4994 return LOOKUP_PREFER_BOTH
;
4998 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4999 ignore it or not. Subroutine of lookup_name_real. */
5002 qualify_lookup (val
, flags
)
5006 if (val
== NULL_TREE
)
5008 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5010 if ((flags
& LOOKUP_PREFER_TYPES
)
5011 && (TREE_CODE (val
) == TYPE_DECL
5012 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5013 && DECL_CLASS_TEMPLATE_P (val
))))
5015 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5020 /* Look up NAME in the current binding level and its superiors in the
5021 namespace of variables, functions and typedefs. Return a ..._DECL
5022 node of some kind representing its definition if there is only one
5023 such declaration, or return a TREE_LIST with all the overloaded
5024 definitions if there are many, or return 0 if it is undefined.
5026 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5027 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5028 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5029 Otherwise we prefer non-TYPE_DECLs.
5031 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5032 using IDENTIFIER_CLASS_VALUE. */
5035 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5037 int prefer_type
, nonclass
, namespaces_only
;
5041 tree from_obj
= NULL_TREE
;
5042 tree locval
, classval
;
5045 /* Hack: copy flag set by parser, if set. */
5046 if (only_namespace_names
)
5047 namespaces_only
= 1;
5049 if (prefer_type
== -2)
5051 extern int looking_for_typename
;
5052 tree type
= NULL_TREE
;
5055 prefer_type
= looking_for_typename
;
5057 flags
= lookup_flags (prefer_type
, namespaces_only
);
5058 /* During parsing, we need to complain. */
5059 flags
|= LOOKUP_COMPLAIN
;
5060 /* If the next thing is '<', class templates are types. */
5061 if (looking_for_template
)
5062 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5064 /* std:: becomes :: for now. */
5065 if (got_scope
== std_node
)
5066 got_scope
= void_type_node
;
5070 else if (got_object
!= error_mark_node
)
5075 if (type
== error_mark_node
)
5076 return error_mark_node
;
5077 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5078 type
= TREE_TYPE (type
);
5081 type
= complete_type (type
);
5083 if (TREE_CODE (type
) == VOID_TYPE
)
5084 type
= global_namespace
;
5085 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5087 struct tree_binding b
;
5088 val
= binding_init (&b
);
5089 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5091 val
= select_decl (val
, flags
);
5093 else if (! IS_AGGR_TYPE (type
)
5094 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5095 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
5096 || TREE_CODE (type
) == TYPENAME_TYPE
)
5097 /* Someone else will give an error about this if needed. */
5099 else if (TYPE_BEING_DEFINED (type
))
5101 val
= IDENTIFIER_CLASS_VALUE (name
);
5102 if (val
&& DECL_CONTEXT (val
) != type
)
5104 struct binding_level
*b
= class_binding_level
;
5105 for (val
= NULL_TREE
; b
; b
= b
->level_chain
)
5107 tree t
= purpose_member (name
, b
->class_shadowed
);
5108 if (t
&& TREE_VALUE (t
)
5109 && DECL_CONTEXT (TREE_VALUE (t
)) == type
)
5111 val
= TREE_VALUE (t
);
5116 if (val
== NULL_TREE
)
5117 val
= lookup_field (type
, name
, 0, 1);
5119 else if (type
== current_class_type
)
5120 val
= IDENTIFIER_CLASS_VALUE (name
);
5122 val
= lookup_member (type
, name
, 0, prefer_type
);
5129 else if (got_object
&& val
)
5133 flags
= lookup_flags (prefer_type
, namespaces_only
);
5135 locval
= classval
= NULL_TREE
;
5137 if (! namespace_bindings_p ())
5138 locval
= qualify_lookup (IDENTIFIER_LOCAL_VALUE (name
), flags
);
5140 /* In C++ class fields are between local and global scope,
5141 just before the global scope. */
5142 if (current_class_type
&& ! nonclass
)
5144 classval
= IDENTIFIER_CLASS_VALUE (name
);
5145 if (classval
== NULL_TREE
&& TYPE_BEING_DEFINED (current_class_type
))
5146 /* Try to find values from base classes if we are presently
5147 defining a type. We are presently only interested in
5149 classval
= lookup_field (current_class_type
, name
, 0, 1);
5151 /* Add implicit 'typename' to types from template bases. lookup_field
5152 will do this for us. If classval is actually from an enclosing
5153 scope, lookup_nested_field will get it for us. */
5154 else if (processing_template_decl
5155 && classval
&& TREE_CODE (classval
) == TYPE_DECL
5156 && ! currently_open_class (DECL_CONTEXT (classval
))
5157 && uses_template_parms (current_class_type
))
5158 classval
= lookup_field (current_class_type
, name
, 0, 1);
5160 /* yylex() calls this with -2, since we should never start digging for
5161 the nested name at the point where we haven't even, for example,
5162 created the COMPONENT_REF or anything like that. */
5163 if (classval
== NULL_TREE
)
5164 classval
= lookup_nested_field (name
, ! yylex
);
5166 classval
= qualify_lookup (classval
, flags
);
5169 if (locval
&& classval
)
5171 /* We have both a local binding and a class-level binding. This
5172 can happen in two ways:
5174 o We are in a member function of a class.
5175 o We are in a local class within a function.
5177 We need to determine which one of these situations is
5178 occuring, and give the innermost binding. One tricky bit is
5179 that with member templates we can be in the first case
5180 without CURRENT_FUNCTION_DECL being set. Consider
5182 struct A { template <class A> void f(A); };
5184 Here, when we look at the `A' in the parameter declaration
5185 for `f' we have a local binding (the template parameter) and
5186 a class-level binding (the TYPE_DECL for the class).
5187 Fortunately, if LOCVAL is a template parameter it is safe to
5188 take it; nothing within the scope of the template parameter
5189 is allowed to have the same name. */
5191 if (decl_template_parm_p (locval
))
5193 else if (current_scope () == current_function_decl
5194 && ! hack_decl_function_context (current_function_decl
))
5195 /* Not in a nested function. */
5199 /* This is incredibly horrible. The whole concept of
5200 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
5201 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
5203 tree lctx
= hack_decl_function_context (locval
);
5204 tree cctx
= hack_decl_function_context (classval
);
5206 if (lctx
== current_scope ())
5208 else if (lctx
== cctx
)
5211 /* I don't know which is right; let's just guess for now. */
5220 val
= unqualified_namespace_lookup (name
, flags
);
5222 /* Any other name takes precedence over an implicit typename. Warn the
5223 user about this potentially confusing lookup. */
5224 if (classval
&& TREE_CODE (val
) == TYPE_DECL
5225 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
5226 && TREE_TYPE (TREE_TYPE (val
)))
5228 if (locval
== NULL_TREE
)
5229 locval
= unqualified_namespace_lookup (name
, flags
);
5231 if (locval
&& val
!= locval
)
5237 /* Only warn when not lexing; we don't want to warn if they
5238 use this name as a declarator. */
5239 subtype
= TREE_TYPE (TREE_TYPE (classval
));
5241 && ! (TREE_CODE (locval
) == TEMPLATE_DECL
5242 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5243 && CLASSTYPE_TI_TEMPLATE (subtype
) == locval
)
5244 && ! (TREE_CODE (locval
) == TYPE_DECL
5245 && same_type_p (TREE_TYPE (locval
), subtype
)))
5247 cp_warning ("lookup of `%D' finds `%#D'", name
, locval
);
5248 cp_warning (" instead of `%D' from dependent base class",
5250 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5251 constructor_name (current_class_type
), name
);
5259 /* This should only warn about types used in qualified-ids. */
5260 if (from_obj
&& from_obj
!= val
)
5262 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5263 && TREE_CODE (val
) == TYPE_DECL
5264 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
5266 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5267 name
, got_object
, TREE_TYPE (from_obj
));
5268 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5272 /* We don't change val to from_obj if got_object depends on
5273 template parms because that breaks implicit typename for
5274 destructor calls. */
5275 if (! uses_template_parms (got_object
))
5279 if ((TREE_CODE (val
) == TEMPLATE_DECL
&& looking_for_template
)
5280 || TREE_CODE (val
) == TYPE_DECL
|| prefer_type
<= 0)
5282 /* Caller wants a class-or-namespace-name. */
5283 else if (prefer_type
== 1 && TREE_CODE (val
) == NAMESPACE_DECL
)
5285 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
5286 val
= TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name
));
5287 else if (TREE_TYPE (val
) == error_mark_node
)
5288 val
= error_mark_node
;
5290 /* If we have a single function from a using decl, pull it out. */
5291 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5292 val
= OVL_FUNCTION (val
);
5301 lookup_name_nonclass (name
)
5304 return lookup_name_real (name
, 0, 1, 0);
5308 lookup_function_nonclass (name
, args
)
5312 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
5316 lookup_name_namespace_only (name
)
5319 /* type-or-namespace, nonclass, namespace_only */
5320 return lookup_name_real (name
, 1, 1, 1);
5324 lookup_name (name
, prefer_type
)
5328 return lookup_name_real (name
, prefer_type
, 0, 0);
5331 /* Similar to `lookup_name' but look only at current binding level. */
5334 lookup_name_current_level (name
)
5337 register tree t
= NULL_TREE
;
5339 if (current_binding_level
->namespace_p
)
5341 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
5343 /* extern "C" function() */
5344 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
5347 else if (IDENTIFIER_LOCAL_VALUE (name
) != NULL_TREE
)
5349 struct binding_level
*b
= current_binding_level
;
5352 if (purpose_member (name
, b
->shadowed
))
5353 return IDENTIFIER_LOCAL_VALUE (name
);
5364 /* Like lookup_name_current_level, but for types. */
5367 lookup_type_current_level (name
)
5370 register tree t
= NULL_TREE
;
5372 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
5374 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
5375 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
5377 struct binding_level
*b
= current_binding_level
;
5380 if (purpose_member (name
, b
->type_shadowed
))
5381 return REAL_IDENTIFIER_TYPE_VALUE (name
);
5393 begin_only_namespace_names ()
5395 only_namespace_names
= 1;
5399 end_only_namespace_names ()
5401 only_namespace_names
= 0;
5404 /* Arrange for the user to get a source line number, even when the
5405 compiler is going down in flames, so that she at least has a
5406 chance of working around problems in the compiler. We used to
5407 call error(), but that let the segmentation fault continue
5408 through; now, it's much more passive by asking them to send the
5409 maintainers mail about the problem. */
5413 int sig ATTRIBUTE_UNUSED
;
5415 signal (SIGSEGV
, SIG_DFL
);
5417 signal (SIGIOT
, SIG_DFL
);
5420 signal (SIGILL
, SIG_DFL
);
5423 signal (SIGABRT
, SIG_DFL
);
5426 signal (SIGBUS
, SIG_DFL
);
5428 my_friendly_abort (0);
5432 /* Unused -- brendan 970107 */
5433 /* Array for holding types considered "built-in". These types
5434 are output in the module in which `main' is defined. */
5435 static tree
*builtin_type_tdescs_arr
;
5436 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
5439 /* Push the declarations of builtin types into the namespace.
5440 RID_INDEX, if < RID_MAX is the index of the builtin type
5441 in the array RID_POINTERS. NAME is the name used when looking
5442 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5445 record_builtin_type (rid_index
, name
, type
)
5450 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
5451 tree tdecl
= NULL_TREE
;
5453 if ((int) rid_index
< (int) RID_MAX
)
5454 rname
= ridpointers
[(int) rid_index
];
5456 tname
= get_identifier (name
);
5458 TYPE_BUILT_IN (type
) = 1;
5462 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
5463 set_identifier_type_value (tname
, NULL_TREE
);
5464 if ((int) rid_index
< (int) RID_MAX
)
5465 /* Built-in types live in the global namespace. */
5466 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
5468 if (rname
!= NULL_TREE
)
5470 if (tname
!= NULL_TREE
)
5472 set_identifier_type_value (rname
, NULL_TREE
);
5473 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
5477 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
5478 set_identifier_type_value (rname
, NULL_TREE
);
5483 /* Record one of the standard Java types.
5484 * Declare it as having the given NAME.
5485 * If SIZE > 0, it is the size of one of the integral types;
5486 * otherwise it is the negative of the size of one of the other types. */
5489 record_builtin_java_type (name
, size
)
5495 type
= make_signed_type (size
);
5496 else if (size
> -32)
5497 { /* "__java_char" or ""__java_boolean". */
5498 type
= make_unsigned_type (-size
);
5499 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5502 { /* "__java_float" or ""__java_double". */
5503 type
= make_node (REAL_TYPE
);
5504 TYPE_PRECISION (type
) = - size
;
5507 record_builtin_type (RID_MAX
, name
, type
);
5508 decl
= TYPE_NAME (type
);
5509 DECL_IGNORED_P (decl
) = 1;
5510 TYPE_FOR_JAVA (type
) = 1;
5514 /* Push a type into the namespace so that the back-ends ignore it. */
5517 record_unknown_type (type
, name
)
5521 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
5522 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5523 DECL_IGNORED_P (decl
) = 1;
5524 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5525 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
5526 TYPE_ALIGN (type
) = 1;
5527 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
5530 /* Push overloaded decl, in global scope, with one argument so it
5531 can be used as a callback from define_function. */
5534 push_overloaded_decl_1 (x
)
5537 push_overloaded_decl (x
, 0);
5544 auto_function (name
, type
, code
)
5546 enum built_in_function code
;
5548 return define_function
5549 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
5550 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
5554 /* Create the predefined scalar types of C,
5555 and some nodes representing standard constants (0, 1, (void *)0).
5556 Initialize the global binding level.
5557 Make definitions for built-in primitive functions. */
5560 init_decl_processing ()
5562 register tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
5564 /* Data type of memcpy. */
5565 tree memcpy_ftype
, strlen_ftype
;
5566 int wchar_type_size
;
5568 tree array_domain_type
;
5569 tree vb_off_identifier
= NULL_TREE
;
5570 /* Function type `char *(char *, char *)' and similar ones */
5571 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
5572 tree sizetype_endlink
;
5573 tree ptr_ftype
, ptr_ftype_unsigned
, ptr_ftype_sizetype
;
5574 tree void_ftype
, void_ftype_int
, void_ftype_ptr
;
5576 /* Have to make these distinct before we try using them. */
5577 lang_name_cplusplus
= get_identifier ("C++");
5578 lang_name_c
= get_identifier ("C");
5579 lang_name_java
= get_identifier ("Java");
5581 /* Enter the global namespace. */
5582 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
5583 my_friendly_assert (current_lang_name
== NULL_TREE
, 375);
5584 current_lang_name
= lang_name_cplusplus
;
5585 push_namespace (get_identifier ("::"));
5586 global_namespace
= current_namespace
;
5587 current_lang_name
= NULL_TREE
;
5589 if (flag_strict_prototype
== 2)
5590 flag_strict_prototype
= pedantic
;
5592 strict_prototypes_lang_c
= flag_strict_prototype
;
5595 current_lang_name
= lang_name_c
;
5597 current_function_decl
= NULL_TREE
;
5598 named_labels
= NULL_TREE
;
5599 named_label_uses
= NULL
;
5600 current_binding_level
= NULL_BINDING_LEVEL
;
5601 free_binding_level
= NULL_BINDING_LEVEL
;
5603 /* Because most segmentation signals can be traced back into user
5604 code, catch them and at least give the user a chance of working
5605 around compiler bugs. */
5606 signal (SIGSEGV
, signal_catch
);
5608 /* We will also catch aborts in the back-end through signal_catch and
5609 give the user a chance to see where the error might be, and to defeat
5610 aborts in the back-end when there have been errors previously in their
5613 signal (SIGIOT
, signal_catch
);
5616 signal (SIGILL
, signal_catch
);
5619 signal (SIGABRT
, signal_catch
);
5622 signal (SIGBUS
, signal_catch
);
5625 gcc_obstack_init (&decl_obstack
);
5627 /* Must lay these out before anything else gets laid out. */
5628 error_mark_node
= make_node (ERROR_MARK
);
5629 TREE_PERMANENT (error_mark_node
) = 1;
5630 TREE_TYPE (error_mark_node
) = error_mark_node
;
5631 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
5632 TREE_TYPE (error_mark_list
) = error_mark_node
;
5634 /* Make the binding_level structure for global names. */
5636 global_binding_level
= current_binding_level
;
5637 /* The global level is the namespace level of ::. */
5638 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
5639 declare_namespace_level ();
5641 this_identifier
= get_identifier (THIS_NAME
);
5642 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
5643 ctor_identifier
= get_identifier (CTOR_NAME
);
5644 dtor_identifier
= get_identifier (DTOR_NAME
);
5645 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
5646 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
5647 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
5648 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
5649 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
5650 if (flag_handle_signatures
)
5652 tag_identifier
= get_identifier (SIGTABLE_TAG_NAME
);
5653 vb_off_identifier
= get_identifier (SIGTABLE_VB_OFF_NAME
);
5654 vt_off_identifier
= get_identifier (SIGTABLE_VT_OFF_NAME
);
5657 /* Define `int' and `char' first so that dbx will output them first. */
5659 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
5660 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
5662 /* Define `char', which is like either `signed char' or `unsigned char'
5663 but not the same as either. */
5667 ? make_signed_type (CHAR_TYPE_SIZE
)
5668 : make_unsigned_type (CHAR_TYPE_SIZE
));
5669 record_builtin_type (RID_CHAR
, "char", char_type_node
);
5671 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
5672 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
5674 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
5675 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
5677 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
5678 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
5679 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
5681 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
5682 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
5684 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
5685 record_builtin_type (RID_MAX
, "long long unsigned int",
5686 long_long_unsigned_type_node
);
5687 record_builtin_type (RID_MAX
, "long long unsigned",
5688 long_long_unsigned_type_node
);
5690 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
5691 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
5692 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
5693 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
5694 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
5696 /* `unsigned long' is the standard type for sizeof.
5697 Note that stddef.h uses `unsigned long',
5698 and this must agree, even if long and int are the same size. */
5700 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
5703 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
5705 /* Define both `signed char' and `unsigned char'. */
5706 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
5707 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
5708 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
5709 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
5711 /* These are types that type_for_size and type_for_mode use. */
5712 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
5713 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
5714 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
5715 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
5716 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
5717 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
5718 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
5719 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
5720 #if HOST_BITS_PER_WIDE_INT >= 64
5721 intTI_type_node
= make_signed_type (GET_MODE_BITSIZE (TImode
));
5722 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intTI_type_node
));
5724 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
5725 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
5726 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
5727 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
5728 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
5729 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
5730 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
5731 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
5732 #if HOST_BITS_PER_WIDE_INT >= 64
5733 unsigned_intTI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (TImode
));
5734 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intTI_type_node
));
5737 float_type_node
= make_node (REAL_TYPE
);
5738 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
5739 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
5740 layout_type (float_type_node
);
5742 double_type_node
= make_node (REAL_TYPE
);
5743 if (flag_short_double
)
5744 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
5746 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
5747 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
5748 layout_type (double_type_node
);
5750 long_double_type_node
= make_node (REAL_TYPE
);
5751 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
5752 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
5753 layout_type (long_double_type_node
);
5755 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
5756 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
5757 complex_integer_type_node
));
5758 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
5759 layout_type (complex_integer_type_node
);
5761 complex_float_type_node
= make_node (COMPLEX_TYPE
);
5762 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
5763 complex_float_type_node
));
5764 TREE_TYPE (complex_float_type_node
) = float_type_node
;
5765 layout_type (complex_float_type_node
);
5767 complex_double_type_node
= make_node (COMPLEX_TYPE
);
5768 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
5769 complex_double_type_node
));
5770 TREE_TYPE (complex_double_type_node
) = double_type_node
;
5771 layout_type (complex_double_type_node
);
5773 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
5774 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
5775 complex_long_double_type_node
));
5776 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
5777 layout_type (complex_long_double_type_node
);
5779 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
5780 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
5781 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
5782 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
5783 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
5784 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
5785 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
5786 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
5788 integer_zero_node
= build_int_2 (0, 0);
5789 TREE_TYPE (integer_zero_node
) = integer_type_node
;
5790 integer_one_node
= build_int_2 (1, 0);
5791 TREE_TYPE (integer_one_node
) = integer_type_node
;
5792 integer_two_node
= build_int_2 (2, 0);
5793 TREE_TYPE (integer_two_node
) = integer_type_node
;
5794 integer_three_node
= build_int_2 (3, 0);
5795 TREE_TYPE (integer_three_node
) = integer_type_node
;
5797 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
5798 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
5799 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
5800 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
5801 TYPE_PRECISION (boolean_type_node
) = 1;
5802 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
5803 boolean_false_node
= build_int_2 (0, 0);
5804 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
5805 boolean_true_node
= build_int_2 (1, 0);
5806 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
5808 /* These are needed by stor-layout.c. */
5809 size_zero_node
= size_int (0);
5810 size_one_node
= size_int (1);
5812 signed_size_zero_node
= build_int_2 (0, 0);
5813 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
5815 void_type_node
= make_node (VOID_TYPE
);
5816 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
5817 layout_type (void_type_node
); /* Uses integer_zero_node. */
5818 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
5819 TREE_PARMLIST (void_list_node
) = 1;
5821 null_pointer_node
= build_int_2 (0, 0);
5822 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
5823 layout_type (TREE_TYPE (null_pointer_node
));
5825 /* Used for expressions that do nothing, but are not errors. */
5826 void_zero_node
= build_int_2 (0, 0);
5827 TREE_TYPE (void_zero_node
) = void_type_node
;
5829 string_type_node
= build_pointer_type (char_type_node
);
5830 const_string_type_node
5831 = build_pointer_type (build_qualified_type (char_type_node
,
5834 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
5837 /* Make a type to be the domain of a few array types
5838 whose domains don't really matter.
5839 200 is small enough that it always fits in size_t
5840 and large enough that it can hold most function names for the
5841 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5842 array_domain_type
= build_index_type (build_int_2 (200, 0));
5844 /* Make a type for arrays of characters.
5845 With luck nothing will ever really depend on the length of this
5847 char_array_type_node
5848 = build_array_type (char_type_node
, array_domain_type
);
5849 /* Likewise for arrays of ints. */
5851 = build_array_type (integer_type_node
, array_domain_type
);
5853 /* This is just some anonymous class type. Nobody should ever
5854 need to look inside this envelope. */
5855 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
5857 default_function_type
5858 = build_function_type (integer_type_node
, NULL_TREE
);
5860 ptr_type_node
= build_pointer_type (void_type_node
);
5862 = build_pointer_type (build_qualified_type (void_type_node
,
5865 record_builtin_type (RID_MAX
, NULL_PTR
, ptr_type_node
);
5867 endlink
= void_list_node
;
5868 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
5869 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
5870 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
5872 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
5873 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
5874 sizetype_endlink
= tree_cons (NULL_TREE
, sizetype
, endlink
);
5875 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5876 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
5878 void_ftype
= build_function_type (void_type_node
, endlink
);
5879 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
5881 = build_function_type (void_type_node
,
5882 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
5884 = build_exception_variant (void_ftype_ptr
,
5885 tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
));
5888 = build_function_type (float_type_node
,
5889 tree_cons (NULL_TREE
, float_type_node
, endlink
));
5892 = build_function_type (double_type_node
, double_endlink
);
5894 ldouble_ftype_ldouble
5895 = build_function_type (long_double_type_node
,
5896 tree_cons (NULL_TREE
, long_double_type_node
,
5899 double_ftype_double_double
5900 = build_function_type (double_type_node
,
5901 tree_cons (NULL_TREE
, double_type_node
,
5905 = build_function_type (integer_type_node
, int_endlink
);
5908 = build_function_type (long_integer_type_node
,
5909 tree_cons (NULL_TREE
, long_integer_type_node
,
5912 int_ftype_cptr_cptr_sizet
5913 = build_function_type (integer_type_node
,
5914 tree_cons (NULL_TREE
, const_ptr_type_node
,
5915 tree_cons (NULL_TREE
, const_ptr_type_node
,
5916 tree_cons (NULL_TREE
,
5920 string_ftype_ptr_ptr
/* strcpy prototype */
5921 = build_function_type (string_type_node
,
5922 tree_cons (NULL_TREE
, string_type_node
,
5923 tree_cons (NULL_TREE
,
5924 const_string_type_node
,
5927 int_ftype_string_string
/* strcmp prototype */
5928 = build_function_type (integer_type_node
,
5929 tree_cons (NULL_TREE
, const_string_type_node
,
5930 tree_cons (NULL_TREE
,
5931 const_string_type_node
,
5934 strlen_ftype
/* strlen prototype */
5935 = build_function_type (sizetype
,
5936 tree_cons (NULL_TREE
, const_string_type_node
,
5939 memcpy_ftype
/* memcpy prototype */
5940 = build_function_type (ptr_type_node
,
5941 tree_cons (NULL_TREE
, ptr_type_node
,
5942 tree_cons (NULL_TREE
, const_ptr_type_node
,
5943 sizetype_endlink
)));
5945 if (flag_huge_objects
)
5946 delta_type_node
= long_integer_type_node
;
5948 delta_type_node
= short_integer_type_node
;
5950 builtin_function ("__builtin_constant_p", default_function_type
,
5951 BUILT_IN_CONSTANT_P
, NULL_PTR
);
5953 builtin_return_address_fndecl
5954 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
5955 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
5957 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
5958 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
5960 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
5961 BUILT_IN_ALLOCA
, "alloca");
5962 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5963 /* Define alloca, ffs as builtins.
5964 Declare _exit just to mark it as volatile. */
5965 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
5967 temp
= builtin_function ("alloca", ptr_ftype_sizetype
,
5968 BUILT_IN_ALLOCA
, NULL_PTR
);
5969 /* Suppress error if redefined as a non-function. */
5970 DECL_BUILT_IN_NONANSI (temp
) = 1;
5971 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5972 /* Suppress error if redefined as a non-function. */
5973 DECL_BUILT_IN_NONANSI (temp
) = 1;
5974 temp
= builtin_function ("_exit", void_ftype_int
,
5975 NOT_BUILT_IN
, NULL_PTR
);
5976 TREE_THIS_VOLATILE (temp
) = 1;
5977 TREE_SIDE_EFFECTS (temp
) = 1;
5978 /* Suppress error if redefined as a non-function. */
5979 DECL_BUILT_IN_NONANSI (temp
) = 1;
5982 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
5983 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
5985 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
5987 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
5989 builtin_function ("__builtin_labs", long_ftype_long
,
5990 BUILT_IN_LABS
, NULL_PTR
);
5991 builtin_function ("__builtin_saveregs", ptr_ftype
,
5992 BUILT_IN_SAVEREGS
, NULL_PTR
);
5993 builtin_function ("__builtin_classify_type", default_function_type
,
5994 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
5995 builtin_function ("__builtin_next_arg", ptr_ftype
,
5996 BUILT_IN_NEXT_ARG
, NULL_PTR
);
5997 builtin_function ("__builtin_args_info", int_ftype_int
,
5998 BUILT_IN_ARGS_INFO
, NULL_PTR
);
5999 builtin_function ("__builtin_setjmp",
6000 build_function_type (integer_type_node
,
6001 tree_cons (NULL_TREE
, ptr_type_node
,
6003 BUILT_IN_SETJMP
, NULL_PTR
);
6004 builtin_function ("__builtin_longjmp",
6005 build_function_type (integer_type_node
,
6006 tree_cons (NULL_TREE
, ptr_type_node
,
6007 tree_cons (NULL_TREE
,
6010 BUILT_IN_LONGJMP
, NULL_PTR
);
6012 /* Untyped call and return. */
6013 builtin_function ("__builtin_apply_args", ptr_ftype
,
6014 BUILT_IN_APPLY_ARGS
, NULL_PTR
);
6016 temp
= tree_cons (NULL_TREE
,
6017 build_pointer_type (build_function_type (void_type_node
,
6019 tree_cons (NULL_TREE
, ptr_ftype_sizetype
, NULL_TREE
));
6020 builtin_function ("__builtin_apply",
6021 build_function_type (ptr_type_node
, temp
),
6022 BUILT_IN_APPLY
, NULL_PTR
);
6023 builtin_function ("__builtin_return", void_ftype_ptr
,
6024 BUILT_IN_RETURN
, NULL_PTR
);
6026 /* Currently under experimentation. */
6027 builtin_function ("__builtin_memcpy", memcpy_ftype
,
6028 BUILT_IN_MEMCPY
, "memcpy");
6029 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
6030 BUILT_IN_MEMCMP
, "memcmp");
6031 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
6032 BUILT_IN_STRCMP
, "strcmp");
6033 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
6034 BUILT_IN_STRCPY
, "strcpy");
6035 builtin_function ("__builtin_strlen", strlen_ftype
,
6036 BUILT_IN_STRLEN
, "strlen");
6037 builtin_function ("__builtin_sqrtf", float_ftype_float
,
6038 BUILT_IN_FSQRT
, "sqrtf");
6039 builtin_function ("__builtin_fsqrt", double_ftype_double
,
6040 BUILT_IN_FSQRT
, NULL_PTR
);
6041 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
6042 BUILT_IN_FSQRT
, "sqrtl");
6043 builtin_function ("__builtin_sinf", float_ftype_float
,
6044 BUILT_IN_SIN
, "sinf");
6045 builtin_function ("__builtin_sin", double_ftype_double
,
6046 BUILT_IN_SIN
, "sin");
6047 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
6048 BUILT_IN_SIN
, "sinl");
6049 builtin_function ("__builtin_cosf", float_ftype_float
,
6050 BUILT_IN_COS
, "cosf");
6051 builtin_function ("__builtin_cos", double_ftype_double
,
6052 BUILT_IN_COS
, "cos");
6053 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
6054 BUILT_IN_COS
, "cosl");
6056 if (!flag_no_builtin
)
6058 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
6059 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
6060 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
6061 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
, NULL_PTR
);
6062 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
6064 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
6065 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
6067 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
6069 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
6071 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
6072 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
, NULL_PTR
);
6073 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
6074 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
6076 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
, NULL_PTR
);
6077 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
, NULL_PTR
);
6078 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
, NULL_PTR
);
6079 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
, NULL_PTR
);
6080 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
, NULL_PTR
);
6081 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
, NULL_PTR
);
6083 /* Declare these functions volatile
6084 to avoid spurious "control drops through" warnings. */
6085 temp
= builtin_function ("abort", void_ftype
,
6086 NOT_BUILT_IN
, NULL_PTR
);
6087 TREE_THIS_VOLATILE (temp
) = 1;
6088 TREE_SIDE_EFFECTS (temp
) = 1;
6089 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
6091 DECL_BUILT_IN_NONANSI (temp
) = 1;
6092 temp
= builtin_function ("exit", void_ftype_int
,
6093 NOT_BUILT_IN
, NULL_PTR
);
6094 TREE_THIS_VOLATILE (temp
) = 1;
6095 TREE_SIDE_EFFECTS (temp
) = 1;
6096 DECL_BUILT_IN_NONANSI (temp
) = 1;
6100 /* Support for these has not been written in either expand_builtin
6101 or build_function_call. */
6102 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
6103 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
6104 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
6106 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
6108 builtin_function ("__builtin_fmod", double_ftype_double_double
,
6109 BUILT_IN_FMOD
, NULL_PTR
);
6110 builtin_function ("__builtin_frem", double_ftype_double_double
,
6111 BUILT_IN_FREM
, NULL_PTR
);
6112 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
6113 BUILT_IN_MEMSET
, NULL_PTR
);
6114 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
6116 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
6120 /* C++ extensions */
6122 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6123 record_unknown_type (unknown_type_node
, "unknown type");
6125 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6126 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6128 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6130 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6132 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6133 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6135 /* This is for handling opaque types in signatures. */
6136 opaque_type_node
= copy_node (ptr_type_node
);
6137 TYPE_MAIN_VARIANT (opaque_type_node
) = opaque_type_node
;
6138 record_builtin_type (RID_MAX
, 0, opaque_type_node
);
6140 /* This is special for C++ so functions can be overloaded. */
6142 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
6143 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6144 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
6145 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
6147 = TREE_UNSIGNED (wchar_type_node
)
6148 ? unsigned_wchar_type_node
6149 : signed_wchar_type_node
;
6150 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6152 /* Artificial declaration of wchar_t -- can be bashed */
6153 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6155 pushdecl (wchar_decl_node
);
6157 /* This is for wide string constants. */
6158 wchar_array_type_node
6159 = build_array_type (wchar_type_node
, array_domain_type
);
6161 if (flag_vtable_thunks
)
6163 /* Make sure we get a unique function type, so we can give
6164 its pointer type a name. (This wins for gdb.) */
6165 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6166 TREE_TYPE (vfunc_type
) = integer_type_node
;
6167 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6168 layout_type (vfunc_type
);
6170 vtable_entry_type
= build_pointer_type (vfunc_type
);
6174 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
6175 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6177 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6179 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6181 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6184 /* Make this part of an invisible union. */
6185 fields
[3] = copy_node (fields
[2]);
6186 TREE_TYPE (fields
[3]) = delta_type_node
;
6187 DECL_NAME (fields
[3]) = delta2_identifier
;
6188 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6189 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6190 TREE_UNSIGNED (fields
[3]) = 0;
6191 TREE_CHAIN (fields
[2]) = fields
[3];
6192 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6195 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6198 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6199 layout_type (vtbl_type_node
);
6200 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6201 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6202 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6203 layout_type (vtbl_ptr_type_node
);
6204 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6206 /* Simplify life by making a "sigtable_entry_type". Give its
6207 fields names so that the debugger can use them. */
6209 if (flag_handle_signatures
)
6211 sigtable_entry_type
= make_lang_type (RECORD_TYPE
);
6212 fields
[0] = build_lang_field_decl (FIELD_DECL
, tag_identifier
,
6214 fields
[1] = build_lang_field_decl (FIELD_DECL
, vb_off_identifier
,
6216 fields
[2] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
6218 fields
[3] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
6220 fields
[4] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
6223 /* Set the alignment to the max of the alignment of ptr_type_node and
6224 delta_type_node. Double alignment wastes a word on the Sparc. */
6225 finish_builtin_type (sigtable_entry_type
, SIGTABLE_PTR_TYPE
, fields
, 4,
6226 (TYPE_ALIGN (ptr_type_node
) > TYPE_ALIGN (delta_type_node
))
6230 /* Make this part of an invisible union. */
6231 fields
[5] = copy_node (fields
[4]);
6232 TREE_TYPE (fields
[5]) = delta_type_node
;
6233 DECL_NAME (fields
[5]) = vt_off_identifier
;
6234 DECL_MODE (fields
[5]) = TYPE_MODE (delta_type_node
);
6235 DECL_SIZE (fields
[5]) = TYPE_SIZE (delta_type_node
);
6236 TREE_UNSIGNED (fields
[5]) = 0;
6237 TREE_CHAIN (fields
[4]) = fields
[5];
6239 sigtable_entry_type
= build_qualified_type (sigtable_entry_type
,
6241 record_builtin_type (RID_MAX
, SIGTABLE_PTR_TYPE
, sigtable_entry_type
);
6244 std_node
= build_decl (NAMESPACE_DECL
,
6245 get_identifier (flag_honor_std
? "fake std":"std"),
6247 pushdecl (std_node
);
6249 global_type_node
= make_node (LANG_TYPE
);
6250 record_unknown_type (global_type_node
, "global type");
6253 current_lang_name
= lang_name_cplusplus
;
6256 tree bad_alloc_type_node
, newtype
, deltype
;
6258 push_namespace (get_identifier ("std"));
6259 bad_alloc_type_node
= xref_tag
6260 (class_type_node
, get_identifier ("bad_alloc"), 1);
6263 newtype
= build_exception_variant
6264 (ptr_ftype_sizetype
, build_tree_list (NULL_TREE
, bad_alloc_type_node
));
6265 deltype
= build_exception_variant
6266 (void_ftype_ptr
, build_tree_list (NULL_TREE
, NULL_TREE
));
6267 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6268 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
6269 auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6270 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
6274 = define_function ("__pure_virtual", void_ftype
,
6275 NOT_BUILT_IN
, 0, 0);
6277 /* Perform other language dependent initializations. */
6278 init_class_processing ();
6279 init_init_processing ();
6280 init_search_processing ();
6282 init_rtti_processing ();
6284 if (flag_exceptions
)
6285 init_exception_processing ();
6288 flag_inline_functions
= 0;
6291 if (! supports_one_only ())
6294 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6295 declare_function_name ();
6297 /* Prepare to check format strings against argument lists. */
6298 init_function_format_info ();
6300 /* Show we use EH for cleanups. */
6301 using_eh_for_cleanups ();
6303 print_error_function
= lang_print_error_function
;
6304 lang_get_alias_set
= &c_get_alias_set
;
6306 /* Maintain consistency. Perhaps we should just complain if they
6307 say -fwritable-strings? */
6308 if (flag_writable_strings
)
6309 flag_const_strings
= 0;
6312 /* Function to print any language-specific context for an error message. */
6315 lang_print_error_function (file
)
6318 default_print_error_function (file
);
6319 maybe_print_template_context ();
6322 /* Make a definition for a builtin function named NAME and whose data type
6323 is TYPE. TYPE should be a function type with argument types.
6324 FUNCTION_CODE tells later passes how to compile calls to this function.
6325 See tree.h for its possible values.
6327 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6328 the name to be called if we can't opencode the function. */
6331 define_function (name
, type
, function_code
, pfn
, library_name
)
6334 enum built_in_function function_code
;
6335 void (*pfn
) PROTO((tree
));
6338 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
6339 DECL_EXTERNAL (decl
) = 1;
6340 TREE_PUBLIC (decl
) = 1;
6341 DECL_ARTIFICIAL (decl
) = 1;
6343 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6344 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6346 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6347 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6348 function in the namespace. */
6349 if (pfn
) (*pfn
) (decl
);
6351 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
6352 make_function_rtl (decl
);
6353 if (function_code
!= NOT_BUILT_IN
)
6355 DECL_BUILT_IN (decl
) = 1;
6356 DECL_FUNCTION_CODE (decl
) = function_code
;
6361 /* When we call finish_struct for an anonymous union, we create
6362 default copy constructors and such. But, an anonymous union
6363 shouldn't have such things; this function undoes the damage to the
6364 anonymous union type T.
6366 (The reason that we create the synthesized methods is that we don't
6367 distinguish `union { int i; }' from `typedef union { int i; } U'.
6368 The first is an anonymous union; the second is just an ordinary
6372 fixup_anonymous_union (t
)
6377 /* Wipe out memory of synthesized methods */
6378 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6379 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6380 TYPE_HAS_INIT_REF (t
) = 0;
6381 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6382 TYPE_HAS_ASSIGN_REF (t
) = 0;
6383 TYPE_HAS_ASSIGNMENT (t
) = 0;
6384 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6386 /* Splice the implicitly generated functions out of the TYPE_METHODS
6388 q
= &TYPE_METHODS (t
);
6391 if (DECL_ARTIFICIAL (*q
))
6392 *q
= TREE_CHAIN (*q
);
6394 q
= &TREE_CHAIN (*q
);
6397 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6398 function members. */
6399 if (TYPE_METHODS (t
))
6400 error ("an anonymous union cannot have function members");
6403 /* Called when a declaration is seen that contains no names to declare.
6404 If its type is a reference to a structure, union or enum inherited
6405 from a containing scope, shadow that tag name for the current scope
6406 with a forward reference.
6407 If its type defines a new named structure or union
6408 or defines an enum, it is valid but we need not do anything here.
6409 Otherwise, it is an error.
6411 C++: may have to grok the declspecs to learn about static,
6412 complain for anonymous unions. */
6415 shadow_tag (declspecs
)
6419 tree ob_modifier
= NULL_TREE
;
6421 register enum tree_code code
, ok_code
= ERROR_MARK
;
6422 register tree t
= NULL_TREE
;
6424 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6426 register tree value
= TREE_VALUE (link
);
6428 code
= TREE_CODE (value
);
6429 if (IS_AGGR_TYPE_CODE (code
) || code
== ENUMERAL_TYPE
)
6431 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6433 maybe_process_partial_specialization (value
);
6439 else if (value
== ridpointers
[(int) RID_STATIC
]
6440 || value
== ridpointers
[(int) RID_EXTERN
]
6441 || value
== ridpointers
[(int) RID_AUTO
]
6442 || value
== ridpointers
[(int) RID_REGISTER
]
6443 || value
== ridpointers
[(int) RID_INLINE
]
6444 || value
== ridpointers
[(int) RID_VIRTUAL
]
6445 || value
== ridpointers
[(int) RID_EXPLICIT
])
6446 ob_modifier
= value
;
6449 /* This is where the variables in an anonymous union are
6450 declared. An anonymous union declaration looks like:
6452 because there is no declarator after the union, the parser
6453 sends that declaration here. */
6454 if (ok_code
== UNION_TYPE
6456 && ((TREE_CODE (TYPE_NAME (t
)) == IDENTIFIER_NODE
6457 && ANON_AGGRNAME_P (TYPE_NAME (t
)))
6458 || (TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
6459 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))))
6461 fixup_anonymous_union (t
);
6463 if (TYPE_FIELDS (t
))
6465 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6467 finish_anon_union (decl
);
6472 /* Anonymous unions are objects, that's why we only check for
6473 inappropriate specifiers in this branch. */
6477 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6478 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6479 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6480 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6481 cp_error ("`%D' can only be specified for constructors",
6484 cp_error ("`%D' can only be specified for objects and functions",
6489 cp_error ("abstract declarator used as declaration");
6490 else if (found_tag
> 1)
6491 pedwarn ("multiple types in one declaration");
6495 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6498 groktypename (typename
)
6501 if (TREE_CODE (typename
) != TREE_LIST
)
6503 return grokdeclarator (TREE_VALUE (typename
),
6504 TREE_PURPOSE (typename
),
6505 TYPENAME
, 0, NULL_TREE
);
6508 /* Decode a declarator in an ordinary declaration or data definition.
6509 This is called as soon as the type information and variable name
6510 have been parsed, before parsing the initializer if any.
6511 Here we create the ..._DECL node, fill in its type,
6512 and put it on the list of decls for the current context.
6513 The ..._DECL node is returned as the value.
6515 Exception: for arrays where the length is not specified,
6516 the type is left null, to be filled in by `cp_finish_decl'.
6518 Function definitions do not come here; they go to start_function
6519 instead. However, external and forward declarations of functions
6520 do go through here. Structure field declarations are done by
6521 grokfield and not through here. */
6523 /* Set this to zero to debug not using the temporary obstack
6524 to parse initializers. */
6525 int debug_temp_inits
= 1;
6528 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
6529 tree declarator
, declspecs
;
6531 tree attributes
, prefix_attributes
;
6534 register tree type
, tem
;
6536 extern int have_extern_spec
;
6537 extern int used_extern_spec
;
6540 /* See code below that used this. */
6541 int init_written
= initialized
;
6544 /* This should only be done once on the top most decl. */
6545 if (have_extern_spec
&& !used_extern_spec
)
6547 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
6549 used_extern_spec
= 1;
6552 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
6554 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
6557 type
= TREE_TYPE (decl
);
6559 /* Don't lose if destructors must be executed at file-level. */
6560 if (! processing_template_decl
&& TREE_STATIC (decl
)
6561 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6562 && !TREE_PERMANENT (decl
))
6564 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6565 decl
= copy_node (decl
);
6566 if (TREE_CODE (type
) == ARRAY_TYPE
)
6568 tree itype
= TYPE_DOMAIN (type
);
6569 if (itype
&& ! TREE_PERMANENT (itype
))
6571 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6572 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6573 TREE_TYPE (decl
) = type
;
6580 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6581 ? DECL_CLASS_CONTEXT (decl
)
6582 : DECL_CONTEXT (decl
);
6584 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
6585 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
6587 /* When parsing the initializer, lookup should use the object's
6589 push_decl_namespace (context
);
6592 /* We are only interested in class contexts, later. */
6593 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
6594 context
= NULL_TREE
;
6597 /* Is it valid for this decl to have an initializer at all?
6598 If not, set INITIALIZED to zero, which will indirectly
6599 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6600 switch (TREE_CODE (decl
))
6603 /* typedef foo = bar means give foo the same type as bar.
6604 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6605 Any other case of an initialization in a TYPE_DECL is an error. */
6606 if (pedantic
|| list_length (declspecs
) > 1)
6608 cp_error ("typedef `%D' is initialized", decl
);
6614 cp_error ("function `%#D' is initialized like a variable", decl
);
6619 if (! processing_template_decl
)
6621 if (type
!= error_mark_node
)
6623 if (TYPE_SIZE (type
) != NULL_TREE
6624 && ! TREE_CONSTANT (TYPE_SIZE (type
)))
6627 ("variable-sized object `%D' may not be initialized",
6632 if (TREE_CODE (type
) == ARRAY_TYPE
6633 && TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6636 ("elements of array `%#D' have incomplete type", decl
);
6645 if (! toplevel_bindings_p ()
6646 && DECL_EXTERNAL (decl
))
6647 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6649 DECL_EXTERNAL (decl
) = 0;
6650 if (toplevel_bindings_p ())
6651 TREE_STATIC (decl
) = 1;
6653 /* Tell `pushdecl' this is an initialized decl
6654 even though we don't yet have the initializer expression.
6655 Also tell `cp_finish_decl' it may store the real initializer. */
6656 DECL_INITIAL (decl
) = error_mark_node
;
6659 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6661 pushclass (context
, 2);
6663 if (TREE_CODE (decl
) == VAR_DECL
)
6665 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6666 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6667 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6670 if (DECL_CONTEXT (field
) != context
)
6672 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6673 DECL_CONTEXT (field
), DECL_NAME (decl
),
6674 context
, DECL_NAME (decl
));
6675 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6677 /* Static data member are tricky; an in-class initialization
6678 still doesn't provide a definition, so the in-class
6679 declaration will have DECL_EXTERNAL set, but will have an
6680 initialization. Thus, duplicate_decls won't warn
6681 about this situation, and so we check here. */
6682 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6683 cp_error ("duplicate initialization of %D", decl
);
6684 if (duplicate_decls (decl
, field
))
6690 tree field
= check_classfn (context
, decl
);
6691 if (field
&& duplicate_decls (decl
, field
))
6695 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6696 DECL_IN_AGGR_P (decl
) = 0;
6697 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
6698 || CLASSTYPE_USE_TEMPLATE (context
))
6699 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
6701 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
6702 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6706 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6707 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
6710 /* Set attributes here so if duplicate decl, will have proper attributes. */
6711 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
6713 /* Add this decl to the current binding level, but not if it
6714 comes from another scope, e.g. a static member variable.
6715 TEM may equal DECL or it may be a previous decl of the same name. */
6717 if ((TREE_CODE (decl
) != PARM_DECL
&& DECL_CONTEXT (decl
) != NULL_TREE
6718 /* Definitions of namespace members outside their namespace are
6720 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
6721 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
6722 || TREE_CODE (type
) == LANG_TYPE
6723 /* The declaration of template specializations does not affect
6724 the functions available for overload resolution, so we do not
6726 || (TREE_CODE (decl
) == FUNCTION_DECL
6727 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
6730 tem
= pushdecl (decl
);
6732 if (processing_template_decl
)
6734 if (! current_function_decl
)
6735 tem
= push_template_decl (tem
);
6736 else if (minimal_parse_mode
)
6738 = build_min_nt (DECL_STMT
, copy_to_permanent (declarator
),
6739 copy_to_permanent (declspecs
),
6744 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6745 /* Tell the back-end to use or not use .common as appropriate. If we say
6746 -fconserve-space, we want this to save .data space, at the expense of
6747 wrong semantics. If we say -fno-conserve-space, we want this to
6748 produce errors about redefs; to do this we force variables into the
6750 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
6753 if (! processing_template_decl
)
6756 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6757 push_obstacks_nochange ();
6760 /* We have no way of knowing whether the initializer will need to be
6761 evaluated at run-time or not until we've parsed it, so let's just put
6762 it in the permanent obstack. (jason) */
6764 && ! (TREE_CODE (tem
) == PARM_DECL
6765 || (TREE_READONLY (tem
)
6766 && (TREE_CODE (tem
) == VAR_DECL
6767 || TREE_CODE (tem
) == FIELD_DECL
))))
6769 /* When parsing and digesting the initializer,
6770 use temporary storage. Do this even if we will ignore the value. */
6771 if (toplevel_bindings_p () && debug_temp_inits
)
6773 if (processing_template_decl
6774 || TYPE_NEEDS_CONSTRUCTING (type
)
6775 || TREE_CODE (type
) == REFERENCE_TYPE
)
6776 /* In this case, the initializer must lay down in permanent
6777 storage, since it will be saved until `finish_file' is run. */
6780 temporary_allocation ();
6792 tree type
= TREE_TYPE (decl
);
6793 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
6795 /* If this type of object needs a cleanup, and control may
6796 jump past it, make a new binding level so that it is cleaned
6797 up only when it is initialized first. */
6798 if (TYPE_NEEDS_DESTRUCTOR (type
)
6799 && current_binding_level
->more_cleanups_ok
== 0)
6800 pushlevel_temporary (1);
6803 /* Is it valid for this decl to have an initializer at all?
6804 If not, set INITIALIZED to zero, which will indirectly
6805 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6807 /* Don't allow initializations for incomplete types except for
6808 arrays which might be completed by the initialization. */
6809 if (type
== error_mark_node
)
6810 ; /* Don't complain again. */
6811 else if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
6812 ; /* A complete type is ok. */
6813 else if (TREE_CODE (type
) != ARRAY_TYPE
)
6815 cp_error ("variable `%#D' has initializer but incomplete type",
6818 type
= TREE_TYPE (decl
) = error_mark_node
;
6820 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6822 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
6823 cp_error ("elements of array `%#D' have incomplete type", decl
);
6824 /* else we already gave an error in start_decl. */
6830 && TREE_CODE (decl
) != TYPE_DECL
6831 && TREE_CODE (decl
) != TEMPLATE_DECL
6832 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
6834 if ((! processing_template_decl
|| ! uses_template_parms (type
))
6835 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
6837 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6839 /* Change the type so that assemble_variable will give
6840 DECL an rtl we can live with: (mem (const_int 0)). */
6841 type
= TREE_TYPE (decl
) = error_mark_node
;
6845 /* If any base type in the hierarchy of TYPE needs a constructor,
6846 then we set initialized to 1. This way any nodes which are
6847 created for the purposes of initializing this aggregate
6848 will live as long as it does. This is necessary for global
6849 aggregates which do not have their initializers processed until
6850 the end of the file. */
6851 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
6856 /* We don't do this yet for GNU C++. */
6857 /* For a local variable, define the RTL now. */
6858 if (! toplevel_bindings_p ()
6859 /* But not if this is a duplicate decl
6860 and we preserved the rtl from the previous one
6861 (which may or may not happen). */
6862 && DECL_RTL (tem
) == NULL_RTX
)
6864 if (TYPE_SIZE (TREE_TYPE (tem
)) != NULL_TREE
)
6866 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
6867 && DECL_INITIAL (tem
) != NULL_TREE
)
6873 DECL_INITIAL (decl
) = NULL_TREE
;
6876 /* Handle initialization of references.
6877 These three arguments are from `cp_finish_decl', and have the
6878 same meaning here that they do there.
6880 Quotes on semantics can be found in ARM 8.4.3. */
6883 grok_reference_init (decl
, type
, init
)
6884 tree decl
, type
, init
;
6888 if (init
== NULL_TREE
)
6890 if ((DECL_LANG_SPECIFIC (decl
) == 0
6891 || DECL_IN_AGGR_P (decl
) == 0)
6892 && ! DECL_THIS_EXTERN (decl
))
6894 cp_error ("`%D' declared as reference but not initialized", decl
);
6895 if (TREE_CODE (decl
) == VAR_DECL
)
6896 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6901 if (init
== error_mark_node
)
6904 if (TREE_CODE (type
) == REFERENCE_TYPE
6905 && TREE_CODE (init
) == CONSTRUCTOR
)
6907 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
6911 if (TREE_CODE (init
) == TREE_LIST
)
6912 init
= build_compound_expr (init
);
6914 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
6915 init
= convert_from_reference (init
);
6917 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
6918 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
6920 /* Note: default conversion is only called in very special cases. */
6921 init
= default_conversion (init
);
6924 tmp
= convert_to_reference
6925 (type
, init
, CONV_IMPLICIT
,
6926 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
6928 if (tmp
== error_mark_node
)
6930 else if (tmp
!= NULL_TREE
)
6933 DECL_INITIAL (decl
) = save_expr (init
);
6937 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
6941 /* ?? Can this be optimized in some cases to
6942 hand back the DECL_INITIAL slot?? */
6943 if (TYPE_SIZE (TREE_TYPE (type
)))
6945 init
= convert_from_reference (decl
);
6946 if (TREE_PERMANENT (decl
))
6947 init
= copy_to_permanent (init
);
6948 SET_DECL_REFERENCE_SLOT (decl
, init
);
6951 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6953 expand_static_init (decl
, DECL_INITIAL (decl
));
6954 DECL_INITIAL (decl
) = NULL_TREE
;
6959 if (TREE_CODE (decl
) == VAR_DECL
)
6960 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6964 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6965 mucking with forces it does not comprehend (i.e. initialization with a
6966 constructor). If we are at global scope and won't go into COMMON, fill
6967 it in with a dummy CONSTRUCTOR to force the variable into .data;
6968 otherwise we can use error_mark_node. */
6971 obscure_complex_init (decl
, init
)
6974 if (! flag_no_inline
&& TREE_STATIC (decl
))
6976 if (extract_init (decl
, init
))
6980 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6981 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
6982 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
6986 DECL_INITIAL (decl
) = error_mark_node
;
6991 /* Issue an error message if DECL is an uninitialized const variable. */
6994 check_for_uninitialized_const_var (decl
)
6997 tree type
= TREE_TYPE (decl
);
6999 /* ``Unless explicitly declared extern, a const object does not have
7000 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7002 if (TREE_CODE (decl
) == VAR_DECL
7003 && TREE_CODE (type
) != REFERENCE_TYPE
7004 && CP_TYPE_CONST_P (type
)
7005 && !TYPE_NEEDS_CONSTRUCTING (type
)
7006 && !DECL_INITIAL (decl
))
7007 cp_error ("uninitialized const `%D'", decl
);
7010 /* Finish processing of a declaration;
7011 install its line number and initial value.
7012 If the length of an array type is not known before,
7013 it must be determined now, from the initial value, or it is an error.
7015 Call `pop_obstacks' iff NEED_POP is nonzero.
7017 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7018 for aggregates that have constructors alive on the permanent obstack,
7019 so that the global initializing functions can be written at the end.
7021 INIT0 holds the value of an initializer that should be allowed to escape
7024 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7025 if the (init) syntax was used.
7027 For functions that take default parameters, DECL points to its
7028 "maximal" instantiation. `cp_finish_decl' must then also declared its
7029 subsequently lower and lower forms of instantiation, checking for
7030 ambiguity as it goes. This can be sped up later. */
7033 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
7040 tree cleanup
= NULL_TREE
, ttype
= NULL_TREE
;
7042 int temporary
= allocation_temporary_p ();
7043 char *asmspec
= NULL
;
7044 int was_readonly
= 0;
7045 int already_used
= 0;
7047 /* If this is 0, then we did not change obstacks. */
7051 error ("assignment (not initialization) in declaration");
7055 /* If a name was specified, get the string. */
7057 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7059 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7061 cp_error ("Cannot initialize `%D' to namespace `%D'",
7066 if (current_class_type
7067 && DECL_REAL_CONTEXT (decl
) == current_class_type
7068 && TYPE_BEING_DEFINED (current_class_type
)
7069 && (DECL_INITIAL (decl
) || init
))
7070 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
7072 if (TREE_CODE (decl
) == VAR_DECL
7073 && DECL_CONTEXT (decl
)
7074 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7075 && DECL_CONTEXT (decl
) != current_namespace
7078 /* Leave the namespace of the object. */
7079 pop_decl_namespace ();
7082 /* If the type of the thing we are declaring either has
7083 a constructor, or has a virtual function table pointer,
7084 AND its initialization was accepted by `start_decl',
7085 then we stayed on the permanent obstack through the
7086 declaration, otherwise, changed obstacks as GCC would. */
7088 type
= TREE_TYPE (decl
);
7090 if (type
== error_mark_node
)
7092 if (toplevel_bindings_p () && temporary
)
7093 end_temporary_allocation ();
7098 if (processing_template_decl
)
7100 if (init
&& DECL_INITIAL (decl
))
7101 DECL_INITIAL (decl
) = init
;
7102 if (minimal_parse_mode
&& ! DECL_ARTIFICIAL (decl
))
7104 tree stmt
= DECL_VINDEX (decl
);
7105 /* If the decl is declaring a member of a local class (in a
7106 template function), the DECL_VINDEX will either be NULL,
7107 or it will be an actual virtual function index, not a
7109 if (stmt
!= NULL_TREE
&& TREE_CODE (stmt
) == DECL_STMT
)
7111 DECL_VINDEX (decl
) = NULL_TREE
;
7112 TREE_OPERAND (stmt
, 2) = copy_to_permanent (init
);
7119 /* Take care of TYPE_DECLs up front. */
7120 if (TREE_CODE (decl
) == TYPE_DECL
)
7122 if (init
&& DECL_INITIAL (decl
))
7124 /* typedef foo = bar; store the type of bar as the type of foo. */
7125 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7126 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7128 if (type
!= error_mark_node
7129 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7131 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7132 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
7133 set_identifier_type_value (DECL_NAME (decl
), type
);
7134 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
7136 GNU_xref_decl (current_function_decl
, decl
);
7138 /* If we have installed this as the canonical typedef for this
7139 type, and that type has not been defined yet, delay emitting
7140 the debug information for it, as we will emit it later. */
7141 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
7142 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
7143 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
7145 rest_of_decl_compilation (decl
, NULL_PTR
,
7146 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
7149 if (TREE_CODE (decl
) != FUNCTION_DECL
)
7151 ttype
= target_type (type
);
7154 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
7155 && TYPE_NEEDS_CONSTRUCTING (type
))
7158 /* Currently, GNU C++ puts constants in text space, making them
7159 impossible to initialize. In the future, one would hope for
7160 an operating system which understood the difference between
7161 initialization and the running of a program. */
7163 TREE_READONLY (decl
) = 0;
7166 if (TREE_CODE (decl
) == FIELD_DECL
)
7168 if (init
&& init
!= error_mark_node
)
7169 my_friendly_assert (TREE_PERMANENT (init
), 147);
7173 /* This must override the asm specifier which was placed
7174 by grokclassfn. Lay this out fresh. */
7175 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
7176 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7177 make_decl_rtl (decl
, asmspec
, 0);
7180 /* If `start_decl' didn't like having an initialization, ignore it now. */
7181 else if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7183 else if (DECL_EXTERNAL (decl
))
7185 else if (TREE_CODE (type
) == REFERENCE_TYPE
7186 || (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE_REFERENCE (type
)))
7188 if (TREE_STATIC (decl
))
7189 make_decl_rtl (decl
, NULL_PTR
,
7190 toplevel_bindings_p ()
7191 || pseudo_global_level_p ());
7192 grok_reference_init (decl
, type
, init
);
7196 GNU_xref_decl (current_function_decl
, decl
);
7198 if (TREE_CODE (decl
) == FIELD_DECL
)
7200 else if (TREE_CODE (decl
) == CONST_DECL
)
7202 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7204 DECL_INITIAL (decl
) = init
;
7206 /* This will keep us from needing to worry about our obstacks. */
7207 my_friendly_assert (init
!= NULL_TREE
, 149);
7212 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7214 if (TREE_CODE (type
) == ARRAY_TYPE
)
7215 init
= digest_init (type
, init
, (tree
*) 0);
7216 else if (TREE_CODE (init
) == CONSTRUCTOR
)
7218 if (TYPE_NON_AGGREGATE_CLASS (type
))
7220 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7222 init
= error_mark_node
;
7225 goto dont_use_constructor
;
7230 dont_use_constructor
:
7231 if (TREE_CODE (init
) != TREE_VEC
)
7232 init
= store_init_value (decl
, init
);
7236 /* We must hide the initializer so that expand_decl
7237 won't try to do something it does not understand. */
7238 init
= obscure_complex_init (decl
, init
);
7240 else if (DECL_EXTERNAL (decl
))
7242 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
7243 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7246 while (TREE_CODE (ctype
) == ARRAY_TYPE
)
7247 ctype
= TREE_TYPE (ctype
);
7248 if (! TYPE_NEEDS_CONSTRUCTING (ctype
))
7250 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype
))
7251 cp_error ("structure `%D' with uninitialized const members", decl
);
7252 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype
))
7253 cp_error ("structure `%D' with uninitialized reference members",
7257 check_for_uninitialized_const_var (decl
);
7259 if (TYPE_SIZE (type
) != NULL_TREE
7260 && TYPE_NEEDS_CONSTRUCTING (type
))
7261 init
= obscure_complex_init (decl
, NULL_TREE
);
7265 check_for_uninitialized_const_var (decl
);
7267 /* For top-level declaration, the initial value was read in
7268 the temporary obstack. MAXINDEX, rtl, etc. to be made below
7269 must go in the permanent obstack; but don't discard the
7270 temporary data yet. */
7272 if (toplevel_bindings_p () && temporary
)
7273 end_temporary_allocation ();
7275 /* Deduce size of array from initialization, if not already known. */
7277 if (TREE_CODE (type
) == ARRAY_TYPE
7278 && TYPE_DOMAIN (type
) == NULL_TREE
7279 && TREE_CODE (decl
) != TYPE_DECL
)
7282 = (TREE_STATIC (decl
)
7283 /* Even if pedantic, an external linkage array
7284 may have incomplete type at first. */
7285 ? pedantic
&& ! DECL_EXTERNAL (decl
)
7286 : !DECL_EXTERNAL (decl
));
7287 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7288 int failure
= complete_array_type (type
, initializer
, do_default
);
7291 cp_error ("initializer fails to determine size of `%D'", decl
);
7296 cp_error ("array size missing in `%D'", decl
);
7297 /* If a `static' var's size isn't known, make it extern as
7298 well as static, so it does not get allocated. If it's not
7299 `static', then don't mark it extern; finish_incomplete_decl
7300 will give it a default size and it will get allocated. */
7301 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7302 DECL_EXTERNAL (decl
) = 1;
7305 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7306 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7308 cp_error ("zero-size array `%D'", decl
);
7310 layout_decl (decl
, 0);
7313 if (TREE_CODE (decl
) == VAR_DECL
)
7315 if (DECL_SIZE (decl
) == NULL_TREE
7316 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
7317 layout_decl (decl
, 0);
7319 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7321 /* A static variable with an incomplete type:
7322 that is an error if it is initialized.
7323 Otherwise, let it through, but if it is not `extern'
7324 then it may cause an error message later. */
7325 if (DECL_INITIAL (decl
) != NULL_TREE
)
7326 cp_error ("storage size of `%D' isn't known", decl
);
7329 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7331 /* An automatic variable with an incomplete type: that is an error.
7332 Don't talk about array types here, since we took care of that
7333 message in grokdeclarator. */
7334 cp_error ("storage size of `%D' isn't known", decl
);
7335 TREE_TYPE (decl
) = error_mark_node
;
7337 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7338 /* Let debugger know it should output info for this type. */
7339 note_debug_info_needed (ttype
);
7341 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7342 note_debug_info_needed (DECL_CONTEXT (decl
));
7344 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7345 && DECL_SIZE (decl
) != NULL_TREE
7346 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7348 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7349 constant_expression_warning (DECL_SIZE (decl
));
7351 cp_error ("storage size of `%D' isn't constant", decl
);
7354 if (! DECL_EXTERNAL (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7355 /* Cleanups for static variables are handled by `finish_file'. */
7356 && ! TREE_STATIC (decl
))
7358 int yes
= suspend_momentary ();
7359 cleanup
= maybe_build_cleanup (decl
);
7360 resume_momentary (yes
);
7363 /* PARM_DECLs get cleanups, too. */
7364 else if (TREE_CODE (decl
) == PARM_DECL
&& TYPE_NEEDS_DESTRUCTOR (type
))
7367 end_temporary_allocation ();
7368 cleanup
= maybe_build_cleanup (decl
);
7370 resume_temporary_allocation ();
7373 /* Output the assembler code and/or RTL code for variables and functions,
7374 unless the type is an undefined structure or union.
7375 If not, it will get done when the type is completed. */
7377 was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
7379 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
7380 || TREE_CODE (decl
) == RESULT_DECL
)
7382 /* ??? FIXME: What about nested classes? */
7383 int toplev
= toplevel_bindings_p () || pseudo_global_level_p ();
7385 = (TREE_STATIC (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
7386 && allocation_temporary_p ());
7389 end_temporary_allocation ();
7391 /* Static data in a function with comdat linkage also has comdat
7393 if (TREE_CODE (decl
) == VAR_DECL
7394 && TREE_STATIC (decl
)
7395 /* Don't mess with __FUNCTION__. */
7396 && ! TREE_ASM_WRITTEN (decl
)
7397 && current_function_decl
7398 && DECL_CONTEXT (decl
) == current_function_decl
7399 && (DECL_THIS_INLINE (current_function_decl
)
7400 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7401 && TREE_PUBLIC (current_function_decl
))
7403 /* Rather than try to get this right with inlining, we suppress
7404 inlining of such functions. */
7405 current_function_cannot_inline
7406 = "function with static variable cannot be inline";
7408 /* If flag_weak, we don't need to mess with this, as we can just
7409 make the function weak, and let it refer to its unique local
7410 copy. This works because we don't allow the function to be
7414 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7416 TREE_PUBLIC (decl
) = 1;
7417 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7419 else if (DECL_INITIAL (decl
) == NULL_TREE
7420 || DECL_INITIAL (decl
) == error_mark_node
)
7422 TREE_PUBLIC (decl
) = 1;
7423 DECL_COMMON (decl
) = 1;
7425 /* else we lose. We can only do this if we can use common,
7426 which we can't if it has been initialized. */
7428 if (TREE_PUBLIC (decl
))
7429 DECL_ASSEMBLER_NAME (decl
)
7430 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7431 else if (! DECL_ARTIFICIAL (decl
))
7433 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7434 cp_warning_at (" you can work around this by removing the initializer"), decl
;
7439 else if (TREE_CODE (decl
) == VAR_DECL
7440 && DECL_LANG_SPECIFIC (decl
)
7441 && DECL_COMDAT (decl
))
7443 /* Dynamically initialized vars go into common. */
7444 if (DECL_INITIAL (decl
) == NULL_TREE
7445 || DECL_INITIAL (decl
) == error_mark_node
)
7446 DECL_COMMON (decl
) = 1;
7447 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7449 DECL_COMMON (decl
) = 1;
7450 DECL_INITIAL (decl
) = error_mark_node
;
7454 /* Statically initialized vars are weak or comdat, if
7457 make_decl_one_only (decl
);
7460 /* We can't do anything useful; leave vars for explicit
7462 DECL_EXTERNAL (decl
) = 1;
7463 DECL_NOT_REALLY_EXTERN (decl
) = 0;
7468 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
7469 make_decl_rtl (decl
, NULL_PTR
, toplev
);
7470 else if (TREE_CODE (decl
) == VAR_DECL
7471 && TREE_READONLY (decl
)
7472 && DECL_INITIAL (decl
) != NULL_TREE
7473 && DECL_INITIAL (decl
) != error_mark_node
7474 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
7476 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
7479 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7482 && TREE_STATIC (decl
)
7483 && ! TREE_SIDE_EFFECTS (decl
)
7484 && ! TREE_PUBLIC (decl
)
7485 && ! DECL_EXTERNAL (decl
)
7486 && ! TYPE_NEEDS_DESTRUCTOR (type
)
7487 && DECL_MODE (decl
) != BLKmode
)
7489 /* If this variable is really a constant, then fill its DECL_RTL
7490 slot with something which won't take up storage.
7491 If something later should take its address, we can always give
7492 it legitimate RTL at that time. */
7493 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
7494 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
7495 TREE_ASM_WRITTEN (decl
) = 1;
7497 else if (toplev
&& ! TREE_PUBLIC (decl
))
7499 /* If this is a static const, change its apparent linkage
7500 if it belongs to a #pragma interface. */
7501 if (!interface_unknown
)
7503 TREE_PUBLIC (decl
) = 1;
7504 DECL_EXTERNAL (decl
) = interface_only
;
7506 make_decl_rtl (decl
, asmspec
, toplev
);
7509 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7511 else if (TREE_CODE (decl
) == VAR_DECL
7512 && DECL_LANG_SPECIFIC (decl
)
7513 && DECL_IN_AGGR_P (decl
))
7515 if (TREE_STATIC (decl
))
7517 if (init
== NULL_TREE
7518 #ifdef DEFAULT_STATIC_DEFS
7519 /* If this code is dead, then users must
7520 explicitly declare static member variables
7521 outside the class def'n as well. */
7522 && TYPE_NEEDS_CONSTRUCTING (type
)
7526 DECL_EXTERNAL (decl
) = 1;
7527 make_decl_rtl (decl
, asmspec
, 1);
7530 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7533 /* Just a constant field. Should not need any rtl. */
7537 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7540 resume_temporary_allocation ();
7542 if (type
!= error_mark_node
7543 && TYPE_LANG_SPECIFIC (type
)
7544 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
7545 abstract_virtuals_error (decl
, type
);
7546 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7547 || TREE_CODE (type
) == METHOD_TYPE
)
7548 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7549 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type
)))
7550 abstract_virtuals_error (decl
, TREE_TYPE (type
));
7552 if (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE (type
))
7553 signature_error (decl
, type
);
7554 else if ((TREE_CODE (type
) == FUNCTION_TYPE
7555 || TREE_CODE (type
) == METHOD_TYPE
)
7556 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
7557 && IS_SIGNATURE (TREE_TYPE (type
)))
7558 signature_error (decl
, TREE_TYPE (type
));
7560 if (TREE_CODE (decl
) == FUNCTION_DECL
)
7562 else if (DECL_EXTERNAL (decl
)
7563 && ! (DECL_LANG_SPECIFIC (decl
)
7564 && DECL_NOT_REALLY_EXTERN (decl
)))
7567 DECL_INITIAL (decl
) = init
;
7569 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
7571 /* Cleanups for static variables are handled by `finish_file'. */
7572 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7573 || TYPE_NEEDS_DESTRUCTOR (type
))
7574 expand_static_init (decl
, init
);
7578 /* This is a declared decl which must live until the
7579 end of the binding contour. It may need a cleanup. */
7581 /* Recompute the RTL of a local array now
7582 if it used to be an incomplete type. */
7583 if (was_incomplete
&& ! TREE_STATIC (decl
))
7585 /* If we used it already as memory, it must stay in memory. */
7586 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7587 /* If it's still incomplete now, no init will save it. */
7588 if (DECL_SIZE (decl
) == NULL_TREE
)
7589 DECL_INITIAL (decl
) = NULL_TREE
;
7592 else if (! TREE_ASM_WRITTEN (decl
)
7593 && (TYPE_SIZE (type
) != NULL_TREE
7594 || TREE_CODE (type
) == ARRAY_TYPE
))
7596 /* Do this here, because we did not expand this decl's
7597 rtl in start_decl. */
7598 if (DECL_RTL (decl
) == NULL_RTX
)
7602 /* XXX: Why don't we use decl here? */
7603 /* Ans: Because it was already expanded? */
7604 if (! expand_decl_cleanup (NULL_TREE
, cleanup
))
7605 cp_error ("parser lost in parsing declaration of `%D'",
7607 /* Cleanup used up here. */
7608 cleanup
= NULL_TREE
;
7612 if (current_binding_level
->is_for_scope
)
7614 struct binding_level
*outer
= current_binding_level
->level_chain
;
7616 /* Check to see if the same name is already bound at
7617 the outer level, either because it was directly declared,
7618 or because a dead for-decl got preserved. In either case,
7619 the code would not have been valid under the ARM
7620 scope rules, so clear is_for_scope for the
7621 current_binding_level.
7623 Otherwise, we need to preserve the temp slot for decl
7624 to last into the outer binding level. */
7626 int handling_dead_for_vars
= 0;
7627 tree link
= outer
->names
;
7628 for (; ; link
= TREE_CHAIN (link
))
7630 if (link
== NULL
&& handling_dead_for_vars
== 0)
7632 link
= outer
->dead_vars_from_for
;
7633 handling_dead_for_vars
= 1;
7637 if (DECL_IN_MEMORY_P (decl
))
7638 preserve_temp_slots (DECL_RTL (decl
));
7641 if (DECL_NAME (link
) == DECL_NAME (decl
))
7643 if (handling_dead_for_vars
)
7646 = purpose_member (DECL_NAME (decl
),
7647 current_binding_level
->shadowed
);
7648 if (shadowing
&& TREE_VALUE (shadowing
) == link
)
7649 TREE_VALUE (shadowing
)
7650 = DECL_SHADOWED_FOR_VAR (link
);
7652 current_binding_level
->is_for_scope
= 0;
7658 expand_start_target_temps ();
7660 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7662 /* Compute and store the initial value. */
7663 expand_decl_init (decl
);
7664 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7666 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7668 emit_line_note (DECL_SOURCE_FILE (decl
),
7669 DECL_SOURCE_LINE (decl
));
7670 expand_aggr_init (decl
, init
, flags
);
7673 /* Set this to 0 so we can tell whether an aggregate which
7674 was initialized was ever used. Don't do this if it has a
7675 destructor, so we don't complain about the 'resource
7676 allocation is initialization' idiom. */
7677 /* Now set attribute((unused)) on types so decls of
7678 that type will be marked used. (see TREE_USED, above.)
7679 This avoids the warning problems this particular code
7680 tried to work around. */
7682 if (TYPE_NEEDS_CONSTRUCTING (type
)
7684 && cleanup
== NULL_TREE
7685 && DECL_NAME (decl
))
7686 TREE_USED (decl
) = 0;
7689 TREE_USED (decl
) = 1;
7692 /* Cleanup any temporaries needed for the initial value. */
7693 expand_end_target_temps ();
7695 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7697 /* Store the cleanup, if there was one. */
7700 if (! expand_decl_cleanup (decl
, cleanup
))
7701 cp_error ("parser lost in parsing declaration of `%D'",
7708 /* Undo call to `pushclass' that was done in `start_decl'
7709 due to initialization of qualified member variable.
7710 I.e., Foo::x = 10; */
7712 tree context
= DECL_REAL_CONTEXT (decl
);
7714 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
7715 && (TREE_CODE (decl
) == VAR_DECL
7716 /* We also have a pushclass done that we need to undo here
7717 if we're at top level and declare a method. */
7718 || TREE_CODE (decl
) == FUNCTION_DECL
)
7719 /* If size hasn't been set, we're still defining it,
7720 and therefore inside the class body; don't pop
7721 the binding level.. */
7722 && TYPE_SIZE (context
) != NULL_TREE
7723 && context
== current_class_type
)
7730 /* If requested, warn about definitions of large data objects. */
7732 if (warn_larger_than
7733 && ! processing_template_decl
7734 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
7735 && !DECL_EXTERNAL (decl
))
7737 register tree decl_size
= DECL_SIZE (decl
);
7739 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
7741 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
7743 if (units
> larger_than_size
)
7744 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
7750 /* Resume permanent allocation, if not within a function. */
7751 /* The corresponding push_obstacks_nochange is in start_decl,
7752 start_method, groktypename, and in grokfield. */
7757 TREE_READONLY (decl
) = 1;
7760 /* This is here for a midend callback from c-common.c */
7763 finish_decl (decl
, init
, asmspec_tree
)
7767 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
7771 expand_static_init (decl
, init
)
7775 tree oldstatic
= value_member (decl
, static_aggregates
);
7779 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
7780 cp_error ("multiple initializations given for `%D'", decl
);
7782 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7784 /* Emit code to perform this initialization but once. */
7787 /* Remember this information until end of file. */
7788 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7790 /* Emit code to perform this initialization but once. */
7791 temp
= get_temp_name (integer_type_node
, 1);
7792 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
7793 expand_start_cond (build_binary_op (EQ_EXPR
, temp
,
7794 integer_zero_node
, 1), 0);
7795 expand_start_target_temps ();
7797 expand_assignment (temp
, integer_one_node
, 0, 0);
7798 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
7799 || (init
&& TREE_CODE (init
) == TREE_LIST
))
7801 expand_aggr_init (decl
, init
, 0);
7802 do_pending_stack_adjust ();
7805 expand_assignment (decl
, init
, 0, 0);
7807 /* Cleanup any temporaries needed for the initial value. */
7808 expand_end_target_temps ();
7810 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7812 tree cleanup
, fcall
;
7813 static tree Atexit
= 0;
7816 tree atexit_fndecl
, PFV
, pfvlist
;
7817 /* Remember this information until end of file. */
7818 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7819 PFV
= build_pointer_type (build_function_type
7820 (void_type_node
, void_list_node
));
7822 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
7824 push_lang_context (lang_name_c
);
7826 = builtin_function ("atexit",
7827 build_function_type (void_type_node
,
7829 NOT_BUILT_IN
, NULL_PTR
);
7830 assemble_external (atexit_fndecl
);
7831 Atexit
= default_conversion (atexit_fndecl
);
7832 pop_lang_context ();
7836 /* Call build_cleanup before we enter the anonymous function
7837 so that any access checks will be done relative to the
7838 current scope, rather than the scope of the anonymous
7840 fcall
= build_cleanup (decl
);
7841 cleanup
= start_anon_func ();
7842 expand_expr_stmt (fcall
);
7844 mark_addressable (cleanup
);
7845 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
7846 fcall
= build_function_call (Atexit
, expr_tree_cons (NULL_TREE
, cleanup
, NULL_TREE
));
7847 expand_expr_stmt (fcall
);
7851 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7853 static_aggregates
= perm_tree_cons (temp
, decl
, static_aggregates
);
7854 TREE_STATIC (static_aggregates
) = 1;
7857 /* Resume old (possibly temporary) allocation. */
7862 /* This code takes into account memory allocation
7863 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7864 does not hold for this object, then we must make permanent
7865 the storage currently in the temporary obstack. */
7866 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
7867 preserve_initializer ();
7868 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
7872 /* Make TYPE a complete type based on INITIAL_VALUE.
7873 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7874 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7877 complete_array_type (type
, initial_value
, do_default
)
7878 tree type
, initial_value
;
7881 register tree maxindex
= NULL_TREE
;
7886 /* Note MAXINDEX is really the maximum index,
7887 one less than the size. */
7888 if (TREE_CODE (initial_value
) == STRING_CST
)
7891 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7892 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
7895 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7897 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
7898 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
7899 for (; elts
; elts
= TREE_CHAIN (elts
))
7901 if (TREE_PURPOSE (elts
))
7902 maxindex
= TREE_PURPOSE (elts
);
7904 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
7906 maxindex
= copy_node (maxindex
);
7910 /* Make an error message unless that happened already. */
7911 if (initial_value
!= error_mark_node
)
7914 /* Prevent further error messages. */
7915 maxindex
= build_int_2 (0, 0);
7922 maxindex
= build_int_2 (0, 0);
7930 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
7931 if (! TREE_TYPE (maxindex
))
7932 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
7934 itype
= TREE_TYPE (initial_value
);
7937 if (itype
&& !TYPE_DOMAIN (itype
))
7938 TYPE_DOMAIN (itype
) = TYPE_DOMAIN (type
);
7939 /* The type of the main variant should never be used for arrays
7940 of different sizes. It should only ever be completed with the
7941 size of the array. */
7942 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
7943 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = TYPE_DOMAIN (type
);
7946 /* Lay out the type now that we can get the real answer. */
7953 /* Return zero if something is declared to be a member of type
7954 CTYPE when in the context of CUR_TYPE. STRING is the error
7955 message to print in that case. Otherwise, quietly return 1. */
7958 member_function_or_else (ctype
, cur_type
, string
)
7959 tree ctype
, cur_type
;
7962 if (ctype
&& ctype
!= cur_type
)
7964 error (string
, TYPE_NAME_STRING (ctype
));
7970 /* Subroutine of `grokdeclarator'. */
7972 /* Generate errors possibly applicable for a given set of specifiers.
7973 This is for ARM $7.1.2. */
7976 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
7979 int virtualp
, quals
, friendp
, raises
, inlinep
;
7982 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
7984 cp_error ("`%D' declared as an `inline' %s", object
, type
);
7986 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7989 cp_error_at ("invalid friend declaration", object
);
7991 cp_error_at ("invalid exception specifications", object
);
7994 /* CTYPE is class type, or null if non-class.
7995 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7997 DECLARATOR is the function's name.
7998 VIRTUALP is truthvalue of whether the function is virtual or not.
7999 FLAGS are to be passed through to `grokclassfn'.
8000 QUALS are qualifiers indicating whether the function is `const'
8002 RAISES is a list of exceptions that this function can raise.
8003 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8004 not look, and -1 if we should not call `grokclassfn' at all.
8006 Returns `error_mark_node' if something goes wrong, after issuing
8007 applicable error messages. */
8010 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8011 raises
, attrlist
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8012 template_count
, in_namespace
)
8015 tree orig_declarator
;
8017 enum overload_flags flags
;
8018 tree quals
, raises
, attrlist
;
8019 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8023 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8027 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8028 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8034 type
= build_exception_variant (type
, raises
);
8037 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8038 /* Propagate volatile out from type to decl. */
8039 if (TYPE_VOLATILE (type
))
8040 TREE_THIS_VOLATILE (decl
) = 1;
8042 /* If this decl has namespace scope, set that up. */
8044 set_decl_namespace (decl
, in_namespace
);
8045 else if (publicp
&& ! ctype
)
8046 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8048 /* `main' and builtins have implicit 'C' linkage. */
8049 if ((MAIN_NAME_P (declarator
)
8050 || (IDENTIFIER_LENGTH (declarator
) > 10
8051 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8052 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8053 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8054 && current_lang_name
== lang_name_cplusplus
8055 && ctype
== NULL_TREE
8056 /* NULL_TREE means global namespace. */
8057 && DECL_CONTEXT (decl
) == NULL_TREE
)
8058 DECL_LANGUAGE (decl
) = lang_c
;
8060 /* Should probably propagate const out from type to decl I bet (mrs). */
8063 DECL_STATIC_FUNCTION_P (decl
) = 1;
8064 DECL_CONTEXT (decl
) = ctype
;
8068 DECL_CLASS_CONTEXT (decl
) = ctype
;
8070 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8073 error ("cannot declare `main' to be inline");
8075 error ("cannot declare `main' to be static");
8080 /* Members of anonymous types have no linkage; make them internal. */
8081 if (ctype
&& ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
)))
8086 /* [basic.link]: A name with no linkage (notably, the name of a class
8087 or enumeration declared in a local scope) shall not be used to
8088 declare an entity with linkage.
8090 Only check this for public decls for now. */
8091 t
= no_linkage_check (TREE_TYPE (decl
));
8094 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8096 if (DECL_LANGUAGE (decl
) == lang_c
)
8097 /* Allow this; it's pretty common in C. */;
8099 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8103 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8108 TREE_PUBLIC (decl
) = publicp
;
8111 DECL_INTERFACE_KNOWN (decl
) = 1;
8112 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8116 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8118 DECL_EXTERNAL (decl
) = 1;
8119 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8121 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8122 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8126 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8127 grok_op_properties (decl
, virtualp
, check
< 0);
8129 if (ctype
&& hack_decl_function_context (decl
))
8130 DECL_NO_STATIC_CHAIN (decl
) = 1;
8132 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8133 if (TREE_PURPOSE (t
)
8134 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8136 add_defarg_fn (decl
);
8141 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8145 ("defining explicit specialization `%D' in friend declaration",
8149 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8151 /* Something like `template <class T> friend void f<T>()'. */
8152 cp_error ("template-id `%D' in declaration of primary template",
8154 return error_mark_node
;
8157 /* A friend declaration of the form friend void f<>(). Record
8158 the information in the TEMPLATE_ID_EXPR. */
8159 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8160 DECL_TEMPLATE_INFO (decl
)
8161 = perm_tree_cons (TREE_OPERAND (orig_declarator
, 0),
8162 TREE_OPERAND (orig_declarator
, 1),
8167 /* Plain overloading: will not be grok'd by grokclassfn. */
8168 if (! ctype
&& ! processing_template_decl
8169 && DECL_LANGUAGE (decl
) != lang_c
8170 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8171 set_mangled_name_for_decl (decl
);
8174 /* Make the init_value nonzero so pushdecl knows this is not
8175 tentative. error_mark_node is replaced later with the BLOCK. */
8176 DECL_INITIAL (decl
) = error_mark_node
;
8178 /* Caller will do the rest of this. */
8182 if (check
&& funcdef_flag
)
8183 DECL_INITIAL (decl
) = error_mark_node
;
8185 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8188 /* Just handle constructors here. We could do this
8189 inside the following if stmt, but I think
8190 that the code is more legible by breaking this
8191 case out. See comments below for what each of
8192 the following calls is supposed to do. */
8193 DECL_CONSTRUCTOR_P (decl
) = 1;
8195 grokclassfn (ctype
, decl
, flags
, quals
);
8197 decl
= check_explicit_specialization (orig_declarator
, decl
,
8199 2 * (funcdef_flag
!= 0) +
8200 4 * (friendp
!= 0));
8201 if (decl
== error_mark_node
)
8202 return error_mark_node
;
8204 if ((! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8207 tmp
= check_classfn (ctype
, decl
);
8209 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8210 tmp
= DECL_TEMPLATE_RESULT(tmp
);
8212 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8213 cp_error ("definition of implicitly-declared `%D'", tmp
);
8214 if (tmp
&& duplicate_decls (decl
, tmp
))
8217 if (! grok_ctor_properties (ctype
, decl
))
8218 return error_mark_node
;
8224 /* Function gets the ugly name, field gets the nice one.
8225 This call may change the type of the function (because
8226 of default parameters)! */
8227 if (ctype
!= NULL_TREE
)
8228 grokclassfn (ctype
, decl
, flags
, quals
);
8230 decl
= check_explicit_specialization (orig_declarator
, decl
,
8232 2 * (funcdef_flag
!= 0) +
8233 4 * (friendp
!= 0));
8234 if (decl
== error_mark_node
)
8235 return error_mark_node
;
8237 if (ctype
!= NULL_TREE
8238 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8241 tmp
= check_classfn (ctype
, decl
);
8243 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
8244 tmp
= DECL_TEMPLATE_RESULT (tmp
);
8246 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
8247 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8249 /* Remove the `this' parm added by grokclassfn.
8250 XXX Isn't this done in start_function, too? */
8251 revert_static_member_fn (&decl
, NULL
, NULL
);
8252 last_function_parms
= TREE_CHAIN (last_function_parms
);
8254 if (tmp
&& DECL_ARTIFICIAL (tmp
))
8255 cp_error ("definition of implicitly-declared `%D'", tmp
);
8258 if (!duplicate_decls (decl
, tmp
))
8259 my_friendly_abort (892);
8264 if (ctype
== NULL_TREE
|| check
)
8268 cplus_decl_attributes (decl
, TREE_PURPOSE (attrlist
),
8269 TREE_VALUE (attrlist
));
8270 make_decl_rtl (decl
, NULL_PTR
, 1);
8274 DECL_VIRTUAL_P (decl
) = 1;
8275 if (DECL_VINDEX (decl
) == NULL_TREE
)
8276 DECL_VINDEX (decl
) = error_mark_node
;
8277 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
8284 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8287 RID_BIT_TYPE
*specbits_in
;
8293 RID_BIT_TYPE specbits
;
8295 specbits
= *specbits_in
;
8297 if (TREE_CODE (type
) == OFFSET_TYPE
)
8299 /* If you declare a static member so that it
8300 can be initialized, the code will reach here. */
8301 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8302 type
= TREE_TYPE (type
);
8303 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
8304 DECL_CONTEXT (decl
) = basetype
;
8305 DECL_CLASS_CONTEXT (decl
) = basetype
;
8306 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
8313 context
= in_namespace
;
8314 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8315 context
= current_namespace
;
8317 context
= NULL_TREE
;
8319 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
8322 set_decl_namespace (decl
, context
);
8324 context
= DECL_CONTEXT (decl
);
8325 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8326 DECL_ASSEMBLER_NAME (decl
) = build_static_name (context
, declarator
);
8330 set_decl_namespace (decl
, in_namespace
);
8332 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
8334 DECL_THIS_EXTERN (decl
) = 1;
8335 DECL_EXTERNAL (decl
) = !initialized
;
8338 /* In class context, static means one per class,
8339 public access, and static storage. */
8340 if (DECL_CLASS_SCOPE_P (decl
))
8342 TREE_PUBLIC (decl
) = 1;
8343 TREE_STATIC (decl
) = 1;
8344 DECL_EXTERNAL (decl
) = 0;
8346 /* At top level, either `static' or no s.c. makes a definition
8347 (perhaps tentative), and absence of `static' makes it public. */
8348 else if (toplevel_bindings_p ())
8350 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
8351 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8352 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8354 /* Not at top level, only `static' makes a static definition. */
8357 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
8358 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8361 if (TREE_PUBLIC (decl
))
8363 /* [basic.link]: A name with no linkage (notably, the name of a class
8364 or enumeration declared in a local scope) shall not be used to
8365 declare an entity with linkage.
8367 Only check this for public decls for now. */
8368 tree t
= no_linkage_check (TREE_TYPE (decl
));
8371 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8372 /* Ignore for now; `enum { foo } e' is pretty common. */;
8374 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8382 /* Create a canonical pointer to member function type. */
8385 build_ptrmemfunc_type (type
)
8392 /* If a canonical type already exists for this type, use it. We use
8393 this method instead of type_hash_canon, because it only does a
8394 simple equality check on the list of field members. */
8396 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8399 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
8401 u
= make_lang_type (UNION_TYPE
);
8402 IS_AGGR_TYPE (u
) = 0;
8403 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
8404 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
8406 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
8407 TYPE_NAME (u
) = NULL_TREE
;
8409 t
= make_lang_type (RECORD_TYPE
);
8411 /* Let the front-end know this is a pointer to member function... */
8412 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8413 /* ... and not really an aggregate. */
8414 IS_AGGR_TYPE (t
) = 0;
8416 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
8418 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
8420 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
8421 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
8425 /* Zap out the name so that the back-end will give us the debugging
8426 information for this anonymous RECORD_TYPE. */
8427 TYPE_NAME (t
) = NULL_TREE
;
8429 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8431 /* Seems to be wanted. */
8432 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
8436 /* Given declspecs and a declarator,
8437 determine the name and type of the object declared
8438 and construct a ..._DECL node for it.
8439 (In one case we can return a ..._TYPE node instead.
8440 For invalid input we sometimes return 0.)
8442 DECLSPECS is a chain of tree_list nodes whose value fields
8443 are the storage classes and type specifiers.
8445 DECL_CONTEXT says which syntactic context this declaration is in:
8446 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8447 FUNCDEF for a function definition. Like NORMAL but a few different
8448 error messages in each case. Return value may be zero meaning
8449 this definition is too screwy to try to parse.
8450 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8451 handle member functions (which have FIELD context).
8452 Return value may be zero meaning this definition is too screwy to
8454 PARM for a parameter declaration (either within a function prototype
8455 or before a function body). Make a PARM_DECL, or return void_type_node.
8456 CATCHPARM for a parameter declaration before a catch clause.
8457 TYPENAME if for a typename (in a cast or sizeof).
8458 Don't make a DECL node; just return the ..._TYPE node.
8459 FIELD for a struct or union field; make a FIELD_DECL.
8460 BITFIELD for a field with specified width.
8461 INITIALIZED is 1 if the decl has an initializer.
8463 In the TYPENAME case, DECLARATOR is really an absolute declarator.
8464 It may also be so in the PARM case, for a prototype where the
8465 argument type is specified but not the name.
8467 This function is where the complicated C meanings of `static'
8468 and `extern' are interpreted.
8470 For C++, if there is any monkey business to do, the function which
8471 calls this one must do it, i.e., prepending instance variables,
8472 renaming overloaded function names, etc.
8474 Note that for this C++, it is an error to define a method within a class
8475 which does not belong to that class.
8477 Except in the case where SCOPE_REFs are implicitly known (such as
8478 methods within a class being redundantly qualified),
8479 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
8480 (class_name::decl_name). The caller must also deal with this.
8482 If a constructor or destructor is seen, and the context is FIELD,
8483 then the type gains the attribute TREE_HAS_x. If such a declaration
8484 is erroneous, NULL_TREE is returned.
8486 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
8487 function, these are the qualifiers to give to the `this' pointer.
8489 May return void_type_node if the declarator turned out to be a friend.
8490 See grokfield for details. */
8492 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
8494 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8495 Check to see that the definition is valid. Issue appropriate error
8496 messages. Return 1 if the definition is particularly bad, or 0
8500 check_static_variable_definition (decl
, type
)
8504 /* Motion 10 at San Diego: If a static const integral data member is
8505 initialized with an integral constant expression, the initializer
8506 may appear either in the declaration (within the class), or in
8507 the definition, but not both. If it appears in the class, the
8508 member is a member constant. The file-scope definition is always
8510 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
8512 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8514 /* If we just return the declaration, crashes will sometimes
8515 occur. We therefore return void_type_node, as if this was a
8516 friend declaration, to cause callers to completely ignore
8517 this declaration. */
8520 else if (!CP_TYPE_CONST_P (type
))
8521 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8523 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
8524 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
8530 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
8533 enum decl_context decl_context
;
8537 RID_BIT_TYPE specbits
;
8540 tree type
= NULL_TREE
;
8546 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8547 int explicit_int
= 0;
8548 int explicit_char
= 0;
8549 int defaulted_int
= 0;
8550 int opaque_typedef
= 0;
8551 tree typedef_decl
= NULL_TREE
;
8553 tree typedef_type
= NULL_TREE
;
8554 int funcdef_flag
= 0;
8555 enum tree_code innermost_code
= ERROR_MARK
;
8558 /* See the code below that used this. */
8559 tree decl_machine_attr
= NULL_TREE
;
8561 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
8562 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
8563 tree init
= NULL_TREE
;
8565 /* Keep track of what sort of function is being processed
8566 so that we can warn about default return values, or explicit
8567 return values which do not match prescribed defaults. */
8568 enum return_types return_type
= return_normal
;
8570 tree dname
= NULL_TREE
;
8571 tree ctype
= current_class_type
;
8572 tree ctor_return_type
= NULL_TREE
;
8573 enum overload_flags flags
= NO_SPECIAL
;
8574 tree quals
= NULL_TREE
;
8575 tree raises
= NULL_TREE
;
8576 int template_count
= 0;
8577 tree in_namespace
= NULL_TREE
;
8581 RIDBIT_RESET_ALL (specbits
);
8582 if (decl_context
== FUNCDEF
)
8583 funcdef_flag
= 1, decl_context
= NORMAL
;
8584 else if (decl_context
== MEMFUNCDEF
)
8585 funcdef_flag
= -1, decl_context
= FIELD
;
8586 else if (decl_context
== BITFIELD
)
8587 bitfield
= 1, decl_context
= FIELD
;
8589 /* Look inside a declarator for the name being declared
8590 and get it as a string, for an error message. */
8592 tree
*next
= &declarator
;
8596 while (next
&& *next
)
8599 switch (TREE_CODE (decl
))
8602 /* For attributes. */
8603 next
= &TREE_VALUE (decl
);
8608 next
= &TREE_OPERAND (decl
, 0);
8611 case BIT_NOT_EXPR
: /* For C++ destructors! */
8613 tree name
= TREE_OPERAND (decl
, 0);
8614 tree rename
= NULL_TREE
;
8616 my_friendly_assert (flags
== NO_SPECIAL
, 152);
8618 return_type
= return_dtor
;
8619 if (TREE_CODE (name
) == TYPE_DECL
)
8620 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
8621 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
8622 if (ctype
== NULL_TREE
)
8624 if (current_class_type
== NULL_TREE
)
8626 error ("destructors must be member functions");
8631 tree t
= constructor_name (current_class_name
);
8638 tree t
= constructor_name (ctype
);
8645 cp_error ("destructor `%T' must match class name `%T'",
8647 TREE_OPERAND (decl
, 0) = rename
;
8653 case ADDR_EXPR
: /* C++ reference declaration */
8658 innermost_code
= TREE_CODE (decl
);
8659 next
= &TREE_OPERAND (decl
, 0);
8663 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
8665 /* This is actually a variable declaration using constructor
8666 syntax. We need to call start_decl and cp_finish_decl so we
8667 can get the variable initialized... */
8669 *next
= TREE_OPERAND (decl
, 0);
8670 init
= TREE_OPERAND (decl
, 1);
8672 decl
= start_decl (declarator
, declspecs
, 1, NULL_TREE
, NULL_TREE
);
8675 /* Look for __unused__ attribute */
8676 if (TREE_USED (TREE_TYPE (decl
)))
8677 TREE_USED (decl
) = 1;
8678 finish_decl (decl
, init
, NULL_TREE
);
8681 cp_error ("invalid declarator");
8684 innermost_code
= TREE_CODE (decl
);
8685 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
8686 ctype
= current_class_type
;
8688 && TREE_OPERAND (decl
, 0)
8689 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
8690 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
8691 == constructor_name_full (ctype
))
8692 || (DECL_NAME (TREE_OPERAND (decl
, 0))
8693 == constructor_name (ctype
)))))
8694 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8695 next
= &TREE_OPERAND (decl
, 0);
8697 if (ctype
!= NULL_TREE
8698 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
8699 && decl
== constructor_name (ctype
))
8701 return_type
= return_ctor
;
8702 ctor_return_type
= ctype
;
8707 case TEMPLATE_ID_EXPR
:
8709 tree fns
= TREE_OPERAND (decl
, 0);
8711 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
8712 fns
= TREE_OPERAND (fns
, 0);
8714 if (TREE_CODE (fns
) == IDENTIFIER_NODE
)
8716 else if (is_overloaded_fn (fns
))
8717 dname
= DECL_NAME (get_first_fn (fns
));
8719 my_friendly_abort (0);
8723 case IDENTIFIER_NODE
:
8724 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8731 cp_error ("declarator-id missing; using reserved word `%D'",
8733 name
= IDENTIFIER_POINTER (dname
);
8735 if (! IDENTIFIER_OPNAME_P (dname
)
8736 /* GNU/Linux headers use '__op'. Arrgh. */
8737 || (IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
)))
8738 name
= IDENTIFIER_POINTER (dname
);
8741 if (IDENTIFIER_TYPENAME_P (dname
))
8743 my_friendly_assert (flags
== NO_SPECIAL
, 154);
8744 flags
= TYPENAME_FLAG
;
8745 ctor_return_type
= TREE_TYPE (dname
);
8746 return_type
= return_conversion
;
8748 name
= operator_name_string (dname
);
8755 /* Perform error checking, and decide on a ctype. */
8756 tree cname
= TREE_OPERAND (decl
, 0);
8757 if (cname
== NULL_TREE
)
8759 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
8762 in_namespace
= TREE_OPERAND (decl
, 0);
8763 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8765 else if (! is_aggr_type (cname
, 1))
8766 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8767 /* Must test TREE_OPERAND (decl, 1), in case user gives
8768 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8769 else if (TREE_OPERAND (decl
, 1)
8770 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
8772 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
8773 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
8775 cp_error ("`%T::%D' is not a valid declarator", cname
,
8776 TREE_OPERAND (decl
, 1));
8777 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8778 cname
, TREE_OPERAND (decl
, 1));
8779 return void_type_node
;
8781 else if (ctype
== NULL_TREE
)
8783 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
8784 TREE_OPERAND (decl
, 0) = ctype
;
8787 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
8789 cp_error ("type `%T' is not derived from type `%T'",
8791 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8797 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
8798 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
8799 == constructor_name_full (ctype
))
8800 || (DECL_NAME (TREE_OPERAND (decl
, 1))
8801 == constructor_name (ctype
))))
8802 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
8803 next
= &TREE_OPERAND (decl
, 1);
8807 if (TREE_CODE (decl
) == IDENTIFIER_NODE
8808 && constructor_name (ctype
) == decl
)
8810 return_type
= return_ctor
;
8811 ctor_return_type
= ctype
;
8813 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
8814 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
8815 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
8816 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
8818 return_type
= return_dtor
;
8819 ctor_return_type
= ctype
;
8821 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8822 next
= &TREE_OPERAND (decl
, 0);
8833 /* Parse error puts this typespec where
8834 a declarator should go. */
8835 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
8836 if (TREE_TYPE (decl
) == current_class_type
)
8837 cp_error (" perhaps you want `%T' for a constructor",
8838 current_class_name
);
8839 dname
= DECL_NAME (decl
);
8840 name
= IDENTIFIER_POINTER (dname
);
8842 /* Avoid giving two errors for this. */
8843 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
8845 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
8852 cp_compiler_error ("`%D' as declarator", decl
);
8853 return 0; /* We used to do a 155 abort here. */
8860 /* A function definition's declarator must have the form of
8861 a function declarator. */
8863 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
8866 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8867 && innermost_code
!= CALL_EXPR
8868 && ! (ctype
&& declspecs
== NULL_TREE
))
8870 cp_error ("declaration of `%D' as non-function", dname
);
8871 return void_type_node
;
8874 /* Anything declared one level down from the top level
8875 must be one of the parameters of a function
8876 (because the body is at least two levels down). */
8878 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8879 by not allowing C++ class definitions to specify their parameters
8880 with xdecls (must be spec.d in the parmlist).
8882 Since we now wait to push a class scope until we are sure that
8883 we are in a legitimate method context, we must set oldcname
8884 explicitly (since current_class_name is not yet alive).
8886 We also want to avoid calling this a PARM if it is in a namespace. */
8888 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
8889 && ! pseudo_global_level_p ())
8891 struct binding_level
*b
= current_binding_level
;
8892 current_binding_level
= b
->level_chain
;
8893 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8894 decl_context
= PARM
;
8895 current_binding_level
= b
;
8898 /* Look through the decl specs and record which ones appear.
8899 Some typespecs are defined as built-in typenames.
8900 Others, the ones that are modifiers of other types,
8901 are represented by bits in SPECBITS: set the bits for
8902 the modifiers that appear. Storage class keywords are also in SPECBITS.
8904 If there is a typedef name or a type, store the type in TYPE.
8905 This includes builtin typedefs such as `int'.
8907 Set EXPLICIT_INT if the type is `int' or `char' and did not
8908 come from a user typedef.
8910 Set LONGLONG if `long' is mentioned twice.
8912 For C++, constructors and destructors have their own fast treatment. */
8914 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
8919 /* Certain parse errors slip through. For example,
8920 `int class;' is not caught by the parser. Try
8921 weakly to recover here. */
8922 if (TREE_CODE (spec
) != TREE_LIST
)
8925 id
= TREE_VALUE (spec
);
8927 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8929 if (id
== ridpointers
[(int) RID_INT
]
8930 || id
== ridpointers
[(int) RID_CHAR
]
8931 || id
== ridpointers
[(int) RID_BOOL
]
8932 || id
== ridpointers
[(int) RID_WCHAR
])
8936 if (id
== ridpointers
[(int) RID_BOOL
])
8937 error ("`bool' is now a keyword");
8939 cp_error ("extraneous `%T' ignored", id
);
8943 if (id
== ridpointers
[(int) RID_INT
])
8945 else if (id
== ridpointers
[(int) RID_CHAR
])
8947 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
8951 /* C++ aggregate types. */
8952 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
8955 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
8957 type
= IDENTIFIER_TYPE_VALUE (id
);
8961 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
8963 if (ridpointers
[i
] == id
)
8965 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
8967 if (pedantic
&& ! in_system_header
&& warn_long_long
)
8968 pedwarn ("ANSI C++ does not support `long long'");
8970 error ("`long long long' is too long for GCC");
8974 else if (RIDBIT_SETP (i
, specbits
))
8975 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
8976 RIDBIT_SET (i
, specbits
);
8981 /* C++ aggregate types. */
8982 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
8985 cp_error ("multiple declarations `%T' and `%T'", type
,
8989 type
= TREE_TYPE (id
);
8990 TREE_VALUE (spec
) = type
;
8995 error ("two or more data types in declaration of `%s'", name
);
8996 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8998 register tree t
= lookup_name (id
, 1);
8999 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9000 error ("`%s' fails to be a typedef or built in type",
9001 IDENTIFIER_POINTER (id
));
9004 type
= TREE_TYPE (t
);
9006 /* See the code below that used this. */
9007 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9012 else if (id
!= error_mark_node
)
9013 /* Can't change CLASS nodes into RECORD nodes here! */
9019 typedef_type
= type
;
9021 /* No type at all: default to `int', and set DEFAULTED_INT
9022 because it was not a user-defined typedef.
9023 Except when we have a `typedef' inside a signature, in
9024 which case the type defaults to `unknown type' and is
9025 instantiated when assigning to a signature pointer or ref. */
9027 if (type
== NULL_TREE
9028 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9029 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9030 || RIDBIT_SETP (RID_LONG
, specbits
)
9031 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9033 /* These imply 'int'. */
9034 type
= integer_type_node
;
9038 if (type
== NULL_TREE
)
9041 if (return_type
== return_dtor
)
9042 type
= void_type_node
;
9043 else if (return_type
== return_ctor
)
9044 type
= build_pointer_type (ctor_return_type
);
9045 else if (return_type
== return_conversion
)
9046 type
= ctor_return_type
;
9047 else if (current_class_type
9048 && IS_SIGNATURE (current_class_type
)
9049 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9050 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
9054 type
= copy_node (opaque_type_node
);
9060 if (warn_return_type
9061 && return_type
== return_normal
)
9062 /* Save warning until we know what is really going on. */
9063 warn_about_return_type
= 1;
9065 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9066 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
9067 else if (innermost_code
!= CALL_EXPR
|| pedantic
9068 || (warn_return_type
&& return_type
== return_normal
))
9070 if (innermost_code
== CALL_EXPR
)
9071 cp_pedwarn ("return-type of `%D' defaults to `int'", dname
);
9073 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
9076 type
= integer_type_node
;
9079 else if (return_type
== return_dtor
)
9081 error ("return type specification for destructor invalid");
9082 type
= void_type_node
;
9084 else if (return_type
== return_ctor
)
9086 error ("return type specification for constructor invalid");
9087 type
= build_pointer_type (ctor_return_type
);
9089 else if (return_type
== return_conversion
)
9091 if (!same_type_p (type
, ctor_return_type
))
9092 cp_error ("operator `%T' declared to return `%T'",
9093 ctor_return_type
, type
);
9095 cp_pedwarn ("return type specified for `operator %T'",
9098 type
= ctor_return_type
;
9103 /* Now process the modifiers that were specified
9104 and check for invalid combinations. */
9106 /* Long double is a special combination. */
9108 if (RIDBIT_SETP (RID_LONG
, specbits
)
9109 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
9111 RIDBIT_RESET (RID_LONG
, specbits
);
9112 type
= build_qualified_type (long_double_type_node
,
9113 CP_TYPE_QUALS (type
));
9116 /* Check all other uses of type modifiers. */
9118 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9119 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9120 || RIDBIT_SETP (RID_LONG
, specbits
)
9121 || RIDBIT_SETP (RID_SHORT
, specbits
))
9125 if (TREE_CODE (type
) == REAL_TYPE
)
9126 error ("short, signed or unsigned invalid for `%s'", name
);
9127 else if (TREE_CODE (type
) != INTEGER_TYPE
)
9128 error ("long, short, signed or unsigned invalid for `%s'", name
);
9129 else if (RIDBIT_SETP (RID_LONG
, specbits
)
9130 && RIDBIT_SETP (RID_SHORT
, specbits
))
9131 error ("long and short specified together for `%s'", name
);
9132 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9133 || RIDBIT_SETP (RID_SHORT
, specbits
))
9135 error ("long or short specified with char for `%s'", name
);
9136 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
9137 || RIDBIT_SETP (RID_SHORT
, specbits
))
9138 && TREE_CODE (type
) == REAL_TYPE
)
9139 error ("long or short specified with floating type for `%s'", name
);
9140 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9141 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
9142 error ("signed and unsigned given together for `%s'", name
);
9146 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
9148 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9150 if (flag_pedantic_errors
)
9155 /* Discard the type modifiers if they are invalid. */
9158 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
9159 RIDBIT_RESET (RID_SIGNED
, specbits
);
9160 RIDBIT_RESET (RID_LONG
, specbits
);
9161 RIDBIT_RESET (RID_SHORT
, specbits
);
9166 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
9167 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9169 error ("complex invalid for `%s'", name
);
9170 RIDBIT_RESET (RID_COMPLEX
, specbits
);
9173 /* Decide whether an integer type is signed or not.
9174 Optionally treat bitfields as signed by default. */
9175 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9176 || (bitfield
&& ! flag_signed_bitfields
9177 && (explicit_int
|| defaulted_int
|| explicit_char
9178 /* A typedef for plain `int' without `signed'
9179 can be controlled just like plain `int'. */
9180 || ! (typedef_decl
!= NULL_TREE
9181 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9182 && TREE_CODE (type
) != ENUMERAL_TYPE
9183 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)))
9186 type
= long_long_unsigned_type_node
;
9187 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9188 type
= long_unsigned_type_node
;
9189 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9190 type
= short_unsigned_type_node
;
9191 else if (type
== char_type_node
)
9192 type
= unsigned_char_type_node
;
9193 else if (typedef_decl
)
9194 type
= unsigned_type (type
);
9196 type
= unsigned_type_node
;
9198 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9199 && type
== char_type_node
)
9200 type
= signed_char_type_node
;
9202 type
= long_long_integer_type_node
;
9203 else if (RIDBIT_SETP (RID_LONG
, specbits
))
9204 type
= long_integer_type_node
;
9205 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
9206 type
= short_integer_type_node
;
9208 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
9210 /* If we just have "complex", it is equivalent to
9211 "complex double", but if any modifiers at all are specified it is
9212 the complex form of TYPE. E.g, "complex short" is
9213 "complex short int". */
9215 if (defaulted_int
&& ! longlong
9216 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
9217 || RIDBIT_SETP (RID_SHORT
, specbits
)
9218 || RIDBIT_SETP (RID_SIGNED
, specbits
)
9219 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
9220 type
= complex_double_type_node
;
9221 else if (type
== integer_type_node
)
9222 type
= complex_integer_type_node
;
9223 else if (type
== float_type_node
)
9224 type
= complex_float_type_node
;
9225 else if (type
== double_type_node
)
9226 type
= complex_double_type_node
;
9227 else if (type
== long_double_type_node
)
9228 type
= complex_long_double_type_node
;
9230 type
= build_complex_type (type
);
9233 if (return_type
== return_conversion
9234 && (RIDBIT_SETP (RID_CONST
, specbits
)
9235 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
9236 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
9237 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9240 /* Set CONSTP if this declaration is `const', whether by
9241 explicit specification or via a typedef.
9242 Likewise for VOLATILEP. */
9244 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
9246 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
9248 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
9249 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9250 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9251 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9252 type
= cp_build_qualified_type (type
, type_quals
);
9254 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
9255 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
9256 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
9257 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
9258 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
9260 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9261 staticp
= 1 + (decl_context
== FIELD
);
9263 if (virtualp
&& staticp
== 2)
9265 cp_error ("member `%D' cannot be declared both virtual and static",
9269 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
9270 RIDBIT_RESET (RID_FRIEND
, specbits
);
9272 /* $7.1.2, Function specifiers */
9273 if (friendp
&& explicitp
)
9274 error ("only declarations of constructors can be `explicit'");
9276 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9278 if (decl_context
== PARM
)
9280 error ("non-member `%s' cannot be declared `mutable'", name
);
9281 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9283 else if (friendp
|| decl_context
== TYPENAME
)
9285 error ("non-object member `%s' cannot be declared `mutable'", name
);
9286 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9290 /* Warn if two storage classes are given. Default to `auto'. */
9292 if (RIDBIT_ANY_SET (specbits
))
9294 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
9295 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
9296 if (decl_context
== PARM
&& nclasses
> 0)
9297 error ("storage class specifiers invalid in parameter declarations");
9298 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9300 if (decl_context
== PARM
)
9301 error ("typedef declaration invalid in parameter declaration");
9304 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
9305 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
9308 /* Give error if `virtual' is used outside of class declaration. */
9310 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9312 error ("virtual outside class declaration");
9315 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
9317 error ("only members can be declared mutable");
9318 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9321 /* Static anonymous unions are dealt with here. */
9322 if (staticp
&& decl_context
== TYPENAME
9323 && TREE_CODE (declspecs
) == TREE_LIST
9324 && ANON_UNION_TYPE_P (TREE_VALUE (declspecs
)))
9325 decl_context
= FIELD
;
9327 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
9328 is used in a signature member function declaration. */
9329 if (decl_context
== FIELD
9330 && IS_SIGNATURE (current_class_type
)
9331 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
9333 if (type_quals
!= TYPE_UNQUALIFIED
)
9335 error ("type qualifiers specified for signature member function `%s'", name
);
9336 type_quals
= TYPE_UNQUALIFIED
;
9340 error ("`inline' specified for signature member function `%s'", name
);
9341 /* Later, we'll make signature member functions inline. */
9346 error ("`friend' declaration in signature definition");
9351 error ("`virtual' specified for signature member function `%s'",
9353 /* Later, we'll make signature member functions virtual. */
9358 /* Warn about storage classes that are invalid for certain
9359 kinds of declarations (parameters, typenames, etc.). */
9362 error ("multiple storage classes in declaration of `%s'", name
);
9363 else if (decl_context
!= NORMAL
&& nclasses
> 0)
9365 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9366 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
9367 || RIDBIT_SETP (RID_AUTO
, specbits
)))
9369 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
9371 else if (decl_context
== FIELD
9372 && ! IS_SIGNATURE (current_class_type
)
9373 /* C++ allows static class elements */
9374 && RIDBIT_SETP (RID_STATIC
, specbits
))
9375 /* C++ also allows inlines and signed and unsigned elements,
9376 but in those cases we don't come in here. */
9380 if (decl_context
== FIELD
)
9382 tree tmp
= NULL_TREE
;
9383 register int op
= 0;
9387 /* Avoid trying to get an operand off an identifier node. */
9388 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9391 tmp
= TREE_OPERAND (declarator
, 0);
9392 op
= IDENTIFIER_OPNAME_P (tmp
);
9394 error ("storage class specified for %s `%s'",
9395 IS_SIGNATURE (current_class_type
)
9397 ? "signature member operator"
9398 : "signature member function")
9399 : (op
? "member operator" : "field"),
9400 op
? operator_name_string (tmp
) : name
);
9403 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9404 ? "storage class specified for parameter `%s'"
9405 : "storage class specified for typename"), name
);
9406 RIDBIT_RESET (RID_REGISTER
, specbits
);
9407 RIDBIT_RESET (RID_AUTO
, specbits
);
9408 RIDBIT_RESET (RID_EXTERN
, specbits
);
9410 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
9412 RIDBIT_RESET (RID_STATIC
, specbits
);
9417 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
9419 if (toplevel_bindings_p ())
9421 /* It's common practice (and completely valid) to have a const
9422 be initialized and declared extern. */
9423 if (!(type_quals
& TYPE_QUAL_CONST
))
9424 warning ("`%s' initialized and declared `extern'", name
);
9427 error ("`%s' has both `extern' and initializer", name
);
9429 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
9430 && ! toplevel_bindings_p ())
9431 error ("nested function `%s' declared `extern'", name
);
9432 else if (toplevel_bindings_p ())
9434 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9435 error ("top-level declaration of `%s' specifies `auto'", name
);
9438 if (nclasses
> 0 && friendp
)
9439 error ("storage class specifiers invalid in friend function declarations");
9441 /* Now figure out the structure of the declarator proper.
9442 Descend through it, creating more complex types, until we reach
9443 the declared identifier (or NULL_TREE, in an absolute declarator). */
9445 inner_attrs
= NULL_TREE
;
9448 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
9449 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9451 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
9452 an INDIRECT_REF (for *...),
9453 a CALL_EXPR (for ...(...)),
9454 an identifier (for the name being declared)
9455 or a null pointer (for the place in an absolute declarator
9456 where the name was omitted).
9457 For the last two cases, we have just exited the loop.
9459 For C++ it could also be
9460 a SCOPE_REF (for class :: ...). In this case, we have converted
9461 sensible names to types, and those are the values we use to
9462 qualify the member name.
9463 an ADDR_EXPR (for &...),
9464 a BIT_NOT_EXPR (for destructors)
9466 At this point, TYPE is the type of elements of an array,
9467 or for a function to return, or for a pointer to point to.
9468 After this sequence of ifs, TYPE is the type of the
9469 array or function or pointer, and DECLARATOR has had its
9470 outermost layer removed. */
9472 if (type
== error_mark_node
)
9474 if (TREE_CODE (declarator
) == SCOPE_REF
)
9475 declarator
= TREE_OPERAND (declarator
, 1);
9477 declarator
= TREE_OPERAND (declarator
, 0);
9480 if (quals
!= NULL_TREE
9481 && (declarator
== NULL_TREE
9482 || TREE_CODE (declarator
) != SCOPE_REF
))
9484 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
9485 ctype
= TYPE_METHOD_BASETYPE (type
);
9486 if (ctype
!= NULL_TREE
)
9488 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
9489 ctype
= grok_method_quals (ctype
, dummy
, quals
);
9490 type
= TREE_TYPE (dummy
);
9495 /* See the comment for the TREE_LIST case, below. */
9498 else if (inner_attrs
)
9500 decl_attributes (type
, inner_attrs
, NULL_TREE
);
9501 inner_attrs
= NULL_TREE
;
9504 switch (TREE_CODE (declarator
))
9508 /* We encode a declarator with embedded attributes using
9509 a TREE_LIST. The attributes apply to the declarator
9510 directly inside them, so we have to skip an iteration
9511 before applying them to the type. If the declarator just
9512 inside is the declarator-id, we apply the attrs to the
9514 inner_attrs
= TREE_PURPOSE (declarator
);
9516 declarator
= TREE_VALUE (declarator
);
9522 register tree itype
= NULL_TREE
;
9523 register tree size
= TREE_OPERAND (declarator
, 1);
9524 /* The index is a signed object `sizetype' bits wide. */
9525 tree index_type
= signed_type (sizetype
);
9527 declarator
= TREE_OPERAND (declarator
, 0);
9529 /* Check for some types that there cannot be arrays of. */
9531 if (TREE_CODE (type
) == VOID_TYPE
)
9533 cp_error ("declaration of `%D' as array of voids", dname
);
9534 type
= error_mark_node
;
9537 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9539 cp_error ("declaration of `%D' as array of functions", dname
);
9540 type
= error_mark_node
;
9543 /* ARM $8.4.3: Since you can't have a pointer to a reference,
9544 you can't have arrays of references. If we allowed them,
9545 then we'd be saying x[i] is valid for an array x, but
9546 then you'd have to ask: what does `*(x + i)' mean? */
9547 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9549 if (decl_context
== TYPENAME
)
9550 cp_error ("cannot make arrays of references");
9552 cp_error ("declaration of `%D' as array of references",
9554 type
= error_mark_node
;
9557 if (TREE_CODE (type
) == OFFSET_TYPE
)
9559 cp_error ("declaration of `%D' as array of data members",
9561 type
= error_mark_node
;
9564 if (TREE_CODE (type
) == METHOD_TYPE
)
9566 cp_error ("declaration of `%D' as array of function members",
9568 type
= error_mark_node
;
9571 if (size
== error_mark_node
)
9572 type
= error_mark_node
;
9573 else if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9577 the constant expressions that specify the bounds of
9578 the arrays can be omitted only for the first member
9580 cp_error ("declaration of `%D' as multidimensional array",
9582 cp_error ("must have bounds for all dimensions except the first");
9583 type
= error_mark_node
;
9586 if (type
== error_mark_node
)
9591 /* Must suspend_momentary here because the index
9592 type may need to live until the end of the function.
9593 For example, it is used in the declaration of a
9594 variable which requires destructing at the end of
9595 the function; then build_vec_delete will need this
9597 int yes
= suspend_momentary ();
9598 /* Might be a cast. */
9599 if (TREE_CODE (size
) == NOP_EXPR
9600 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
9601 size
= TREE_OPERAND (size
, 0);
9603 /* If this involves a template parameter, it'll be
9604 constant, but we don't know what the value is yet. */
9605 if (processing_template_decl
)
9607 /* Resolve a qualified reference to an enumerator or
9608 static const data member of ours. */
9609 if (TREE_CODE (size
) == SCOPE_REF
9610 && TREE_OPERAND (size
, 0) == current_class_type
)
9612 tree t
= lookup_field (current_class_type
,
9613 TREE_OPERAND (size
, 1), 0, 0);
9618 itype
= make_node (INTEGER_TYPE
);
9619 TYPE_MIN_VALUE (itype
) = size_zero_node
;
9620 TYPE_MAX_VALUE (itype
) = build_min
9621 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
9622 goto dont_grok_size
;
9625 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9626 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
9628 cp_error ("size of array `%D' has non-integer type",
9630 size
= integer_one_node
;
9632 if (TREE_READONLY_DECL_P (size
))
9633 size
= decl_constant_value (size
);
9634 if (pedantic
&& integer_zerop (size
))
9635 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
9636 if (TREE_CONSTANT (size
))
9638 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9639 int old_pedantic
= pedantic
;
9640 pedantic
= flag_pedantic_errors
= 1;
9641 /* Always give overflow errors on array subscripts. */
9642 constant_expression_warning (size
);
9643 pedantic
= old_pedantic
;
9644 flag_pedantic_errors
= old_flag_pedantic_errors
;
9645 if (INT_CST_LT (size
, integer_zero_node
))
9647 cp_error ("size of array `%D' is negative", dname
);
9648 size
= integer_one_node
;
9656 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
9659 cp_pedwarn ("ANSI C++ forbids variable-size array");
9664 = fold (build_binary_op (MINUS_EXPR
,
9665 cp_convert (index_type
, size
),
9666 cp_convert (index_type
,
9667 integer_one_node
), 1));
9668 if (! TREE_CONSTANT (itype
))
9669 itype
= variable_size (itype
);
9670 else if (TREE_OVERFLOW (itype
))
9672 error ("overflow in array dimension");
9673 TREE_OVERFLOW (itype
) = 0;
9676 /* If we're a parm, we need to have a permanent type so
9677 mangling checks for re-use will work right. If both the
9678 element and index types are permanent, the array type
9680 if (decl_context
== PARM
9681 && allocation_temporary_p () && TREE_PERMANENT (type
))
9683 push_obstacks (&permanent_obstack
, &permanent_obstack
);
9684 itype
= build_index_type (itype
);
9688 itype
= build_index_type (itype
);
9691 resume_momentary (yes
);
9694 type
= build_cplus_array_type (type
, itype
);
9703 tree inner_parms
= TREE_OPERAND (declarator
, 1);
9704 tree inner_decl
= TREE_OPERAND (declarator
, 0);
9706 /* Declaring a function type.
9707 Make sure we have a valid type for the function to return. */
9709 /* We now know that the TYPE_QUALS don't apply to the
9710 decl, but to its return type. */
9711 type_quals
= TYPE_UNQUALIFIED
;
9713 /* Warn about some types functions can't return. */
9715 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9717 error ("`%s' declared as function returning a function", name
);
9718 type
= integer_type_node
;
9720 if (TREE_CODE (type
) == ARRAY_TYPE
)
9722 error ("`%s' declared as function returning an array", name
);
9723 type
= integer_type_node
;
9726 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
9727 inner_decl
= TREE_OPERAND (inner_decl
, 1);
9729 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
9732 /* Pick up type qualifiers which should be applied to `this'. */
9733 quals
= TREE_OPERAND (declarator
, 2);
9735 /* Pick up the exception specifications. */
9736 raises
= TREE_TYPE (declarator
);
9738 /* Say it's a definition only for the CALL_EXPR
9739 closest to the identifier. */
9742 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
9743 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
9744 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
9746 if (ctype
== NULL_TREE
9747 && decl_context
== FIELD
9749 && (friendp
== 0 || dname
== current_class_name
))
9750 ctype
= current_class_type
;
9752 if (ctype
&& return_type
== return_conversion
)
9753 TYPE_HAS_CONVERSION (ctype
) = 1;
9754 if (ctype
&& constructor_name (ctype
) == dname
)
9756 /* We are within a class's scope. If our declarator name
9757 is the same as the class name, and we are defining
9758 a function, then it is a constructor/destructor, and
9759 therefore returns a void type. */
9761 if (flags
== DTOR_FLAG
)
9763 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
9764 not be declared const or volatile. A destructor
9765 may not be static. */
9767 error ("destructor cannot be static member function");
9770 cp_error ("destructors may not be `%s'",
9771 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9774 if (decl_context
== FIELD
)
9776 if (! member_function_or_else (ctype
, current_class_type
,
9777 "destructor for alien class `%s' cannot be a member"))
9778 return void_type_node
;
9781 else /* It's a constructor. */
9785 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
9786 not be declared const or volatile. A constructor may
9787 not be virtual. A constructor may not be static. */
9789 error ("constructor cannot be static member function");
9792 pedwarn ("constructors cannot be declared virtual");
9797 cp_error ("constructors may not be `%s'",
9798 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
9802 RID_BIT_TYPE tmp_bits
;
9803 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
9804 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
9805 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
9806 if (RIDBIT_ANY_SET (tmp_bits
))
9807 error ("return value type specifier for constructor ignored");
9809 type
= build_pointer_type (ctype
);
9810 if (decl_context
== FIELD
9811 && IS_SIGNATURE (current_class_type
))
9813 error ("constructor not allowed in signature");
9814 return void_type_node
;
9816 else if (decl_context
== FIELD
)
9818 if (! member_function_or_else (ctype
, current_class_type
,
9819 "constructor for alien class `%s' cannot be member"))
9820 return void_type_node
;
9821 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
9822 if (return_type
!= return_ctor
)
9826 if (decl_context
== FIELD
)
9832 error ("can't initialize friend function `%s'", name
);
9835 /* Cannot be both friend and virtual. */
9836 error ("virtual functions cannot be friends");
9837 RIDBIT_RESET (RID_FRIEND
, specbits
);
9840 if (decl_context
== NORMAL
)
9841 error ("friend declaration not in class definition");
9842 if (current_function_decl
&& funcdef_flag
)
9843 cp_error ("can't define friend function `%s' in a local class definition",
9847 /* Construct the function type and go to the next
9848 inner layer of declarator. */
9850 declarator
= TREE_OPERAND (declarator
, 0);
9852 /* FIXME: This is where default args should be fully
9855 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
9857 if (declarator
&& flags
== DTOR_FLAG
)
9859 /* A destructor declared in the body of a class will
9860 be represented as a BIT_NOT_EXPR. But, we just
9861 want the underlying IDENTIFIER. */
9862 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
9863 declarator
= TREE_OPERAND (declarator
, 0);
9865 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
9866 arg_types
= void_list_node
;
9867 else if (arg_types
== NULL_TREE
9868 || arg_types
!= void_list_node
)
9870 cp_error ("destructors may not have parameters");
9871 arg_types
= void_list_node
;
9872 last_function_parms
= NULL_TREE
;
9876 /* ANSI says that `const int foo ();'
9877 does not make the function foo const. */
9878 type
= build_function_type (type
, arg_types
);
9882 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
9883 if (TREE_PURPOSE (t
)
9884 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9886 add_defarg_fn (type
);
9895 /* Filter out pointers-to-references and references-to-references.
9896 We can get these if a TYPE_DECL is used. */
9898 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9900 error ("cannot declare %s to references",
9901 TREE_CODE (declarator
) == ADDR_EXPR
9902 ? "references" : "pointers");
9903 declarator
= TREE_OPERAND (declarator
, 0);
9907 if (TREE_CODE (type
) == OFFSET_TYPE
9908 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
9909 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
9911 cp_error ("cannot declare pointer to `%#T' member",
9913 type
= TREE_TYPE (type
);
9916 /* Merge any constancy or volatility into the target type
9919 /* We now know that the TYPE_QUALS don't apply to the decl,
9920 but to the target of the pointer. */
9921 type_quals
= TYPE_UNQUALIFIED
;
9923 if (IS_SIGNATURE (type
))
9925 if (TREE_CODE (declarator
) == ADDR_EXPR
)
9927 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9928 && TYPE_SIZE (type
))
9929 cp_warning ("empty signature `%T' used in signature reference declaration",
9932 type
= build_signature_reference_type (type
);
9934 sorry ("signature reference");
9940 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9941 && TYPE_SIZE (type
))
9942 cp_warning ("empty signature `%T' used in signature pointer declaration",
9944 type
= build_signature_pointer_type (type
);
9947 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
9949 if (TREE_CODE (type
) == VOID_TYPE
)
9950 error ("invalid type: `void &'");
9952 type
= build_reference_type (type
);
9954 else if (TREE_CODE (type
) == METHOD_TYPE
)
9956 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9959 type
= build_pointer_type (type
);
9961 /* Process a list of type modifier keywords (such as
9962 const or volatile) that were given inside the `*' or `&'. */
9964 if (TREE_TYPE (declarator
))
9966 register tree typemodlist
;
9972 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
9973 typemodlist
= TREE_CHAIN (typemodlist
))
9975 tree qualifier
= TREE_VALUE (typemodlist
);
9977 if (qualifier
== ridpointers
[(int) RID_CONST
])
9979 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
9981 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
9986 error ("invalid type modifier within pointer declarator");
9990 pedwarn ("duplicate `const'");
9992 pedwarn ("duplicate `volatile'");
9994 pedwarn ("duplicate `restrict'");
9996 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
9997 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
9998 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
9999 if (TREE_CODE (declarator
) == ADDR_EXPR
10000 && (constp
|| volatilep
))
10003 pedwarn ("discarding `const' applied to a reference");
10005 pedwarn ("discarding `volatile' applied to a reference");
10006 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10008 type
= cp_build_qualified_type (type
, type_quals
);
10010 declarator
= TREE_OPERAND (declarator
, 0);
10016 /* We have converted type names to NULL_TREE if the
10017 name was bogus, or to a _TYPE node, if not.
10019 The variable CTYPE holds the type we will ultimately
10020 resolve to. The code here just needs to build
10021 up appropriate member types. */
10022 tree sname
= TREE_OPERAND (declarator
, 1);
10025 /* Destructors can have their visibilities changed as well. */
10026 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10027 sname
= TREE_OPERAND (sname
, 0);
10029 if (TREE_COMPLEXITY (declarator
) == 0)
10030 /* This needs to be here, in case we are called
10031 multiple times. */ ;
10032 else if (TREE_COMPLEXITY (declarator
) == -1)
10033 /* Namespace member. */
10034 pop_decl_namespace ();
10035 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10036 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10037 else if (! IS_AGGR_TYPE_CODE
10038 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10040 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10042 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10043 that refer to ctype. They couldn't be resolved earlier
10044 because we hadn't pushed into the class yet.
10045 Example: resolve 'B<T>::type' in
10046 'B<typename B<T>::type> B<T>::f () { }'. */
10047 if (current_template_parms
10048 && uses_template_parms (type
)
10049 && uses_template_parms (current_class_type
))
10051 tree args
= current_template_args ();
10052 type
= tsubst (type
, args
, NULL_TREE
);
10055 /* This pop_nested_class corresponds to the
10056 push_nested_class used to push into class scope for
10057 parsing the argument list of a function decl, in
10059 pop_nested_class (1);
10060 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10063 my_friendly_abort (16);
10065 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10067 /* We had a reference to a global decl, or
10068 perhaps we were given a non-aggregate typedef,
10069 in which case we cleared this out, and should just
10070 keep going as though it wasn't there. */
10071 declarator
= sname
;
10074 ctype
= TREE_OPERAND (declarator
, 0);
10077 while (t
!= NULL_TREE
)
10079 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
10080 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
10081 template_count
+= 1;
10082 t
= TYPE_MAIN_DECL (t
);
10083 if (DECL_LANG_SPECIFIC (t
))
10084 t
= DECL_CLASS_CONTEXT (t
);
10089 if (sname
== NULL_TREE
)
10092 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10094 /* This is the `standard' use of the scoping operator:
10095 basetype :: member . */
10097 if (ctype
== current_class_type
)
10103 Is this ill-formed? */
10106 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10109 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10111 if (current_class_type
== NULL_TREE
10113 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10114 TYPE_ARG_TYPES (type
));
10117 cp_error ("cannot declare member function `%T::%s' within `%T'",
10118 ctype
, name
, current_class_type
);
10119 return void_type_node
;
10122 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10123 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
10125 /* Have to move this code elsewhere in this function.
10126 this code is used for i.e., typedef int A::M; M *pm;
10128 It is? How? jason 10/2/94 */
10130 if (current_class_type
)
10132 cp_error ("cannot declare member `%T::%s' within `%T'",
10133 ctype
, name
, current_class_type
);
10134 return void_type_node
;
10136 type
= build_offset_type (ctype
, type
);
10138 else if (uses_template_parms (ctype
))
10140 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10142 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10143 TYPE_ARG_TYPES (type
));
10147 cp_error ("structure `%T' not yet defined", ctype
);
10148 return error_mark_node
;
10151 declarator
= sname
;
10153 else if (TREE_CODE (sname
) == SCOPE_REF
)
10154 my_friendly_abort (17);
10158 declarator
= TREE_OPERAND (declarator
, 1);
10159 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10160 /* In this case, we will deal with it later. */
10164 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10165 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10166 TYPE_ARG_TYPES (type
));
10168 type
= build_offset_type (ctype
, type
);
10175 declarator
= TREE_OPERAND (declarator
, 0);
10180 case ENUMERAL_TYPE
:
10181 declarator
= NULL_TREE
;
10185 declarator
= NULL_TREE
;
10189 my_friendly_abort (158);
10193 /* See the comment for the TREE_LIST case, above. */
10196 if (! ignore_attrs
)
10197 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10199 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10201 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
10204 if (explicitp
== 1)
10206 error ("only constructors can be declared `explicit'");
10210 /* Now TYPE has the actual type. */
10212 /* If this is declaring a typedef name, return a TYPE_DECL. */
10214 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10216 if (type_quals
& TYPE_QUAL_CONST
)
10218 error ("const `%s' cannot be declared `mutable'", name
);
10219 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10223 error ("static `%s' cannot be declared `mutable'", name
);
10224 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10228 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10232 /* Note that the grammar rejects storage classes
10233 in typenames, fields or parameters. */
10234 if (current_lang_name
== lang_name_java
)
10235 TYPE_FOR_JAVA (type
) = 1;
10237 if (decl_context
== FIELD
)
10239 if (declarator
== current_class_name
)
10240 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10242 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10243 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
10244 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
10248 /* Make sure this typedef lives as long as its type,
10249 since it might be used as a template parameter. */
10250 if (type
!= error_mark_node
)
10251 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
10252 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10253 if (type
!= error_mark_node
)
10257 /* If the user declares "struct {...} foo" then `foo' will have
10258 an anonymous name. Fill that name in now. Nothing can
10259 refer to it, so nothing needs know about the name change.
10260 The TYPE_NAME field was filled in by build_struct_xref. */
10261 if (type
!= error_mark_node
10262 && TYPE_NAME (type
)
10263 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10264 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
10266 /* FIXME: This is bogus; we should not be doing this for
10267 cv-qualified types. */
10269 /* For anonymous structs that are cv-qualified, need to use
10270 TYPE_MAIN_VARIANT so that name will mangle correctly. As
10271 type not referenced after this block, don't bother
10272 resetting type to original type, ie. TREE_TYPE (decl). */
10273 type
= TYPE_MAIN_VARIANT (type
);
10275 /* Replace the anonymous name with the real name everywhere. */
10276 lookup_tag_reverse (type
, declarator
);
10277 TYPE_NAME (type
) = decl
;
10279 if (TYPE_LANG_SPECIFIC (type
))
10280 TYPE_WAS_ANONYMOUS (type
) = 1;
10282 /* XXX Temporarily set the scope.
10283 When returning, start_decl expects it as NULL_TREE,
10284 and will then then set it using pushdecl. */
10285 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
10286 if (current_class_type
)
10287 DECL_CONTEXT (decl
) = current_class_type
;
10289 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10291 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
10292 DECL_ASSEMBLER_NAME (decl
)
10293 = get_identifier (build_overload_name (type
, 1, 1));
10294 DECL_CONTEXT (decl
) = NULL_TREE
;
10296 /* FIXME remangle member functions; member functions of a
10297 type with external linkage have external linkage. */
10300 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10302 cp_error_at ("typedef name may not be class-qualified", decl
);
10307 if (ctype
== NULL_TREE
)
10309 if (TREE_CODE (type
) != METHOD_TYPE
)
10310 cp_error_at ("invalid type qualifier for non-method type", decl
);
10312 ctype
= TYPE_METHOD_BASETYPE (type
);
10314 if (ctype
!= NULL_TREE
)
10315 grok_method_quals (ctype
, decl
, quals
);
10318 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10319 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10320 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10322 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10323 error ("non-object member `%s' cannot be declared mutable", name
);
10325 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
10326 inlinep
, friendp
, raises
!= NULL_TREE
);
10329 error ("typedef declaration includes an initializer");
10334 /* Detect the case of an array type of unspecified size
10335 which came, as such, direct from a typedef name.
10336 We must copy the type, so that each identifier gets
10337 a distinct type, so that each identifier's size can be
10338 controlled separately by its own initializer. */
10340 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
10341 && TYPE_DOMAIN (type
) == NULL_TREE
)
10343 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
10346 /* If this is a type name (such as, in a cast or sizeof),
10347 compute the type and return it now. */
10349 if (decl_context
== TYPENAME
)
10351 /* Note that the grammar rejects storage classes
10352 in typenames, fields or parameters. */
10353 if (type_quals
!= TYPE_UNQUALIFIED
)
10355 if (IS_SIGNATURE (type
))
10356 error ("type qualifiers specified for signature type");
10357 type_quals
= TYPE_UNQUALIFIED
;
10360 /* Special case: "friend class foo" looks like a TYPENAME context. */
10363 if (type_quals
!= TYPE_UNQUALIFIED
)
10365 cp_error ("type qualifiers specified for friend class declaration");
10366 type_quals
= TYPE_UNQUALIFIED
;
10370 cp_error ("`inline' specified for friend class declaration");
10374 /* Only try to do this stuff if we didn't already give up. */
10375 if (type
!= integer_type_node
)
10377 /* A friendly class? */
10378 if (current_class_type
)
10379 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
10381 error ("trying to make class `%s' a friend of global scope",
10382 TYPE_NAME_STRING (type
));
10383 type
= void_type_node
;
10388 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
10389 if (ctype
== NULL_TREE
)
10391 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
10392 ctype
= TYPE_METHOD_BASETYPE (type
);
10394 grok_method_quals (ctype
, dummy
, quals
);
10395 type
= TREE_TYPE (dummy
);
10400 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
10401 && decl_context
!= CATCHPARM
10402 && TREE_CODE (type
) != UNION_TYPE
10405 cp_error ("abstract declarator `%T' used as declaration", type
);
10406 declarator
= make_anon_name ();
10409 /* `void' at top level (not within pointer)
10410 is allowed only in typedefs or type names.
10411 We don't complain about parms either, but that is because
10412 a better error message can be made later. */
10414 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
10417 error ("unnamed variable or field declared void");
10418 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10420 if (IDENTIFIER_OPNAME_P (declarator
))
10421 my_friendly_abort (356);
10423 error ("variable or field `%s' declared void", name
);
10426 error ("variable or field declared void");
10427 type
= integer_type_node
;
10430 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10431 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10433 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10435 if (ctype
|| in_namespace
)
10436 error ("cannot use `::' in parameter declaration");
10438 /* A parameter declared as an array of T is really a pointer to T.
10439 One declared as a function is really a pointer to a function.
10440 One declared as a member is really a pointer to member. */
10442 if (TREE_CODE (type
) == ARRAY_TYPE
)
10444 /* Transfer const-ness of array into that of type pointed to. */
10445 type
= build_pointer_type (TREE_TYPE (type
));
10446 type_quals
= TYPE_UNQUALIFIED
;
10448 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10449 type
= build_pointer_type (type
);
10450 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10451 type
= build_pointer_type (type
);
10452 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
10454 error ("declaration of `%s' as void", name
);
10460 register tree decl
;
10462 if (decl_context
== PARM
)
10464 decl
= build_decl (PARM_DECL
, declarator
, complete_type (type
));
10466 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
10467 inlinep
, friendp
, raises
!= NULL_TREE
);
10468 if (current_class_type
10469 && IS_SIGNATURE (current_class_type
))
10472 error ("parameter of signature member function declared `inline'");
10473 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10474 error ("parameter of signature member function declared `auto'");
10475 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10476 error ("parameter of signature member function declared `register'");
10479 /* Compute the type actually passed in the parmlist,
10480 for the case where there is no prototype.
10481 (For example, shorts and chars are passed as ints.)
10482 When there is a prototype, this is overridden later. */
10484 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
10486 else if (decl_context
== FIELD
)
10488 if (type
== error_mark_node
)
10490 /* Happens when declaring arrays of sizes which
10491 are error_mark_node, for example. */
10494 else if (in_namespace
&& !friendp
)
10496 /* Something like struct S { int N::j; }; */
10497 cp_error ("invalid use of `::'");
10500 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10503 tree function_context
;
10505 /* We catch the others as conflicts with the builtin
10507 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
10509 cp_error ("function `%D' cannot be declared friend",
10516 if (ctype
== NULL_TREE
)
10517 ctype
= current_class_type
;
10519 if (ctype
== NULL_TREE
)
10521 cp_error ("can't make `%D' into a method -- not in a class",
10523 return void_type_node
;
10526 /* ``A union may [ ... ] not [ have ] virtual functions.''
10528 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10530 cp_error ("function `%D' declared virtual inside a union",
10532 return void_type_node
;
10535 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
10536 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
10537 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
10538 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10542 cp_error ("`%D' cannot be declared virtual, since it is always static",
10547 else if (staticp
< 2)
10548 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10549 TYPE_ARG_TYPES (type
));
10552 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10553 function_context
= (ctype
!= NULL_TREE
) ?
10554 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10555 publicp
= (! friendp
|| ! staticp
)
10556 && function_context
== NULL_TREE
;
10557 decl
= grokfndecl (ctype
, type
,
10558 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
10559 ? declarator
: dname
,
10561 virtualp
, flags
, quals
, raises
, attrlist
,
10562 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
10563 funcdef_flag
, template_count
, in_namespace
);
10564 if (decl
== NULL_TREE
|| decl
== error_mark_node
)
10567 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10568 /* The decl and setting of decl_machine_attr is also turned off. */
10569 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
10572 /* [class.conv.ctor]
10574 A constructor declared without the function-specifier
10575 explicit that can be called with a single parameter
10576 specifies a conversion from the type of its first
10577 parameter to the type of its class. Such a constructor
10578 is called a converting constructor. */
10579 if (explicitp
== 2)
10580 DECL_NONCONVERTING_P (decl
) = 1;
10581 else if (DECL_CONSTRUCTOR_P (decl
))
10583 /* The constructor can be called with exactly one
10584 parameter if there is at least one parameter, and
10585 any subsequent parameters have default arguments.
10586 We don't look at the first parameter, which is
10587 really just the `this' parameter for the new
10590 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
10592 /* Skip the `in_chrg' argument too, if present. */
10593 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl
)))
10594 arg_types
= TREE_CHAIN (arg_types
);
10596 if (arg_types
== void_list_node
10598 && TREE_CHAIN (arg_types
)
10599 && TREE_CHAIN (arg_types
) != void_list_node
10600 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
10601 DECL_NONCONVERTING_P (decl
) = 1;
10604 else if (TREE_CODE (type
) == METHOD_TYPE
)
10606 /* We only get here for friend declarations of
10607 members of other classes. */
10608 /* All method decls are public, so tell grokfndecl to set
10609 TREE_PUBLIC, also. */
10610 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
10611 virtualp
, flags
, quals
, raises
, attrlist
,
10612 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
10613 template_count
, in_namespace
);
10614 if (decl
== NULL_TREE
)
10617 else if (!staticp
&& ! processing_template_decl
10618 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
10619 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10622 cp_error ("field `%D' has incomplete type", declarator
);
10624 cp_error ("name `%T' has incomplete type", type
);
10626 /* If we're instantiating a template, tell them which
10627 instantiation made the field's type be incomplete. */
10628 if (current_class_type
10629 && TYPE_NAME (current_class_type
)
10630 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
10631 && declspecs
&& TREE_VALUE (declspecs
)
10632 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
10633 cp_error (" in instantiation of template `%T'",
10634 current_class_type
);
10636 type
= error_mark_node
;
10643 error ("`%s' is neither function nor method; cannot be declared friend",
10644 IDENTIFIER_POINTER (declarator
));
10652 /* Friends are treated specially. */
10653 if (ctype
== current_class_type
)
10654 warning ("member functions are implicitly friends of their class");
10657 tree t
= NULL_TREE
;
10658 if (decl
&& DECL_NAME (decl
))
10660 if (template_class_depth (current_class_type
) == 0)
10663 = check_explicit_specialization
10665 template_count
, 2 * (funcdef_flag
!= 0) + 4);
10666 if (decl
== error_mark_node
)
10667 return error_mark_node
;
10670 t
= do_friend (ctype
, declarator
, decl
,
10671 last_function_parms
, flags
, quals
,
10674 if (t
&& funcdef_flag
)
10677 return void_type_node
;
10681 /* Structure field. It may not be a function, except for C++ */
10683 if (decl
== NULL_TREE
)
10689 /* An attempt is being made to initialize a non-static
10690 member. But, from [class.mem]:
10692 4 A member-declarator can contain a
10693 constant-initializer only if it declares a static
10694 member (_class.static_) of integral or enumeration
10695 type, see _class.static.data_.
10697 This used to be relatively common practice, but
10698 the rest of the compiler does not correctly
10699 handle the initialization unless the member is
10700 static so we make it static below. */
10701 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
10703 cp_pedwarn ("making `%D' static", declarator
);
10707 if (uses_template_parms (type
))
10708 /* We'll check at instantiation time. */
10710 else if (check_static_variable_definition (declarator
,
10712 /* If we just return the declaration, crashes
10713 will sometimes occur. We therefore return
10714 void_type_node, as if this was a friend
10715 declaration, to cause callers to completely
10716 ignore this declaration. */
10717 return void_type_node
;
10722 /* ANSI C++ Apr '95 wp 9.2 */
10723 if (declarator
== current_class_name
)
10724 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
10727 /* C++ allows static class members.
10728 All other work for this is done by grokfield.
10729 This VAR_DCL is built by build_lang_field_decl.
10730 All other VAR_DECLs are built by build_decl. */
10731 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
10732 TREE_STATIC (decl
) = 1;
10733 /* In class context, 'static' means public access. */
10734 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
10738 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
10739 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10741 DECL_MUTABLE_P (decl
) = 1;
10742 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10746 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
10747 inlinep
, friendp
, raises
!= NULL_TREE
);
10750 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
10752 tree original_name
;
10758 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10759 original_name
= dname
;
10761 original_name
= declarator
;
10763 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10764 error ("storage class `auto' invalid for function `%s'", name
);
10765 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10766 error ("storage class `register' invalid for function `%s'", name
);
10768 /* Function declaration not at top level.
10769 Storage classes other than `extern' are not allowed
10770 and `extern' makes no difference. */
10771 if (! toplevel_bindings_p ()
10772 && (RIDBIT_SETP (RID_STATIC
, specbits
)
10773 || RIDBIT_SETP (RID_INLINE
, specbits
))
10776 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10777 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
10779 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
10782 if (ctype
== NULL_TREE
)
10786 error ("virtual non-class function `%s'", name
);
10790 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
10791 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10792 TYPE_ARG_TYPES (type
));
10794 /* Record presence of `static'. */
10795 publicp
= (ctype
!= NULL_TREE
10796 || RIDBIT_SETP (RID_EXTERN
, specbits
)
10797 || !RIDBIT_SETP (RID_STATIC
, specbits
));
10799 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
10800 virtualp
, flags
, quals
, raises
, attrlist
,
10802 publicp
, inlinep
, funcdef_flag
,
10803 template_count
, in_namespace
);
10804 if (decl
== NULL_TREE
)
10807 /* Among other times, could occur from check_explicit_specialization
10808 returning an error_mark_node. */
10809 if (decl
== error_mark_node
)
10810 return error_mark_node
;
10814 int illegal_static
= 0;
10816 /* Don't allow a static member function in a class, and forbid
10817 declaring main to be static. */
10818 if (TREE_CODE (type
) == METHOD_TYPE
)
10820 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
10821 illegal_static
= 1;
10823 else if (current_function_decl
)
10825 /* FIXME need arm citation */
10826 error ("cannot declare static function inside another function");
10827 illegal_static
= 1;
10830 if (illegal_static
)
10833 RIDBIT_RESET (RID_STATIC
, specbits
);
10839 /* It's a variable. */
10841 /* An uninitialized decl with `extern' is a reference. */
10842 decl
= grokvardecl (type
, declarator
, &specbits
,
10844 (type_quals
& TYPE_QUAL_CONST
) != 0,
10846 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
10847 inlinep
, friendp
, raises
!= NULL_TREE
);
10851 DECL_CONTEXT (decl
) = ctype
;
10854 cp_pedwarn ("static member `%D' re-declared as static", decl
);
10856 RIDBIT_RESET (RID_STATIC
, specbits
);
10858 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
10860 cp_error ("static member `%D' declared `register'", decl
);
10861 RIDBIT_RESET (RID_REGISTER
, specbits
);
10863 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
10865 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10867 RIDBIT_RESET (RID_EXTERN
, specbits
);
10872 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10874 error ("`%s' cannot be declared mutable", name
);
10877 /* Record `register' declaration for warnings on &
10878 and in case doing stupid register allocation. */
10880 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10881 DECL_REGISTER (decl
) = 1;
10883 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
10884 DECL_THIS_EXTERN (decl
) = 1;
10886 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10887 DECL_THIS_STATIC (decl
) = 1;
10889 /* Record constancy and volatility. */
10890 /* FIXME: Disallow `restrict' pointer-to-member declarations. */
10891 c_apply_type_quals_to_decl (type_quals
, decl
);
10897 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10898 An empty exprlist is a parmlist. An exprlist which
10899 contains only identifiers at the global level
10900 is a parmlist. Otherwise, it is an exprlist. */
10903 parmlist_is_exprlist (exprs
)
10906 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
10909 if (toplevel_bindings_p ())
10911 /* At the global level, if these are all identifiers,
10912 then it is a parmlist. */
10915 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
10917 exprs
= TREE_CHAIN (exprs
);
10924 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10927 C++: also subroutine of `start_function'. */
10930 require_complete_types_for_parms (parms
)
10933 if (processing_template_decl
)
10938 tree type
= TREE_TYPE (parms
);
10939 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
10941 if (DECL_NAME (parms
))
10942 error ("parameter `%s' has incomplete type",
10943 IDENTIFIER_POINTER (DECL_NAME (parms
)));
10945 error ("parameter has incomplete type");
10946 TREE_TYPE (parms
) = error_mark_node
;
10949 /* If the arg types are incomplete in a declaration,
10950 they must include undefined tags.
10951 These tags can never be defined in the scope of the declaration,
10952 so the types can never be completed,
10953 and no call can be compiled successfully. */
10954 /* This is not the right behavior for C++, but not having
10955 it is also probably wrong. */
10958 /* Now warn if is a pointer to an incomplete type. */
10959 while (TREE_CODE (type
) == POINTER_TYPE
10960 || TREE_CODE (type
) == REFERENCE_TYPE
)
10961 type
= TREE_TYPE (type
);
10962 type
= TYPE_MAIN_VARIANT (type
);
10963 if (TYPE_SIZE (type
) == NULL_TREE
)
10965 if (DECL_NAME (parm
) != NULL_TREE
)
10966 warning ("parameter `%s' points to incomplete type",
10967 IDENTIFIER_POINTER (DECL_NAME (parm
)));
10969 warning ("parameter points to incomplete type");
10973 parms
= TREE_CHAIN (parms
);
10977 /* Decode the list of parameter types for a function type.
10978 Given the list of things declared inside the parens,
10979 return a list of types.
10981 The list we receive can have three kinds of elements:
10982 an IDENTIFIER_NODE for names given without types,
10983 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10984 or void_type_node, to mark the end of an argument list
10985 when additional arguments are not permitted (... was not used).
10987 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10988 a mere declaration. A nonempty identifier-list gets an error message
10989 when FUNCDEF_FLAG is zero.
10990 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10991 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10993 If all elements of the input list contain types,
10994 we return a list of the types.
10995 If all elements contain no type (except perhaps a void_type_node
10996 at the end), we return a null list.
10997 If some have types and some do not, it is an error, and we
10998 return a null list.
11000 Also set last_function_parms to either
11001 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11002 A list of names is converted to a chain of PARM_DECLs
11003 by store_parm_decls so that ultimately it is always a chain of decls.
11005 Note that in C++, parameters can take default values. These default
11006 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11007 an error to specify default values which are followed by parameters
11008 that have no default values, or an ELLIPSES. For simplicities sake,
11009 only parameters which are specified with their types can take on
11013 grokparms (first_parm
, funcdef_flag
)
11017 tree result
= NULL_TREE
;
11018 tree decls
= NULL_TREE
;
11020 if (first_parm
!= NULL_TREE
11021 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11023 if (! funcdef_flag
)
11024 pedwarn ("parameter names (without types) in function declaration");
11025 last_function_parms
= first_parm
;
11028 else if (first_parm
!= NULL_TREE
11029 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11030 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11031 my_friendly_abort (145);
11034 /* Types were specified. This is a list of declarators
11035 each represented as a TREE_LIST node. */
11036 register tree parm
, chain
;
11037 int any_init
= 0, any_error
= 0;
11039 if (first_parm
!= NULL_TREE
)
11041 tree last_result
= NULL_TREE
;
11042 tree last_decl
= NULL_TREE
;
11044 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11046 tree type
= NULL_TREE
, list_node
= parm
;
11047 register tree decl
= TREE_VALUE (parm
);
11048 tree init
= TREE_PURPOSE (parm
);
11050 chain
= TREE_CHAIN (parm
);
11051 /* @@ weak defense against parse errors. */
11052 if (TREE_CODE (decl
) != VOID_TYPE
11053 && TREE_CODE (decl
) != TREE_LIST
)
11055 /* Give various messages as the need arises. */
11056 if (TREE_CODE (decl
) == STRING_CST
)
11057 cp_error ("invalid string constant `%E'", decl
);
11058 else if (TREE_CODE (decl
) == INTEGER_CST
)
11059 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11063 if (TREE_CODE (decl
) != VOID_TYPE
)
11065 decl
= grokdeclarator (TREE_VALUE (decl
),
11066 TREE_PURPOSE (decl
),
11067 PARM
, init
!= NULL_TREE
,
11069 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11072 /* Top-level qualifiers on the parameters are
11073 ignored for function types. */
11074 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
11076 if (TREE_CODE (type
) == VOID_TYPE
)
11077 decl
= void_type_node
;
11078 else if (TREE_CODE (type
) == METHOD_TYPE
)
11080 if (DECL_NAME (decl
))
11081 /* Cannot use the decl here because
11082 we don't have DECL_CONTEXT set up yet. */
11083 cp_error ("parameter `%D' invalidly declared method type",
11086 error ("parameter invalidly declared method type");
11087 type
= build_pointer_type (type
);
11088 TREE_TYPE (decl
) = type
;
11090 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11092 if (DECL_NAME (decl
))
11093 cp_error ("parameter `%D' invalidly declared offset type",
11096 error ("parameter invalidly declared offset type");
11097 type
= build_pointer_type (type
);
11098 TREE_TYPE (decl
) = type
;
11100 else if (TREE_CODE (type
) == RECORD_TYPE
11101 && TYPE_LANG_SPECIFIC (type
)
11102 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
11104 abstract_virtuals_error (decl
, type
);
11105 any_error
= 1; /* Seems like a good idea. */
11107 else if (TREE_CODE (type
) == RECORD_TYPE
11108 && TYPE_LANG_SPECIFIC (type
)
11109 && IS_SIGNATURE (type
))
11111 signature_error (decl
, type
);
11112 any_error
= 1; /* Seems like a good idea. */
11114 else if (POINTER_TYPE_P (type
))
11117 while (POINTER_TYPE_P (t
)
11118 || (TREE_CODE (t
) == ARRAY_TYPE
11119 && TYPE_DOMAIN (t
) != NULL_TREE
))
11121 if (TREE_CODE (t
) == ARRAY_TYPE
)
11122 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11124 TYPE_PTR_P (type
) ? "pointer" : "reference");
11128 if (TREE_CODE (decl
) == VOID_TYPE
)
11130 if (result
== NULL_TREE
)
11132 result
= void_list_node
;
11133 last_result
= result
;
11137 TREE_CHAIN (last_result
) = void_list_node
;
11138 last_result
= void_list_node
;
11141 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
11142 error ("`void' in parameter list must be entire list");
11146 /* Since there is a prototype, args are passed in their own types. */
11147 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11148 #ifdef PROMOTE_PROTOTYPES
11149 if ((TREE_CODE (type
) == INTEGER_TYPE
11150 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11151 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11152 DECL_ARG_TYPE (decl
) = integer_type_node
;
11159 if (TREE_CODE (init
) == SAVE_EXPR
)
11160 PARM_DECL_EXPR (init
) = 1;
11161 else if (processing_template_decl
)
11163 /* Unparsed default arg from in-class decl. */
11164 else if (TREE_CODE (init
) == DEFAULT_ARG
)
11166 else if (TREE_CODE (init
) == VAR_DECL
11167 || TREE_CODE (init
) == PARM_DECL
)
11169 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init
)))
11171 /* ``Local variables may not be used in default
11172 argument expressions.'' dpANSI C++ 8.2.6 */
11173 /* If extern int i; within a function is not
11174 considered a local variable, then this code is
11176 cp_error ("local variable `%D' may not be used as a default argument", init
);
11179 else if (TREE_READONLY_DECL_P (init
))
11180 init
= decl_constant_value (init
);
11182 else if (TREE_TYPE (init
) == NULL_TREE
)
11184 error ("argument list may not have an initializer list");
11185 init
= error_mark_node
;
11188 if (! processing_template_decl
11189 && init
!= error_mark_node
11190 && TREE_CODE (init
) != DEFAULT_ARG
11191 && ! can_convert_arg (type
, TREE_TYPE (init
), init
))
11192 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
11193 TREE_TYPE (init
), decl
);
11199 if (decls
== NULL_TREE
)
11206 TREE_CHAIN (last_decl
) = decl
;
11209 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
11211 TREE_PURPOSE (list_node
) = init
;
11212 TREE_VALUE (list_node
) = type
;
11213 TREE_CHAIN (list_node
) = NULL_TREE
;
11216 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
11217 if (result
== NULL_TREE
)
11219 result
= list_node
;
11220 last_result
= result
;
11224 TREE_CHAIN (last_result
) = list_node
;
11225 last_result
= list_node
;
11229 TREE_CHAIN (last_result
) = NULL_TREE
;
11230 /* If there are no parameters, and the function does not end
11231 with `...', then last_decl will be NULL_TREE. */
11232 if (last_decl
!= NULL_TREE
)
11233 TREE_CHAIN (last_decl
) = NULL_TREE
;
11237 last_function_parms
= decls
;
11239 /* In a fcn definition, arg types must be complete. */
11240 if (funcdef_flag
> 0)
11241 require_complete_types_for_parms (last_function_parms
);
11246 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11247 FUNCTION_TYPE with the newly parsed version of its default argument, which
11248 was previously digested as text. See snarf_defarg et al in lex.c. */
11251 replace_defarg (arg
, init
)
11254 if (! processing_template_decl
11255 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
11256 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11257 TREE_TYPE (init
), TREE_VALUE (arg
));
11258 TREE_PURPOSE (arg
) = init
;
11265 tree t
= FUNCTION_ARG_CHAIN (d
);
11266 if (DECL_CONSTRUCTOR_P (d
)
11267 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
11268 t
= TREE_CHAIN (t
);
11269 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11270 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11271 == DECL_CLASS_CONTEXT (d
))
11272 && (TREE_CHAIN (t
) == NULL_TREE
11273 || TREE_CHAIN (t
) == void_list_node
11274 || TREE_PURPOSE (TREE_CHAIN (t
))))
11279 /* These memoizing functions keep track of special properties which
11280 a class may have. `grok_ctor_properties' notices whether a class
11281 has a constructor of the form X(X&), and also complains
11282 if the class has a constructor of the form X(X).
11283 `grok_op_properties' takes notice of the various forms of
11284 operator= which are defined, as well as what sorts of type conversion
11285 may apply. Both functions take a FUNCTION_DECL as an argument. */
11288 grok_ctor_properties (ctype
, decl
)
11291 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11292 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11294 /* When a type has virtual baseclasses, a magical first int argument is
11295 added to any ctor so we can tell if the class has been initialized
11296 yet. This could screw things up in this function, so we deliberately
11297 ignore the leading int if we're in that situation. */
11298 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
11300 my_friendly_assert (parmtypes
11301 && TREE_VALUE (parmtypes
) == integer_type_node
,
11303 parmtypes
= TREE_CHAIN (parmtypes
);
11304 parmtype
= TREE_VALUE (parmtypes
);
11307 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11308 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11309 && (TREE_CHAIN (parmtypes
) == NULL_TREE
11310 || TREE_CHAIN (parmtypes
) == void_list_node
11311 || TREE_PURPOSE (TREE_CHAIN (parmtypes
))))
11313 TYPE_HAS_INIT_REF (ctype
) = 1;
11314 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11315 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11317 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11318 && TREE_CHAIN (parmtypes
) != NULL_TREE
11319 && TREE_CHAIN (parmtypes
) == void_list_node
)
11321 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11323 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
11326 else if (TREE_CODE (parmtype
) == VOID_TYPE
11327 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
11328 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
11333 /* An operator with this name can be either unary or binary. */
11339 return (name
== ansi_opname
[(int) INDIRECT_REF
]
11340 || name
== ansi_opname
[(int) ADDR_EXPR
]
11341 || name
== ansi_opname
[(int) NEGATE_EXPR
]
11342 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11343 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
11344 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
11347 /* An operator with this name can only be unary. */
11353 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
11354 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
11355 || name
== ansi_opname
[(int) COMPONENT_REF
]
11356 || OPERATOR_TYPENAME_P (name
));
11359 /* Do a little sanity-checking on how they declared their operator. */
11362 grok_op_properties (decl
, virtualp
, friendp
)
11364 int virtualp
, friendp
;
11366 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11367 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11368 tree name
= DECL_NAME (decl
);
11370 if (current_class_type
== NULL_TREE
)
11375 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11376 TYPE_HAS_ASSIGNMENT (current_class_type
) = 1;
11377 else if (name
== ansi_opname
[(int) CALL_EXPR
])
11378 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
11379 else if (name
== ansi_opname
[(int) ARRAY_REF
])
11380 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
11381 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
11382 || name
== ansi_opname
[(int) MEMBER_REF
])
11383 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
11384 else if (name
== ansi_opname
[(int) NEW_EXPR
])
11385 TYPE_GETS_NEW (current_class_type
) |= 1;
11386 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
11387 TYPE_GETS_DELETE (current_class_type
) |= 1;
11388 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11389 TYPE_GETS_NEW (current_class_type
) |= 2;
11390 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11391 TYPE_GETS_DELETE (current_class_type
) |= 2;
11394 if (name
== ansi_opname
[(int) NEW_EXPR
]
11395 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
11397 /* When the compiler encounters the definition of A::operator new, it
11398 doesn't look at the class declaration to find out if it's static. */
11400 revert_static_member_fn (&decl
, NULL
, NULL
);
11402 /* Take care of function decl if we had syntax errors. */
11403 if (argtypes
== NULL_TREE
)
11405 = build_function_type (ptr_type_node
,
11406 hash_tree_chain (integer_type_node
,
11409 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11411 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
11412 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
11415 revert_static_member_fn (&decl
, NULL
, NULL
);
11417 if (argtypes
== NULL_TREE
)
11419 = build_function_type (void_type_node
,
11420 hash_tree_chain (ptr_type_node
,
11424 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11426 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
11427 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
11428 != void_list_node
))
11429 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
11434 /* An operator function must either be a non-static member function
11435 or have at least one parameter of a class, a reference to a class,
11436 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11437 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11439 if (OPERATOR_TYPENAME_P (name
)
11440 || name
== ansi_opname
[(int) CALL_EXPR
]
11441 || name
== ansi_opname
[(int) MODIFY_EXPR
]
11442 || name
== ansi_opname
[(int) COMPONENT_REF
]
11443 || name
== ansi_opname
[(int) ARRAY_REF
])
11444 cp_error ("`%D' must be a nonstatic member function", decl
);
11449 if (DECL_STATIC_FUNCTION_P (decl
))
11450 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
11453 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
11455 tree arg
= TREE_VALUE (p
);
11456 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
11457 arg
= TREE_TYPE (arg
);
11459 /* This lets bad template code slip through. */
11460 if (IS_AGGR_TYPE (arg
)
11461 || TREE_CODE (arg
) == ENUMERAL_TYPE
11462 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
11463 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
11467 ("`%D' must have an argument of class or enumerated type",
11474 if (name
== ansi_opname
[(int) CALL_EXPR
])
11475 return; /* No restrictions on args. */
11477 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
11479 tree t
= TREE_TYPE (name
);
11480 if (TREE_CODE (t
) == VOID_TYPE
)
11481 pedwarn ("void is not a valid type conversion operator");
11482 else if (! friendp
)
11484 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11487 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11489 if (t
== current_class_type
)
11490 what
= "the same type";
11491 /* Don't force t to be complete here. */
11492 else if (IS_AGGR_TYPE (t
)
11494 && DERIVED_FROM_P (t
, current_class_type
))
11495 what
= "a base class";
11498 warning ("conversion to %s%s will never use a type conversion operator",
11499 ref
? "a reference to " : "", what
);
11503 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
11507 if (list_length (argtypes
) != 3 && methodp
)
11509 cp_error ("`%D' must take exactly one argument", decl
);
11512 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
11514 if (copy_assignment_arg_p (parmtype
, virtualp
)
11517 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
11518 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
11519 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11520 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
11523 else if (name
== ansi_opname
[(int) COND_EXPR
])
11526 pedwarn ("ANSI C++ prohibits overloading operator ?:");
11527 if (list_length (argtypes
) != 4)
11528 cp_error ("`%D' must take exactly three arguments", decl
);
11530 else if (ambi_op_p (name
))
11532 if (list_length (argtypes
) == 2)
11534 else if (list_length (argtypes
) == 3)
11536 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11537 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11538 && ! processing_template_decl
11539 && TREE_VALUE (TREE_CHAIN (argtypes
)) != integer_type_node
)
11542 cp_error ("postfix `%D' must take `int' as its argument",
11546 ("postfix `%D' must take `int' as its second argument",
11553 cp_error ("`%D' must take either zero or one argument", decl
);
11555 cp_error ("`%D' must take either one or two arguments", decl
);
11558 /* More Effective C++ rule 6. */
11560 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11561 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
11563 tree arg
= TREE_VALUE (argtypes
);
11564 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11565 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11566 arg
= TREE_TYPE (arg
);
11567 arg
= TYPE_MAIN_VARIANT (arg
);
11568 if (list_length (argtypes
) == 2)
11570 if (TREE_CODE (ret
) != REFERENCE_TYPE
11571 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11573 cp_warning ("prefix `%D' should return `%T'", decl
,
11574 build_reference_type (arg
));
11578 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11579 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
11583 else if (unary_op_p (name
))
11585 if (list_length (argtypes
) != 2)
11588 cp_error ("`%D' must take `void'", decl
);
11590 cp_error ("`%D' must take exactly one argument", decl
);
11593 else /* if (binary_op_p (name)) */
11595 if (list_length (argtypes
) != 3)
11598 cp_error ("`%D' must take exactly one argument", decl
);
11600 cp_error ("`%D' must take exactly two arguments", decl
);
11603 /* More Effective C++ rule 7. */
11605 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
11606 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
11607 || name
== ansi_opname
[COMPOUND_EXPR
]))
11608 cp_warning ("user-defined `%D' always evaluates both arguments",
11612 /* Effective C++ rule 23. */
11614 && list_length (argtypes
) == 3
11615 && (name
== ansi_opname
[PLUS_EXPR
]
11616 || name
== ansi_opname
[MINUS_EXPR
]
11617 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
11618 || name
== ansi_opname
[MULT_EXPR
])
11619 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11620 cp_warning ("`%D' should return by value", decl
);
11624 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
11625 if (TREE_PURPOSE (argtypes
))
11627 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11628 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
11629 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
11632 cp_pedwarn ("`%D' cannot have default arguments", decl
);
11635 cp_error ("`%D' cannot have default arguments", decl
);
11640 /* Get the struct, enum or union (CODE says which) with tag NAME.
11641 Define the tag as a forward-reference if it is not defined.
11643 C++: If a class derivation is given, process it here, and report
11644 an error if multiple derivation declarations are not identical.
11646 If this is a definition, come in through xref_tag and only look in
11647 the current frame for the name (since C++ allows new names in any
11651 xref_tag (code_type_node
, name
, globalize
)
11652 tree code_type_node
;
11656 enum tag_types tag_code
;
11657 enum tree_code code
;
11659 register tree ref
, t
;
11660 struct binding_level
*b
= inner_binding_level
;
11662 tree attributes
= NULL_TREE
;
11664 /* If we are called from the parser, code_type_node will sometimes be a
11665 TREE_LIST. This indicates that the user wrote
11666 "class __attribute__ ((foo)) bar". Extract the attributes so we can
11668 if (TREE_CODE (code_type_node
) == TREE_LIST
)
11670 attributes
= TREE_PURPOSE (code_type_node
);
11671 code_type_node
= TREE_VALUE (code_type_node
);
11674 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11679 case signature_type
:
11680 code
= RECORD_TYPE
;
11686 code
= ENUMERAL_TYPE
;
11689 my_friendly_abort (18);
11692 /* If a cross reference is requested, look up the type
11693 already defined for this tag and return it. */
11694 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
11697 name
= TYPE_IDENTIFIER (t
);
11701 t
= IDENTIFIER_TYPE_VALUE (name
);
11703 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
11704 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
11709 if (t
&& (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
11710 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
))
11712 cp_error ("redeclaration of template type-parameter `%T'", name
);
11713 cp_error_at (" previously declared here `%#D'",
11714 TEMPLATE_TYPE_DECL (t
));
11716 if (t
&& TYPE_CONTEXT (t
) && got_type
)
11719 /* If we know we are defining this tag, only look it up in
11720 this scope and don't try to find it as a type. */
11721 ref
= lookup_tag (code
, name
, b
, 1);
11725 if (current_class_type
11726 && template_class_depth (current_class_type
)
11727 && PROCESSING_REAL_TEMPLATE_DECL_P ())
11728 /* Since GLOBALIZE is non-zero, we are not looking at a
11729 definition of this tag. Since, in addition, we are currently
11730 processing a (member) template declaration of a template
11731 class, we don't want to do any lookup at all; consider:
11738 { template <class V>
11739 friend struct S1; };
11741 Here, the S2::S1 declaration should not be confused with the
11742 outer declaration. In particular, the inner version should
11743 have a template parameter of level 2, not level 1. This
11744 would be particularly important if the member declaration
11747 template <class V = U> friend struct S1;
11749 say, when we should tsubst into `U' when instantiating S2. */
11756 ref
= lookup_tag (code
, name
, b
, 0);
11760 /* Try finding it as a type declaration. If that wins,
11762 ref
= lookup_name (name
, 1);
11764 if (ref
!= NULL_TREE
11765 && processing_template_decl
11766 && DECL_CLASS_TEMPLATE_P (ref
)
11767 && template_class_depth (current_class_type
) == 0)
11768 /* Since GLOBALIZE is true, we're declaring a global
11769 template, so we want this type. */
11770 ref
= DECL_RESULT (ref
);
11772 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
11773 && TREE_CODE (TREE_TYPE (ref
)) == code
)
11774 ref
= TREE_TYPE (ref
);
11781 push_obstacks_nochange ();
11785 /* If no such tag is yet defined, create a forward-reference node
11786 and record it as the "definition".
11787 When a real declaration of this type is found,
11788 the forward-reference will be altered into a real type. */
11790 /* In C++, since these migrate into the global scope, we must
11791 build them on the permanent obstack. */
11793 temp
= allocation_temporary_p ();
11795 end_temporary_allocation ();
11797 if (code
== ENUMERAL_TYPE
)
11799 cp_error ("use of enum `%#D' without previous declaration", name
);
11801 ref
= make_node (ENUMERAL_TYPE
);
11803 /* Give the type a default layout like unsigned int
11804 to avoid crashing if it does not get defined. */
11805 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
11806 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
11807 TREE_UNSIGNED (ref
) = 1;
11808 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
11809 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
11810 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
11812 /* Enable us to recognize when a type is created in class context.
11813 To do nested classes correctly, this should probably be cleared
11814 out when we leave this classes scope. Currently this in only
11815 done in `start_enum'. */
11817 pushtag (name
, ref
, globalize
);
11821 struct binding_level
*old_b
= class_binding_level
;
11823 ref
= make_lang_type (code
);
11825 if (tag_code
== signature_type
)
11827 SET_SIGNATURE (ref
);
11828 /* Since a signature type will be turned into the type
11829 of signature tables, it's not only an interface. */
11830 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
11831 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
11832 /* A signature doesn't have a vtable. */
11833 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
11836 #ifdef NONNESTED_CLASSES
11837 /* Class types don't nest the way enums do. */
11838 class_binding_level
= (struct binding_level
*)0;
11840 pushtag (name
, ref
, globalize
);
11841 class_binding_level
= old_b
;
11846 /* If it no longer looks like a nested type, make sure it's
11848 If it is not an IDENTIFIER, this is not a declaration */
11849 if (b
->namespace_p
&& !class_binding_level
11850 && TREE_CODE (name
) == IDENTIFIER_NODE
)
11852 if (IDENTIFIER_NAMESPACE_VALUE (name
) == NULL_TREE
)
11853 SET_IDENTIFIER_NAMESPACE_VALUE (name
, TYPE_NAME (ref
));
11856 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
11857 redeclare_class_template (ref
, current_template_parms
);
11860 /* Until the type is defined, tentatively accept whatever
11861 structure tag the user hands us. */
11862 if (TYPE_SIZE (ref
) == NULL_TREE
11863 && ref
!= current_class_type
11864 /* Have to check this, in case we have contradictory tag info. */
11865 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
11867 if (tag_code
== class_type
)
11868 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
11869 else if (tag_code
== record_type
|| tag_code
== signature_type
)
11870 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
11875 TREE_TYPE (ref
) = attributes
;
11877 if (ref
&& TYPE_P (ref
))
11881 If the identifier resolves to a typedef-name or a template
11882 type-parameter, the elaborated-type-specifier is
11884 if (TYPE_LANG_SPECIFIC (ref
) && TYPE_WAS_ANONYMOUS (ref
))
11885 cp_error ("`%T' is a typedef name", ref
);
11886 else if (TREE_CODE (ref
) == TEMPLATE_TYPE_PARM
)
11887 cp_error ("`%T' is a template type paramter", ref
);
11894 xref_tag_from_type (old
, id
, globalize
)
11898 tree code_type_node
;
11900 if (TREE_CODE (old
) == RECORD_TYPE
)
11901 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
11902 ? class_type_node
: record_type_node
);
11904 code_type_node
= union_type_node
;
11906 if (id
== NULL_TREE
)
11907 id
= TYPE_IDENTIFIER (old
);
11909 return xref_tag (code_type_node
, id
, globalize
);
11913 xref_basetypes (code_type_node
, name
, ref
, binfo
)
11914 tree code_type_node
;
11918 /* In the declaration `A : X, Y, ... Z' we mark all the types
11919 (A, X, Y, ..., Z) so we can check for duplicates. */
11922 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11924 if (tag_code
== union_type
)
11926 cp_error ("derived union `%T' invalid", ref
);
11930 len
= list_length (binfo
);
11931 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
11933 SET_CLASSTYPE_MARKED (ref
);
11934 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
11936 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
11938 /* The base of a derived struct is public by default. */
11940 = (TREE_PURPOSE (binfo
) == access_public_node
11941 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11942 || (tag_code
!= class_type
11943 && (TREE_PURPOSE (binfo
) == access_default_node
11944 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
11946 = (TREE_PURPOSE (binfo
) == access_protected_node
11947 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
11949 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
11950 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
11951 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11952 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
11953 tree basetype
= TREE_VALUE (binfo
);
11956 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
11957 basetype
= TREE_TYPE (basetype
);
11959 || (TREE_CODE (basetype
) != RECORD_TYPE
11960 && TREE_CODE (basetype
) != TYPENAME_TYPE
11961 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
11962 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
11964 cp_error ("base type `%T' fails to be a struct or class type",
11965 TREE_VALUE (binfo
));
11969 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
11972 /* This code replaces similar code in layout_basetypes.
11973 We put the complete_type first for implicit `typename'. */
11974 if (TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
11975 && ! (current_template_parms
&& uses_template_parms (basetype
)))
11977 cp_error ("base class `%T' has incomplete type", basetype
);
11983 if (CLASSTYPE_MARKED (basetype
))
11985 if (basetype
== ref
)
11986 cp_error ("recursive type `%T' undefined", basetype
);
11988 cp_error ("duplicate base type `%T' invalid", basetype
);
11992 if (TYPE_FOR_JAVA (basetype
)
11993 && current_lang_stack
== current_lang_base
)
11994 TYPE_FOR_JAVA (ref
) = 1;
11996 /* Note that the BINFO records which describe individual
11997 inheritances are *not* shared in the lattice! They
11998 cannot be shared because a given baseclass may be
11999 inherited with different `accessibility' by different
12000 derived classes. (Each BINFO record describing an
12001 individual inheritance contains flags which say what
12002 the `accessibility' of that particular inheritance is.) */
12004 base_binfo
= make_binfo (integer_zero_node
, basetype
,
12005 TYPE_BINFO_VTABLE (basetype
),
12006 TYPE_BINFO_VIRTUALS (basetype
));
12008 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12009 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12010 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12011 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12012 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12014 /* We need to unshare the binfos now so that lookups during class
12015 definition work. */
12016 unshare_base_binfos (base_binfo
);
12018 SET_CLASSTYPE_MARKED (basetype
);
12020 /* We are free to modify these bits because they are meaningless
12021 at top level, and BASETYPE is a top-level type. */
12022 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12024 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12025 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12028 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
12029 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12034 TREE_VEC_LENGTH (binfos
) = i
;
12036 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12039 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12041 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12042 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos
, 0)));
12043 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
12044 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
12046 /* Unmark all the types. */
12048 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12049 CLEAR_CLASSTYPE_MARKED (ref
);
12055 /* Begin compiling the definition of an enumeration type.
12056 NAME is its name (or null if anonymous).
12057 Returns the type object, as yet incomplete.
12058 Also records info about it so that build_enumerator
12059 may be used to declare the individual values as they are read. */
12065 register tree enumtype
= NULL_TREE
;
12066 struct binding_level
*b
= inner_binding_level
;
12068 /* We are wasting space here and putting these on the permanent_obstack so
12069 that typeid(local enum) will work correctly. */
12071 if (processing_template_decl
&& current_function_decl
)
12074 end_temporary_allocation ();
12076 /* If this is the real definition for a previous forward reference,
12077 fill in the contents in the same object that used to be the
12078 forward reference. */
12080 if (name
!= NULL_TREE
)
12081 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12083 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12084 cp_error ("multiple definition of `%#T'", enumtype
);
12087 enumtype
= make_node (ENUMERAL_TYPE
);
12088 pushtag (name
, enumtype
, 0);
12091 if (current_class_type
)
12092 TREE_ADDRESSABLE (b
->tags
) = 1;
12094 /* We don't copy this value because build_enumerator needs to do it. */
12095 enum_next_value
= integer_zero_node
;
12098 GNU_xref_decl (current_function_decl
, enumtype
);
12102 /* After processing and defining all the values of an enumeration type,
12103 install their decls in the enumeration type and finish it off.
12104 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12105 Returns ENUMTYPE. */
12108 finish_enum (enumtype
)
12111 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12112 /* Calculate the maximum value of any enumerator in this type. */
12114 tree values
= TYPE_VALUES (enumtype
);
12119 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12124 /* The TREE_VALUE is a CONST_DECL for this enumeration
12126 decl
= TREE_VALUE (pair
);
12128 /* The DECL_INITIAL will be NULL if we are processing a
12129 template declaration and this enumeration constant had no
12130 explicit initializer. */
12131 value
= DECL_INITIAL (decl
);
12132 if (value
&& !processing_template_decl
)
12134 /* Set the TREE_TYPE for the VALUE as well. That's so
12135 that when we call decl_constant_value we get an
12136 entity of the right type (but with the constant
12137 value). Since we shouldn't ever call
12138 decl_constant_value on a template type, there's no
12139 reason to do that when processing_template_decl.
12140 And, if the expression is something like a
12141 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12142 wreak havoc on the intended type of the expression.
12144 Of course, there's also no point in trying to compute
12145 minimum or maximum values if we're in a template. */
12146 TREE_TYPE (value
) = enumtype
;
12149 minnode
= maxnode
= value
;
12150 else if (tree_int_cst_lt (maxnode
, value
))
12152 else if (tree_int_cst_lt (value
, minnode
))
12156 if (processing_template_decl
)
12157 /* If this is just a template, leave the CONST_DECL
12158 alone. That way tsubst_copy will find CONST_DECLs for
12159 CONST_DECLs, and not INTEGER_CSTs. */
12162 /* In the list we're building up, we want the enumeration
12163 values, not the CONST_DECLs. */
12164 TREE_VALUE (pair
) = value
;
12168 maxnode
= minnode
= integer_zero_node
;
12170 TYPE_VALUES (enumtype
) = nreverse (values
);
12172 if (processing_template_decl
)
12174 tree scope
= current_scope ();
12175 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12177 add_tree (build_min (TAG_DEFN
, enumtype
));
12178 resume_temporary_allocation ();
12184 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12185 int lowprec
= min_precision (minnode
, unsignedp
);
12186 int highprec
= min_precision (maxnode
, unsignedp
);
12187 int precision
= MAX (lowprec
, highprec
);
12189 TYPE_SIZE (enumtype
) = NULL_TREE
;
12191 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12193 TYPE_PRECISION (enumtype
) = precision
;
12195 fixup_unsigned_type (enumtype
);
12197 fixup_signed_type (enumtype
);
12199 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
12200 /* Use the width of the narrowest normal C type which is wide enough. */
12201 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
12204 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
12206 TYPE_SIZE (enumtype
) = 0;
12207 layout_type (enumtype
);
12213 /* Fix up all variant types of this enum type. */
12214 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
12215 tem
= TYPE_NEXT_VARIANT (tem
))
12217 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
12218 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
12219 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
12220 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
12221 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
12222 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
12223 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
12224 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
12225 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
12229 /* Finish debugging output for this type. */
12230 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12235 /* Build and install a CONST_DECL for an enumeration constant of the
12236 enumeration type TYPE whose NAME and VALUE (if any) are provided.
12237 Assignment of sequential values by default is handled here. */
12240 build_enumerator (name
, value
, type
)
12248 /* Remove no-op casts from the value. */
12250 STRIP_TYPE_NOPS (value
);
12252 if (! processing_template_decl
)
12254 /* Validate and default VALUE. */
12255 if (value
!= NULL_TREE
)
12257 if (TREE_READONLY_DECL_P (value
))
12258 value
= decl_constant_value (value
);
12260 if (TREE_CODE (value
) == INTEGER_CST
)
12262 value
= default_conversion (value
);
12263 constant_expression_warning (value
);
12267 cp_error ("enumerator value for `%D' not integer constant", name
);
12272 /* Default based on previous value. */
12273 if (value
== NULL_TREE
&& ! processing_template_decl
)
12275 value
= enum_next_value
;
12277 cp_error ("overflow in enumeration values at `%D'", name
);
12280 /* Remove no-op casts from the value. */
12282 STRIP_TYPE_NOPS (value
);
12284 /* To fix MAX_VAL enum consts. (bkoz) */
12285 TREE_TYPE (value
) = integer_type_node
;
12289 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12290 Even in other cases, we will later (in finish_enum) be setting the
12292 if (value
!= NULL_TREE
)
12293 value
= copy_node (value
);
12295 /* C++ associates enums with global, function, or class declarations. */
12297 context
= current_scope ();
12298 if (context
&& context
== current_class_type
)
12299 /* This enum declaration is local to the class. */
12300 decl
= build_lang_field_decl (CONST_DECL
, name
, type
);
12302 /* It's a global enum, or it's local to a function. (Note local to
12303 a function could mean local to a class method. */
12304 decl
= build_decl (CONST_DECL
, name
, type
);
12306 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
12307 DECL_INITIAL (decl
) = value
;
12308 TREE_READONLY (decl
) = 1;
12310 if (context
&& context
== current_class_type
)
12312 pushdecl_class_level (decl
);
12313 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12314 on the TYPE_FIELDS list for `S'. (That's so that you can say
12315 things like `S::i' later.) */
12316 finish_member_declaration (decl
);
12321 GNU_xref_decl (current_function_decl
, decl
);
12324 if (! processing_template_decl
)
12326 /* Set basis for default for next value. */
12327 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
12328 integer_one_node
, PLUS_EXPR
);
12329 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
12332 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
12337 static int function_depth
;
12339 /* Create the FUNCTION_DECL for a function definition.
12340 DECLSPECS and DECLARATOR are the parts of the declaration;
12341 they describe the function's name and the type it returns,
12342 but twisted together in a fashion that parallels the syntax of C.
12344 This function creates a binding context for the function body
12345 as well as setting up the FUNCTION_DECL in current_function_decl.
12347 Returns 1 on success. If the DECLARATOR is not suitable for a function
12348 (it defines a datum instead), we return 0, which tells
12349 yyparse to report a parse error.
12351 For C++, we must first check whether that datum makes any sense.
12352 For example, "class A local_a(1,2);" means that variable local_a
12353 is an aggregate of type A, which should have a constructor
12354 applied to it with the argument list [1, 2].
12356 @@ There is currently no way to retrieve the storage
12357 @@ allocated to FUNCTION (or all of its parms) if we return
12358 @@ something we had previously. */
12361 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
12362 tree declspecs
, declarator
, attrs
;
12366 tree ctype
= NULL_TREE
;
12369 extern int have_extern_spec
;
12370 extern int used_extern_spec
;
12371 int doing_friend
= 0;
12373 /* Sanity check. */
12374 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
12375 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
12377 /* Assume, until we see it does. */
12378 current_function_returns_value
= 0;
12379 current_function_returns_null
= 0;
12380 warn_about_return_type
= 0;
12382 shadowed_labels
= 0;
12383 current_function_assigns_this
= 0;
12384 current_function_just_assigned_this
= 0;
12385 current_function_parms_stored
= 0;
12386 original_result_rtx
= NULL_RTX
;
12387 base_init_expr
= NULL_TREE
;
12388 current_base_init_list
= NULL_TREE
;
12389 current_member_init_list
= NULL_TREE
;
12390 ctor_label
= dtor_label
= NULL_TREE
;
12391 static_labelno
= 0;
12393 clear_temp_name ();
12395 /* This should only be done once on the top most decl. */
12396 if (have_extern_spec
&& !used_extern_spec
)
12398 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
12399 used_extern_spec
= 1;
12404 decl1
= declarator
;
12407 /* What was this testing for, exactly? */
12408 if (! DECL_ARGUMENTS (decl1
)
12409 && !DECL_STATIC_FUNCTION_P (decl1
)
12410 && !DECL_ARTIFICIAL (decl1
)
12411 && DECL_CLASS_SCOPE_P (decl1
)
12412 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
12413 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
12415 tree binding
= binding_for_name (DECL_NAME (decl1
),
12416 current_namespace
);
12417 cp_error ("redeclaration of `%#D'", decl1
);
12418 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
12419 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
12420 else if (BINDING_VALUE (binding
))
12421 cp_error_at ("previous declaration here", BINDING_VALUE (binding
));
12425 fntype
= TREE_TYPE (decl1
);
12426 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12427 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12429 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12430 class is in the (lexical) scope of the class in which it is
12432 if (!ctype
&& DECL_FRIEND_P (decl1
))
12434 ctype
= DECL_CLASS_CONTEXT (decl1
);
12436 /* CTYPE could be null here if we're dealing with a template;
12437 for example, `inline friend float foo()' inside a template
12438 will have no CTYPE set. */
12439 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12445 /* In a fcn definition, arg types must be complete. */
12446 require_complete_types_for_parms (DECL_ARGUMENTS (decl1
));
12448 /* In case some arg types were completed since the declaration was
12449 parsed, fix up the decls. */
12451 tree t
= DECL_ARGUMENTS (decl1
);
12452 for (; t
; t
= TREE_CHAIN (t
))
12453 layout_decl (t
, 0);
12456 last_function_parms
= DECL_ARGUMENTS (decl1
);
12457 last_function_parm_tags
= NULL_TREE
;
12461 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
12462 /* If the declarator is not suitable for a function definition,
12463 cause a syntax error. */
12464 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
12466 fntype
= TREE_TYPE (decl1
);
12468 restype
= TREE_TYPE (fntype
);
12469 if (IS_AGGR_TYPE (restype
) && ! TYPE_PTRMEMFUNC_P (restype
)
12470 && ! CLASSTYPE_GOT_SEMICOLON (restype
))
12472 cp_error ("semicolon missing after declaration of `%#T'", restype
);
12473 shadow_tag (build_expr_list (NULL_TREE
, restype
));
12474 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
12475 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
12476 fntype
= build_function_type (integer_type_node
,
12477 TYPE_ARG_TYPES (fntype
));
12479 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
12481 TYPE_ARG_TYPES (fntype
));
12482 TREE_TYPE (decl1
) = fntype
;
12485 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12486 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12487 else if (DECL_MAIN_P (decl1
))
12489 /* If this doesn't return integer_type, complain. */
12490 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
12492 if (pedantic
|| warn_return_type
)
12493 pedwarn ("return type for `main' changed to `int'");
12494 TREE_TYPE (decl1
) = fntype
= default_function_type
;
12496 warn_about_return_type
= 0;
12500 /* Warn if function was previously implicitly declared
12501 (but not if we warned then). */
12502 if (! warn_implicit
12503 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
12504 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
12506 current_function_decl
= decl1
;
12507 /* Save the parm names or decls from this function's declarator
12508 where store_parm_decls will find them. */
12509 current_function_parms
= last_function_parms
;
12510 current_function_parm_tags
= last_function_parm_tags
;
12512 announce_function (decl1
);
12514 if (! processing_template_decl
)
12516 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
12518 cp_error ("return-type `%#T' is an incomplete type",
12519 TREE_TYPE (fntype
));
12521 /* Make it return void instead, but don't change the
12522 type of the DECL_RESULT, in case we have a named return value. */
12525 = build_cplus_method_type (build_type_variant (ctype
,
12526 TREE_READONLY (decl1
),
12527 TREE_SIDE_EFFECTS (decl1
)),
12529 FUNCTION_ARG_CHAIN (decl1
));
12532 = build_function_type (void_type_node
,
12533 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
12534 DECL_RESULT (decl1
)
12535 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
12536 TREE_READONLY (DECL_RESULT (decl1
))
12537 = CP_TYPE_CONST_P (TREE_TYPE (fntype
));
12538 TREE_THIS_VOLATILE (DECL_RESULT (decl1
))
12539 = CP_TYPE_VOLATILE_P (TREE_TYPE (fntype
));
12542 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype
))
12543 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype
)))
12544 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
12547 if (warn_about_return_type
)
12548 pedwarn ("return-type defaults to `int'");
12550 /* Effective C++ rule 15. See also c_expand_return. */
12552 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
12553 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12554 cp_warning ("`operator=' should return a reference to `*this'");
12556 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12557 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12558 DECL_INITIAL (decl1
) = error_mark_node
;
12560 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
12561 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
12564 /* This function exists in static storage.
12565 (This does not mean `static' in the C sense!) */
12566 TREE_STATIC (decl1
) = 1;
12568 /* Set up current_class_type, and enter the scope of the class, if
12571 push_nested_class (ctype
, 1);
12572 else if (DECL_STATIC_FUNCTION_P (decl1
))
12573 push_nested_class (DECL_CONTEXT (decl1
), 2);
12575 /* We must call push_template_decl after current_class_type is set
12576 up. (If we are processing inline definitions after exiting a
12577 class scope, current_class_type will be NULL_TREE until set above
12578 by push_nested_class.) */
12579 if (processing_template_decl
)
12580 decl1
= push_template_decl (decl1
);
12582 /* Record the decl so that the function name is defined.
12583 If we already have a decl for this name, and it is a FUNCTION_DECL,
12584 use the old decl. */
12585 if (!processing_template_decl
&& pre_parsed_p
== 0)
12587 /* A specialization is not used to guide overload resolution. */
12588 if ((flag_guiding_decls
12589 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
12590 && ! DECL_FUNCTION_MEMBER_P (decl1
))
12591 decl1
= pushdecl (decl1
);
12594 /* We need to set the DECL_CONTEXT. */
12595 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
12596 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
12597 /* And make sure we have enough default args. */
12598 check_default_args (decl1
);
12600 DECL_MAIN_VARIANT (decl1
) = decl1
;
12601 fntype
= TREE_TYPE (decl1
);
12604 current_function_decl
= decl1
;
12606 if (DECL_INTERFACE_KNOWN (decl1
))
12608 tree ctx
= hack_decl_function_context (decl1
);
12610 if (DECL_NOT_REALLY_EXTERN (decl1
))
12611 DECL_EXTERNAL (decl1
) = 0;
12613 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
12614 && TREE_PUBLIC (ctx
))
12615 /* This is a function in a local class in an extern inline
12617 comdat_linkage (decl1
);
12619 /* If this function belongs to an interface, it is public.
12620 If it belongs to someone else's interface, it is also external.
12621 It doesn't matter whether it's inline or not. */
12622 else if (interface_unknown
== 0
12623 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
12624 || flag_alt_external_templates
))
12626 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
12627 || processing_template_decl
)
12628 DECL_EXTERNAL (decl1
)
12630 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
));
12632 DECL_EXTERNAL (decl1
) = 0;
12633 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12634 DECL_INTERFACE_KNOWN (decl1
) = 1;
12638 /* This is a definition, not a reference.
12639 So clear DECL_EXTERNAL. */
12640 DECL_EXTERNAL (decl1
) = 0;
12642 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
12643 && ! DECL_INTERFACE_KNOWN (decl1
)
12644 /* Don't try to defer nested functions for now. */
12645 && ! hack_decl_function_context (decl1
))
12646 DECL_DEFER_OUTPUT (decl1
) = 1;
12648 DECL_INTERFACE_KNOWN (decl1
) = 1;
12651 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
12653 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12654 TREE_TYPE (decl1
) = fntype
12655 = build_function_type (TREE_TYPE (fntype
),
12656 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
12657 current_function_parms
= TREE_CHAIN (current_function_parms
);
12658 DECL_ARGUMENTS (decl1
) = current_function_parms
;
12661 restype
= TREE_TYPE (fntype
);
12665 /* If we're compiling a friend function, neither of the variables
12666 current_class_ptr nor current_class_type will have values. */
12667 if (! doing_friend
)
12669 /* We know that this was set up by `grokclassfn'.
12670 We do not wait until `store_parm_decls', since evil
12671 parse errors may never get us to that point. Here
12672 we keep the consistency between `current_class_type'
12673 and `current_class_ptr'. */
12674 tree t
= current_function_parms
;
12676 my_friendly_assert (t
!= NULL_TREE
12677 && TREE_CODE (t
) == PARM_DECL
, 162);
12679 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
12681 int i
= suspend_momentary ();
12683 /* Fool build_indirect_ref. */
12684 current_class_ptr
= NULL_TREE
;
12685 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
12686 current_class_ptr
= t
;
12687 resume_momentary (i
);
12690 /* We're having a signature pointer here. */
12691 current_class_ref
= current_class_ptr
= t
;
12697 current_class_ptr
= current_class_ref
= NULL_TREE
;
12701 current_binding_level
->parm_flag
= 1;
12703 GNU_xref_function (decl1
, current_function_parms
);
12706 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
12708 make_function_rtl (decl1
);
12710 /* Promote the value to int before returning it. */
12711 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
12712 restype
= type_promotes_to (restype
);
12714 /* If this fcn was already referenced via a block-scope `extern' decl
12715 (or an implicit decl), propagate certain information about the usage. */
12716 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
12717 TREE_ADDRESSABLE (decl1
) = 1;
12719 if (DECL_RESULT (decl1
) == NULL_TREE
)
12721 DECL_RESULT (decl1
)
12722 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
12723 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
12724 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
12727 /* Allocate further tree nodes temporarily during compilation
12728 of this function only. Tiemann moved up here from bottom of fn. */
12729 /* If this is a nested function, then we must continue to allocate RTL
12730 on the permanent obstack in case we need to inline it later. */
12731 if (! hack_decl_function_context (decl1
))
12732 temporary_allocation ();
12734 if (processing_template_decl
)
12736 ++minimal_parse_mode
;
12737 last_tree
= DECL_SAVED_TREE (decl1
)
12738 = build_nt (EXPR_STMT
, void_zero_node
);
12743 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
12744 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
12746 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12747 ctor_label
= NULL_TREE
;
12751 dtor_label
= NULL_TREE
;
12752 if (DECL_CONSTRUCTOR_P (decl1
))
12753 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12759 /* Called after store_parm_decls for a function-try-block. We need to update
12760 last_parm_cleanup_insn so that the base initializers for a constructor
12761 are run within this block, not before it. */
12764 expand_start_early_try_stmts ()
12766 expand_start_try_stmts ();
12767 last_parm_cleanup_insn
= get_last_insn ();
12770 /* Store the parameter declarations into the current function declaration.
12771 This is called after parsing the parameter declarations, before
12772 digesting the body of the function.
12774 Also install to binding contour return value identifier, if any. */
12777 store_parm_decls ()
12779 register tree fndecl
= current_function_decl
;
12780 register tree parm
;
12781 int parms_have_cleanups
= 0;
12782 tree cleanups
= NULL_TREE
;
12784 /* This is either a chain of PARM_DECLs (when a prototype is used). */
12785 tree specparms
= current_function_parms
;
12787 /* This is a list of types declared among parms in a prototype. */
12788 tree parmtags
= current_function_parm_tags
;
12790 /* This is a chain of any other decls that came in among the parm
12791 declarations. If a parm is declared with enum {foo, bar} x;
12792 then CONST_DECLs for foo and bar are put here. */
12793 tree nonparms
= NULL_TREE
;
12795 if (toplevel_bindings_p ())
12796 fatal ("parse errors have confused me too much");
12798 /* Initialize RTL machinery. */
12799 init_function_start (fndecl
, input_filename
, lineno
);
12801 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
12802 declare_function_name ();
12804 /* Create a binding level for the parms. */
12805 expand_start_bindings (0);
12807 if (specparms
!= NULL_TREE
)
12809 /* This case is when the function was defined with an ANSI prototype.
12810 The parms already have decls, so we need not do anything here
12811 except record them as in effect
12812 and complain if any redundant old-style parm decls were written. */
12814 register tree next
;
12816 /* Must clear this because it might contain TYPE_DECLs declared
12818 storedecls (NULL_TREE
);
12820 for (parm
= nreverse (specparms
); parm
; parm
= next
)
12822 next
= TREE_CHAIN (parm
);
12823 if (TREE_CODE (parm
) == PARM_DECL
)
12826 if (DECL_NAME (parm
) == NULL_TREE
)
12830 else if (TREE_CODE (TREE_TYPE (parm
)) == VOID_TYPE
)
12831 cp_error ("parameter `%D' declared void", parm
);
12834 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
12835 A parameter is assumed not to have any side effects.
12836 If this should change for any reason, then this
12837 will have to wrap the bashed reference type in a save_expr.
12839 Also, if the parameter type is declared to be an X
12840 and there is an X(X&) constructor, we cannot lay it
12841 into the stack (any more), so we make this parameter
12842 look like it is really of reference type. Functions
12843 which pass parameters to this function will know to
12844 create a temporary in their frame, and pass a reference
12847 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
12848 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
12849 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
12853 if (! processing_template_decl
12854 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
12856 expand_decl (parm
);
12857 parms_have_cleanups
= 1;
12859 /* Keep track of the cleanups. */
12860 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
12865 /* If we find an enum constant or a type tag,
12866 put it aside for the moment. */
12867 TREE_CHAIN (parm
) = NULL_TREE
;
12868 nonparms
= chainon (nonparms
, parm
);
12872 /* Get the decls in their original chain order
12873 and record in the function. This is all and only the
12874 PARM_DECLs that were pushed into scope by the loop above. */
12875 DECL_ARGUMENTS (fndecl
) = getdecls ();
12877 storetags (chainon (parmtags
, gettags ()));
12880 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
12882 /* Now store the final chain of decls for the arguments
12883 as the decl-chain of the current lexical scope.
12884 Put the enumerators in as well, at the front so that
12885 DECL_ARGUMENTS is not modified. */
12887 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
12889 /* Initialize the RTL code for the function. */
12890 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
12891 if (! processing_template_decl
)
12892 expand_function_start (fndecl
, parms_have_cleanups
);
12894 current_function_parms_stored
= 1;
12896 /* If this function is `main', emit a call to `__main'
12897 to run global initializers, etc. */
12898 if (DECL_MAIN_P (fndecl
))
12899 expand_main_function ();
12901 /* Now that we have initialized the parms, we can start their
12902 cleanups. We cannot do this before, since expand_decl_cleanup
12903 should not be called before the parm can be used. */
12905 && ! processing_template_decl
)
12907 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
12909 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
12910 cp_error ("parser lost in parsing declaration of `%D'",
12911 TREE_PURPOSE (cleanups
));
12915 /* Create a binding contour which can be used to catch
12916 cleanup-generated temporaries. Also, if the return value needs or
12917 has initialization, deal with that now. */
12918 if (parms_have_cleanups
)
12921 expand_start_bindings (0);
12924 if (! processing_template_decl
&& flag_exceptions
)
12926 /* Do the starting of the exception specifications, if we have any. */
12927 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
12928 expand_start_eh_spec ();
12931 last_parm_cleanup_insn
= get_last_insn ();
12932 last_dtor_insn
= get_last_insn ();
12935 /* Bind a name and initialization to the return value of
12936 the current function. */
12939 store_return_init (return_id
, init
)
12940 tree return_id
, init
;
12942 tree decl
= DECL_RESULT (current_function_decl
);
12945 /* Give this error as many times as there are occurrences,
12946 so that users can use Emacs compilation buffers to find
12947 and fix all such places. */
12948 pedwarn ("ANSI C++ does not permit named return values");
12950 if (return_id
!= NULL_TREE
)
12952 if (DECL_NAME (decl
) == NULL_TREE
)
12954 DECL_NAME (decl
) = return_id
;
12955 DECL_ASSEMBLER_NAME (decl
) = return_id
;
12958 cp_error ("return identifier `%D' already in place", decl
);
12961 /* Can't let this happen for constructors. */
12962 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12964 error ("can't redefine default return value for constructors");
12968 /* If we have a named return value, put that in our scope as well. */
12969 if (DECL_NAME (decl
) != NULL_TREE
)
12971 /* If this named return value comes in a register,
12972 put it in a pseudo-register. */
12973 if (DECL_REGISTER (decl
))
12975 original_result_rtx
= DECL_RTL (decl
);
12976 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
12979 /* Let `cp_finish_decl' know that this initializer is ok. */
12980 DECL_INITIAL (decl
) = init
;
12983 if (minimal_parse_mode
)
12984 add_tree (build_min_nt (RETURN_INIT
, return_id
,
12985 copy_to_permanent (init
)));
12987 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
12992 /* Finish up a function declaration and compile that function
12993 all the way to assembler language output. The free the storage
12994 for the function definition.
12996 This is called after parsing the body of the function definition.
12997 LINENO is the current line number.
12999 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
13000 (and expand_end_bindings) must be made to take care of the binding
13001 contour for the base initializers. This is only relevant for
13004 NESTED is nonzero if we were in the middle of compiling another function
13005 when we started on this one. */
13008 finish_function (lineno
, call_poplevel
, nested
)
13013 register tree fndecl
= current_function_decl
;
13014 tree fntype
, ctype
= NULL_TREE
;
13015 rtx last_parm_insn
, insns
;
13016 /* Label to use if this function is supposed to return a value. */
13017 tree no_return_label
= NULL_TREE
;
13018 tree decls
= NULL_TREE
;
13020 /* When we get some parse errors, we can end up without a
13021 current_function_decl, so cope. */
13022 if (fndecl
== NULL_TREE
)
13025 if (! nested
&& function_depth
> 1)
13028 fntype
= TREE_TYPE (fndecl
);
13030 /* TREE_READONLY (fndecl) = 1;
13031 This caused &foo to be of type ptr-to-const-function
13032 which then got a warning when stored in a ptr-to-function variable. */
13034 /* This happens on strange parse errors. */
13035 if (! current_function_parms_stored
)
13038 store_parm_decls ();
13041 if (processing_template_decl
)
13043 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
13045 decls
= getdecls ();
13046 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13047 poplevel (decls
!= NULL_TREE
, 0, 0);
13052 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13054 tree ttype
= target_type (fntype
);
13057 if (IS_AGGR_TYPE (ttype
))
13058 /* Let debugger know it should output info for this type. */
13059 note_debug_info_needed (ttype
);
13061 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
13063 ttype
= target_type (TREE_TYPE (parmdecl
));
13064 if (IS_AGGR_TYPE (ttype
))
13065 /* Let debugger know it should output info for this type. */
13066 note_debug_info_needed (ttype
);
13070 /* Clean house because we will need to reorder insns here. */
13071 do_pending_stack_adjust ();
13075 tree binfo
= TYPE_BINFO (current_class_type
);
13076 tree cond
= integer_one_node
;
13078 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
13080 int ok_to_optimize_dtor
= 0;
13081 int empty_dtor
= get_last_insn () == last_dtor_insn
;
13083 if (current_function_assigns_this
)
13084 cond
= build (NE_EXPR
, boolean_type_node
,
13085 current_class_ptr
, integer_zero_node
);
13088 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
13090 /* If this destructor is empty, then we don't need to check
13091 whether `this' is NULL in some cases. */
13092 if ((flag_this_is_variable
& 1) == 0)
13093 ok_to_optimize_dtor
= 1;
13094 else if (empty_dtor
)
13095 ok_to_optimize_dtor
13096 = (n_baseclasses
== 0
13097 || (n_baseclasses
== 1
13098 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
13101 /* These initializations might go inline. Protect
13102 the binding level of the parms. */
13104 expand_start_bindings (0);
13106 if (current_function_assigns_this
)
13108 current_function_assigns_this
= 0;
13109 current_function_just_assigned_this
= 0;
13112 /* Generate the code to call destructor on base class.
13113 If this destructor belongs to a class with virtual
13114 functions, then set the virtual function table
13115 pointer to represent the type of our base class. */
13117 /* This side-effect makes call to `build_delete' generate the
13118 code we have to have at the end of this destructor.
13119 `build_delete' will set the flag again. */
13120 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13122 /* These are two cases where we cannot delegate deletion. */
13123 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
13124 || TYPE_GETS_REG_DELETE (current_class_type
))
13125 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
13126 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13128 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
13129 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
13131 /* If we did not assign to this, then `this' is non-zero at
13132 the end of a destructor. As a special optimization, don't
13133 emit test if this is an empty destructor. If it does nothing,
13134 it does nothing. If it calls a base destructor, the base
13135 destructor will perform the test. */
13137 if (exprstmt
!= error_mark_node
13138 && (TREE_CODE (exprstmt
) != NOP_EXPR
13139 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13140 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13142 expand_label (dtor_label
);
13143 if (cond
!= integer_one_node
)
13144 expand_start_cond (cond
, 0);
13145 if (exprstmt
!= void_zero_node
)
13146 /* Don't call `expand_expr_stmt' if we're not going to do
13147 anything, since -Wall will give a diagnostic. */
13148 expand_expr_stmt (exprstmt
);
13150 /* Run destructor on all virtual baseclasses. */
13151 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13153 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
13154 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
13155 in_charge_node
, integer_two_node
), 0);
13158 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
13160 tree vb
= get_vbase
13161 (BINFO_TYPE (vbases
),
13162 TYPE_BINFO (current_class_type
));
13164 (build_scoped_method_call
13165 (current_class_ref
, vb
, dtor_identifier
,
13166 build_expr_list (NULL_TREE
, integer_zero_node
)));
13168 vbases
= TREE_CHAIN (vbases
);
13170 expand_end_cond ();
13173 do_pending_stack_adjust ();
13174 if (cond
!= integer_one_node
)
13175 expand_end_cond ();
13178 virtual_size
= c_sizeof (current_class_type
);
13180 /* At the end, call delete if that's what's requested. */
13182 /* FDIS sez: At the point of definition of a virtual destructor
13183 (including an implicit definition), non-placement operator
13184 delete shall be looked up in the scope of the destructor's
13185 class and if found shall be accessible and unambiguous.
13187 This is somewhat unclear, but I take it to mean that if the
13188 class only defines placement deletes we don't do anything here.
13189 So we pass LOOKUP_SPECULATIVELY; delete_sanity will complain
13190 for us if they ever try to delete one of these. */
13192 if (TYPE_GETS_REG_DELETE (current_class_type
)
13193 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13194 exprstmt
= build_op_delete_call
13195 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13196 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13198 exprstmt
= NULL_TREE
;
13202 cond
= build (BIT_AND_EXPR
, integer_type_node
,
13203 in_charge_node
, integer_one_node
);
13204 expand_start_cond (cond
, 0);
13205 expand_expr_stmt (exprstmt
);
13206 expand_end_cond ();
13209 /* End of destructor. */
13210 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
13211 poplevel (2, 0, 0); /* XXX change to 1 */
13213 /* Back to the top of destructor. */
13214 /* Don't execute destructor code if `this' is NULL. */
13218 /* If the dtor is empty, and we know there is not possible way we
13219 could use any vtable entries, before they are possibly set by
13220 a base class dtor, we don't have to setup the vtables, as we
13221 know that any base class dtoring will set up any vtables it
13222 needs. We avoid MI, because one base class dtor can do a
13223 virtual dispatch to an overridden function that would need to
13224 have a non-related vtable set up, we cannot avoid setting up
13225 vtables in that case. We could change this to see if there is
13226 just one vtable. */
13227 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
13229 /* Make all virtual function table pointers in non-virtual base
13230 classes point to CURRENT_CLASS_TYPE's virtual function
13232 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
13234 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13235 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
13238 if (! ok_to_optimize_dtor
)
13240 cond
= build_binary_op (NE_EXPR
,
13241 current_class_ptr
, integer_zero_node
, 1);
13242 expand_start_cond (cond
, 0);
13245 insns
= get_insns ();
13248 last_parm_insn
= get_first_nonparm_insn ();
13249 if (last_parm_insn
== NULL_RTX
)
13250 last_parm_insn
= get_last_insn ();
13252 last_parm_insn
= previous_insn (last_parm_insn
);
13254 emit_insns_after (insns
, last_parm_insn
);
13256 if (! ok_to_optimize_dtor
)
13257 expand_end_cond ();
13259 else if (current_function_assigns_this
)
13261 /* Does not need to call emit_base_init, because
13262 that is done (if needed) just after assignment to this
13265 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13267 end_protect_partials ();
13268 expand_label (ctor_label
);
13269 ctor_label
= NULL_TREE
;
13273 decls
= getdecls ();
13274 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13275 poplevel (decls
!= NULL_TREE
, 0, 0);
13277 /* c_expand_return knows to return 'this' from a constructor. */
13278 c_expand_return (NULL_TREE
);
13280 else if (TREE_CODE (TREE_TYPE (DECL_RESULT (current_function_decl
))) != VOID_TYPE
13281 && return_label
!= NULL_RTX
)
13282 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13284 current_function_assigns_this
= 0;
13285 current_function_just_assigned_this
= 0;
13286 base_init_expr
= NULL_TREE
;
13288 else if (DECL_CONSTRUCTOR_P (fndecl
))
13290 tree cond
= NULL_TREE
, thenclause
= NULL_TREE
;
13291 /* Allow constructor for a type to get a new instance of the object
13292 using `build_new'. */
13293 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
13294 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
13296 DECL_RETURNS_FIRST_ARG (fndecl
) = 1;
13298 if (flag_this_is_variable
> 0)
13300 cond
= build_binary_op (EQ_EXPR
,
13301 current_class_ptr
, integer_zero_node
, 1);
13302 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
13303 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
13306 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
13310 if (flag_this_is_variable
> 0)
13312 expand_start_cond (cond
, 0);
13313 expand_expr_stmt (thenclause
);
13314 expand_end_cond ();
13317 /* Emit insns from `emit_base_init' which sets up virtual
13318 function table pointer(s). */
13319 if (base_init_expr
)
13321 expand_expr_stmt (base_init_expr
);
13322 base_init_expr
= NULL_TREE
;
13325 insns
= get_insns ();
13328 /* This is where the body of the constructor begins. */
13330 emit_insns_after (insns
, last_parm_cleanup_insn
);
13332 end_protect_partials ();
13334 /* This is where the body of the constructor ends. */
13335 expand_label (ctor_label
);
13336 ctor_label
= NULL_TREE
;
13340 decls
= getdecls ();
13341 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
13342 poplevel (decls
!= NULL_TREE
, 1, 0);
13345 /* c_expand_return knows to return 'this' from a constructor. */
13346 c_expand_return (NULL_TREE
);
13348 current_function_assigns_this
= 0;
13349 current_function_just_assigned_this
= 0;
13351 else if (DECL_MAIN_P (fndecl
))
13353 /* Make it so that `main' always returns 0 by default. */
13355 c_expand_return (integer_one_node
);
13357 c_expand_return (integer_zero_node
);
13360 else if (return_label
!= NULL_RTX
13361 && current_function_return_value
== NULL_TREE
13362 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
13363 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13365 if (flag_exceptions
)
13366 expand_exception_blocks ();
13368 /* If this function is supposed to return a value, ensure that
13369 we do not fall into the cleanups by mistake. The end of our
13370 function will look like this:
13372 user code (may have return stmt somewhere)
13373 goto no_return_label
13378 NOTE_INSN_FUNCTION_END
13382 If the user omits a return stmt in the USER CODE section, we
13383 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13384 Otherwise, we won't. */
13385 if (no_return_label
)
13387 DECL_CONTEXT (no_return_label
) = fndecl
;
13388 DECL_INITIAL (no_return_label
) = error_mark_node
;
13389 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
13390 DECL_SOURCE_LINE (no_return_label
) = lineno
;
13391 expand_goto (no_return_label
);
13396 /* Remove the binding contour which is used
13397 to catch cleanup-generated temporaries. */
13398 expand_end_bindings (0, 0, 0);
13399 poplevel (0, 0, 0);
13401 /* Emit label at beginning of cleanup code for parameters. */
13402 emit_label (cleanup_label
);
13405 /* Get return value into register if that's where it's supposed to be. */
13406 if (original_result_rtx
)
13407 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
13409 /* Finish building code that will trigger warnings if users forget
13410 to make their functions return values. */
13411 if (no_return_label
|| cleanup_label
)
13412 emit_jump (return_label
);
13413 if (no_return_label
)
13415 /* We don't need to call `expand_*_return' here because we
13416 don't need any cleanups here--this path of code is only
13417 for error checking purposes. */
13418 expand_label (no_return_label
);
13421 /* Generate rtl for function exit. */
13422 expand_function_end (input_filename
, lineno
, 1);
13425 /* This must come after expand_function_end because cleanups might
13426 have declarations (from inline functions) that need to go into
13427 this function's blocks. */
13428 if (current_binding_level
->parm_flag
!= 1)
13429 my_friendly_abort (122);
13430 poplevel (1, 0, 1);
13432 /* Reset scope for C++: if we were in the scope of a class,
13433 then when we finish this function, we are not longer so.
13434 This cannot be done until we know for sure that no more
13435 class members will ever be referenced in this function
13436 (i.e., calls to destructors). */
13437 if (current_class_name
)
13439 ctype
= current_class_type
;
13440 pop_nested_class (1);
13443 /* Must mark the RESULT_DECL as being in this function. */
13444 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13446 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13447 to the FUNCTION_DECL node itself. */
13448 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13450 if (! processing_template_decl
)
13452 int saved_flag_keep_inline_functions
=
13453 flag_keep_inline_functions
;
13455 /* So we can tell if jump_optimize sets it to 1. */
13458 if (DECL_CONTEXT (fndecl
) != NULL_TREE
13459 && hack_decl_function_context (fndecl
))
13460 /* Trick rest_of_compilation into not deferring output of this
13461 function, even if it is inline, since the rtl_obstack for
13462 this function is the function_obstack of the enclosing
13463 function and will be deallocated when the enclosing
13464 function is gone. See save_tree_status. */
13465 flag_keep_inline_functions
= 1;
13467 /* Run the optimizers and output the assembler code for this
13470 if (DECL_ARTIFICIAL (fndecl
))
13472 /* Do we really *want* to inline this synthesized method? */
13474 int save_fif
= flag_inline_functions
;
13475 flag_inline_functions
= 1;
13477 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13478 will check our size. */
13479 DECL_INLINE (fndecl
) = 0;
13481 rest_of_compilation (fndecl
);
13482 flag_inline_functions
= save_fif
;
13485 rest_of_compilation (fndecl
);
13487 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
13489 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
13491 /* Set DECL_EXTERNAL so that assemble_external will be called as
13492 necessary. We'll clear it again in finish_file. */
13493 if (! DECL_EXTERNAL (fndecl
))
13494 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
13495 DECL_EXTERNAL (fndecl
) = 1;
13496 mark_inline_for_output (fndecl
);
13499 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
13500 note_debug_info_needed (ctype
);
13502 current_function_returns_null
|= can_reach_end
;
13504 /* Since we don't normally go through c_expand_return for constructors,
13505 this normally gets the wrong value.
13506 Also, named return values have their return codes emitted after
13507 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13508 if (DECL_CONSTRUCTOR_P (fndecl
)
13509 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
13510 current_function_returns_null
= 0;
13512 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
13513 cp_warning ("`noreturn' function `%D' does return", fndecl
);
13514 else if ((warn_return_type
|| pedantic
)
13515 && current_function_returns_null
13516 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
)
13518 /* If this function returns non-void and control can drop through,
13520 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
13522 /* With just -W, complain only if function returns both with
13523 and without a value. */
13524 else if (extra_warnings
13525 && current_function_returns_value
&& current_function_returns_null
)
13526 warning ("this function may return with or without a value");
13531 /* Free all the tree nodes making up this function. */
13532 /* Switch back to allocating nodes permanently
13533 until we start another function. */
13534 if (processing_template_decl
)
13536 --minimal_parse_mode
;
13537 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
13541 permanent_allocation (1);
13543 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
13547 /* Stop pointing to the local nodes about to be freed. */
13548 /* But DECL_INITIAL must remain nonzero so we know this
13549 was an actual function definition. */
13550 DECL_INITIAL (fndecl
) = error_mark_node
;
13551 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
13552 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
13555 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
13556 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
13557 if (DECL_STATIC_DESTRUCTOR (fndecl
))
13558 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
13562 /* Let the error reporting routines know that we're outside a
13563 function. For a nested function, this value is used in
13564 pop_cp_function_context and then reset via pop_function_context. */
13565 current_function_decl
= NULL_TREE
;
13568 named_label_uses
= NULL
;
13569 current_class_ptr
= NULL_TREE
;
13570 current_class_ref
= NULL_TREE
;
13573 /* Create the FUNCTION_DECL for a function definition.
13574 LINE1 is the line number that the definition absolutely begins on.
13575 LINE2 is the line number that the name of the function appears on.
13576 DECLSPECS and DECLARATOR are the parts of the declaration;
13577 they describe the return type and the name of the function,
13578 but twisted together in a fashion that parallels the syntax of C.
13580 This function creates a binding context for the function body
13581 as well as setting up the FUNCTION_DECL in current_function_decl.
13583 Returns a FUNCTION_DECL on success.
13585 If the DECLARATOR is not suitable for a function (it defines a datum
13586 instead), we return 0, which tells yyparse to report a parse error.
13588 May return void_type_node indicating that this method is actually
13589 a friend. See grokfield for more details.
13591 Came here with a `.pushlevel' .
13593 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13594 CHANGES TO CODE IN `grokfield'. */
13597 start_method (declspecs
, declarator
, attrlist
)
13598 tree declarator
, declspecs
, attrlist
;
13600 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13603 /* Something too ugly to handle. */
13604 if (fndecl
== NULL_TREE
)
13607 /* Pass friends other than inline friend functions back. */
13608 if (fndecl
== void_type_node
)
13611 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
13612 /* Not a function, tell parser to report parse error. */
13615 if (IS_SIGNATURE (current_class_type
))
13616 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
13618 if (DECL_IN_AGGR_P (fndecl
))
13620 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
13622 if (DECL_CONTEXT (fndecl
)
13623 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
13624 cp_error ("`%D' is already defined in class %s", fndecl
,
13625 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
13627 return void_type_node
;
13630 DECL_THIS_INLINE (fndecl
) = 1;
13632 if (flag_default_inline
)
13633 DECL_INLINE (fndecl
) = 1;
13635 /* We process method specializations in finish_struct_1. */
13636 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13637 fndecl
= push_template_decl (fndecl
);
13639 /* We read in the parameters on the maybepermanent_obstack,
13640 but we won't be getting back to them until after we
13641 may have clobbered them. So the call to preserve_data
13642 will keep them safe. */
13645 if (! DECL_FRIEND_P (fndecl
))
13647 if (TREE_CHAIN (fndecl
))
13649 fndecl
= copy_node (fndecl
);
13650 TREE_CHAIN (fndecl
) = NULL_TREE
;
13653 if (DECL_CONSTRUCTOR_P (fndecl
))
13655 if (! grok_ctor_properties (current_class_type
, fndecl
))
13656 return void_type_node
;
13658 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
13659 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
13662 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
13664 /* Make a place for the parms */
13666 current_binding_level
->parm_flag
= 1;
13668 DECL_IN_AGGR_P (fndecl
) = 1;
13672 /* Go through the motions of finishing a function definition.
13673 We don't compile this method until after the whole class has
13676 FINISH_METHOD must return something that looks as though it
13677 came from GROKFIELD (since we are defining a method, after all).
13679 This is called after parsing the body of the function definition.
13680 STMTS is the chain of statements that makes up the function body.
13682 DECL is the ..._DECL that `start_method' provided. */
13685 finish_method (decl
)
13688 register tree fndecl
= decl
;
13691 register tree link
;
13693 if (decl
== void_type_node
)
13696 old_initial
= DECL_INITIAL (fndecl
);
13698 /* Undo the level for the parms (from start_method).
13699 This is like poplevel, but it causes nothing to be
13700 saved. Saving information here confuses symbol-table
13701 output routines. Besides, this information will
13702 be correctly output when this method is actually
13705 /* Clear out the meanings of the local variables of this level;
13706 also record in each decl which block it belongs to. */
13708 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
13710 if (DECL_NAME (link
) != NULL_TREE
)
13711 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
13712 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
13713 DECL_CONTEXT (link
) = NULL_TREE
;
13716 /* Restore all name-meanings of the outer levels
13717 that were shadowed by this level. */
13719 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
13720 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13721 for (link
= current_binding_level
->class_shadowed
;
13722 link
; link
= TREE_CHAIN (link
))
13723 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
13724 for (link
= current_binding_level
->type_shadowed
;
13725 link
; link
= TREE_CHAIN (link
))
13726 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
13728 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
13729 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
13730 current_binding_level
->parm_flag
,
13731 current_binding_level
->keep
);
13733 poplevel (0, 0, 0);
13735 DECL_INITIAL (fndecl
) = old_initial
;
13737 /* We used to check if the context of FNDECL was different from
13738 current_class_type as another way to get inside here. This didn't work
13739 for String.cc in libg++. */
13740 if (DECL_FRIEND_P (fndecl
))
13742 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
13743 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
13744 decl
= void_type_node
;
13750 /* Called when a new struct TYPE is defined.
13751 If this structure or union completes the type of any previous
13752 variable declaration, lay it out and output its rtl. */
13755 hack_incomplete_structures (type
)
13760 if (current_binding_level
->incomplete
== NULL_TREE
)
13763 if (!type
) /* Don't do this for class templates. */
13766 for (list
= ¤t_binding_level
->incomplete
; *list
; )
13768 tree decl
= TREE_VALUE (*list
);
13769 if ((decl
&& TREE_TYPE (decl
) == type
)
13770 || (TREE_TYPE (decl
)
13771 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13772 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
13774 int toplevel
= toplevel_bindings_p ();
13775 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
13776 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
13777 layout_type (TREE_TYPE (decl
));
13778 layout_decl (decl
, 0);
13779 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
13783 expand_decl (decl
);
13784 cleanup
= maybe_build_cleanup (decl
);
13785 expand_decl_init (decl
);
13786 if (! expand_decl_cleanup (decl
, cleanup
))
13787 cp_error ("parser lost in parsing declaration of `%D'",
13790 *list
= TREE_CHAIN (*list
);
13793 list
= &TREE_CHAIN (*list
);
13797 /* If DECL is of a type which needs a cleanup, build that cleanup here.
13798 See build_delete for information about AUTO_DELETE.
13800 Don't build these on the momentary obstack; they must live
13801 the life of the binding contour. */
13804 maybe_build_cleanup_1 (decl
, auto_delete
)
13805 tree decl
, auto_delete
;
13807 tree type
= TREE_TYPE (decl
);
13808 if (TYPE_NEEDS_DESTRUCTOR (type
))
13810 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
13813 if (TREE_CODE (decl
) != PARM_DECL
)
13814 temp
= suspend_momentary ();
13816 if (TREE_CODE (type
) == ARRAY_TYPE
)
13820 mark_addressable (decl
);
13821 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
13824 /* Optimize for space over speed here. */
13825 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
13826 || flag_expensive_optimizations
)
13827 flags
|= LOOKUP_NONVIRTUAL
;
13829 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
13831 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
13832 && ! TYPE_HAS_DESTRUCTOR (type
))
13833 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
13834 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
13836 if (TREE_CODE (decl
) != PARM_DECL
)
13837 resume_momentary (temp
);
13844 /* If DECL is of a type which needs a cleanup, build that cleanup
13845 here. The cleanup does free the storage with a call to delete. */
13848 maybe_build_cleanup_and_delete (decl
)
13851 return maybe_build_cleanup_1 (decl
, integer_three_node
);
13854 /* If DECL is of a type which needs a cleanup, build that cleanup
13855 here. The cleanup does not free the storage with a call a delete. */
13858 maybe_build_cleanup (decl
)
13861 return maybe_build_cleanup_1 (decl
, integer_two_node
);
13864 /* Expand a C++ expression at the statement level.
13865 This is needed to ferret out nodes which have UNKNOWN_TYPE.
13866 The C++ type checker should get all of these out when
13867 expressions are combined with other, type-providing, expressions,
13868 leaving only orphan expressions, such as:
13870 &class::bar; / / takes its address, but does nothing with it. */
13873 cplus_expand_expr_stmt (exp
)
13876 if (processing_template_decl
)
13878 add_tree (build_min_nt (EXPR_STMT
, exp
));
13882 /* Arrange for all temps to disappear. */
13883 expand_start_target_temps ();
13885 if (TREE_TYPE (exp
) == unknown_type_node
)
13887 if (TREE_CODE (exp
) == ADDR_EXPR
|| TREE_CODE (exp
) == TREE_LIST
)
13888 error ("address of overloaded function with no contextual type information");
13889 else if (TREE_CODE (exp
) == COMPONENT_REF
)
13890 warning ("useless reference to a member function name, did you forget the ()?");
13894 if (TREE_CODE (exp
) == FUNCTION_DECL
)
13896 cp_warning ("reference, not call, to function `%D'", exp
);
13897 warning ("at this point in file");
13901 /* We should do this eventually, but right now this causes regex.o from
13902 libg++ to miscompile, and tString to core dump. */
13903 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
13906 /* Strip unused implicit INDIRECT_REFs of references. */
13907 if (TREE_CODE (exp
) == INDIRECT_REF
13908 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
13909 exp
= TREE_OPERAND (exp
, 0);
13911 /* If we don't do this, we end up down inside expand_expr
13912 trying to do TYPE_MODE on the ERROR_MARK, and really
13913 go outside the bounds of the type. */
13914 if (exp
!= error_mark_node
)
13915 expand_expr_stmt (break_out_cleanups (exp
));
13918 /* Clean up any pending cleanups. This happens when a function call
13919 returns a cleanup-needing value that nobody uses. */
13920 expand_end_target_temps ();
13923 /* When a stmt has been parsed, this function is called.
13925 Currently, this function only does something within a
13926 constructor's scope: if a stmt has just assigned to this,
13927 and we are in a derived class, we call `emit_base_init'. */
13932 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
13935 if (current_function_assigns_this
13936 || ! current_function_just_assigned_this
)
13938 if (DECL_CONSTRUCTOR_P (current_function_decl
))
13940 /* Constructors must wait until we are out of control
13941 zones before calling base constructors. */
13942 if (cond_stack
|| loop_stack
|| case_stack
)
13944 expand_expr_stmt (base_init_expr
);
13945 check_base_init (current_class_type
);
13947 current_function_assigns_this
= 1;
13950 /* Change a static member function definition into a FUNCTION_TYPE, instead
13951 of the METHOD_TYPE that we create when it's originally parsed.
13953 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
13954 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
13955 other decls. Either pass the addresses of local variables or NULL. */
13958 revert_static_member_fn (decl
, fn
, argtypes
)
13959 tree
*decl
, *fn
, *argtypes
;
13962 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
13963 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
13965 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
13966 != TYPE_UNQUALIFIED
)
13967 cp_error ("static member function `%#D' declared with type qualifiers",
13970 args
= TREE_CHAIN (args
);
13971 tmp
= build_function_type (TREE_TYPE (function
), args
);
13972 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
13973 tmp
= build_exception_variant (tmp
,
13974 TYPE_RAISES_EXCEPTIONS (function
));
13975 TREE_TYPE (*decl
) = tmp
;
13976 if (DECL_ARGUMENTS (*decl
))
13977 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
13978 DECL_STATIC_FUNCTION_P (*decl
) = 1;
13986 id_in_current_class (id
)
13989 return !!purpose_member (id
, class_binding_level
->class_shadowed
);
13996 int warn_about_return_type
;
13998 int just_assigned_this
;
14000 int temp_name_counter
;
14002 tree shadowed_labels
;
14005 rtx last_dtor_insn
;
14006 rtx last_parm_cleanup_insn
;
14007 tree base_init_list
;
14008 tree member_init_list
;
14009 tree base_init_expr
;
14010 tree current_class_ptr
;
14011 tree current_class_ref
;
14013 struct cp_function
*next
;
14014 struct binding_level
*binding_level
;
14015 int static_labelno
;
14018 static struct cp_function
*cp_function_chain
;
14020 extern int temp_name_counter
;
14022 /* Save and reinitialize the variables
14023 used during compilation of a C++ function. */
14026 push_cp_function_context (context
)
14029 struct cp_function
*p
14030 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
14032 push_function_context_to (context
);
14034 p
->next
= cp_function_chain
;
14035 cp_function_chain
= p
;
14037 p
->named_labels
= named_labels
;
14038 p
->shadowed_labels
= shadowed_labels
;
14039 p
->returns_value
= current_function_returns_value
;
14040 p
->returns_null
= current_function_returns_null
;
14041 p
->warn_about_return_type
= warn_about_return_type
;
14042 p
->binding_level
= current_binding_level
;
14043 p
->ctor_label
= ctor_label
;
14044 p
->dtor_label
= dtor_label
;
14045 p
->last_dtor_insn
= last_dtor_insn
;
14046 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
14047 p
->assigns_this
= current_function_assigns_this
;
14048 p
->just_assigned_this
= current_function_just_assigned_this
;
14049 p
->parms_stored
= current_function_parms_stored
;
14050 p
->result_rtx
= original_result_rtx
;
14051 p
->base_init_expr
= base_init_expr
;
14052 p
->temp_name_counter
= temp_name_counter
;
14053 p
->base_init_list
= current_base_init_list
;
14054 p
->member_init_list
= current_member_init_list
;
14055 p
->current_class_ptr
= current_class_ptr
;
14056 p
->current_class_ref
= current_class_ref
;
14057 p
->static_labelno
= static_labelno
;
14060 /* Restore the variables used during compilation of a C++ function. */
14063 pop_cp_function_context (context
)
14066 struct cp_function
*p
= cp_function_chain
;
14069 /* Bring back all the labels that were shadowed. */
14070 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
14071 if (DECL_NAME (TREE_VALUE (link
)) != 0)
14072 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
14073 TREE_VALUE (link
));
14075 pop_function_context_from (context
);
14077 cp_function_chain
= p
->next
;
14079 named_labels
= p
->named_labels
;
14080 shadowed_labels
= p
->shadowed_labels
;
14081 current_function_returns_value
= p
->returns_value
;
14082 current_function_returns_null
= p
->returns_null
;
14083 warn_about_return_type
= p
->warn_about_return_type
;
14084 current_binding_level
= p
->binding_level
;
14085 ctor_label
= p
->ctor_label
;
14086 dtor_label
= p
->dtor_label
;
14087 last_dtor_insn
= p
->last_dtor_insn
;
14088 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
14089 current_function_assigns_this
= p
->assigns_this
;
14090 current_function_just_assigned_this
= p
->just_assigned_this
;
14091 current_function_parms_stored
= p
->parms_stored
;
14092 original_result_rtx
= p
->result_rtx
;
14093 base_init_expr
= p
->base_init_expr
;
14094 temp_name_counter
= p
->temp_name_counter
;
14095 current_base_init_list
= p
->base_init_list
;
14096 current_member_init_list
= p
->member_init_list
;
14097 current_class_ptr
= p
->current_class_ptr
;
14098 current_class_ref
= p
->current_class_ref
;
14099 static_labelno
= p
->static_labelno
;
14107 return function_depth
!= 0;