1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
38 #include <sys/types.h>
49 #ifdef NEED_DECLARATION_FREE
50 extern void free
PROTO((void *));
53 #define obstack_chunk_alloc xmalloc
54 #define obstack_chunk_free free
56 extern tree builtin_return_address_fndecl
;
58 extern struct obstack permanent_obstack
;
60 extern int current_class_depth
;
62 extern tree static_ctors
, static_dtors
;
64 extern int static_labelno
;
66 /* Stack of places to restore the search obstack back to. */
68 /* Obstack used for remembering local class declarations (like
69 enums and static (const) members. */
71 struct obstack decl_obstack
;
72 static struct stack_level
*decl_stack
;
74 #ifndef CHAR_TYPE_SIZE
75 #define CHAR_TYPE_SIZE BITS_PER_UNIT
78 #ifndef SHORT_TYPE_SIZE
79 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
83 #define INT_TYPE_SIZE BITS_PER_WORD
86 #ifndef LONG_TYPE_SIZE
87 #define LONG_TYPE_SIZE BITS_PER_WORD
90 #ifndef LONG_LONG_TYPE_SIZE
91 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
94 #ifndef WCHAR_UNSIGNED
95 #define WCHAR_UNSIGNED 0
98 #ifndef FLOAT_TYPE_SIZE
99 #define FLOAT_TYPE_SIZE BITS_PER_WORD
102 #ifndef DOUBLE_TYPE_SIZE
103 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
106 #ifndef LONG_DOUBLE_TYPE_SIZE
107 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
110 #ifndef BOOL_TYPE_SIZE
111 #ifdef SLOW_BYTE_ACCESS
112 #define BOOL_TYPE_SIZE ((SLOW_BYTE_ACCESS) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
114 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
118 /* We let tm.h override the types used here, to handle trivial differences
119 such as the choice of unsigned int or long unsigned int for size_t.
120 When machines start needing nontrivial differences in the size type,
121 it would be best to do something here to figure out automatically
122 from other information what type to use. */
125 #define SIZE_TYPE "long unsigned int"
129 #define PTRDIFF_TYPE "long int"
133 #define WCHAR_TYPE "int"
136 static tree grokparms
PROTO((tree
, int));
137 static tree lookup_nested_type
PROTO((tree
, tree
));
138 static char *redeclaration_error_message
PROTO((tree
, tree
));
139 static void revert_static_member_fn
PROTO((tree
*, tree
*, tree
*));
140 static tree push_overloaded_decl
PROTO((tree
, int));
141 static void push_overloaded_decl_top_level
PROTO((tree
, int));
143 static struct stack_level
*push_decl_level
PROTO((struct stack_level
*,
145 static void push_binding_level
PROTO((struct binding_level
*, int,
147 static void pop_binding_level
PROTO((void));
148 static void suspend_binding_level
PROTO((void));
149 static void resume_binding_level
PROTO((struct binding_level
*));
150 static struct binding_level
*make_binding_level
PROTO((void));
151 static int namespace_bindings_p
PROTO((void));
152 static void declare_namespace_level
PROTO((void));
153 static tree get_unique_name
PROTO((void));
154 static void signal_catch
PROTO((int));
155 static void storedecls
PROTO((tree
));
156 static void storetags
PROTO((tree
));
157 static void require_complete_types_for_parms
PROTO((tree
));
158 static void push_overloaded_decl_1
PROTO((tree
));
159 static int ambi_op_p
PROTO((tree
));
160 static int unary_op_p
PROTO((tree
));
161 static tree store_bindings
PROTO((tree
, tree
));
162 static tree lookup_tag_reverse
PROTO((tree
, tree
));
163 static tree obscure_complex_init
PROTO((tree
, tree
));
164 static tree maybe_build_cleanup_1
PROTO((tree
, tree
));
165 static tree lookup_name_real
PROTO((tree
, int, int));
166 static void warn_extern_redeclared_static
PROTO((tree
, tree
));
167 static void grok_reference_init
PROTO((tree
, tree
, tree
, tree
*));
168 static tree grokfndecl
PROTO((tree
, tree
, tree
, tree
, int,
170 tree
, tree
, tree
, int, int, int, int, int, int));
171 static tree grokvardecl
PROTO((tree
, tree
, RID_BIT_TYPE
*, int, int));
172 static tree lookup_tag
PROTO((enum tree_code
, tree
,
173 struct binding_level
*, int));
174 static void set_identifier_type_value_with_scope
175 PROTO((tree
, tree
, struct binding_level
*));
176 static void record_builtin_type
PROTO((enum rid
, char *, tree
));
177 static int member_function_or_else
PROTO((tree
, tree
, char *));
178 static void bad_specifiers
PROTO((tree
, char *, int, int, int, int,
181 /* a node which has tree code ERROR_MARK, and whose type is itself.
182 All erroneous expressions are replaced with this node. All functions
183 that accept nodes as arguments should avoid generating error messages
184 if this node is one of the arguments, since it is undesirable to get
185 multiple error messages from one error in the input. */
187 tree error_mark_node
;
189 /* Erroneous argument lists can use this *IFF* they do not modify it. */
190 tree error_mark_list
;
192 /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
194 tree short_integer_type_node
;
195 tree integer_type_node
;
196 tree long_integer_type_node
;
197 tree long_long_integer_type_node
;
199 tree short_unsigned_type_node
;
200 tree unsigned_type_node
;
201 tree long_unsigned_type_node
;
202 tree long_long_unsigned_type_node
;
204 tree ptrdiff_type_node
;
206 tree unsigned_char_type_node
;
207 tree signed_char_type_node
;
209 tree wchar_type_node
;
210 tree signed_wchar_type_node
;
211 tree unsigned_wchar_type_node
;
213 tree wchar_decl_node
;
215 tree float_type_node
;
216 tree double_type_node
;
217 tree long_double_type_node
;
219 tree complex_integer_type_node
;
220 tree complex_float_type_node
;
221 tree complex_double_type_node
;
222 tree complex_long_double_type_node
;
224 tree intQI_type_node
;
225 tree intHI_type_node
;
226 tree intSI_type_node
;
227 tree intDI_type_node
;
229 tree unsigned_intQI_type_node
;
230 tree unsigned_intHI_type_node
;
231 tree unsigned_intSI_type_node
;
232 tree unsigned_intDI_type_node
;
234 /* a VOID_TYPE node, and the same, packaged in a TREE_LIST. */
236 tree void_type_node
, void_list_node
;
239 /* Nodes for types `void *' and `const void *'. */
242 tree const_ptr_type_node
;
244 /* Nodes for types `char *' and `const char *'. */
246 tree string_type_node
, const_string_type_node
;
248 /* Type `char[256]' or something like it.
249 Used when an array of char is needed and the size is irrelevant. */
251 tree char_array_type_node
;
253 /* Type `int[256]' or something like it.
254 Used when an array of int needed and the size is irrelevant. */
256 tree int_array_type_node
;
258 /* Type `wchar_t[256]' or something like it.
259 Used when a wide string literal is created. */
261 tree wchar_array_type_node
;
263 /* The bool data type, and constants */
264 tree boolean_type_node
, boolean_true_node
, boolean_false_node
;
266 /* type `int ()' -- used for implicit declaration of functions. */
268 tree default_function_type
;
270 /* function types `double (double)' and `double (double, double)', etc. */
272 static tree double_ftype_double
, double_ftype_double_double
;
273 static tree int_ftype_int
, long_ftype_long
;
274 static tree float_ftype_float
;
275 static tree ldouble_ftype_ldouble
;
277 /* Function type `int (const void *, const void *, size_t)' */
278 static tree int_ftype_cptr_cptr_sizet
;
281 tree vtable_entry_type
;
282 tree delta_type_node
;
284 /* Old rtti stuff. */
285 tree __baselist_desc_type_node
;
286 tree __i_desc_type_node
, __m_desc_type_node
;
287 tree __t_desc_array_type
, __i_desc_array_type
, __m_desc_array_type
;
289 tree __t_desc_type_node
;
291 tree __tp_desc_type_node
;
293 tree __access_mode_type_node
;
294 tree __bltn_desc_type_node
, __user_desc_type_node
, __class_desc_type_node
;
295 tree __ptr_desc_type_node
, __attr_desc_type_node
, __func_desc_type_node
;
296 tree __ptmf_desc_type_node
, __ptmd_desc_type_node
;
298 /* Not needed yet? May be needed one day? */
299 tree __bltn_desc_array_type
, __user_desc_array_type
, __class_desc_array_type
;
300 tree __ptr_desc_array_type
, __attr_dec_array_type
, __func_desc_array_type
;
301 tree __ptmf_desc_array_type
, __ptmd_desc_array_type
;
304 tree class_star_type_node
;
305 tree class_type_node
, record_type_node
, union_type_node
, enum_type_node
;
306 tree unknown_type_node
;
307 tree opaque_type_node
, signature_type_node
;
308 tree sigtable_entry_type
;
310 /* Array type `vtable_entry_type[]' */
316 /* In a destructor, the point at which all derived class destroying
317 has been done, just before any base class destroying will be done. */
321 /* In a destructor, the last insn emitted after the start of the
322 function and the parms. */
324 static rtx last_dtor_insn
;
326 /* In a constructor, the last insn emitted after the start of the
327 function and the parms, the exception specification and any
328 function-try-block. The constructor initializers are emitted after
331 static rtx last_parm_cleanup_insn
;
333 /* In a constructor, the point at which we are ready to return
334 the pointer to the initialized object. */
338 /* A FUNCTION_DECL which can call `abort'. Not necessarily the
339 one that the user will declare, but sufficient to be called
340 by routines that want to abort the program. */
344 extern rtx cleanup_label
, return_label
;
346 /* If original DECL_RESULT of current function was a register,
347 but due to being an addressable named return value, would up
348 on the stack, this variable holds the named return value's
349 original location. */
350 static rtx original_result_rtx
;
352 /* Sequence of insns which represents base initialization. */
355 /* C++: Keep these around to reduce calls to `get_identifier'.
356 Identifiers for `this' in member functions and the auto-delete
357 parameter for destructors. */
358 tree this_identifier
, in_charge_identifier
;
359 tree ctor_identifier
, dtor_identifier
;
360 /* Used in pointer to member functions, in vtables, and in sigtables. */
361 tree pfn_identifier
, index_identifier
, delta_identifier
, delta2_identifier
;
362 tree pfn_or_delta2_identifier
, tag_identifier
;
363 tree vt_off_identifier
;
365 struct named_label_list
367 struct binding_level
*binding_level
;
370 char *filename_o_goto
;
372 struct named_label_list
*next
;
375 /* A list (chain of TREE_LIST nodes) of named label uses.
376 The TREE_PURPOSE field is the list of variables defined
377 the the label's scope defined at the point of use.
378 The TREE_VALUE field is the LABEL_DECL used.
379 The TREE_TYPE field holds `current_binding_level' at the
380 point of the label's use.
382 BWAHAHAAHAHahhahahahaah. No, no, no, said the little chicken.
384 Look at the pretty struct named_label_list. See the pretty struct
385 with the pretty named fields that describe what they do. See the
386 pretty lack of gratuitous casts. Notice the code got a lot cleaner.
388 Used only for jumps to as-yet undefined labels, since
389 jumps to defined labels can have their validity checked
392 static struct named_label_list
*named_label_uses
= NULL
;
394 /* A list of objects which have constructors or destructors
395 which reside in the global scope. The decl is stored in
396 the TREE_VALUE slot and the initializer is stored
397 in the TREE_PURPOSE slot. */
398 tree static_aggregates
;
400 /* Nonzero if we lookup name inside template argument. */
401 int arg_looking_for_template
;
405 /* Two expressions that are constants with value zero.
406 The first is of type `int', the second of type `void *'. */
408 tree integer_zero_node
;
409 tree null_pointer_node
;
411 /* The value for __null (NULL), either of type `void *' or, with -ansi,
412 an integer type of the same size. */
416 /* A node for the integer constants 1, 2, and 3. */
418 tree integer_one_node
, integer_two_node
, integer_three_node
;
420 /* While defining an enum type, this is 1 plus the last enumerator
423 static tree enum_next_value
;
425 /* Nonzero means that there was overflow computing enum_next_value. */
427 static int enum_overflow
;
429 /* Parsing a function declarator leaves a list of parameter names
430 or a chain or parameter decls here. */
432 tree last_function_parms
;
434 /* Parsing a function declarator leaves here a chain of structure
435 and enum types declared in the parmlist. */
437 static tree last_function_parm_tags
;
439 /* After parsing the declarator that starts a function definition,
440 `start_function' puts here the list of parameter names or chain of decls.
441 `store_parm_decls' finds it here. */
443 static tree current_function_parms
;
445 /* Similar, for last_function_parm_tags. */
446 static tree current_function_parm_tags
;
448 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
449 that have names. Here so we can clear out their names' definitions
450 at the end of the function. */
452 static tree named_labels
;
454 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
456 static tree shadowed_labels
;
458 /* The FUNCTION_DECL for the function currently being compiled,
459 or 0 if between functions. */
460 tree current_function_decl
;
462 /* Set to 0 at beginning of a function definition, set to 1 if
463 a return statement that specifies a return value is seen. */
465 int current_function_returns_value
;
467 /* Set to 0 at beginning of a function definition, set to 1 if
468 a return statement with no argument is seen. */
470 int current_function_returns_null
;
472 /* Set to 0 at beginning of a function definition, and whenever
473 a label (case or named) is defined. Set to value of expression
474 returned from function when that value can be transformed into
475 a named return value. */
477 tree current_function_return_value
;
479 /* Set to nonzero by `grokdeclarator' for a function
480 whose return type is defaulted, if warnings for this are desired. */
482 static int warn_about_return_type
;
484 /* Nonzero means give `double' the same size as `float'. */
486 extern int flag_short_double
;
488 /* Nonzero means don't recognize any builtin functions. */
490 extern int flag_no_builtin
;
492 /* Nonzero means don't recognize the non-ANSI builtin functions.
495 extern int flag_no_nonansi_builtin
;
497 /* Nonzero means enable obscure ANSI features and disable GNU extensions
498 that might cause ANSI-compliant code to be miscompiled. */
500 extern int flag_ansi
;
502 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
504 extern int flag_huge_objects
;
506 /* Nonzero if we want to conserve space in the .o files. We do this
507 by putting uninitialized data and runtime initialized data into
508 .common instead of .data at the expense of not flagging multiple
510 extern int flag_conserve_space
;
512 /* Pointers to the base and current top of the language name stack. */
514 extern tree
*current_lang_base
, *current_lang_stack
;
516 /* C and C++ flags are in decl2.c. */
518 /* Set to 0 at beginning of a constructor, set to 1
519 if that function does an allocation before referencing its
520 instance variable. */
521 static int current_function_assigns_this
;
522 int current_function_just_assigned_this
;
524 /* Set to 0 at beginning of a function. Set non-zero when
525 store_parm_decls is called. Don't call store_parm_decls
526 if this flag is non-zero! */
527 int current_function_parms_stored
;
529 /* Flag used when debugging spew.c */
531 extern int spew_debug
;
533 /* This is a copy of the class_shadowed list of the previous class binding
534 contour when at global scope. It's used to reset IDENTIFIER_CLASS_VALUEs
535 when entering another class scope (i.e. a cache miss). */
536 extern tree previous_class_values
;
538 /* A expression of value 0 with the same precision as a sizetype
540 tree signed_size_zero_node
;
543 /* Allocate a level of searching. */
547 push_decl_level (stack
, obstack
)
548 struct stack_level
*stack
;
549 struct obstack
*obstack
;
551 struct stack_level tem
;
554 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
557 /* For each binding contour we allocate a binding_level structure
558 which records the names defined in that contour.
561 1) one for each function definition,
562 where internal declarations of the parameters appear.
563 2) one for each compound statement,
564 to record its declarations.
566 The current meaning of a name can be found by searching the levels
567 from the current one out to the global one.
569 Off to the side, may be the class_binding_level. This exists only
570 to catch class-local declarations. It is otherwise nonexistent.
572 Also there may be binding levels that catch cleanups that must be
573 run when exceptions occur. */
575 /* Note that the information in the `names' component of the global contour
576 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
580 /* A chain of _DECL nodes for all variables, constants, functions,
581 and typedef types. These are in the reverse of the order
585 /* A list of structure, union and enum definitions, for looking up
587 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
588 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
589 or ENUMERAL_TYPE node.
591 C++: the TREE_VALUE nodes can be simple types for
592 component_bindings. */
595 /* For each level, a list of shadowed outer-level local definitions
596 to be restored when this level is popped.
597 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
598 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
601 /* Same, for IDENTIFIER_CLASS_VALUE. */
604 /* Same, for IDENTIFIER_TYPE_VALUE. */
607 /* For each level (except not the global one),
608 a chain of BLOCK nodes for all the levels
609 that were entered and exited one level down. */
612 /* The BLOCK node for this level, if one has been preallocated.
613 If 0, the BLOCK is allocated (if needed) when the level is popped. */
616 /* The binding level which this one is contained in (inherits from). */
617 struct binding_level
*level_chain
;
619 /* List of decls in `names' that have incomplete
620 structure or union types. */
623 /* List of VAR_DECLS saved from a previous for statement.
624 These would be dead in ANSI-conforming code, but might
625 be referenced in ARM-era code. */
626 tree dead_vars_from_for
;
628 /* 1 for the level that holds the parameters of a function.
629 2 for the level that holds a class declaration.
630 3 for levels that hold parameter declarations. */
631 unsigned parm_flag
: 4;
633 /* 1 means make a BLOCK for this level regardless of all else.
634 2 for temporary binding contours created by the compiler. */
637 /* Nonzero if this level "doesn't exist" for tags. */
638 unsigned tag_transparent
: 1;
640 /* Nonzero if this level can safely have additional
641 cleanup-needing variables added to it. */
642 unsigned more_cleanups_ok
: 1;
643 unsigned have_cleanups
: 1;
645 /* Nonzero if this level is for storing the decls for template
646 parameters and generic decls; these decls will be discarded and
647 replaced with a TEMPLATE_DECL. */
648 unsigned pseudo_global
: 1;
650 /* This is set for a namespace binding level. */
651 unsigned namespace_p
: 1;
653 /* True if this level is that of a for-statement where we need to
654 worry about ambiguous (ARM or ANSI) scope rules. */
655 unsigned is_for_scope
: 1;
657 /* Two bits left for this word. */
659 #if defined(DEBUG_CP_BINDING_LEVELS)
660 /* Binding depth at which this level began. */
661 unsigned binding_depth
;
662 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
665 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
667 /* The (non-class) binding level currently in effect. */
669 static struct binding_level
*current_binding_level
;
671 /* The binding level of the current class, if any. */
673 static struct binding_level
*class_binding_level
;
675 /* The current (class or non-class) binding level currently in effect. */
677 #define inner_binding_level \
678 (class_binding_level ? class_binding_level : current_binding_level)
680 /* A chain of binding_level structures awaiting reuse. */
682 static struct binding_level
*free_binding_level
;
684 /* The outermost binding level, for names of file scope.
685 This is created when the compiler is started and exists
686 through the entire run. */
688 static struct binding_level
*global_binding_level
;
690 /* Binding level structures are initialized by copying this one. */
692 static struct binding_level clear_binding_level
;
694 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
696 static int keep_next_level_flag
;
698 #if defined(DEBUG_CP_BINDING_LEVELS)
699 static int binding_depth
= 0;
700 static int is_class_level
= 0;
707 for (i
= 0; i
< binding_depth
*2; i
++)
710 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
712 static tree pushdecl_with_scope
PROTO((tree
, struct binding_level
*));
715 push_binding_level (newlevel
, tag_transparent
, keep
)
716 struct binding_level
*newlevel
;
717 int tag_transparent
, keep
;
719 /* Add this level to the front of the chain (stack) of levels that
721 *newlevel
= clear_binding_level
;
722 if (class_binding_level
)
724 newlevel
->level_chain
= class_binding_level
;
725 class_binding_level
= (struct binding_level
*)0;
729 newlevel
->level_chain
= current_binding_level
;
731 current_binding_level
= newlevel
;
732 newlevel
->tag_transparent
= tag_transparent
;
733 newlevel
->more_cleanups_ok
= 1;
734 newlevel
->keep
= keep
;
735 #if defined(DEBUG_CP_BINDING_LEVELS)
736 newlevel
->binding_depth
= binding_depth
;
738 fprintf (stderr
, "push %s level 0x%08x line %d\n",
739 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
742 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
748 if (class_binding_level
)
749 current_binding_level
= class_binding_level
;
751 if (global_binding_level
)
753 /* cannot pop a level, if there are none left to pop. */
754 if (current_binding_level
== global_binding_level
)
755 my_friendly_abort (123);
757 /* Pop the current level, and free the structure for reuse. */
758 #if defined(DEBUG_CP_BINDING_LEVELS)
761 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
762 (is_class_level
) ? "class" : "block",
763 current_binding_level
, lineno
);
764 if (is_class_level
!= (current_binding_level
== class_binding_level
))
767 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
770 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
772 register struct binding_level
*level
= current_binding_level
;
773 current_binding_level
= current_binding_level
->level_chain
;
774 level
->level_chain
= free_binding_level
;
775 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
776 if (level
->binding_depth
!= binding_depth
)
778 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
779 free_binding_level
= level
;
781 class_binding_level
= current_binding_level
;
782 if (class_binding_level
->parm_flag
!= 2)
783 class_binding_level
= 0;
784 while (current_binding_level
->parm_flag
== 2)
785 current_binding_level
= current_binding_level
->level_chain
;
790 suspend_binding_level ()
792 if (class_binding_level
)
793 current_binding_level
= class_binding_level
;
795 if (global_binding_level
)
797 /* cannot suspend a level, if there are none left to suspend. */
798 if (current_binding_level
== global_binding_level
)
799 my_friendly_abort (123);
801 /* Suspend the current level. */
802 #if defined(DEBUG_CP_BINDING_LEVELS)
805 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
806 (is_class_level
) ? "class" : "block",
807 current_binding_level
, lineno
);
808 if (is_class_level
!= (current_binding_level
== class_binding_level
))
811 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
814 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
816 current_binding_level
= current_binding_level
->level_chain
;
817 class_binding_level
= current_binding_level
;
818 if (class_binding_level
->parm_flag
!= 2)
819 class_binding_level
= 0;
820 while (current_binding_level
->parm_flag
== 2)
821 current_binding_level
= current_binding_level
->level_chain
;
826 resume_binding_level (b
)
827 struct binding_level
*b
;
829 if (class_binding_level
)
832 /* These are here because we cannot deal with shadows yet. */
833 sorry ("cannot resume a namespace inside class");
836 b
->level_chain
= class_binding_level
;
837 class_binding_level
= (struct binding_level
*)0;
843 /* These are here because we cannot deal with shadows yet. */
844 if (b
->level_chain
!= current_binding_level
)
846 sorry ("cannot resume a namespace inside a different namespace");
850 b
->level_chain
= current_binding_level
;
852 current_binding_level
= b
;
853 #if defined(DEBUG_CP_BINDING_LEVELS)
854 b
->binding_depth
= binding_depth
;
856 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
857 (is_class_level
) ? "class" : "block", b
, lineno
);
860 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
863 /* Create a new `struct binding_level'. */
866 struct binding_level
*
867 make_binding_level ()
870 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
873 /* Nonzero if we are currently in the global binding level. */
878 return current_binding_level
== global_binding_level
;
881 /* Nonzero if we are currently in a toplevel binding level. This
882 means either the global binding level or a namespace in a toplevel
886 toplevel_bindings_p ()
888 struct binding_level
*b
= current_binding_level
;
892 if (b
== global_binding_level
)
894 if (b
->pseudo_global
)
896 if (! b
->namespace_p
)
902 /* Nonzero if this is a namespace scope. */
905 namespace_bindings_p ()
907 return current_binding_level
->namespace_p
;
913 keep_next_level_flag
= 1;
916 /* Nonzero if the current level needs to have a BLOCK made. */
921 return (current_binding_level
->blocks
!= NULL_TREE
922 || current_binding_level
->keep
923 || current_binding_level
->names
!= NULL_TREE
924 || (current_binding_level
->tags
!= NULL_TREE
925 && !current_binding_level
->tag_transparent
));
928 /* Identify this binding level as a level of parameters. */
931 declare_parm_level ()
933 current_binding_level
->parm_flag
= 1;
937 declare_pseudo_global_level ()
939 current_binding_level
->pseudo_global
= 1;
943 declare_namespace_level ()
945 current_binding_level
->namespace_p
= 1;
949 pseudo_global_level_p ()
951 return current_binding_level
->pseudo_global
;
955 set_class_shadows (shadows
)
958 class_binding_level
->class_shadowed
= shadows
;
961 /* Enter a new binding level.
962 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
963 not for that of tags. */
966 pushlevel (tag_transparent
)
969 register struct binding_level
*newlevel
= NULL_BINDING_LEVEL
;
971 /* If this is the top level of a function,
972 just make sure that NAMED_LABELS is 0.
973 They should have been set to 0 at the end of the previous function. */
975 if (current_binding_level
== global_binding_level
)
976 my_friendly_assert (named_labels
== NULL_TREE
, 134);
978 /* Reuse or create a struct for this binding level. */
980 #if defined(DEBUG_CP_BINDING_LEVELS)
982 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
983 if (free_binding_level
)
984 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
986 newlevel
= free_binding_level
;
987 free_binding_level
= free_binding_level
->level_chain
;
991 newlevel
= make_binding_level ();
994 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
995 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
996 keep_next_level_flag
= 0;
1000 note_level_for_for ()
1002 current_binding_level
->is_for_scope
= 1;
1006 pushlevel_temporary (tag_transparent
)
1007 int tag_transparent
;
1009 pushlevel (tag_transparent
);
1010 current_binding_level
->keep
= 2;
1013 /* Note we don't call push_momentary() here. Otherwise, it would cause
1014 cleanups to be allocated on the momentary obstack, and they will be
1015 overwritten by the next statement. */
1017 expand_start_bindings (0);
1020 /* Exit a binding level.
1021 Pop the level off, and restore the state of the identifier-decl mappings
1022 that were in effect when this level was entered.
1024 If KEEP == 1, this level had explicit declarations, so
1025 and create a "block" (a BLOCK node) for the level
1026 to record its declarations and subblocks for symbol table output.
1028 If KEEP == 2, this level's subblocks go to the front,
1029 not the back of the current binding level. This happens,
1030 for instance, when code for constructors and destructors
1031 need to generate code at the end of a function which must
1032 be moved up to the front of the function.
1034 If FUNCTIONBODY is nonzero, this level is the body of a function,
1035 so create a block as if KEEP were set and also clear out all
1038 If REVERSE is nonzero, reverse the order of decls before putting
1039 them into the BLOCK. */
1042 poplevel (keep
, reverse
, functionbody
)
1048 /* The chain of decls was accumulated in reverse order.
1049 Put it into forward order, just for cleanliness. */
1051 int tmp
= functionbody
;
1052 int real_functionbody
= current_binding_level
->keep
== 2
1053 ? ((functionbody
= 0), tmp
) : functionbody
;
1054 tree tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1055 tree subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1056 tree block
= NULL_TREE
;
1058 int block_previously_created
;
1060 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1061 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1062 current_binding_level
->parm_flag
,
1063 current_binding_level
->keep
);
1065 if (current_binding_level
->keep
== 1)
1068 /* Get the decls in the order they were written.
1069 Usually current_binding_level->names is in reverse order.
1070 But parameter decls were previously put in forward order. */
1073 current_binding_level
->names
1074 = decls
= nreverse (current_binding_level
->names
);
1076 decls
= current_binding_level
->names
;
1078 /* Output any nested inline functions within this block
1079 if they weren't already output. */
1081 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1082 if (TREE_CODE (decl
) == FUNCTION_DECL
1083 && ! TREE_ASM_WRITTEN (decl
)
1084 && DECL_INITIAL (decl
) != NULL_TREE
1085 && TREE_ADDRESSABLE (decl
)
1086 && decl_function_context (decl
) == current_function_decl
)
1088 /* If this decl was copied from a file-scope decl
1089 on account of a block-scope extern decl,
1090 propagate TREE_ADDRESSABLE to the file-scope decl. */
1091 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1092 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1095 push_function_context ();
1096 output_inline_function (decl
);
1097 pop_function_context ();
1101 /* If there were any declarations or structure tags in that level,
1102 or if this level is a function body,
1103 create a BLOCK to record them for the life of this function. */
1106 block_previously_created
= (current_binding_level
->this_block
!= NULL_TREE
);
1107 if (block_previously_created
)
1108 block
= current_binding_level
->this_block
;
1109 else if (keep
== 1 || functionbody
)
1110 block
= make_node (BLOCK
);
1111 if (block
!= NULL_TREE
)
1113 if (block_previously_created
)
1115 if (decls
|| tags
|| subblocks
)
1117 if (BLOCK_VARS (block
) || BLOCK_TYPE_TAGS (block
))
1119 warning ("internal compiler error: debugging info corrupted");
1121 BLOCK_VARS (block
) = decls
;
1122 BLOCK_TYPE_TAGS (block
) = tags
;
1124 /* We can have previous subblocks and new subblocks when
1125 doing fixup_gotos with complex cleanups. We chain the new
1126 subblocks onto the end of any pre-existing subblocks. */
1127 BLOCK_SUBBLOCKS (block
) = chainon (BLOCK_SUBBLOCKS (block
),
1130 /* If we created the block earlier on, and we are just
1131 diddling it now, then it already should have a proper
1132 BLOCK_END_NOTE value associated with it. */
1136 BLOCK_VARS (block
) = decls
;
1137 BLOCK_TYPE_TAGS (block
) = tags
;
1138 BLOCK_SUBBLOCKS (block
) = subblocks
;
1139 /* Otherwise, for a new block, install a new BLOCK_END_NOTE value. */
1140 remember_end_note (block
);
1144 /* In each subblock, record that this is its superior. */
1147 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1148 BLOCK_SUPERCONTEXT (link
) = block
;
1150 /* Clear out the meanings of the local variables of this level. */
1152 if (current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1)
1154 struct binding_level
*outer
= current_binding_level
->level_chain
;
1155 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1157 if (TREE_CODE (link
) == VAR_DECL
)
1158 DECL_DEAD_FOR_LOCAL (link
) = 1;
1160 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1163 /* Save declarations made in a 'for' statement so we can support pre-ANSI
1164 'for' scoping semantics. */
1166 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1168 tree id
= TREE_PURPOSE (link
);
1169 tree decl
= IDENTIFIER_LOCAL_VALUE (id
);
1171 if (decl
&& DECL_DEAD_FOR_LOCAL (decl
))
1173 /* In this case keep the dead for-decl visible,
1174 but remember what (if anything) it shadowed. */
1175 DECL_SHADOWED_FOR_VAR (decl
) = TREE_VALUE (link
);
1176 TREE_CHAIN (decl
) = outer
->dead_vars_from_for
;
1177 outer
->dead_vars_from_for
= decl
;
1180 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VALUE (link
);
1183 else /* Not special for scope. */
1185 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1187 if (DECL_NAME (link
) != NULL_TREE
)
1189 /* If the ident. was used or addressed via a local extern decl,
1190 don't forget that fact. */
1191 if (DECL_EXTERNAL (link
))
1193 if (TREE_USED (link
))
1194 TREE_USED (DECL_ASSEMBLER_NAME (link
)) = 1;
1195 if (TREE_ADDRESSABLE (link
))
1196 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1198 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1202 /* Restore all name-meanings of the outer levels
1203 that were shadowed by this level. */
1205 for (link
= current_binding_level
->shadowed
;
1206 link
; link
= TREE_CHAIN (link
))
1207 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1209 /* We first restore the regular decls and *then* the dead_vars_from_for
1210 to handle this case:
1214 for (int i; ; ) { ...} // i#2
1218 In this case, we want remove the binding for i#3, restoring
1219 that of i#2. Then we want to remove the binding for i#2,
1220 and restore that of i#1. */
1222 link
= current_binding_level
->dead_vars_from_for
;
1223 for (; link
!= NULL_TREE
; link
= TREE_CHAIN (link
))
1225 tree id
= DECL_NAME (link
);
1226 if (IDENTIFIER_LOCAL_VALUE (id
) == link
)
1227 IDENTIFIER_LOCAL_VALUE (id
) = DECL_SHADOWED_FOR_VAR (link
);
1230 for (link
= current_binding_level
->class_shadowed
;
1231 link
; link
= TREE_CHAIN (link
))
1232 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1233 for (link
= current_binding_level
->type_shadowed
;
1234 link
; link
= TREE_CHAIN (link
))
1235 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1238 /* If the level being exited is the top level of a function,
1239 check over all the labels. */
1243 /* If this is the top level block of a function,
1244 the vars are the function's parameters.
1245 Don't leave them in the BLOCK because they are
1246 found in the FUNCTION_DECL instead. */
1248 BLOCK_VARS (block
) = 0;
1250 /* Clear out the definitions of all label names,
1251 since their scopes end here. */
1253 for (link
= named_labels
; link
; link
= TREE_CHAIN (link
))
1255 register tree label
= TREE_VALUE (link
);
1257 if (DECL_INITIAL (label
) == NULL_TREE
)
1259 cp_error_at ("label `%D' used but not defined", label
);
1260 /* Avoid crashing later. */
1261 define_label (input_filename
, 1, DECL_NAME (label
));
1263 else if (warn_unused
&& !TREE_USED (label
))
1264 cp_warning_at ("label `%D' defined but not used", label
);
1265 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), NULL_TREE
);
1267 /* Put the labels into the "variables" of the
1268 top-level block, so debugger can see them. */
1269 TREE_CHAIN (label
) = BLOCK_VARS (block
);
1270 BLOCK_VARS (block
) = label
;
1273 named_labels
= NULL_TREE
;
1276 /* Any uses of undefined labels now operate under constraints
1277 of next binding contour. */
1279 struct binding_level
*level_chain
;
1280 level_chain
= current_binding_level
->level_chain
;
1283 struct named_label_list
*labels
;
1284 for (labels
= named_label_uses
; labels
; labels
= labels
->next
)
1285 if (labels
->binding_level
== current_binding_level
)
1287 labels
->binding_level
= level_chain
;
1288 labels
->names_in_scope
= level_chain
->names
;
1293 tmp
= current_binding_level
->keep
;
1295 pop_binding_level ();
1297 DECL_INITIAL (current_function_decl
) = block
;
1300 if (!block_previously_created
)
1301 current_binding_level
->blocks
1302 = chainon (current_binding_level
->blocks
, block
);
1304 /* If we did not make a block for the level just exited,
1305 any blocks made for inner levels
1306 (since they cannot be recorded as subblocks in that level)
1307 must be carried forward so they will later become subblocks
1308 of something else. */
1312 current_binding_level
->blocks
1313 = chainon (subblocks
, current_binding_level
->blocks
);
1315 current_binding_level
->blocks
1316 = chainon (current_binding_level
->blocks
, subblocks
);
1319 /* Take care of compiler's internal binding structures. */
1322 expand_end_bindings (getdecls (), keep
, 1);
1323 /* Each and every BLOCK node created here in `poplevel' is important
1324 (e.g. for proper debugging information) so if we created one
1325 earlier, mark it as "used". */
1327 TREE_USED (block
) = 1;
1328 block
= poplevel (keep
, reverse
, real_functionbody
);
1331 /* Each and every BLOCK node created here in `poplevel' is important
1332 (e.g. for proper debugging information) so if we created one
1333 earlier, mark it as "used". */
1335 TREE_USED (block
) = 1;
1339 /* Resume a binding level for a namespace. */
1343 struct binding_level
*b
;
1347 resume_binding_level (b
);
1349 /* Resume the variable caches. */
1350 decls
= current_binding_level
->names
;
1352 /* Restore the meanings of the local variables of this level. */
1354 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1356 /* If it doesn't have a name, there is nothing left to do with it. */
1357 if (DECL_NAME (link
) == NULL_TREE
)
1360 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = link
;
1362 /* If this is a TYPE_DECL, push it into the type value slot. */
1363 if (TREE_CODE (link
) == TYPE_DECL
)
1364 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (link
), TREE_TYPE (link
));
1368 /* Delete the node BLOCK from the current binding level.
1369 This is used for the block inside a stmt expr ({...})
1370 so that the block can be reinserted where appropriate. */
1373 delete_block (block
)
1377 if (current_binding_level
->blocks
== block
)
1378 current_binding_level
->blocks
= TREE_CHAIN (block
);
1379 for (t
= current_binding_level
->blocks
; t
;)
1381 if (TREE_CHAIN (t
) == block
)
1382 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1386 TREE_CHAIN (block
) = NULL_TREE
;
1387 /* Clear TREE_USED which is always set by poplevel.
1388 The flag is set again if insert_block is called. */
1389 TREE_USED (block
) = 0;
1392 /* Insert BLOCK at the end of the list of subblocks of the
1393 current binding level. This is used when a BIND_EXPR is expanded,
1394 to handle the BLOCK node inside the BIND_EXPR. */
1397 insert_block (block
)
1400 TREE_USED (block
) = 1;
1401 current_binding_level
->blocks
1402 = chainon (current_binding_level
->blocks
, block
);
1405 /* Set the BLOCK node for the innermost scope
1406 (the one we are currently in). */
1410 register tree block
;
1412 current_binding_level
->this_block
= block
;
1415 /* Do a pushlevel for class declarations. */
1420 register struct binding_level
*newlevel
;
1422 /* Reuse or create a struct for this binding level. */
1423 #if defined(DEBUG_CP_BINDING_LEVELS)
1425 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1426 if (free_binding_level
)
1427 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1429 newlevel
= free_binding_level
;
1430 free_binding_level
= free_binding_level
->level_chain
;
1434 newlevel
= make_binding_level ();
1437 #if defined(DEBUG_CP_BINDING_LEVELS)
1439 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1441 push_binding_level (newlevel
, 0, 0);
1443 decl_stack
= push_decl_level (decl_stack
, &decl_obstack
);
1444 class_binding_level
= current_binding_level
;
1445 class_binding_level
->parm_flag
= 2;
1446 /* We have just pushed into a new binding level. Now, fake out the rest
1447 of the compiler. Set the `current_binding_level' back to point to
1448 the most closely containing non-class binding level. */
1451 current_binding_level
= current_binding_level
->level_chain
;
1453 while (current_binding_level
->parm_flag
== 2);
1456 /* ...and a poplevel for class declarations. FORCE is used to force
1457 clearing out of CLASS_VALUEs after a class definition. */
1460 poplevel_class (force
)
1463 register struct binding_level
*level
= class_binding_level
;
1464 tree block
= NULL_TREE
;
1467 my_friendly_assert (level
!= 0, 354);
1469 decl_stack
= pop_stack_level (decl_stack
);
1470 for (shadowed
= level
->shadowed
; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
1471 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1472 /* If we're leaving a toplevel class, don't bother to do the setting
1473 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1474 shouldn't even be used when current_class_type isn't set, and second,
1475 if we don't touch it here, we're able to use the cache effect if the
1476 next time we're entering a class scope, it is the same class. */
1477 if (current_class_depth
!= 1 || force
)
1478 for (shadowed
= level
->class_shadowed
;
1480 shadowed
= TREE_CHAIN (shadowed
))
1481 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1483 /* Remember to save what IDENTIFIER's were bound in this scope so we
1484 can recover from cache misses. */
1486 previous_class_type
= current_class_type
;
1487 previous_class_values
= class_binding_level
->class_shadowed
;
1489 for (shadowed
= level
->type_shadowed
;
1491 shadowed
= TREE_CHAIN (shadowed
))
1492 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
)) = TREE_VALUE (shadowed
);
1494 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1495 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1496 class_binding_level
->parm_flag
,
1497 class_binding_level
->keep
);
1499 if (class_binding_level
->parm_flag
!= 2)
1500 class_binding_level
= (struct binding_level
*)0;
1502 /* Now, pop out of the the binding level which we created up in the
1503 `pushlevel_class' routine. */
1504 #if defined(DEBUG_CP_BINDING_LEVELS)
1506 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1508 pop_binding_level ();
1513 /* For debugging. */
1514 static int no_print_functions
= 0;
1515 static int no_print_builtins
= 0;
1518 print_binding_level (lvl
)
1519 struct binding_level
*lvl
;
1523 fprintf (stderr
, " blocks=");
1524 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
1525 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
1526 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
1527 if (lvl
->tag_transparent
)
1528 fprintf (stderr
, " tag-transparent");
1529 if (lvl
->more_cleanups_ok
)
1530 fprintf (stderr
, " more-cleanups-ok");
1531 if (lvl
->have_cleanups
)
1532 fprintf (stderr
, " have-cleanups");
1533 fprintf (stderr
, "\n");
1536 fprintf (stderr
, " names:\t");
1537 /* We can probably fit 3 names to a line? */
1538 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
1540 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
1542 if (no_print_builtins
1543 && (TREE_CODE (t
) == TYPE_DECL
)
1544 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
1547 /* Function decls tend to have longer names. */
1548 if (TREE_CODE (t
) == FUNCTION_DECL
)
1555 fprintf (stderr
, "\n\t");
1558 print_node_brief (stderr
, "", t
, 0);
1559 if (t
== error_mark_node
)
1563 fprintf (stderr
, "\n");
1567 fprintf (stderr
, " tags:\t");
1569 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
1571 if (TREE_PURPOSE (t
) == NULL_TREE
)
1573 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1580 fprintf (stderr
, "\n\t");
1583 if (TREE_PURPOSE (t
) == NULL_TREE
)
1585 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
1586 fprintf (stderr
, ">");
1588 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
1589 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1592 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
1593 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
1594 fprintf (stderr
, ">");
1598 fprintf (stderr
, "\n");
1602 fprintf (stderr
, " shadowed:");
1603 for (t
= lvl
->shadowed
; t
; t
= TREE_CHAIN (t
))
1605 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1607 fprintf (stderr
, "\n");
1609 if (lvl
->class_shadowed
)
1611 fprintf (stderr
, " class-shadowed:");
1612 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
1614 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1616 fprintf (stderr
, "\n");
1618 if (lvl
->type_shadowed
)
1620 fprintf (stderr
, " type-shadowed:");
1621 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1623 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
1625 fprintf (stderr
, "\n");
1630 print_other_binding_stack (stack
)
1631 struct binding_level
*stack
;
1633 struct binding_level
*level
;
1634 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
1636 fprintf (stderr
, "binding level ");
1637 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
1638 fprintf (stderr
, "\n");
1639 print_binding_level (level
);
1644 print_binding_stack ()
1646 struct binding_level
*b
;
1647 fprintf (stderr
, "current_binding_level=");
1648 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
1649 fprintf (stderr
, "\nclass_binding_level=");
1650 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
1651 fprintf (stderr
, "\nglobal_binding_level=");
1652 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
1653 fprintf (stderr
, "\n");
1654 if (class_binding_level
)
1656 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
1657 if (b
== current_binding_level
)
1660 b
= class_binding_level
;
1662 b
= current_binding_level
;
1665 b
= current_binding_level
;
1666 print_other_binding_stack (b
);
1667 fprintf (stderr
, "global:\n");
1668 print_binding_level (global_binding_level
);
1671 extern char * first_global_object_name
;
1673 /* Get a unique name for each call to this routine for unnamed namespaces.
1674 Mostly copied from get_file_function_name. */
1679 static int temp_name_counter
= 0;
1683 if (first_global_object_name
)
1684 p
= first_global_object_name
;
1685 else if (main_input_filename
)
1686 p
= main_input_filename
;
1690 #define UNNAMED_NAMESPACE_FORMAT "__%s_%d"
1692 buf
= (char *) alloca (sizeof (UNNAMED_NAMESPACE_FORMAT
) + strlen (p
));
1694 sprintf (buf
, UNNAMED_NAMESPACE_FORMAT
, p
, temp_name_counter
++);
1696 /* Don't need to pull weird characters out of global names. */
1697 if (p
!= first_global_object_name
)
1699 for (p
= buf
+11; *p
; p
++)
1700 if (! ((*p
>= '0' && *p
<= '9')
1701 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
1704 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
1707 || (*p
>= 'A' && *p
<= 'Z')
1708 || (*p
>= 'a' && *p
<= 'z')))
1712 return get_identifier (buf
);
1715 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
1716 select a name that is unique to this compilation unit. */
1719 push_namespace (name
)
1725 sorry ("namespace");
1729 extern tree current_namespace
;
1730 tree old_id
= get_namespace_id ();
1736 /* Create a truly ugly name! */
1737 name
= get_unique_name ();
1740 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
1742 /* Mark them as external, so redeclaration_error_message doesn't think
1743 they are duplicates. */
1745 DECL_EXTERNAL (d
) = 1;
1748 if (NAMESPACE_LEVEL (d
) == 0)
1750 /* This is new for this compilation unit. */
1752 declare_namespace_level ();
1753 NAMESPACE_LEVEL (d
) = current_binding_level
;
1756 resume_level (NAMESPACE_LEVEL (d
));
1758 /* This code is just is bit old now... */
1759 current_namespace
= tree_cons (NULL_TREE
, name
, current_namespace
);
1760 buf
= (char *) alloca (4 + (old_id
? IDENTIFIER_LENGTH (old_id
) : 0)
1761 + IDENTIFIER_LENGTH (name
));
1762 sprintf (buf
, "%s%s", old_id
? IDENTIFIER_POINTER (old_id
) : "",
1763 IDENTIFIER_POINTER (name
));
1764 TREE_PURPOSE (current_namespace
) = get_identifier (buf
);
1768 /* Pop from the scope of the current namespace. */
1774 extern tree current_namespace
;
1776 current_namespace
= TREE_CHAIN (current_namespace
);
1778 /* Just in case we get out of sync. */
1779 if (! namespace_bindings_p ())
1782 decls
= current_binding_level
->names
;
1784 /* Clear out the meanings of the local variables of this level. */
1786 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1788 if (DECL_NAME (link
) != NULL_TREE
)
1790 /* If the ident. was used or addressed via a local extern decl,
1791 don't forget that fact. */
1792 if (DECL_EXTERNAL (link
))
1794 if (TREE_USED (link
))
1795 TREE_USED (DECL_ASSEMBLER_NAME (link
)) = 1;
1796 if (TREE_ADDRESSABLE (link
))
1797 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link
)) = 1;
1799 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = NULL_TREE
;
1803 /* Restore all name-meanings of the outer levels
1804 that were shadowed by this level. */
1806 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
1807 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1808 for (link
= current_binding_level
->class_shadowed
;
1809 link
; link
= TREE_CHAIN (link
))
1810 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1811 for (link
= current_binding_level
->type_shadowed
;
1812 link
; link
= TREE_CHAIN (link
))
1813 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
1815 /* suspend a level. */
1816 suspend_binding_level ();
1820 /* Subroutines for reverting temporarily to top-level for instantiation
1821 of templates and such. We actually need to clear out the class- and
1822 local-value slots of all identifiers, so that only the global values
1823 are at all visible. Simply setting current_binding_level to the global
1824 scope isn't enough, because more binding levels may be pushed. */
1825 struct saved_scope
{
1826 struct binding_level
*old_binding_level
;
1828 struct saved_scope
*prev
;
1829 tree class_name
, class_type
, function_decl
;
1830 struct binding_level
*class_bindings
;
1831 tree
*lang_base
, *lang_stack
, lang_name
;
1833 int minimal_parse_mode
;
1834 tree last_function_parms
;
1835 tree template_parms
;
1836 HOST_WIDE_INT processing_template_decl
;
1837 tree previous_class_type
, previous_class_values
;
1838 int processing_specialization
;
1839 int processing_explicit_instantiation
;
1841 static struct saved_scope
*current_saved_scope
;
1844 store_bindings (names
, old_bindings
)
1845 tree names
, old_bindings
;
1848 for (t
= names
; t
; t
= TREE_CHAIN (t
))
1850 tree binding
, t1
, id
;
1852 if (TREE_CODE (t
) == TREE_LIST
)
1853 id
= TREE_PURPOSE (t
);
1858 || (!IDENTIFIER_LOCAL_VALUE (id
)
1859 && !IDENTIFIER_CLASS_VALUE (id
)))
1862 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
1863 if (TREE_VEC_ELT (t1
, 0) == id
)
1866 binding
= make_tree_vec (4);
1869 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
1870 TREE_VEC_ELT (binding
, 0) = id
;
1871 TREE_VEC_ELT (binding
, 1) = IDENTIFIER_TYPE_VALUE (id
);
1872 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_LOCAL_VALUE (id
);
1873 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
1874 IDENTIFIER_LOCAL_VALUE (id
) = NULL_TREE
;
1875 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
1877 TREE_CHAIN (binding
) = old_bindings
;
1878 old_bindings
= binding
;
1882 return old_bindings
;
1886 maybe_push_to_top_level (pseudo
)
1889 extern int current_lang_stacksize
;
1890 struct saved_scope
*s
1891 = (struct saved_scope
*) xmalloc (sizeof (struct saved_scope
));
1892 struct binding_level
*b
= inner_binding_level
;
1893 tree old_bindings
= NULL_TREE
;
1895 if (current_function_decl
)
1896 push_cp_function_context (NULL_TREE
);
1898 if (previous_class_type
)
1899 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
1901 /* Have to include global_binding_level, because class-level decls
1902 aren't listed anywhere useful. */
1903 for (; b
; b
= b
->level_chain
)
1907 if (b
== global_binding_level
|| (pseudo
&& b
->pseudo_global
))
1910 old_bindings
= store_bindings (b
->names
, old_bindings
);
1911 /* We also need to check class_shadowed to save class-level type
1912 bindings, since pushclass doesn't fill in b->names. */
1913 if (b
->parm_flag
== 2)
1914 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
1916 /* Unwind type-value slots back to top level. */
1917 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
1918 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
1921 s
->old_binding_level
= current_binding_level
;
1922 current_binding_level
= b
;
1924 s
->class_name
= current_class_name
;
1925 s
->class_type
= current_class_type
;
1926 s
->function_decl
= current_function_decl
;
1927 s
->class_bindings
= class_binding_level
;
1928 s
->lang_stack
= current_lang_stack
;
1929 s
->lang_base
= current_lang_base
;
1930 s
->lang_stacksize
= current_lang_stacksize
;
1931 s
->lang_name
= current_lang_name
;
1932 s
->minimal_parse_mode
= minimal_parse_mode
;
1933 s
->last_function_parms
= last_function_parms
;
1934 s
->template_parms
= current_template_parms
;
1935 s
->processing_template_decl
= processing_template_decl
;
1936 s
->previous_class_type
= previous_class_type
;
1937 s
->previous_class_values
= previous_class_values
;
1938 s
->processing_specialization
= processing_specialization
;
1939 s
->processing_explicit_instantiation
= processing_explicit_instantiation
;
1941 current_class_name
= current_class_type
= NULL_TREE
;
1942 current_function_decl
= NULL_TREE
;
1943 class_binding_level
= (struct binding_level
*)0;
1944 current_lang_stacksize
= 10;
1945 current_lang_stack
= current_lang_base
1946 = (tree
*) xmalloc (current_lang_stacksize
* sizeof (tree
));
1947 current_lang_name
= lang_name_cplusplus
;
1948 strict_prototype
= strict_prototypes_lang_cplusplus
;
1949 named_labels
= NULL_TREE
;
1950 minimal_parse_mode
= 0;
1951 previous_class_type
= previous_class_values
= NULL_TREE
;
1952 processing_specialization
= 0;
1953 processing_explicit_instantiation
= 0;
1956 current_template_parms
= NULL_TREE
;
1957 processing_template_decl
= 0;
1960 s
->prev
= current_saved_scope
;
1961 s
->old_bindings
= old_bindings
;
1962 current_saved_scope
= s
;
1964 push_obstacks (&permanent_obstack
, &permanent_obstack
);
1968 push_to_top_level ()
1970 maybe_push_to_top_level (0);
1974 pop_from_top_level ()
1976 extern int current_lang_stacksize
;
1977 struct saved_scope
*s
= current_saved_scope
;
1980 /* Clear out class-level bindings cache. */
1981 if (previous_class_type
)
1984 previous_class_type
= NULL_TREE
;
1989 current_binding_level
= s
->old_binding_level
;
1990 current_saved_scope
= s
->prev
;
1991 for (t
= s
->old_bindings
; t
; t
= TREE_CHAIN (t
))
1993 tree id
= TREE_VEC_ELT (t
, 0);
1996 IDENTIFIER_TYPE_VALUE (id
) = TREE_VEC_ELT (t
, 1);
1997 IDENTIFIER_LOCAL_VALUE (id
) = TREE_VEC_ELT (t
, 2);
1998 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2001 current_class_name
= s
->class_name
;
2002 current_class_type
= s
->class_type
;
2003 current_function_decl
= s
->function_decl
;
2004 class_binding_level
= s
->class_bindings
;
2005 free (current_lang_base
);
2006 current_lang_base
= s
->lang_base
;
2007 current_lang_stack
= s
->lang_stack
;
2008 current_lang_name
= s
->lang_name
;
2009 current_lang_stacksize
= s
->lang_stacksize
;
2010 if (current_lang_name
== lang_name_cplusplus
)
2011 strict_prototype
= strict_prototypes_lang_cplusplus
;
2012 else if (current_lang_name
== lang_name_c
)
2013 strict_prototype
= strict_prototypes_lang_c
;
2014 minimal_parse_mode
= s
->minimal_parse_mode
;
2015 last_function_parms
= s
->last_function_parms
;
2016 current_template_parms
= s
->template_parms
;
2017 processing_template_decl
= s
->processing_template_decl
;
2018 previous_class_type
= s
->previous_class_type
;
2019 previous_class_values
= s
->previous_class_values
;
2020 processing_specialization
= s
->processing_specialization
;
2021 processing_explicit_instantiation
= s
->processing_explicit_instantiation
;
2025 if (current_function_decl
)
2026 pop_cp_function_context (NULL_TREE
);
2029 /* Push a definition of struct, union or enum tag "name".
2030 into binding_level "b". "type" should be the type node,
2031 We assume that the tag "name" is not already defined.
2033 Note that the definition may really be just a forward reference.
2034 In that case, the TYPE_SIZE will be a NULL_TREE.
2036 C++ gratuitously puts all these tags in the name space. */
2038 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2039 record the shadowed value for this binding contour. TYPE is
2040 the type that ID maps to. */
2043 set_identifier_type_value_with_scope (id
, type
, b
)
2046 struct binding_level
*b
;
2048 if (b
!= global_binding_level
)
2050 tree old_type_value
= IDENTIFIER_TYPE_VALUE (id
);
2052 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2054 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2057 /* As set_identifier_type_value_with_scope, but using inner_binding_level. */
2060 set_identifier_type_value (id
, type
)
2064 set_identifier_type_value_with_scope (id
, type
, inner_binding_level
);
2067 /* Pop off extraneous binding levels left over due to syntax errors.
2069 We don't pop past namespaces, as they might be valid. */
2074 #ifdef DEBUG_CP_BINDING_LEVELS
2075 fprintf (stderr
, "XXX entering pop_everything ()\n");
2077 while (! toplevel_bindings_p () && ! pseudo_global_level_p ())
2079 if (class_binding_level
)
2080 pop_nested_class (1);
2084 #ifdef DEBUG_CP_BINDING_LEVELS
2085 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2089 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2090 Normally put into into the inner-most non-tag-transparent scope,
2091 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2092 The latter is needed for implicit declarations. */
2095 pushtag (name
, type
, globalize
)
2099 register struct binding_level
*b
;
2103 b
= inner_binding_level
;
2104 while (b
->tag_transparent
2105 || (globalize
&& b
->parm_flag
== 2))
2108 if (toplevel_bindings_p ())
2109 b
->tags
= perm_tree_cons (name
, type
, b
->tags
);
2111 b
->tags
= saveable_tree_cons (name
, type
, b
->tags
);
2115 context
= type
? TYPE_CONTEXT (type
) : NULL_TREE
;
2116 if (! context
&& ! globalize
)
2117 context
= current_scope ();
2119 c_decl
= TREE_CODE (context
) == FUNCTION_DECL
2120 ? context
: TYPE_MAIN_DECL (context
);
2122 /* Do C++ gratuitous typedefing. */
2123 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2128 if (b
->parm_flag
!= 2
2129 || TYPE_SIZE (current_class_type
) != NULL_TREE
)
2131 d
= lookup_nested_type (type
, c_decl
);
2136 d
= build_decl (TYPE_DECL
, name
, type
);
2137 SET_DECL_ARTIFICIAL (d
);
2138 set_identifier_type_value_with_scope (name
, type
, b
);
2141 d
= TYPE_MAIN_DECL (d
);
2143 TYPE_NAME (type
) = d
;
2144 DECL_CONTEXT (d
) = context
;
2145 if (! globalize
&& processing_template_decl
&& IS_AGGR_TYPE (type
))
2146 push_template_decl (d
);
2148 if (b
->parm_flag
== 2)
2149 d
= pushdecl_class_level (d
);
2151 d
= pushdecl_with_scope (d
, b
);
2155 /* Make nested declarations go into class-level scope. */
2157 d
= build_decl (TYPE_DECL
, name
, type
);
2158 SET_DECL_ARTIFICIAL (d
);
2159 TYPE_NAME (type
) = d
;
2160 DECL_CONTEXT (d
) = context
;
2161 if (! globalize
&& processing_template_decl
&& IS_AGGR_TYPE (type
))
2162 push_template_decl (d
);
2164 d
= pushdecl_class_level (d
);
2168 if (ANON_AGGRNAME_P (name
))
2169 DECL_IGNORED_P (d
) = 1;
2171 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2172 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2173 DECL_ASSEMBLER_NAME (d
)
2174 = get_identifier (build_overload_name (type
, 1, 1));
2177 if (b
->parm_flag
== 2)
2179 TREE_NONLOCAL_FLAG (type
) = 1;
2180 if (TYPE_SIZE (current_class_type
) == NULL_TREE
)
2181 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2185 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2186 /* Use the canonical TYPE_DECL for this node. */
2187 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2190 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2191 will be the tagged type we just added to the current
2192 binding level. This fake NULL-named TYPE_DECL node helps
2193 dwarfout.c to know when it needs to output a
2194 representation of a tagged type, and it also gives us a
2195 convenient place to record the "scope start" address for
2198 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2199 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2203 /* Counter used to create anonymous type names. */
2205 static int anon_cnt
= 0;
2207 /* Return an IDENTIFIER which can be used as a name for
2208 anonymous structs and unions. */
2215 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2216 return get_identifier (buf
);
2219 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2220 This keeps dbxout from getting confused. */
2225 register struct binding_level
*b
;
2227 static int last_cnt
= 0;
2229 /* Fast out if no new anon names were declared. */
2230 if (last_cnt
== anon_cnt
)
2233 b
= current_binding_level
;
2234 while (b
->tag_transparent
)
2239 /* A NULL purpose means we have already processed all tags
2240 from here to the end of the list. */
2241 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2243 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2244 TREE_PURPOSE (tags
) = NULL_TREE
;
2245 tags
= TREE_CHAIN (tags
);
2247 last_cnt
= anon_cnt
;
2250 /* Subroutine of duplicate_decls: return truthvalue of whether
2251 or not types of these decls match.
2253 For C++, we must compare the parameter list so that `int' can match
2254 `int&' in a parameter position, but `int&' is not confused with
2258 decls_match (newdecl
, olddecl
)
2259 tree newdecl
, olddecl
;
2263 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2264 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2266 tree f1
= TREE_TYPE (newdecl
);
2267 tree f2
= TREE_TYPE (olddecl
);
2268 tree p1
= TYPE_ARG_TYPES (f1
);
2269 tree p2
= TYPE_ARG_TYPES (f2
);
2271 /* When we parse a static member function definition,
2272 we put together a FUNCTION_DECL which thinks its type
2273 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2275 if (TREE_CODE (f1
) == METHOD_TYPE
&& DECL_STATIC_FUNCTION_P (olddecl
))
2276 revert_static_member_fn (&newdecl
, &f1
, &p1
);
2277 else if (TREE_CODE (f2
) == METHOD_TYPE
2278 && DECL_STATIC_FUNCTION_P (newdecl
))
2279 revert_static_member_fn (&olddecl
, &f2
, &p2
);
2281 /* Here we must take care of the case where new default
2282 parameters are specified. Also, warn if an old
2283 declaration becomes ambiguous because default
2284 parameters may cause the two to be ambiguous. */
2285 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2287 if (TREE_CODE (f1
) == OFFSET_TYPE
)
2288 cp_compiler_error ("`%D' redeclared as member function", newdecl
);
2290 cp_compiler_error ("`%D' redeclared as non-member function", newdecl
);
2294 if (comptypes (TREE_TYPE (f1
), TREE_TYPE (f2
), 1))
2296 if (! strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
) == lang_c
2299 types_match
= self_promoting_args_p (p1
);
2300 if (p1
== void_list_node
)
2301 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2303 else if (!strict_prototypes_lang_c
&& DECL_LANGUAGE (olddecl
)==lang_c
2304 && DECL_LANGUAGE (newdecl
) == lang_c
&& p1
== NULL_TREE
)
2306 types_match
= self_promoting_args_p (p2
);
2307 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2310 types_match
= compparms (p1
, p2
, 3);
2315 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
2316 && TREE_CODE (olddecl
) == TEMPLATE_DECL
)
2318 tree newargs
= DECL_TEMPLATE_PARMS (newdecl
);
2319 tree oldargs
= DECL_TEMPLATE_PARMS (olddecl
);
2322 /* Run through all the levels of template parameters, checking
2324 while (newargs
&& oldargs
)
2326 int len
= TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (newargs
));
2328 if (TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS (oldargs
)) != len
)
2331 for (i
= 0; i
< len
; i
++)
2334 TREE_VALUE (TREE_VEC_ELT
2335 (INNERMOST_TEMPLATE_PARMS (newargs
), i
));
2337 TREE_VALUE (TREE_VEC_ELT
2338 (INNERMOST_TEMPLATE_PARMS (oldargs
), i
));
2339 if (TREE_CODE (newarg
) != TREE_CODE (oldarg
))
2341 else if (TREE_CODE (newarg
) == TYPE_DECL
)
2343 else if (! comptypes (TREE_TYPE (newarg
), TREE_TYPE (oldarg
), 1))
2346 newargs
= TREE_CHAIN (newargs
);
2347 oldargs
= TREE_CHAIN (oldargs
);
2350 if ((newargs
== NULL_TREE
) != (oldargs
== NULL_TREE
))
2351 /* One declaration has more levels that the other. */
2354 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2357 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
2358 DECL_TEMPLATE_RESULT (newdecl
));
2362 if (TREE_TYPE (newdecl
) == error_mark_node
)
2363 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
2364 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
2365 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
2366 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
2368 /* Qualifiers must match, and they may be present on either, the type
2370 else if ((TREE_READONLY (newdecl
)
2371 || TYPE_READONLY (TREE_TYPE (newdecl
)))
2372 == (TREE_READONLY (olddecl
)
2373 || TYPE_READONLY (TREE_TYPE (olddecl
)))
2374 && (TREE_THIS_VOLATILE (newdecl
)
2375 || TYPE_VOLATILE (TREE_TYPE (newdecl
)))
2376 == (TREE_THIS_VOLATILE (olddecl
)
2377 || TYPE_VOLATILE (TREE_TYPE (olddecl
))))
2378 types_match
= comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (newdecl
)),
2379 TYPE_MAIN_VARIANT (TREE_TYPE (olddecl
)), 1);
2387 /* If NEWDECL is `static' and an `extern' was seen previously,
2388 warn about it. (OLDDECL may be NULL_TREE; NAME contains
2389 information about previous usage as an `extern'.)
2391 Note that this does not apply to the C++ case of declaring
2392 a variable `extern const' and then later `const'.
2394 Don't complain about built-in functions, since they are beyond
2395 the user's control. */
2398 warn_extern_redeclared_static (newdecl
, olddecl
)
2399 tree newdecl
, olddecl
;
2403 static char *explicit_extern_static_warning
2404 = "`%D' was declared `extern' and later `static'";
2405 static char *implicit_extern_static_warning
2406 = "`%D' was declared implicitly `extern' and later `static'";
2408 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2411 name
= DECL_ASSEMBLER_NAME (newdecl
);
2412 if (TREE_PUBLIC (name
) && DECL_THIS_STATIC (newdecl
))
2414 /* It's okay to redeclare an ANSI built-in function as static,
2415 or to declare a non-ANSI built-in function as anything. */
2416 if (! (TREE_CODE (newdecl
) == FUNCTION_DECL
2417 && olddecl
!= NULL_TREE
2418 && TREE_CODE (olddecl
) == FUNCTION_DECL
2419 && (DECL_BUILT_IN (olddecl
)
2420 || DECL_BUILT_IN_NONANSI (olddecl
))))
2422 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
2423 ? implicit_extern_static_warning
2424 : explicit_extern_static_warning
, newdecl
);
2425 if (olddecl
!= NULL_TREE
)
2426 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
2431 /* Handle when a new declaration NEWDECL has the same name as an old
2432 one OLDDECL in the same binding contour. Prints an error message
2435 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2436 Otherwise, return 0. */
2439 duplicate_decls (newdecl
, olddecl
)
2440 tree newdecl
, olddecl
;
2442 extern struct obstack permanent_obstack
;
2443 unsigned olddecl_uid
= DECL_UID (olddecl
);
2444 int olddecl_friend
= 0, types_match
= 0;
2445 int new_defines_function
;
2447 if (newdecl
== olddecl
)
2450 if (TREE_CODE_CLASS (TREE_CODE (olddecl
)) == 'd')
2451 DECL_MACHINE_ATTRIBUTES (newdecl
) = DECL_MACHINE_ATTRIBUTES (olddecl
);
2453 types_match
= decls_match (newdecl
, olddecl
);
2455 if (TREE_CODE (olddecl
) != TREE_LIST
)
2456 olddecl_friend
= DECL_LANG_SPECIFIC (olddecl
) && DECL_FRIEND_P (olddecl
);
2458 /* If either the type of the new decl or the type of the old decl is an
2459 error_mark_node, then that implies that we have already issued an
2460 error (earlier) for some bogus type specification, and in that case,
2461 it is rather pointless to harass the user with yet more error message
2462 about the same declaration, so well just pretent the types match here. */
2463 if (TREE_TYPE (newdecl
) == error_mark_node
2464 || TREE_TYPE (olddecl
) == error_mark_node
)
2467 if (TREE_CODE (olddecl
) == FUNCTION_DECL
2468 && DECL_ARTIFICIAL (olddecl
)
2469 && (DECL_BUILT_IN (olddecl
) || DECL_BUILT_IN_NONANSI (olddecl
)))
2471 /* If you declare a built-in or predefined function name as static,
2472 the old definition is overridden, but optionally warn this was a
2473 bad choice of name. Ditto for overloads. */
2474 if (! TREE_PUBLIC (newdecl
)
2475 || (TREE_CODE (newdecl
) == FUNCTION_DECL
2476 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
)))
2479 cp_warning ("shadowing %s function `%#D'",
2480 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
2482 /* Discard the old built-in function. */
2485 else if (! types_match
)
2487 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
2489 /* If the built-in is not ansi, then programs can override
2490 it even globally without an error. */
2491 if (! DECL_BUILT_IN (olddecl
))
2492 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2496 cp_error ("declaration of `%#D'", newdecl
);
2497 cp_error ("conflicts with built-in declaration `%#D'",
2503 cp_warning ("declaration of `%#D'", newdecl
);
2504 cp_warning ("conflicts with built-in declaration `%#D'",
2508 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
2510 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
2511 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
2512 || (TREE_CODE (olddecl
) == FUNCTION_DECL
2513 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
2516 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
2517 if (TREE_CODE (olddecl
) == TREE_LIST
)
2518 olddecl
= TREE_VALUE (olddecl
);
2519 cp_error_at ("previous declaration of `%#D'", olddecl
);
2521 /* New decl is completely inconsistent with the old one =>
2522 tell caller to replace the old one. */
2526 else if (!types_match
)
2528 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2530 /* The name of a class template may not be declared to refer to
2531 any other template, class, function, object, namespace, value,
2532 or type in the same scope. */
2533 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
2534 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2536 cp_error ("declaration of template `%#D'", newdecl
);
2537 cp_error_at ("conflicts with previous declaration `%#D'",
2540 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
2541 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
2542 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
2543 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))), 3)
2544 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2545 DECL_TEMPLATE_PARMS (olddecl
)))
2547 cp_error ("new declaration `%#D'", newdecl
);
2548 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2552 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2554 if (DECL_LANGUAGE (newdecl
) == lang_c
2555 && DECL_LANGUAGE (olddecl
) == lang_c
)
2557 cp_error ("declaration of C function `%#D' conflicts with",
2559 cp_error_at ("previous declaration `%#D' here", olddecl
);
2561 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
2562 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)), 3))
2564 cp_error ("new declaration `%#D'", newdecl
);
2565 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
2571 /* Already complained about this, so don't do so again. */
2572 else if (current_class_type
== NULL_TREE
2573 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
2575 cp_error ("conflicting types for `%#D'", newdecl
);
2576 cp_error_at ("previous declaration as `%#D'", olddecl
);
2579 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2580 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
2581 && (!DECL_TEMPLATE_INFO (newdecl
)
2582 || (DECL_TI_TEMPLATE (newdecl
)
2583 != DECL_TI_TEMPLATE (olddecl
))))
2584 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2585 && (!DECL_TEMPLATE_INFO (olddecl
)
2586 || (DECL_TI_TEMPLATE (olddecl
)
2587 != DECL_TI_TEMPLATE (newdecl
))))))
2588 /* It's OK to have a template specialization and a non-template
2589 with the same type, or to have specializations of two
2590 different templates with the same type. Note that if one is a
2591 specialization, and the other is an instantiation of the same
2592 template, that we do not exit at this point. That situation
2593 can occur if we instantiate a template class, and then
2594 specialize one of its methods. This situation is legal, but
2595 the declarations must be merged in the usual way. */
2597 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2598 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
2599 && !DECL_USE_TEMPLATE (newdecl
))
2600 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
2601 && !DECL_USE_TEMPLATE (olddecl
))))
2602 /* One of the declarations is a template instantiation, and the
2603 other is not a template at all. That's OK. */
2607 char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
2610 cp_error (errmsg
, newdecl
);
2611 if (DECL_NAME (olddecl
) != NULL_TREE
)
2612 cp_error_at ((DECL_INITIAL (olddecl
)
2613 && current_binding_level
== global_binding_level
)
2614 ? "`%#D' previously defined here"
2615 : "`%#D' previously declared here", olddecl
);
2617 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2618 && DECL_INITIAL (olddecl
) != NULL_TREE
2619 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
2620 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
2622 /* Prototype decl follows defn w/o prototype. */
2623 cp_warning_at ("prototype for `%#D'", newdecl
);
2624 cp_warning_at ("follows non-prototype definition here", olddecl
);
2626 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
2627 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
2629 /* extern "C" int foo ();
2630 int foo () { bar (); }
2632 if (current_lang_stack
== current_lang_base
)
2633 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
2636 cp_error_at ("previous declaration of `%#D' with %L linkage",
2637 olddecl
, DECL_LANGUAGE (olddecl
));
2638 cp_error ("conflicts with new declaration with %L linkage",
2639 DECL_LANGUAGE (newdecl
));
2643 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
2645 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2647 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
2648 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
2651 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
2652 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
2654 for (; t1
&& t1
!= void_list_node
;
2655 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
2656 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
2658 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
2663 cp_pedwarn ("default argument given for parameter %d of `%#D'",
2665 cp_pedwarn_at ("after previous specification in `%#D'",
2671 cp_error ("default argument given for parameter %d of `%#D'",
2673 cp_error_at ("after previous specification in `%#D'",
2678 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
2679 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
2681 cp_warning ("`%#D' was used before it was declared inline",
2683 cp_warning_at ("previous non-inline declaration here",
2687 /* These bits are logically part of the type for non-functions. */
2688 else if (TREE_READONLY (newdecl
) != TREE_READONLY (olddecl
)
2689 || TREE_THIS_VOLATILE (newdecl
) != TREE_THIS_VOLATILE (olddecl
))
2691 cp_pedwarn ("type qualifiers for `%#D'", newdecl
);
2692 cp_pedwarn_at ("conflict with previous decl `%#D'", olddecl
);
2696 /* If new decl is `static' and an `extern' was seen previously,
2698 warn_extern_redeclared_static (newdecl
, olddecl
);
2700 /* We have committed to returning 1 at this point. */
2701 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2703 /* Now that functions must hold information normally held
2704 by field decls, there is extra work to do so that
2705 declaration information does not get destroyed during
2707 if (DECL_VINDEX (olddecl
))
2708 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
2709 if (DECL_CONTEXT (olddecl
))
2710 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
2711 if (DECL_CLASS_CONTEXT (olddecl
))
2712 DECL_CLASS_CONTEXT (newdecl
) = DECL_CLASS_CONTEXT (olddecl
);
2713 if (DECL_CHAIN (newdecl
) == NULL_TREE
)
2714 DECL_CHAIN (newdecl
) = DECL_CHAIN (olddecl
);
2715 if (DECL_PENDING_INLINE_INFO (newdecl
) == (struct pending_inline
*)0)
2716 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2717 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
2718 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
2719 DECL_ABSTRACT_VIRTUAL_P (newdecl
) |= DECL_ABSTRACT_VIRTUAL_P (olddecl
);
2720 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
2723 /* Deal with C++: must preserve virtual function table size. */
2724 if (TREE_CODE (olddecl
) == TYPE_DECL
)
2726 register tree newtype
= TREE_TYPE (newdecl
);
2727 register tree oldtype
= TREE_TYPE (olddecl
);
2729 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
2730 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
2732 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
2733 CLASSTYPE_FRIEND_CLASSES (newtype
)
2734 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
2738 /* Special handling ensues if new decl is a function definition. */
2739 new_defines_function
= (TREE_CODE (newdecl
) == FUNCTION_DECL
2740 && DECL_INITIAL (newdecl
) != NULL_TREE
);
2742 /* Optionally warn about more than one declaration for the same name,
2743 but don't warn about a function declaration followed by a definition. */
2744 if (warn_redundant_decls
2745 && ! DECL_ARTIFICIAL (olddecl
)
2746 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
2747 /* Don't warn about extern decl followed by (tentative) definition. */
2748 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
)))
2750 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
2751 cp_warning_at ("previous declaration of `%D'", olddecl
);
2754 /* Copy all the DECL_... slots specified in the new decl
2755 except for any that we copy here from the old type. */
2757 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2759 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)) == NULL_TREE
)
2761 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2762 DECL_TEMPLATE_RESULT (olddecl
) = DECL_TEMPLATE_RESULT (newdecl
);
2763 DECL_TEMPLATE_PARMS (olddecl
) = DECL_TEMPLATE_PARMS (newdecl
);
2770 /* Automatically handles default parameters. */
2771 tree oldtype
= TREE_TYPE (olddecl
);
2774 /* Make sure we put the new type in the same obstack as the old one. */
2776 push_obstacks (TYPE_OBSTACK (oldtype
), TYPE_OBSTACK (oldtype
));
2779 push_obstacks_nochange ();
2780 end_temporary_allocation ();
2783 /* Merge the data types specified in the two decls. */
2784 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2786 if (TREE_CODE (newdecl
) == VAR_DECL
)
2787 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2788 /* Do this after calling `common_type' so that default
2789 parameters don't confuse us. */
2790 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
2791 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
2792 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
2794 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
2795 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
2796 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
2797 TYPE_RAISES_EXCEPTIONS (oldtype
));
2799 if ((pedantic
|| (! DECL_IN_SYSTEM_HEADER (olddecl
)
2800 && DECL_SOURCE_LINE (olddecl
) != 0))
2802 && ! compexcepttypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2804 cp_pedwarn ("declaration of `%D' throws different exceptions",
2806 cp_pedwarn_at ("previous declaration here", olddecl
);
2809 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2811 /* Lay the type out, unless already done. */
2812 if (oldtype
!= TREE_TYPE (newdecl
)
2813 && TREE_TYPE (newdecl
) != error_mark_node
2814 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2815 layout_type (TREE_TYPE (newdecl
));
2817 if ((TREE_CODE (newdecl
) == VAR_DECL
2818 || TREE_CODE (newdecl
) == PARM_DECL
2819 || TREE_CODE (newdecl
) == RESULT_DECL
2820 || TREE_CODE (newdecl
) == FIELD_DECL
2821 || TREE_CODE (newdecl
) == TYPE_DECL
)
2822 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2823 layout_decl (newdecl
, 0);
2825 /* Merge the type qualifiers. */
2826 if (TREE_READONLY (newdecl
))
2827 TREE_READONLY (olddecl
) = 1;
2828 if (TREE_THIS_VOLATILE (newdecl
))
2829 TREE_THIS_VOLATILE (olddecl
) = 1;
2831 /* Merge the initialization information. */
2832 if (DECL_INITIAL (newdecl
) == NULL_TREE
2833 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2835 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2836 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
2837 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
2840 /* Merge the section attribute.
2841 We want to issue an error if the sections conflict but that must be
2842 done later in decl_attributes since we are called before attributes
2844 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2845 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2847 /* Keep the old rtl since we can safely use it, unless it's the
2848 call to abort() used for abstract virtuals. */
2849 if ((DECL_LANG_SPECIFIC (olddecl
)
2850 && !DECL_ABSTRACT_VIRTUAL_P (olddecl
))
2851 || DECL_RTL (olddecl
) != DECL_RTL (abort_fndecl
))
2852 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
2856 /* If cannot merge, then use the new type and qualifiers,
2857 and don't preserve the old rtl. */
2860 /* Clean out any memory we had of the old declaration. */
2861 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2863 TREE_VALUE (oldstatic
) = error_mark_node
;
2865 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2866 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2867 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2868 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2871 /* Merge the storage class information. */
2872 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
2873 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
2874 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2875 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2876 if (! DECL_EXTERNAL (olddecl
))
2877 DECL_EXTERNAL (newdecl
) = 0;
2879 if (DECL_LANG_SPECIFIC (newdecl
))
2881 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2882 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2883 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2886 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2888 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2889 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2891 /* If newdecl is not a specialization, then it is not a
2892 template-related function at all. And that means that we
2893 shoud have exited above, returning 0. */
2894 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
2897 if (TREE_USED (olddecl
))
2898 /* From [temp.expl.spec]:
2900 If a template, a member template or the member of a class
2901 template is explicitly specialized then that
2902 specialization shall be declared before the first use of
2903 that specialization that would cause an implicit
2904 instantiation to take place, in every translation unit in
2905 which such a use occurs. */
2906 cp_error ("explicit specialization of %D after first use",
2909 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2911 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
2913 /* If either decl says `inline', this fn is inline, unless its
2914 definition was passed already. */
2915 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
2916 DECL_INLINE (olddecl
) = 1;
2917 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
2921 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
2922 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
2923 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
2925 if (! types_match
|| new_defines_function
)
2927 /* These need to be copied so that the names are available. */
2928 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2929 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2931 if (new_defines_function
)
2932 /* If defining a function declared with other language
2933 linkage, use the previously declared language linkage. */
2934 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
2937 /* If redeclaring a builtin function, and not a definition,
2938 it stays built in. */
2939 if (DECL_BUILT_IN (olddecl
))
2941 DECL_BUILT_IN (newdecl
) = 1;
2942 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2943 /* If we're keeping the built-in definition, keep the rtl,
2944 regardless of declaration matches. */
2945 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
2948 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
2950 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2951 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
2952 /* Previously saved insns go together with
2953 the function's previous definition. */
2954 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2955 /* Don't clear out the arguments if we're redefining a function. */
2956 if (DECL_ARGUMENTS (olddecl
))
2957 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2959 if (DECL_LANG_SPECIFIC (olddecl
))
2960 DECL_MAIN_VARIANT (newdecl
) = DECL_MAIN_VARIANT (olddecl
);
2963 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2965 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2968 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2970 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
)
2971 = DECL_TEMPLATE_SPECIALIZATIONS (olddecl
);
2972 if (DECL_CHAIN (newdecl
) == NULL_TREE
)
2973 DECL_CHAIN (newdecl
) = DECL_CHAIN (olddecl
);
2976 /* Now preserve various other info from the definition. */
2977 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2978 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2979 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2980 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
2982 /* Don't really know how much of the language-specific
2983 values we should copy from old to new. */
2984 if (DECL_LANG_SPECIFIC (olddecl
))
2986 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2987 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
2988 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2989 if (DECL_TEMPLATE_INFO (newdecl
) == NULL_TREE
)
2991 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2992 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2996 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2999 struct lang_decl
*ol
= DECL_LANG_SPECIFIC (olddecl
);
3000 struct lang_decl
*nl
= DECL_LANG_SPECIFIC (newdecl
);
3002 function_size
= sizeof (struct tree_decl
);
3004 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3005 (char *) olddecl
+ sizeof (struct tree_common
),
3006 function_size
- sizeof (struct tree_common
));
3008 /* Can we safely free the storage used by newdecl? */
3010 #define ROUND(x) ((x + obstack_alignment_mask (&permanent_obstack)) \
3011 & ~ obstack_alignment_mask (&permanent_obstack))
3013 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3015 /* If newdecl is a template instantiation, it is possible that
3016 the following sequence of events has occurred:
3018 o A friend function was declared in a class template. The
3019 class template was instantiated.
3021 o The instantiation of the friend declaration was
3022 recorded on the instantiation list, and is newdecl.
3024 o Later, however, instantiate_class_template called pushdecl
3025 on the newdecl to perform name injection. But, pushdecl in
3026 turn called duplicate_decls when it discovered that another
3027 declaration of a global function with the same name already
3030 o Here, in duplicate_decls, we decided to clobber newdecl.
3032 If we're going to do that, we'd better make sure that
3033 olddecl, and not newdecl, is on the list of
3034 instantiations so that if we try to do the instantiation
3035 again we won't get the clobbered declaration. */
3037 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3038 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3040 for (; decls
; decls
= TREE_CHAIN (decls
))
3041 if (TREE_VALUE (decls
) == newdecl
)
3042 TREE_VALUE (decls
) = olddecl
;
3045 if ((char *)newdecl
+ ROUND (function_size
)
3046 + ROUND (sizeof (struct lang_decl
))
3047 == obstack_next_free (&permanent_obstack
))
3049 DECL_MAIN_VARIANT (newdecl
) = olddecl
;
3050 DECL_LANG_SPECIFIC (olddecl
) = ol
;
3051 bcopy ((char *)nl
, (char *)ol
, sizeof (struct lang_decl
));
3053 obstack_free (&permanent_obstack
, newdecl
);
3055 else if (LANG_DECL_PERMANENT (ol
) && ol
!= nl
)
3057 if (DECL_MAIN_VARIANT (olddecl
) == olddecl
)
3059 /* Save these lang_decls that would otherwise be lost. */
3060 extern tree free_lang_decl_chain
;
3061 tree free_lang_decl
= (tree
) ol
;
3063 if (DECL_LANG_SPECIFIC (olddecl
) == ol
)
3066 TREE_CHAIN (free_lang_decl
) = free_lang_decl_chain
;
3067 free_lang_decl_chain
= free_lang_decl
;
3071 /* Storage leak. */;
3077 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3078 (char *) olddecl
+ sizeof (struct tree_common
),
3079 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3080 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3083 DECL_UID (olddecl
) = olddecl_uid
;
3085 DECL_FRIEND_P (olddecl
) = 1;
3090 /* Record a decl-node X as belonging to the current lexical scope.
3091 Check for errors (such as an incompatible declaration for the same
3092 name already seen in the same scope).
3094 Returns either X or an old decl for the same name.
3095 If an old decl is returned, it may have been smashed
3096 to agree with what X says. */
3103 register tree name
= DECL_ASSEMBLER_NAME (x
);
3104 register struct binding_level
*b
= current_binding_level
;
3106 if (x
!= current_function_decl
3107 /* Don't change DECL_CONTEXT of virtual methods. */
3108 && (TREE_CODE (x
) != FUNCTION_DECL
|| !DECL_VIRTUAL_P (x
))
3109 && ! DECL_CONTEXT (x
))
3110 DECL_CONTEXT (x
) = current_function_decl
;
3111 /* A local declaration for a function doesn't constitute nesting. */
3112 if (TREE_CODE (x
) == FUNCTION_DECL
&& DECL_INITIAL (x
) == 0)
3113 DECL_CONTEXT (x
) = 0;
3115 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3116 compiler wants to use. */
3117 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
3118 || TREE_CODE (x
) == NAMESPACE_DECL
|| TREE_CODE (x
) == TEMPLATE_TYPE_PARM
3119 || TREE_CODE (x
) == TEMPLATE_TEMPLATE_PARM
)
3120 name
= DECL_NAME (x
);
3125 /* Not needed...see below. */
3129 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3130 name
= TREE_OPERAND (name
, 0);
3132 t
= lookup_name_current_level (name
);
3133 if (t
== error_mark_node
)
3135 /* error_mark_node is 0 for a while during initialization! */
3137 cp_error_at ("`%#D' used prior to declaration", x
);
3140 else if (t
!= NULL_TREE
)
3143 /* This is turned off until I have time to do it right (bpk). */
3144 /* With the code below that uses it... */
3145 file
= DECL_SOURCE_FILE (t
);
3146 line
= DECL_SOURCE_LINE (t
);
3148 if (TREE_CODE (t
) == PARM_DECL
)
3150 if (DECL_CONTEXT (t
) == NULL_TREE
)
3151 fatal ("parse errors have confused me too much");
3153 /* Check for duplicate params. */
3154 if (duplicate_decls (x
, t
))
3157 else if (((TREE_CODE (x
) == FUNCTION_DECL
&& DECL_LANGUAGE (x
) == lang_c
)
3158 || DECL_FUNCTION_TEMPLATE_P (x
))
3159 && is_overloaded_fn (t
))
3160 /* don't do anything just yet */;
3161 else if (t
== wchar_decl_node
)
3163 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3164 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3166 /* Throw away the redeclaration. */
3169 else if (TREE_CODE (t
) != TREE_CODE (x
))
3171 if ((TREE_CODE (t
) == TYPE_DECL
&& DECL_ARTIFICIAL (t
)
3172 && TREE_CODE (x
) != TYPE_DECL
3173 && ! (TREE_CODE (x
) == TEMPLATE_DECL
3174 && TREE_CODE (DECL_TEMPLATE_RESULT (x
)) == TYPE_DECL
))
3175 || (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3176 && TREE_CODE (t
) != TYPE_DECL
3177 && ! (TREE_CODE (t
) == TEMPLATE_DECL
3178 && (TREE_CODE (DECL_TEMPLATE_RESULT (t
))
3181 /* We do nothing special here, because C++ does such nasty
3182 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3183 get shadowed, and know that if we need to find a TYPE_DECL
3184 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3185 slot of the identifier. */
3188 else if (duplicate_decls (x
, t
))
3191 else if (duplicate_decls (x
, t
))
3194 /* This is turned off until I have time to do it right (bpk). */
3196 /* Also warn if they did a prototype with `static' on it, but
3197 then later left the `static' off. */
3198 if (! TREE_PUBLIC (name
) && TREE_PUBLIC (x
))
3200 if (DECL_LANG_SPECIFIC (t
) && DECL_FRIEND_P (t
))
3205 cp_warning ("`static' missing from declaration of `%D'",
3207 warning_with_file_and_line (file
, line
,
3208 "previous declaration of `%s'",
3209 decl_as_string (t
, 0));
3212 /* Now fix things so it'll do what they expect. */
3213 if (current_function_decl
)
3214 TREE_PUBLIC (current_function_decl
) = 0;
3216 /* Due to interference in memory reclamation (X may be
3217 obstack-deallocated at this point), we must guard against
3218 one really special case. [jason: This should be handled
3219 by start_function] */
3220 if (current_function_decl
== x
)
3221 current_function_decl
= t
;
3223 if (TREE_CODE (t
) == TYPE_DECL
)
3224 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3225 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3226 check_default_args (t
);
3232 if (TREE_CODE (x
) == FUNCTION_DECL
&& ! DECL_FUNCTION_MEMBER_P (x
))
3234 t
= push_overloaded_decl (x
, 1);
3235 if (t
!= x
|| DECL_LANGUAGE (x
) == lang_c
)
3238 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_CONTEXT (x
) == NULL_TREE
)
3239 return push_overloaded_decl (x
, 0);
3241 /* If declaring a type as a typedef, and the type has no known
3242 typedef name, install this TYPE_DECL as its typedef name. */
3243 if (TREE_CODE (x
) == TYPE_DECL
)
3245 tree type
= TREE_TYPE (x
);
3246 tree name
= (type
!= error_mark_node
) ? TYPE_NAME (type
) : x
;
3248 if (name
== NULL_TREE
|| TREE_CODE (name
) != TYPE_DECL
)
3250 /* If these are different names, and we're at the global
3251 binding level, make two equivalent definitions. */
3253 if (global_bindings_p ())
3254 TYPE_NAME (type
) = x
;
3256 my_friendly_assert (TREE_CODE (name
) == TYPE_DECL
, 140);
3258 if (type
!= error_mark_node
3260 && TYPE_IDENTIFIER (type
))
3261 set_identifier_type_value_with_scope (DECL_NAME (x
), type
, b
);
3264 /* Multiple external decls of the same identifier ought to match.
3266 We get warnings about inline functions where they are defined.
3267 We get warnings about other functions from push_overloaded_decl.
3269 Avoid duplicate warnings where they are used. */
3270 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3274 if (IDENTIFIER_GLOBAL_VALUE (name
) != NULL_TREE
3275 && (DECL_EXTERNAL (IDENTIFIER_GLOBAL_VALUE (name
))
3276 || TREE_PUBLIC (IDENTIFIER_GLOBAL_VALUE (name
))))
3277 decl
= IDENTIFIER_GLOBAL_VALUE (name
);
3282 /* If different sort of thing, we already gave an error. */
3283 && TREE_CODE (decl
) == TREE_CODE (x
)
3284 && ! comptypes (TREE_TYPE (x
), TREE_TYPE (decl
), 1))
3286 cp_pedwarn ("type mismatch with previous external decl", x
);
3287 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
3291 /* This name is new in its binding level.
3292 Install the new declaration and return it. */
3293 if (b
== global_binding_level
)
3295 /* Install a global value. */
3297 /* If the first global decl has external linkage,
3298 warn if we later see static one. */
3299 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
3300 TREE_PUBLIC (name
) = 1;
3302 /* Don't install an artificial TYPE_DECL if we already have
3303 another _DECL with that name. */
3304 if (TREE_CODE (x
) != TYPE_DECL
3306 || ! DECL_ARTIFICIAL (x
))
3307 IDENTIFIER_GLOBAL_VALUE (name
) = x
;
3309 /* Don't forget if the function was used via an implicit decl. */
3310 if (IDENTIFIER_IMPLICIT_DECL (name
)
3311 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
3314 /* Don't forget if its address was taken in that way. */
3315 if (IDENTIFIER_IMPLICIT_DECL (name
)
3316 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
3317 TREE_ADDRESSABLE (x
) = 1;
3319 /* Warn about mismatches against previous implicit decl. */
3320 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
3321 /* If this real decl matches the implicit, don't complain. */
3322 && ! (TREE_CODE (x
) == FUNCTION_DECL
3323 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
3325 ("`%D' was previously implicitly declared to return `int'", x
);
3327 /* If new decl is `static' and an `extern' was seen previously,
3329 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
3330 warn_extern_redeclared_static (x
, t
);
3334 /* Here to install a non-global value. */
3335 tree oldlocal
= IDENTIFIER_LOCAL_VALUE (name
);
3336 tree oldglobal
= IDENTIFIER_GLOBAL_VALUE (name
);
3338 /* Don't install an artificial TYPE_DECL if we already have
3339 another _DECL with that name. */
3340 if (TREE_CODE (x
) != TYPE_DECL
3342 || ! DECL_ARTIFICIAL (x
))
3344 b
->shadowed
= tree_cons (name
, oldlocal
, b
->shadowed
);
3345 IDENTIFIER_LOCAL_VALUE (name
) = x
;
3348 /* If this is a TYPE_DECL, push it into the type value slot. */
3349 if (TREE_CODE (x
) == TYPE_DECL
)
3350 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
), b
);
3352 /* Clear out any TYPE_DECL shadowed by a namespace so that
3353 we won't think this is a type. The C struct hack doesn't
3354 go through namespaces. */
3355 if (TREE_CODE (x
) == NAMESPACE_DECL
)
3356 set_identifier_type_value_with_scope (name
, NULL_TREE
, b
);
3358 /* If this is an extern function declaration, see if we
3359 have a global definition or declaration for the function. */
3360 if (oldlocal
== NULL_TREE
3361 && DECL_EXTERNAL (x
)
3362 && oldglobal
!= NULL_TREE
3363 && TREE_CODE (x
) == FUNCTION_DECL
3364 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
3366 /* We have one. Their types must agree. */
3367 if (decls_match (x
, oldglobal
))
3371 cp_warning ("extern declaration of `%#D' doesn't match", x
);
3372 cp_warning_at ("global declaration `%#D'", oldglobal
);
3375 /* If we have a local external declaration,
3376 and no file-scope declaration has yet been seen,
3377 then if we later have a file-scope decl it must not be static. */
3378 if (oldlocal
== NULL_TREE
3379 && oldglobal
== NULL_TREE
3380 && DECL_EXTERNAL (x
)
3383 TREE_PUBLIC (name
) = 1;
3386 if (DECL_FROM_INLINE (x
))
3387 /* Inline decls shadow nothing. */;
3389 /* Warn if shadowing an argument at the top level of the body. */
3390 else if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
3391 && TREE_CODE (oldlocal
) == PARM_DECL
3392 && TREE_CODE (x
) != PARM_DECL
)
3394 /* Go to where the parms should be and see if we
3396 struct binding_level
*b
= current_binding_level
->level_chain
;
3402 if (b
->parm_flag
== 1)
3403 cp_error ("declaration of `%#D' shadows a parameter", name
);
3405 else if (warn_shadow
&& oldlocal
!= NULL_TREE
&& b
->is_for_scope
3406 && !DECL_DEAD_FOR_LOCAL (oldlocal
))
3408 warning ("variable `%s' shadows local",
3409 IDENTIFIER_POINTER (name
));
3410 cp_warning_at (" this is the shadowed declaration", oldlocal
);
3412 /* Maybe warn if shadowing something else. */
3413 else if (warn_shadow
&& !DECL_EXTERNAL (x
)
3414 /* No shadow warnings for internally generated vars. */
3415 && ! DECL_ARTIFICIAL (x
)
3416 /* No shadow warnings for vars made for inlining. */
3417 && ! DECL_FROM_INLINE (x
))
3419 char *warnstring
= NULL
;
3421 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
3422 warnstring
= "declaration of `%s' shadows a parameter";
3423 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
3424 && current_class_ptr
3425 && !TREE_STATIC (name
))
3426 warnstring
= "declaration of `%s' shadows a member of `this'";
3427 else if (oldlocal
!= NULL_TREE
)
3428 warnstring
= "declaration of `%s' shadows previous local";
3429 else if (oldglobal
!= NULL_TREE
)
3430 warnstring
= "declaration of `%s' shadows global declaration";
3433 warning (warnstring
, IDENTIFIER_POINTER (name
));
3437 if (TREE_CODE (x
) == FUNCTION_DECL
)
3438 check_default_args (x
);
3440 /* Keep count of variables in this level with incomplete type. */
3441 if (TREE_CODE (x
) == VAR_DECL
3442 && TREE_TYPE (x
) != error_mark_node
3443 && ((TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
3444 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
3445 /* RTTI TD entries are created while defining the type_info. */
3446 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
3447 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
3448 b
->incomplete
= tree_cons (NULL_TREE
, x
, b
->incomplete
);
3451 /* Put decls on list in reverse order.
3452 We will reverse them later if necessary. */
3453 TREE_CHAIN (x
) = b
->names
;
3455 if (! (b
!= global_binding_level
|| TREE_PERMANENT (x
)))
3456 my_friendly_abort (124);
3461 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
3462 caller to set DECL_CONTEXT properly. */
3465 pushdecl_with_scope (x
, level
)
3467 struct binding_level
*level
;
3469 register struct binding_level
*b
= current_binding_level
;
3470 tree function_decl
= current_function_decl
;
3472 current_function_decl
= NULL_TREE
;
3473 current_binding_level
= level
;
3475 current_binding_level
= b
;
3476 current_function_decl
= function_decl
;
3480 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
3484 pushdecl_top_level (x
)
3487 register struct binding_level
*b
= inner_binding_level
;
3488 register tree t
= pushdecl_with_scope (x
, global_binding_level
);
3490 /* Now, the type_shadowed stack may screw us. Munge it so it does
3492 if (TREE_CODE (x
) == TYPE_DECL
)
3494 tree name
= DECL_NAME (x
);
3496 tree
*ptr
= (tree
*)0;
3497 for (; b
!= global_binding_level
; b
= b
->level_chain
)
3499 tree shadowed
= b
->type_shadowed
;
3500 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
3501 if (TREE_PURPOSE (shadowed
) == name
)
3503 ptr
= &TREE_VALUE (shadowed
);
3504 /* Can't break out of the loop here because sometimes
3505 a binding level will have duplicate bindings for
3506 PT names. It's gross, but I haven't time to fix it. */
3509 newval
= TREE_TYPE (x
);
3510 if (ptr
== (tree
*)0)
3512 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3513 up here if this is changed to an assertion. --KR */
3514 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
3524 /* Like push_overloaded_decl, only it places X in GLOBAL_BINDING_LEVEL,
3528 push_overloaded_decl_top_level (x
, forget
)
3532 struct binding_level
*b
= current_binding_level
;
3534 current_binding_level
= global_binding_level
;
3535 push_overloaded_decl (x
, forget
);
3536 current_binding_level
= b
;
3539 /* Make the declaration of X appear in CLASS scope. */
3542 pushdecl_class_level (x
)
3545 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
3546 scope looks for the pre-mangled name. */
3547 register tree name
= DECL_NAME (x
);
3551 if (TYPE_BEING_DEFINED (current_class_type
))
3553 /* Check for inconsistent use of this name in the class body.
3554 Types, enums, and static vars are checked here; other
3555 members are checked in finish_struct. */
3556 tree icv
= IDENTIFIER_CLASS_VALUE (name
);
3559 /* Don't complain about inherited names. */
3560 && id_in_current_class (name
)
3561 /* Or shadowed tags. */
3562 && !(TREE_CODE (icv
) == TYPE_DECL
3563 && DECL_CONTEXT (icv
) == current_class_type
))
3565 cp_error ("declaration of identifier `%D' as `%#D'", name
, x
);
3566 cp_error_at ("conflicts with previous use in class as `%#D'",
3571 push_class_level_binding (name
, x
);
3572 if (TREE_CODE (x
) == TYPE_DECL
)
3574 set_identifier_type_value (name
, TREE_TYPE (x
));
3581 /* This function is used to push the mangled decls for nested types into
3582 the appropriate scope. Previously pushdecl_top_level was used, but that
3583 is incorrect for members of local classes. */
3586 pushdecl_nonclass_level (x
)
3589 struct binding_level
*b
= current_binding_level
;
3591 my_friendly_assert (b
->parm_flag
!= 2, 180);
3594 /* Get out of template binding levels */
3595 while (b
->pseudo_global
)
3599 pushdecl_with_scope (x
, b
);
3603 /* Make the declaration(s) of X appear in CLASS scope
3604 under the name NAME. */
3607 push_class_level_binding (name
, x
)
3611 /* The class_binding_level will be NULL if x is a template
3612 parameter name in a member template. */
3613 if (!class_binding_level
)
3616 if (TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
3617 && purpose_member (name
, class_binding_level
->class_shadowed
))
3620 maybe_push_cache_obstack ();
3621 class_binding_level
->class_shadowed
3622 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
3623 class_binding_level
->class_shadowed
);
3625 IDENTIFIER_CLASS_VALUE (name
) = x
;
3626 obstack_ptr_grow (&decl_obstack
, x
);
3629 /* Tell caller how to interpret a TREE_LIST which contains
3630 chains of FUNCTION_DECLS. */
3633 overloaded_globals_p (list
)
3636 my_friendly_assert (TREE_CODE (list
) == TREE_LIST
, 142);
3638 /* Don't commit caller to seeing them as globals. */
3639 if (TREE_NONLOCAL_FLAG (list
))
3641 /* Do commit caller to not seeing them as globals. */
3642 if (TREE_CODE (TREE_VALUE (list
)) == TREE_LIST
)
3644 /* Do commit caller to seeing them as globals. */
3648 /* DECL is a FUNCTION_DECL which may have other definitions already in
3649 place. We get around this by making the value of the identifier point
3650 to a list of all the things that want to be referenced by that name. It
3651 is then up to the users of that name to decide what to do with that
3654 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
3655 slot. It is dealt with the same way.
3657 The value returned may be a previous declaration if we guessed wrong
3658 about what language DECL should belong to (C or C++). Otherwise,
3659 it's always DECL (and never something that's not a _DECL). */
3662 push_overloaded_decl (decl
, forgettable
)
3666 tree orig_name
= DECL_NAME (decl
);
3668 int doing_global
= (global_bindings_p () || ! forgettable
);
3672 old
= IDENTIFIER_GLOBAL_VALUE (orig_name
);
3673 if (old
&& TREE_CODE (old
) == FUNCTION_DECL
3674 && DECL_ARTIFICIAL (old
)
3675 && (DECL_BUILT_IN (old
) || DECL_BUILT_IN_NONANSI (old
)))
3677 if (duplicate_decls (decl
, old
))
3684 old
= IDENTIFIER_LOCAL_VALUE (orig_name
);
3686 if (! purpose_member (orig_name
, current_binding_level
->shadowed
))
3688 current_binding_level
->shadowed
3689 = tree_cons (orig_name
, old
, current_binding_level
->shadowed
);
3696 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
3698 tree t
= TREE_TYPE (old
);
3699 if (IS_AGGR_TYPE (t
) && warn_shadow
3700 && (! DECL_IN_SYSTEM_HEADER (decl
)
3701 || ! DECL_IN_SYSTEM_HEADER (old
)))
3702 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
3705 else if (is_overloaded_fn (old
))
3709 for (tmp
= get_first_fn (old
); tmp
; tmp
= DECL_CHAIN (tmp
))
3710 if (decl
== tmp
|| duplicate_decls (decl
, tmp
))
3715 cp_error_at ("previous non-function declaration `%#D'", old
);
3716 cp_error ("conflicts with function declaration `%#D'", decl
);
3721 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
3723 if (old
&& is_overloaded_fn (old
))
3724 DECL_CHAIN (decl
) = get_first_fn (old
);
3726 DECL_CHAIN (decl
) = NULL_TREE
;
3727 old
= tree_cons (orig_name
, decl
, NULL_TREE
);
3728 TREE_TYPE (old
) = unknown_type_node
;
3731 /* orig_name is not ambiguous. */
3735 IDENTIFIER_GLOBAL_VALUE (orig_name
) = old
;
3737 IDENTIFIER_LOCAL_VALUE (orig_name
) = old
;
3742 /* Generate an implicit declaration for identifier FUNCTIONID
3743 as a function of type int (). Print a warning if appropriate. */
3746 implicitly_declare (functionid
)
3750 int temp
= allocation_temporary_p ();
3752 push_obstacks_nochange ();
3754 /* Save the decl permanently so we can warn if definition follows.
3755 In ANSI C, warn_implicit is usually false, so the saves little space.
3756 But in C++, it's usually true, hence the extra code. */
3757 if (temp
&& (! warn_implicit
|| toplevel_bindings_p ()))
3758 end_temporary_allocation ();
3760 /* We used to reuse an old implicit decl here,
3761 but this loses with inline functions because it can clobber
3762 the saved decl chains. */
3763 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
3765 DECL_EXTERNAL (decl
) = 1;
3766 TREE_PUBLIC (decl
) = 1;
3768 /* ANSI standard says implicit declarations are in the innermost block.
3769 So we record the decl in the standard fashion. */
3771 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
3774 /* Only one warning per identifier. */
3775 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
3777 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
3780 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
3787 /* Return zero if the declaration NEWDECL is valid
3788 when the declaration OLDDECL (assumed to be for the same name)
3789 has already been seen.
3790 Otherwise return an error message format string with a %s
3791 where the identifier should go. */
3794 redeclaration_error_message (newdecl
, olddecl
)
3795 tree newdecl
, olddecl
;
3797 if (TREE_CODE (newdecl
) == TYPE_DECL
)
3799 /* Because C++ can put things into name space for free,
3800 constructs like "typedef struct foo { ... } foo"
3801 would look like an erroneous redeclaration. */
3802 if (comptypes (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
), 0))
3805 return "redefinition of `%#D'";
3807 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3809 /* If this is a pure function, its olddecl will actually be
3810 the original initialization to `0' (which we force to call
3811 abort()). Don't complain about redefinition in this case. */
3812 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_ABSTRACT_VIRTUAL_P (olddecl
))
3815 /* We'll complain about linkage mismatches in
3816 warn_extern_redeclared_static. */
3818 /* defining the same name twice is no good. */
3819 if (DECL_INITIAL (olddecl
) != NULL_TREE
3820 && DECL_INITIAL (newdecl
) != NULL_TREE
)
3822 if (DECL_NAME (olddecl
) == NULL_TREE
)
3823 return "`%#D' not declared in class";
3825 return "redefinition of `%#D'";
3829 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3831 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3832 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
3833 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
3834 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
3835 && TYPE_SIZE (TREE_TYPE (newdecl
))
3836 && TYPE_SIZE (TREE_TYPE (olddecl
))))
3837 return "redefinition of `%#D'";
3840 else if (toplevel_bindings_p ())
3842 /* Objects declared at top level: */
3843 /* If at least one is a reference, it's ok. */
3844 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
3846 /* Reject two definitions. */
3847 return "redefinition of `%#D'";
3851 /* Objects declared with block scope: */
3852 /* Reject two definitions, and reject a definition
3853 together with an external reference. */
3854 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
3855 return "redeclaration of `%#D'";
3860 /* Get the LABEL_DECL corresponding to identifier ID as a label.
3861 Create one if none exists so far for the current function.
3862 This function is called for both label definitions and label references. */
3868 register tree decl
= IDENTIFIER_LABEL_VALUE (id
);
3870 if (current_function_decl
== NULL_TREE
)
3872 error ("label `%s' referenced outside of any function",
3873 IDENTIFIER_POINTER (id
));
3877 if ((decl
== NULL_TREE
3878 || DECL_SOURCE_LINE (decl
) == 0)
3879 && (named_label_uses
== NULL
3880 || named_label_uses
->names_in_scope
!= current_binding_level
->names
3881 || named_label_uses
->label_decl
!= decl
))
3883 struct named_label_list
*new_ent
;
3885 = (struct named_label_list
*)oballoc (sizeof (struct named_label_list
));
3886 new_ent
->label_decl
= decl
;
3887 new_ent
->names_in_scope
= current_binding_level
->names
;
3888 new_ent
->binding_level
= current_binding_level
;
3889 new_ent
->lineno_o_goto
= lineno
;
3890 new_ent
->filename_o_goto
= input_filename
;
3891 new_ent
->next
= named_label_uses
;
3892 named_label_uses
= new_ent
;
3895 /* Use a label already defined or ref'd with this name. */
3896 if (decl
!= NULL_TREE
)
3898 /* But not if it is inherited and wasn't declared to be inheritable. */
3899 if (DECL_CONTEXT (decl
) != current_function_decl
3900 && ! C_DECLARED_LABEL_FLAG (decl
))
3901 return shadow_label (id
);
3905 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
3907 /* Make sure every label has an rtx. */
3910 /* A label not explicitly declared must be local to where it's ref'd. */
3911 DECL_CONTEXT (decl
) = current_function_decl
;
3913 DECL_MODE (decl
) = VOIDmode
;
3915 /* Say where one reference is to the label,
3916 for the sake of the error if it is not defined. */
3917 DECL_SOURCE_LINE (decl
) = lineno
;
3918 DECL_SOURCE_FILE (decl
) = input_filename
;
3920 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
3922 named_labels
= tree_cons (NULL_TREE
, decl
, named_labels
);
3923 named_label_uses
->label_decl
= decl
;
3928 /* Make a label named NAME in the current function,
3929 shadowing silently any that may be inherited from containing functions
3930 or containing scopes.
3932 Note that valid use, if the label being shadowed
3933 comes from another scope in the same function,
3934 requires calling declare_nonlocal_label right away. */
3940 register tree decl
= IDENTIFIER_LABEL_VALUE (name
);
3942 if (decl
!= NULL_TREE
)
3944 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
3945 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
3946 SET_IDENTIFIER_LABEL_VALUE (decl
, NULL_TREE
);
3949 return lookup_label (name
);
3952 /* Define a label, specifying the location in the source file.
3953 Return the LABEL_DECL node for the label, if the definition is valid.
3954 Otherwise return 0. */
3957 define_label (filename
, line
, name
)
3964 if (minimal_parse_mode
)
3966 push_obstacks (&permanent_obstack
, &permanent_obstack
);
3967 decl
= build_decl (LABEL_DECL
, name
, void_type_node
);
3969 DECL_SOURCE_LINE (decl
) = line
;
3970 DECL_SOURCE_FILE (decl
) = filename
;
3975 decl
= lookup_label (name
);
3977 /* After labels, make any new cleanups go into their
3978 own new (temporary) binding contour. */
3979 current_binding_level
->more_cleanups_ok
= 0;
3981 /* If label with this name is known from an outer context, shadow it. */
3982 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) != current_function_decl
)
3984 shadowed_labels
= tree_cons (NULL_TREE
, decl
, shadowed_labels
);
3985 SET_IDENTIFIER_LABEL_VALUE (name
, NULL_TREE
);
3986 decl
= lookup_label (name
);
3989 if (name
== get_identifier ("wchar_t"))
3990 cp_pedwarn ("label named wchar_t");
3992 if (DECL_INITIAL (decl
) != NULL_TREE
)
3994 cp_error ("duplicate label `%D'", decl
);
3999 struct named_label_list
*uses
, *prev
;
4002 /* Mark label as having been defined. */
4003 DECL_INITIAL (decl
) = error_mark_node
;
4004 /* Say where in the source. */
4005 DECL_SOURCE_FILE (decl
) = filename
;
4006 DECL_SOURCE_LINE (decl
) = line
;
4009 uses
= named_label_uses
;
4010 while (uses
!= NULL
)
4011 if (uses
->label_decl
== decl
)
4013 struct binding_level
*b
= current_binding_level
;
4016 tree new_decls
= b
->names
;
4017 tree old_decls
= (b
== uses
->binding_level
)
4018 ? uses
->names_in_scope
: NULL_TREE
;
4019 while (new_decls
!= old_decls
)
4021 if (TREE_CODE (new_decls
) == VAR_DECL
4022 /* Don't complain about crossing initialization
4023 of internal entities. They can't be accessed,
4024 and they should be cleaned up
4025 by the time we get to the label. */
4026 && ! DECL_ARTIFICIAL (new_decls
)
4027 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4028 && DECL_INITIAL (new_decls
) != error_mark_node
)
4029 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4033 cp_error ("jump to label `%D'", decl
);
4034 error_with_file_and_line (uses
->filename_o_goto
,
4035 uses
->lineno_o_goto
,
4039 cp_error_at (" crosses initialization of `%#D'",
4042 new_decls
= TREE_CHAIN (new_decls
);
4044 if (b
== uses
->binding_level
)
4050 prev
->next
= uses
->next
;
4052 named_label_uses
= uses
->next
;
4061 current_function_return_value
= NULL_TREE
;
4068 struct binding_level
*level
;
4069 struct cp_switch
*next
;
4072 static struct cp_switch
*switch_stack
;
4078 = (struct cp_switch
*) oballoc (sizeof (struct cp_switch
));
4079 p
->level
= current_binding_level
;
4080 p
->next
= switch_stack
;
4087 switch_stack
= switch_stack
->next
;
4090 /* Same, but for CASE labels. If DECL is NULL_TREE, it's the default. */
4091 /* XXX Note decl is never actually used. (bpk) */
4094 define_case_label (decl
)
4097 tree cleanup
= last_cleanup_this_contour ();
4098 struct binding_level
*b
= current_binding_level
;
4103 static int explained
= 0;
4104 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup
));
4105 warning ("where case label appears here");
4108 warning ("(enclose actions of previous case statements requiring");
4109 warning ("destructors in their own binding contours.)");
4114 for (; b
&& b
!= switch_stack
->level
; b
= b
->level_chain
)
4116 tree new_decls
= b
->names
;
4117 for (; new_decls
; new_decls
= TREE_CHAIN (new_decls
))
4119 if (TREE_CODE (new_decls
) == VAR_DECL
4120 /* Don't complain about crossing initialization
4121 of internal entities. They can't be accessed,
4122 and they should be cleaned up
4123 by the time we get to the label. */
4124 && ! DECL_ARTIFICIAL (new_decls
)
4125 && ((DECL_INITIAL (new_decls
) != NULL_TREE
4126 && DECL_INITIAL (new_decls
) != error_mark_node
)
4127 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls
))))
4130 error ("jump to case label");
4132 cp_error_at (" crosses initialization of `%#D'",
4138 /* After labels, make any new cleanups go into their
4139 own new (temporary) binding contour. */
4141 current_binding_level
->more_cleanups_ok
= 0;
4142 current_function_return_value
= NULL_TREE
;
4145 /* Return the list of declarations of the current level.
4146 Note that this list is in reverse order unless/until
4147 you nreverse it; and when you do nreverse it, you must
4148 store the result back using `storedecls' or you will lose. */
4153 return current_binding_level
->names
;
4156 /* Return the list of type-tags (for structs, etc) of the current level. */
4161 return current_binding_level
->tags
;
4164 /* Store the list of declarations of the current level.
4165 This is done for the parameter declarations of a function being defined,
4166 after they are modified in the light of any missing parameters. */
4172 current_binding_level
->names
= decls
;
4175 /* Similarly, store the list of tags of the current level. */
4181 current_binding_level
->tags
= tags
;
4184 /* Given NAME, an IDENTIFIER_NODE,
4185 return the structure (or union or enum) definition for that name.
4186 Searches binding levels from BINDING_LEVEL up to the global level.
4187 If THISLEVEL_ONLY is nonzero, searches only the specified context
4188 (but skips any tag-transparent contexts to find one that is
4189 meaningful for tags).
4190 FORM says which kind of type the caller wants;
4191 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4192 If the wrong kind of type is found, and it's not a template, an error is
4196 lookup_tag (form
, name
, binding_level
, thislevel_only
)
4197 enum tree_code form
;
4199 struct binding_level
*binding_level
;
4202 register struct binding_level
*level
;
4204 for (level
= binding_level
; level
; level
= level
->level_chain
)
4207 if (ANON_AGGRNAME_P (name
))
4208 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4210 /* There's no need for error checking here, because
4211 anon names are unique throughout the compilation. */
4212 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
4213 return TREE_VALUE (tail
);
4216 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4218 if (TREE_PURPOSE (tail
) == name
)
4220 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
4221 /* Should tighten this up; it'll probably permit
4222 UNION_TYPE and a struct template, for example. */
4224 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
4226 /* Definition isn't the kind we were looking for. */
4227 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
4231 return TREE_VALUE (tail
);
4234 if (thislevel_only
&& ! level
->tag_transparent
)
4236 if (level
->pseudo_global
)
4238 tree t
= IDENTIFIER_GLOBAL_VALUE (name
);
4239 if (t
&& TREE_CODE (t
) == TEMPLATE_DECL
4240 && TREE_CODE (DECL_TEMPLATE_RESULT (t
)) == TYPE_DECL
)
4241 return TREE_TYPE (t
);
4245 if (current_class_type
&& level
->level_chain
== global_binding_level
)
4247 /* Try looking in this class's tags before heading into
4248 global binding level. */
4249 tree context
= current_class_type
;
4252 switch (TREE_CODE_CLASS (TREE_CODE (context
)))
4256 these_tags
= CLASSTYPE_TAGS (context
);
4257 if (ANON_AGGRNAME_P (name
))
4260 if (TYPE_IDENTIFIER (TREE_VALUE (these_tags
))
4262 return TREE_VALUE (tail
);
4263 these_tags
= TREE_CHAIN (these_tags
);
4268 if (TREE_PURPOSE (these_tags
) == name
)
4270 if (TREE_CODE (TREE_VALUE (these_tags
)) != form
)
4272 cp_error ("`%#D' redeclared as %C in class scope",
4273 TREE_VALUE (tail
), form
);
4276 return TREE_VALUE (tail
);
4278 these_tags
= TREE_CHAIN (these_tags
);
4280 /* If this type is not yet complete, then don't
4281 look at its context. */
4282 if (TYPE_SIZE (context
) == NULL_TREE
)
4284 /* Go to next enclosing type, if any. */
4285 context
= DECL_CONTEXT (TYPE_MAIN_DECL (context
));
4288 context
= DECL_CONTEXT (context
);
4291 my_friendly_abort (10);
4304 set_current_level_tags_transparency (tags_transparent
)
4305 int tags_transparent
;
4307 current_binding_level
->tag_transparent
= tags_transparent
;
4311 /* Given a type, find the tag that was defined for it and return the tag name.
4312 Otherwise return 0. However, the value can never be 0
4313 in the cases in which this is used.
4315 C++: If NAME is non-zero, this is the new name to install. This is
4316 done when replacing anonymous tags with real tag names. */
4319 lookup_tag_reverse (type
, name
)
4323 register struct binding_level
*level
;
4325 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
4328 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
4330 if (TREE_VALUE (tail
) == type
)
4333 TREE_PURPOSE (tail
) = name
;
4334 return TREE_PURPOSE (tail
);
4341 /* Lookup TYPE in CONTEXT (a chain of nested types or a FUNCTION_DECL).
4342 Return the type value, or NULL_TREE if not found. */
4345 lookup_nested_type (type
, context
)
4349 if (context
== NULL_TREE
)
4353 switch (TREE_CODE (context
))
4357 tree ctype
= TREE_TYPE (context
);
4358 tree match
= value_member (type
, CLASSTYPE_TAGS (ctype
));
4360 return TREE_VALUE (match
);
4361 context
= DECL_CONTEXT (context
);
4363 /* When we have a nested class whose member functions have
4364 local types (e.g., a set of enums), we'll arrive here
4365 with the DECL_CONTEXT as the actual RECORD_TYPE node for
4366 the enclosing class. Instead, we want to make sure we
4367 come back in here with the TYPE_DECL, not the RECORD_TYPE. */
4368 if (context
&& TREE_CODE (context
) == RECORD_TYPE
)
4369 context
= TREE_CHAIN (context
);
4373 if (TYPE_NAME (type
) && TYPE_IDENTIFIER (type
))
4374 return lookup_name (TYPE_IDENTIFIER (type
), 1);
4377 my_friendly_abort (12);
4383 /* Look up NAME in the NAMESPACE. */
4386 lookup_namespace_name (namespace, name
)
4387 tree
namespace, name
;
4389 struct binding_level
*b
= (struct binding_level
*)NAMESPACE_LEVEL (namespace);
4393 /* This searches just one level. */
4396 for (x
= b
->names
; x
; x
= TREE_CHAIN (x
))
4397 if (DECL_NAME (x
) == name
|| DECL_ASSEMBLER_NAME (x
) == name
)
4401 /* This searches all levels. */
4402 for (; b
&& !x
; b
= b
->level_chain
)
4404 for (x
= b
->names
; x
; x
= TREE_CHAIN (x
))
4405 if (DECL_NAME (x
) == name
|| DECL_ASSEMBLER_NAME (x
) == name
)
4413 make_typename_type (context
, name
)
4418 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
4419 name
= TYPE_IDENTIFIER (name
);
4420 else if (TREE_CODE (name
) == TYPE_DECL
)
4421 name
= DECL_NAME (name
);
4422 else if (TREE_CODE (name
) != IDENTIFIER_NODE
)
4423 my_friendly_abort (2000);
4425 if (! uses_template_parms (context
)
4426 || context
== current_class_type
)
4428 if (IS_AGGR_TYPE (context
))
4429 t
= lookup_field (context
, name
, 0, 1);
4435 cp_error ("no type named `%#T' in `%#T'", name
, context
);
4436 return error_mark_node
;
4438 return TREE_TYPE (t
);
4441 if (processing_template_decl
)
4442 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4443 t
= make_lang_type (TYPENAME_TYPE
);
4444 d
= build_decl (TYPE_DECL
, name
, t
);
4445 if (processing_template_decl
)
4448 TYPE_CONTEXT (t
) = context
;
4449 TYPE_NAME (TREE_TYPE (d
)) = d
;
4450 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
4451 DECL_CONTEXT (d
) = context
;
4452 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
4457 /* Given a TYPE_DECL T looked up in CONTEXT, return a TYPENAME_TYPE
4458 where the scope is either CONTEXT or the first base of CONTEXT along the
4459 inheritance chain to T that depends on template parameters.
4461 Called from lookup_name_real to implement the implicit typename
4465 make_implicit_typename (context
, t
)
4470 if (uses_template_parms (DECL_CONTEXT (t
))
4471 && DECL_CONTEXT (t
) != context
)
4473 tree binfo
= get_binfo (DECL_CONTEXT (t
), context
, 0);
4476 tree next
= BINFO_INHERITANCE_CHAIN (binfo
);
4477 if (! uses_template_parms (BINFO_TYPE (next
))
4478 || BINFO_TYPE (next
) == context
)
4483 retval
= make_typename_type (BINFO_TYPE (binfo
), DECL_NAME (t
));
4485 /* FIXME: find the enclosing class whose base t comes from. */
4486 retval
= make_typename_type (DECL_CONTEXT (t
), DECL_NAME (t
));
4489 retval
= make_typename_type (context
, DECL_NAME (t
));
4491 TREE_TYPE (retval
) = TREE_TYPE (t
);
4495 /* Look up NAME in the current binding level and its superiors in the
4496 namespace of variables, functions and typedefs. Return a ..._DECL
4497 node of some kind representing its definition if there is only one
4498 such declaration, or return a TREE_LIST with all the overloaded
4499 definitions if there are many, or return 0 if it is undefined.
4501 If PREFER_TYPE is > 0, we prefer TYPE_DECLs.
4502 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
4503 Otherwise we prefer non-TYPE_DECLs. */
4506 lookup_name_real (name
, prefer_type
, nonclass
)
4508 int prefer_type
, nonclass
;
4512 tree from_obj
= NULL_TREE
;
4513 tree locval
, classval
;
4515 if (prefer_type
== -2)
4517 extern int looking_for_typename
;
4518 tree type
= NULL_TREE
;
4521 prefer_type
= looking_for_typename
;
4523 /* std:: becomes :: for now. */
4524 if (got_scope
== std_node
)
4525 got_scope
= void_type_node
;
4529 else if (got_object
!= error_mark_node
)
4534 if (type
== error_mark_node
)
4535 return error_mark_node
;
4536 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
4537 type
= TREE_TYPE (type
);
4539 type
= complete_type (type
);
4541 if (type
== void_type_node
)
4542 val
= IDENTIFIER_GLOBAL_VALUE (name
);
4543 else if (TREE_CODE (type
) == NAMESPACE_DECL
)
4545 val
= lookup_namespace_name (type
, name
);
4547 else if (! IS_AGGR_TYPE (type
)
4548 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
4549 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
4550 || TREE_CODE (type
) == TYPENAME_TYPE
)
4551 /* Someone else will give an error about this if needed. */
4553 else if (TYPE_BEING_DEFINED (type
))
4555 val
= IDENTIFIER_CLASS_VALUE (name
);
4556 if (val
&& DECL_CONTEXT (val
) != type
)
4558 struct binding_level
*b
= class_binding_level
;
4559 for (val
= NULL_TREE
; b
; b
= b
->level_chain
)
4561 tree t
= purpose_member (name
, b
->class_shadowed
);
4562 if (t
&& TREE_VALUE (t
)
4563 && DECL_CONTEXT (TREE_VALUE (t
)) == type
)
4565 val
= TREE_VALUE (t
);
4570 if (val
== NULL_TREE
)
4571 val
= lookup_field (type
, name
, 0, 1);
4573 else if (type
== current_class_type
)
4574 val
= IDENTIFIER_CLASS_VALUE (name
);
4576 val
= lookup_field (type
, name
, 0, prefer_type
);
4581 /* Add implicit 'typename' to scoped types from other classes. */
4582 if (got_scope
&& processing_template_decl
4583 && got_scope
!= current_class_type
4584 && uses_template_parms (got_scope
)
4585 && val
&& TREE_CODE (val
) == TYPE_DECL
4586 && ! DECL_ARTIFICIAL (val
))
4588 tree t
= make_implicit_typename (got_scope
, val
);
4589 val
= TYPE_MAIN_DECL (t
);
4594 else if (got_object
&& val
)
4598 locval
= classval
= NULL_TREE
;
4600 if (current_binding_level
!= global_binding_level
4601 && IDENTIFIER_LOCAL_VALUE (name
))
4602 locval
= IDENTIFIER_LOCAL_VALUE (name
);
4604 /* In C++ class fields are between local and global scope,
4605 just before the global scope. */
4606 if (current_class_type
&& ! nonclass
)
4608 classval
= IDENTIFIER_CLASS_VALUE (name
);
4609 if (classval
== NULL_TREE
&& TYPE_BEING_DEFINED (current_class_type
))
4610 /* Try to find values from base classes if we are presently
4611 defining a type. We are presently only interested in
4613 classval
= lookup_field (current_class_type
, name
, 0, 1);
4615 /* yylex() calls this with -2, since we should never start digging for
4616 the nested name at the point where we haven't even, for example,
4617 created the COMPONENT_REF or anything like that. */
4618 if (classval
== NULL_TREE
)
4619 classval
= lookup_nested_field (name
, ! yylex
);
4621 /* Add implicit 'typename' to types from base classes. */
4622 if (processing_template_decl
4623 && classval
&& TREE_CODE (classval
) == TYPE_DECL
4624 && DECL_CONTEXT (classval
) != current_class_type
4625 && uses_template_parms (DECL_CONTEXT (classval
))
4626 && ! DECL_ARTIFICIAL (classval
))
4628 tree t
= make_implicit_typename (current_class_type
, classval
);
4629 classval
= TYPE_MAIN_DECL (t
);
4633 if (locval
&& classval
)
4635 if (current_scope () == current_function_decl
4636 && ! hack_decl_function_context (current_function_decl
))
4637 /* Not in a nested function. */
4641 /* This is incredibly horrible. The whole concept of
4642 IDENTIFIER_LOCAL_VALUE / IDENTIFIER_CLASS_VALUE /
4643 IDENTIFIER_GLOBAL_VALUE needs to be scrapped for local
4645 tree lctx
= hack_decl_function_context (locval
);
4646 tree cctx
= hack_decl_function_context (classval
);
4648 if (lctx
== current_scope ())
4650 else if (lctx
== cctx
)
4653 /* I don't know which is right; let's just guess for now. */
4662 val
= IDENTIFIER_GLOBAL_VALUE (name
);
4667 /* This should only warn about types used in qualified-ids. */
4668 if (from_obj
&& from_obj
!= val
)
4670 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
4671 && TREE_CODE (val
) == TYPE_DECL
4672 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
4674 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
4675 name
, got_object
, TREE_TYPE (from_obj
));
4676 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
4683 if (TREE_CODE (val
) == TEMPLATE_DECL
&& arg_looking_for_template
)
4685 /* TEMPLATE_TEMPLATE_PARM node is preferred over TEMPLATE_DECL. */
4686 if (DECL_TEMPLATE_TEMPLATE_PARM_P (val
))
4687 val
= TREE_TYPE (val
);
4689 else if ((TREE_CODE (val
) == TEMPLATE_DECL
&& looking_for_template
)
4690 || TREE_CODE (val
) == TYPE_DECL
|| prefer_type
<= 0)
4692 else if (IDENTIFIER_HAS_TYPE_VALUE (name
))
4693 val
= TYPE_MAIN_DECL (IDENTIFIER_TYPE_VALUE (name
));
4694 else if (TREE_TYPE (val
) == error_mark_node
)
4695 val
= error_mark_node
;
4704 lookup_name_nonclass (name
)
4707 return lookup_name_real (name
, 0, 1);
4711 lookup_name (name
, prefer_type
)
4715 return lookup_name_real (name
, prefer_type
, 0);
4718 /* Similar to `lookup_name' but look only at current binding level. */
4721 lookup_name_current_level (name
)
4724 register tree t
= NULL_TREE
;
4726 if (current_binding_level
== global_binding_level
)
4728 t
= IDENTIFIER_GLOBAL_VALUE (name
);
4730 /* extern "C" function() */
4731 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
4734 else if (IDENTIFIER_LOCAL_VALUE (name
) != NULL_TREE
)
4736 struct binding_level
*b
= current_binding_level
;
4739 for (t
= b
->names
; t
; t
= TREE_CHAIN (t
))
4740 if (DECL_NAME (t
) == name
|| DECL_ASSEMBLER_NAME (t
) == name
)
4754 /* Arrange for the user to get a source line number, even when the
4755 compiler is going down in flames, so that she at least has a
4756 chance of working around problems in the compiler. We used to
4757 call error(), but that let the segmentation fault continue
4758 through; now, it's much more passive by asking them to send the
4759 maintainers mail about the problem. */
4765 signal (SIGSEGV
, SIG_DFL
);
4767 signal (SIGIOT
, SIG_DFL
);
4770 signal (SIGILL
, SIG_DFL
);
4773 signal (SIGABRT
, SIG_DFL
);
4776 signal (SIGBUS
, SIG_DFL
);
4778 my_friendly_abort (0);
4782 /* Unused -- brendan 970107 */
4783 /* Array for holding types considered "built-in". These types
4784 are output in the module in which `main' is defined. */
4785 static tree
*builtin_type_tdescs_arr
;
4786 static int builtin_type_tdescs_len
, builtin_type_tdescs_max
;
4789 /* Push the declarations of builtin types into the namespace.
4790 RID_INDEX, if < RID_MAX is the index of the builtin type
4791 in the array RID_POINTERS. NAME is the name used when looking
4792 up the builtin type. TYPE is the _TYPE node for the builtin type. */
4795 record_builtin_type (rid_index
, name
, type
)
4800 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
4803 if ((int) rid_index
< (int) RID_MAX
)
4804 rname
= ridpointers
[(int) rid_index
];
4806 tname
= get_identifier (name
);
4808 TYPE_BUILT_IN (type
) = 1;
4812 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
4813 set_identifier_type_value (tname
, NULL_TREE
);
4814 if ((int) rid_index
< (int) RID_MAX
)
4815 IDENTIFIER_GLOBAL_VALUE (tname
) = tdecl
;
4817 if (rname
!= NULL_TREE
)
4819 if (tname
!= NULL_TREE
)
4821 set_identifier_type_value (rname
, NULL_TREE
);
4822 IDENTIFIER_GLOBAL_VALUE (rname
) = tdecl
;
4826 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
4827 set_identifier_type_value (rname
, NULL_TREE
);
4832 /* Push overloaded decl, in global scope, with one argument so it
4833 can be used as a callback from define_function. */
4836 push_overloaded_decl_1 (x
)
4839 push_overloaded_decl (x
, 0);
4846 auto_function (name
, type
, code
)
4848 enum built_in_function code
;
4850 return define_function
4851 (IDENTIFIER_POINTER (name
), type
, code
, push_overloaded_decl_1
,
4852 IDENTIFIER_POINTER (build_decl_overload (name
, TYPE_ARG_TYPES (type
),
4856 /* Create the predefined scalar types of C,
4857 and some nodes representing standard constants (0, 1, (void *)0).
4858 Initialize the global binding level.
4859 Make definitions for built-in primitive functions. */
4862 init_decl_processing ()
4865 register tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
4867 /* Data type of memcpy. */
4868 tree memcpy_ftype
, strlen_ftype
;
4869 int wchar_type_size
;
4871 tree array_domain_type
;
4872 extern int flag_strict_prototype
;
4873 tree vb_off_identifier
;
4874 /* Function type `char *(char *, char *)' and similar ones */
4875 tree string_ftype_ptr_ptr
, int_ftype_string_string
;
4876 tree sizetype_endlink
;
4877 tree ptr_ftype
, ptr_ftype_unsigned
, ptr_ftype_sizetype
;
4878 tree void_ftype
, void_ftype_int
, void_ftype_ptr
, ptr_ftype_void
;
4880 /* Have to make these distinct before we try using them. */
4881 lang_name_cplusplus
= get_identifier ("C++");
4882 lang_name_c
= get_identifier ("C");
4884 if (flag_strict_prototype
== 2)
4887 strict_prototypes_lang_c
= strict_prototypes_lang_cplusplus
;
4890 strict_prototypes_lang_c
= flag_strict_prototype
;
4893 current_lang_name
= lang_name_c
;
4895 current_function_decl
= NULL_TREE
;
4896 named_labels
= NULL_TREE
;
4897 named_label_uses
= NULL
;
4898 current_binding_level
= NULL_BINDING_LEVEL
;
4899 free_binding_level
= NULL_BINDING_LEVEL
;
4901 #ifndef __CYGWIN32__
4902 /* Because most segmentation signals can be traced back into user
4903 code, catch them and at least give the user a chance of working
4904 around compiler bugs. */
4905 signal (SIGSEGV
, signal_catch
);
4907 /* We will also catch aborts in the back-end through signal_catch and
4908 give the user a chance to see where the error might be, and to defeat
4909 aborts in the back-end when there have been errors previously in their
4912 signal (SIGIOT
, signal_catch
);
4915 signal (SIGILL
, signal_catch
);
4918 signal (SIGABRT
, signal_catch
);
4921 signal (SIGBUS
, signal_catch
);
4923 #else /* ndef __CYGWIN32__ */
4924 /* Cygwin32 cannot handle catching signals other than
4925 SIGABRT yet. We hope this will cease to be the case soon. */
4927 signal (SIGABRT
, signal_catch
);
4929 #endif /* ndef __CYGWIN32__ */
4931 gcc_obstack_init (&decl_obstack
);
4933 /* Must lay these out before anything else gets laid out. */
4934 error_mark_node
= make_node (ERROR_MARK
);
4935 TREE_PERMANENT (error_mark_node
) = 1;
4936 TREE_TYPE (error_mark_node
) = error_mark_node
;
4937 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
4938 TREE_TYPE (error_mark_list
) = error_mark_node
;
4940 /* Make the binding_level structure for global names. */
4942 global_binding_level
= current_binding_level
;
4944 this_identifier
= get_identifier (THIS_NAME
);
4945 in_charge_identifier
= get_identifier (IN_CHARGE_NAME
);
4946 ctor_identifier
= get_identifier (CTOR_NAME
);
4947 dtor_identifier
= get_identifier (DTOR_NAME
);
4948 pfn_identifier
= get_identifier (VTABLE_PFN_NAME
);
4949 index_identifier
= get_identifier (VTABLE_INDEX_NAME
);
4950 delta_identifier
= get_identifier (VTABLE_DELTA_NAME
);
4951 delta2_identifier
= get_identifier (VTABLE_DELTA2_NAME
);
4952 pfn_or_delta2_identifier
= get_identifier ("__pfn_or_delta2");
4953 if (flag_handle_signatures
)
4955 tag_identifier
= get_identifier (SIGTABLE_TAG_NAME
);
4956 vb_off_identifier
= get_identifier (SIGTABLE_VB_OFF_NAME
);
4957 vt_off_identifier
= get_identifier (SIGTABLE_VT_OFF_NAME
);
4960 /* Define `int' and `char' first so that dbx will output them first. */
4962 integer_type_node
= make_signed_type (INT_TYPE_SIZE
);
4963 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
4965 /* Define `char', which is like either `signed char' or `unsigned char'
4966 but not the same as either. */
4970 ? make_signed_type (CHAR_TYPE_SIZE
)
4971 : make_unsigned_type (CHAR_TYPE_SIZE
));
4972 record_builtin_type (RID_CHAR
, "char", char_type_node
);
4974 long_integer_type_node
= make_signed_type (LONG_TYPE_SIZE
);
4975 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
4977 unsigned_type_node
= make_unsigned_type (INT_TYPE_SIZE
);
4978 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
4980 long_unsigned_type_node
= make_unsigned_type (LONG_TYPE_SIZE
);
4981 record_builtin_type (RID_MAX
, "long unsigned int", long_unsigned_type_node
);
4982 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
4984 long_long_integer_type_node
= make_signed_type (LONG_LONG_TYPE_SIZE
);
4985 record_builtin_type (RID_MAX
, "long long int", long_long_integer_type_node
);
4987 long_long_unsigned_type_node
= make_unsigned_type (LONG_LONG_TYPE_SIZE
);
4988 record_builtin_type (RID_MAX
, "long long unsigned int",
4989 long_long_unsigned_type_node
);
4990 record_builtin_type (RID_MAX
, "long long unsigned",
4991 long_long_unsigned_type_node
);
4993 short_integer_type_node
= make_signed_type (SHORT_TYPE_SIZE
);
4994 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
4995 short_unsigned_type_node
= make_unsigned_type (SHORT_TYPE_SIZE
);
4996 record_builtin_type (RID_MAX
, "short unsigned int", short_unsigned_type_node
);
4997 record_builtin_type (RID_MAX
, "unsigned short", short_unsigned_type_node
);
4999 /* `unsigned long' is the standard type for sizeof.
5000 Note that stddef.h uses `unsigned long',
5001 and this must agree, even if long and int are the same size. */
5003 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
5006 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
5008 /* Define both `signed char' and `unsigned char'. */
5009 signed_char_type_node
= make_signed_type (CHAR_TYPE_SIZE
);
5010 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
5011 unsigned_char_type_node
= make_unsigned_type (CHAR_TYPE_SIZE
);
5012 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
5014 /* These are types that type_for_size and type_for_mode use. */
5015 intQI_type_node
= make_signed_type (GET_MODE_BITSIZE (QImode
));
5016 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
5017 intHI_type_node
= make_signed_type (GET_MODE_BITSIZE (HImode
));
5018 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
5019 intSI_type_node
= make_signed_type (GET_MODE_BITSIZE (SImode
));
5020 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
5021 intDI_type_node
= make_signed_type (GET_MODE_BITSIZE (DImode
));
5022 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
5023 unsigned_intQI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (QImode
));
5024 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
5025 unsigned_intHI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (HImode
));
5026 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
5027 unsigned_intSI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (SImode
));
5028 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
5029 unsigned_intDI_type_node
= make_unsigned_type (GET_MODE_BITSIZE (DImode
));
5030 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
5032 float_type_node
= make_node (REAL_TYPE
);
5033 TYPE_PRECISION (float_type_node
) = FLOAT_TYPE_SIZE
;
5034 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
5035 layout_type (float_type_node
);
5037 double_type_node
= make_node (REAL_TYPE
);
5038 if (flag_short_double
)
5039 TYPE_PRECISION (double_type_node
) = FLOAT_TYPE_SIZE
;
5041 TYPE_PRECISION (double_type_node
) = DOUBLE_TYPE_SIZE
;
5042 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
5043 layout_type (double_type_node
);
5045 long_double_type_node
= make_node (REAL_TYPE
);
5046 TYPE_PRECISION (long_double_type_node
) = LONG_DOUBLE_TYPE_SIZE
;
5047 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
5048 layout_type (long_double_type_node
);
5050 complex_integer_type_node
= make_node (COMPLEX_TYPE
);
5051 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
5052 complex_integer_type_node
));
5053 TREE_TYPE (complex_integer_type_node
) = integer_type_node
;
5054 layout_type (complex_integer_type_node
);
5056 complex_float_type_node
= make_node (COMPLEX_TYPE
);
5057 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
5058 complex_float_type_node
));
5059 TREE_TYPE (complex_float_type_node
) = float_type_node
;
5060 layout_type (complex_float_type_node
);
5062 complex_double_type_node
= make_node (COMPLEX_TYPE
);
5063 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
5064 complex_double_type_node
));
5065 TREE_TYPE (complex_double_type_node
) = double_type_node
;
5066 layout_type (complex_double_type_node
);
5068 complex_long_double_type_node
= make_node (COMPLEX_TYPE
);
5069 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
5070 complex_long_double_type_node
));
5071 TREE_TYPE (complex_long_double_type_node
) = long_double_type_node
;
5072 layout_type (complex_long_double_type_node
);
5074 integer_zero_node
= build_int_2 (0, 0);
5075 TREE_TYPE (integer_zero_node
) = integer_type_node
;
5076 integer_one_node
= build_int_2 (1, 0);
5077 TREE_TYPE (integer_one_node
) = integer_type_node
;
5078 integer_two_node
= build_int_2 (2, 0);
5079 TREE_TYPE (integer_two_node
) = integer_type_node
;
5080 integer_three_node
= build_int_2 (3, 0);
5081 TREE_TYPE (integer_three_node
) = integer_type_node
;
5083 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
5084 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
5085 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
5086 boolean_false_node
= build_int_2 (0, 0);
5087 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
5088 boolean_true_node
= build_int_2 (1, 0);
5089 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
5091 /* These are needed by stor-layout.c. */
5092 size_zero_node
= size_int (0);
5093 size_one_node
= size_int (1);
5095 signed_size_zero_node
= build_int_2 (0, 0);
5096 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
5098 void_type_node
= make_node (VOID_TYPE
);
5099 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
5100 layout_type (void_type_node
); /* Uses integer_zero_node. */
5101 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
5102 TREE_PARMLIST (void_list_node
) = 1;
5104 null_pointer_node
= build_int_2 (0, 0);
5105 TREE_TYPE (null_pointer_node
) = build_pointer_type (void_type_node
);
5106 layout_type (TREE_TYPE (null_pointer_node
));
5108 /* Used for expressions that do nothing, but are not errors. */
5109 void_zero_node
= build_int_2 (0, 0);
5110 TREE_TYPE (void_zero_node
) = void_type_node
;
5112 string_type_node
= build_pointer_type (char_type_node
);
5113 const_string_type_node
5114 = build_pointer_type (build_type_variant (char_type_node
, 1, 0));
5116 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
5119 /* Make a type to be the domain of a few array types
5120 whose domains don't really matter.
5121 200 is small enough that it always fits in size_t
5122 and large enough that it can hold most function names for the
5123 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5124 array_domain_type
= build_index_type (build_int_2 (200, 0));
5126 /* make a type for arrays of characters.
5127 With luck nothing will ever really depend on the length of this
5129 char_array_type_node
5130 = build_array_type (char_type_node
, array_domain_type
);
5131 /* Likewise for arrays of ints. */
5133 = build_array_type (integer_type_node
, array_domain_type
);
5135 /* This is just some anonymous class type. Nobody should ever
5136 need to look inside this envelope. */
5137 class_star_type_node
= build_pointer_type (make_lang_type (RECORD_TYPE
));
5139 default_function_type
5140 = build_function_type (integer_type_node
, NULL_TREE
);
5142 ptr_type_node
= build_pointer_type (void_type_node
);
5144 = build_pointer_type (build_type_variant (void_type_node
, 1, 0));
5146 record_builtin_type (RID_MAX
, NULL_PTR
, ptr_type_node
);
5148 endlink
= void_list_node
;
5149 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
5150 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
5151 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
5153 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
5154 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
5155 sizetype_endlink
= tree_cons (NULL_TREE
, sizetype
, endlink
);
5156 /* We realloc here because sizetype could be int or unsigned. S'ok. */
5157 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
5159 void_ftype
= build_function_type (void_type_node
, endlink
);
5160 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
5162 = build_function_type (void_type_node
,
5163 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
5165 = build_exception_variant (void_ftype_ptr
,
5166 tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
));
5169 = build_function_type (float_type_node
,
5170 tree_cons (NULL_TREE
, float_type_node
, endlink
));
5173 = build_function_type (double_type_node
, double_endlink
);
5175 ldouble_ftype_ldouble
5176 = build_function_type (long_double_type_node
,
5177 tree_cons (NULL_TREE
, long_double_type_node
,
5180 double_ftype_double_double
5181 = build_function_type (double_type_node
,
5182 tree_cons (NULL_TREE
, double_type_node
,
5186 = build_function_type (integer_type_node
, int_endlink
);
5189 = build_function_type (long_integer_type_node
,
5190 tree_cons (NULL_TREE
, long_integer_type_node
,
5193 int_ftype_cptr_cptr_sizet
5194 = build_function_type (integer_type_node
,
5195 tree_cons (NULL_TREE
, const_ptr_type_node
,
5196 tree_cons (NULL_TREE
, const_ptr_type_node
,
5197 tree_cons (NULL_TREE
,
5201 string_ftype_ptr_ptr
/* strcpy prototype */
5202 = build_function_type (string_type_node
,
5203 tree_cons (NULL_TREE
, string_type_node
,
5204 tree_cons (NULL_TREE
,
5205 const_string_type_node
,
5208 int_ftype_string_string
/* strcmp prototype */
5209 = build_function_type (integer_type_node
,
5210 tree_cons (NULL_TREE
, const_string_type_node
,
5211 tree_cons (NULL_TREE
,
5212 const_string_type_node
,
5215 strlen_ftype
/* strlen prototype */
5216 = build_function_type (sizetype
,
5217 tree_cons (NULL_TREE
, const_string_type_node
,
5220 memcpy_ftype
/* memcpy prototype */
5221 = build_function_type (ptr_type_node
,
5222 tree_cons (NULL_TREE
, ptr_type_node
,
5223 tree_cons (NULL_TREE
, const_ptr_type_node
,
5224 sizetype_endlink
)));
5226 if (flag_huge_objects
)
5227 delta_type_node
= long_integer_type_node
;
5229 delta_type_node
= short_integer_type_node
;
5231 builtin_function ("__builtin_constant_p", default_function_type
,
5232 BUILT_IN_CONSTANT_P
, NULL_PTR
);
5234 builtin_return_address_fndecl
5235 = builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
5236 BUILT_IN_RETURN_ADDRESS
, NULL_PTR
);
5238 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
5239 BUILT_IN_FRAME_ADDRESS
, NULL_PTR
);
5241 ptr_ftype_void
= build_function_type (ptr_type_node
, endlink
);
5242 builtin_function ("__builtin_fp", ptr_ftype_void
, BUILT_IN_FP
, NULL_PTR
);
5243 builtin_function ("__builtin_sp", ptr_ftype_void
, BUILT_IN_SP
, NULL_PTR
);
5245 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
5246 BUILT_IN_ALLOCA
, "alloca");
5247 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5248 /* Define alloca, ffs as builtins.
5249 Declare _exit just to mark it as volatile. */
5250 if (! flag_no_builtin
&& !flag_no_nonansi_builtin
)
5252 temp
= builtin_function ("alloca", ptr_ftype_sizetype
,
5253 BUILT_IN_ALLOCA
, NULL_PTR
);
5254 /* Suppress error if redefined as a non-function. */
5255 DECL_BUILT_IN_NONANSI (temp
) = 1;
5256 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
, NULL_PTR
);
5257 /* Suppress error if redefined as a non-function. */
5258 DECL_BUILT_IN_NONANSI (temp
) = 1;
5259 temp
= builtin_function ("_exit", void_ftype_int
,
5260 NOT_BUILT_IN
, NULL_PTR
);
5261 TREE_THIS_VOLATILE (temp
) = 1;
5262 TREE_SIDE_EFFECTS (temp
) = 1;
5263 /* Suppress error if redefined as a non-function. */
5264 DECL_BUILT_IN_NONANSI (temp
) = 1;
5267 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
5268 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
5270 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
5272 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
5274 builtin_function ("__builtin_labs", long_ftype_long
,
5275 BUILT_IN_LABS
, NULL_PTR
);
5276 builtin_function ("__builtin_saveregs", ptr_ftype
,
5277 BUILT_IN_SAVEREGS
, NULL_PTR
);
5278 builtin_function ("__builtin_classify_type", default_function_type
,
5279 BUILT_IN_CLASSIFY_TYPE
, NULL_PTR
);
5280 builtin_function ("__builtin_next_arg", ptr_ftype
,
5281 BUILT_IN_NEXT_ARG
, NULL_PTR
);
5282 builtin_function ("__builtin_args_info", int_ftype_int
,
5283 BUILT_IN_ARGS_INFO
, NULL_PTR
);
5284 builtin_function ("__builtin_setjmp",
5285 build_function_type (integer_type_node
,
5286 tree_cons (NULL_TREE
, ptr_type_node
,
5288 BUILT_IN_SETJMP
, NULL_PTR
);
5289 builtin_function ("__builtin_longjmp",
5290 build_function_type (integer_type_node
,
5291 tree_cons (NULL_TREE
, ptr_type_node
,
5292 tree_cons (NULL_TREE
,
5295 BUILT_IN_LONGJMP
, NULL_PTR
);
5297 /* Untyped call and return. */
5298 builtin_function ("__builtin_apply_args", ptr_ftype
,
5299 BUILT_IN_APPLY_ARGS
, NULL_PTR
);
5301 temp
= tree_cons (NULL_TREE
,
5302 build_pointer_type (build_function_type (void_type_node
,
5304 ptr_ftype_sizetype
);
5305 builtin_function ("__builtin_apply",
5306 build_function_type (ptr_type_node
, temp
),
5307 BUILT_IN_APPLY
, NULL_PTR
);
5308 builtin_function ("__builtin_return", void_ftype_ptr
,
5309 BUILT_IN_RETURN
, NULL_PTR
);
5311 /* Currently under experimentation. */
5312 builtin_function ("__builtin_memcpy", memcpy_ftype
,
5313 BUILT_IN_MEMCPY
, "memcpy");
5314 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
5315 BUILT_IN_MEMCMP
, "memcmp");
5316 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
5317 BUILT_IN_STRCMP
, "strcmp");
5318 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
5319 BUILT_IN_STRCPY
, "strcpy");
5320 builtin_function ("__builtin_strlen", strlen_ftype
,
5321 BUILT_IN_STRLEN
, "strlen");
5322 builtin_function ("__builtin_sqrtf", float_ftype_float
,
5323 BUILT_IN_FSQRT
, "sqrtf");
5324 builtin_function ("__builtin_fsqrt", double_ftype_double
,
5325 BUILT_IN_FSQRT
, NULL_PTR
);
5326 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
5327 BUILT_IN_FSQRT
, "sqrtl");
5328 builtin_function ("__builtin_sinf", float_ftype_float
,
5329 BUILT_IN_SIN
, "sinf");
5330 builtin_function ("__builtin_sin", double_ftype_double
,
5331 BUILT_IN_SIN
, "sin");
5332 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
5333 BUILT_IN_SIN
, "sinl");
5334 builtin_function ("__builtin_cosf", float_ftype_float
,
5335 BUILT_IN_COS
, "cosf");
5336 builtin_function ("__builtin_cos", double_ftype_double
,
5337 BUILT_IN_COS
, "cos");
5338 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
5339 BUILT_IN_COS
, "cosl");
5341 if (!flag_no_builtin
)
5343 #if 0 /* These do not work well with libg++. */
5344 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
, NULL_PTR
);
5345 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
, NULL_PTR
);
5346 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
, NULL_PTR
);
5348 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
, NULL_PTR
);
5349 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
5351 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
, NULL_PTR
);
5352 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
5354 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
5356 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
5358 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
, NULL_PTR
);
5359 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
, NULL_PTR
);
5360 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
, NULL_PTR
);
5361 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
5363 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
, NULL_PTR
);
5364 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
, NULL_PTR
);
5365 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
, NULL_PTR
);
5366 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
, NULL_PTR
);
5367 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
, NULL_PTR
);
5368 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
, NULL_PTR
);
5370 /* Declare these functions volatile
5371 to avoid spurious "control drops through" warnings. */
5372 temp
= builtin_function ("abort", void_ftype
,
5373 NOT_BUILT_IN
, NULL_PTR
);
5374 TREE_THIS_VOLATILE (temp
) = 1;
5375 TREE_SIDE_EFFECTS (temp
) = 1;
5376 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
5378 DECL_BUILT_IN_NONANSI (temp
) = 1;
5379 temp
= builtin_function ("exit", void_ftype_int
,
5380 NOT_BUILT_IN
, NULL_PTR
);
5381 TREE_THIS_VOLATILE (temp
) = 1;
5382 TREE_SIDE_EFFECTS (temp
) = 1;
5383 DECL_BUILT_IN_NONANSI (temp
) = 1;
5387 /* Support for these has not been written in either expand_builtin
5388 or build_function_call. */
5389 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
, NULL_PTR
);
5390 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
, NULL_PTR
);
5391 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
5393 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
5395 builtin_function ("__builtin_fmod", double_ftype_double_double
,
5396 BUILT_IN_FMOD
, NULL_PTR
);
5397 builtin_function ("__builtin_frem", double_ftype_double_double
,
5398 BUILT_IN_FREM
, NULL_PTR
);
5399 builtin_function ("__builtin_memset", ptr_ftype_ptr_int_int
,
5400 BUILT_IN_MEMSET
, NULL_PTR
);
5401 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
5403 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
5407 /* C++ extensions */
5409 unknown_type_node
= make_node (UNKNOWN_TYPE
);
5410 decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier ("unknown type"),
5411 unknown_type_node
));
5412 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5413 DECL_IGNORED_P (decl
) = 1;
5414 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5415 TYPE_SIZE (unknown_type_node
) = TYPE_SIZE (void_type_node
);
5416 TYPE_ALIGN (unknown_type_node
) = 1;
5417 TYPE_MODE (unknown_type_node
) = TYPE_MODE (void_type_node
);
5418 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
5419 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
5422 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
5424 TREE_TYPE (null_node
) = build_pointer_type (unknown_type_node
);
5426 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
5428 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
5429 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
5431 /* This is for handling opaque types in signatures. */
5432 opaque_type_node
= copy_node (ptr_type_node
);
5433 TYPE_MAIN_VARIANT (opaque_type_node
) = opaque_type_node
;
5434 record_builtin_type (RID_MAX
, 0, opaque_type_node
);
5436 /* This is special for C++ so functions can be overloaded. */
5438 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (WCHAR_TYPE
)));
5439 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
5440 signed_wchar_type_node
= make_signed_type (wchar_type_size
);
5441 unsigned_wchar_type_node
= make_unsigned_type (wchar_type_size
);
5443 = TREE_UNSIGNED (wchar_type_node
)
5444 ? unsigned_wchar_type_node
5445 : signed_wchar_type_node
;
5446 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
5448 /* Artificial declaration of wchar_t -- can be bashed */
5449 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
5451 pushdecl (wchar_decl_node
);
5453 /* This is for wide string constants. */
5454 wchar_array_type_node
5455 = build_array_type (wchar_type_node
, array_domain_type
);
5457 if (flag_vtable_thunks
)
5459 /* Make sure we get a unique function type, so we can give
5460 its pointer type a name. (This wins for gdb.) */
5461 tree vfunc_type
= make_node (FUNCTION_TYPE
);
5462 TREE_TYPE (vfunc_type
) = integer_type_node
;
5463 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
5464 layout_type (vfunc_type
);
5466 vtable_entry_type
= build_pointer_type (vfunc_type
);
5470 vtable_entry_type
= make_lang_type (RECORD_TYPE
);
5471 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
5473 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
5475 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
5477 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
5480 /* Make this part of an invisible union. */
5481 fields
[3] = copy_node (fields
[2]);
5482 TREE_TYPE (fields
[3]) = delta_type_node
;
5483 DECL_NAME (fields
[3]) = delta2_identifier
;
5484 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
5485 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
5486 TREE_UNSIGNED (fields
[3]) = 0;
5487 TREE_CHAIN (fields
[2]) = fields
[3];
5488 vtable_entry_type
= build_type_variant (vtable_entry_type
, 1, 0);
5490 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
5493 = build_array_type (vtable_entry_type
, NULL_TREE
);
5494 layout_type (vtbl_type_node
);
5495 vtbl_type_node
= cp_build_type_variant (vtbl_type_node
, 1, 0);
5496 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
5498 /* Simplify life by making a "sigtable_entry_type". Give its
5499 fields names so that the debugger can use them. */
5501 if (flag_handle_signatures
)
5503 sigtable_entry_type
= make_lang_type (RECORD_TYPE
);
5504 fields
[0] = build_lang_field_decl (FIELD_DECL
, tag_identifier
,
5506 fields
[1] = build_lang_field_decl (FIELD_DECL
, vb_off_identifier
,
5508 fields
[2] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
5510 fields
[3] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
5512 fields
[4] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
,
5515 /* Set the alignment to the max of the alignment of ptr_type_node and
5516 delta_type_node. Double alignment wastes a word on the Sparc. */
5517 finish_builtin_type (sigtable_entry_type
, SIGTABLE_PTR_TYPE
, fields
, 4,
5518 (TYPE_ALIGN (ptr_type_node
) > TYPE_ALIGN (delta_type_node
))
5522 /* Make this part of an invisible union. */
5523 fields
[5] = copy_node (fields
[4]);
5524 TREE_TYPE (fields
[5]) = delta_type_node
;
5525 DECL_NAME (fields
[5]) = vt_off_identifier
;
5526 DECL_MODE (fields
[5]) = TYPE_MODE (delta_type_node
);
5527 DECL_SIZE (fields
[5]) = TYPE_SIZE (delta_type_node
);
5528 TREE_UNSIGNED (fields
[5]) = 0;
5529 TREE_CHAIN (fields
[4]) = fields
[5];
5531 sigtable_entry_type
= build_type_variant (sigtable_entry_type
, 1, 0);
5532 record_builtin_type (RID_MAX
, SIGTABLE_PTR_TYPE
, sigtable_entry_type
);
5535 std_node
= build_decl (NAMESPACE_DECL
, get_identifier ("std"),
5537 pushdecl (std_node
);
5542 /* Must build __t_desc type. Currently, type descriptors look like this:
5549 struct __t_desc *points_to;
5550 int ivars_count, meths_count;
5551 struct __i_desc *ivars[];
5552 struct __m_desc *meths[];
5553 struct __t_desc *parents[];
5554 struct __t_desc *vbases[];
5558 ...as per Linton's paper. */
5560 __t_desc_type_node
= make_lang_type (RECORD_TYPE
);
5561 __i_desc_type_node
= make_lang_type (RECORD_TYPE
);
5562 __m_desc_type_node
= make_lang_type (RECORD_TYPE
);
5564 = build_array_type (build_pointer_type (__t_desc_type_node
),
5567 = build_array_type (build_pointer_type (__i_desc_type_node
),
5570 = build_array_type (build_pointer_type (__m_desc_type_node
),
5573 fields
[0] = build_lang_field_decl (FIELD_DECL
, get_identifier ("name"),
5575 fields
[1] = build_lang_field_decl (FIELD_DECL
, get_identifier ("size"),
5576 unsigned_type_node
);
5577 fields
[2] = build_lang_field_decl (FIELD_DECL
, get_identifier ("bits"),
5578 unsigned_type_node
);
5579 fields
[3] = build_lang_field_decl (FIELD_DECL
,
5580 get_identifier ("points_to"),
5581 build_pointer_type (__t_desc_type_node
));
5582 fields
[4] = build_lang_field_decl (FIELD_DECL
,
5583 get_identifier ("ivars_count"),
5585 fields
[5] = build_lang_field_decl (FIELD_DECL
,
5586 get_identifier ("meths_count"),
5588 fields
[6] = build_lang_field_decl (FIELD_DECL
, get_identifier ("ivars"),
5589 build_pointer_type (__i_desc_array_type
));
5590 fields
[7] = build_lang_field_decl (FIELD_DECL
, get_identifier ("meths"),
5591 build_pointer_type (__m_desc_array_type
));
5592 fields
[8] = build_lang_field_decl (FIELD_DECL
, get_identifier ("parents"),
5593 build_pointer_type (__t_desc_array_type
));
5594 fields
[9] = build_lang_field_decl (FIELD_DECL
, get_identifier ("vbases"),
5595 build_pointer_type (__t_desc_array_type
));
5596 fields
[10] = build_lang_field_decl (FIELD_DECL
, get_identifier ("offsets"),
5597 build_pointer_type (integer_type_node
));
5598 finish_builtin_type (__t_desc_type_node
, "__t_desc", fields
, 10, integer_type_node
);
5600 /* ivar descriptors look like this:
5606 struct __t_desc *type;
5610 fields
[0] = build_lang_field_decl (FIELD_DECL
, get_identifier ("name"),
5612 fields
[1] = build_lang_field_decl (FIELD_DECL
, get_identifier ("offset"),
5614 fields
[2] = build_lang_field_decl (FIELD_DECL
, get_identifier ("type"),
5615 build_pointer_type (__t_desc_type_node
));
5616 finish_builtin_type (__i_desc_type_node
, "__i_desc", fields
, 2,
5619 /* method descriptors look like this:
5625 struct __t_desc *vcontext;
5626 struct __t_desc *return_type;
5629 short required_parms;
5630 struct __t_desc *parm_types[];
5634 fields
[0] = build_lang_field_decl (FIELD_DECL
, get_identifier ("name"),
5636 fields
[1] = build_lang_field_decl (FIELD_DECL
, get_identifier ("vindex"),
5638 fields
[2] = build_lang_field_decl (FIELD_DECL
, get_identifier ("vcontext"),
5639 build_pointer_type (__t_desc_type_node
));
5640 fields
[3] = build_lang_field_decl (FIELD_DECL
, get_identifier ("return_type"),
5641 build_pointer_type (__t_desc_type_node
));
5642 fields
[4] = build_lang_field_decl (FIELD_DECL
, get_identifier ("address"),
5643 build_pointer_type (default_function_type
));
5644 fields
[5] = build_lang_field_decl (FIELD_DECL
, get_identifier ("parm_count"),
5645 short_integer_type_node
);
5646 fields
[6] = build_lang_field_decl (FIELD_DECL
, get_identifier ("required_parms"),
5647 short_integer_type_node
);
5648 fields
[7] = build_lang_field_decl (FIELD_DECL
, get_identifier ("parm_types"),
5649 build_pointer_type (build_array_type (build_pointer_type (__t_desc_type_node
), NULL_TREE
)));
5650 finish_builtin_type (__m_desc_type_node
, "__m_desc", fields
, 7,
5653 #endif /*flag_rtti*/
5656 current_lang_name
= lang_name_cplusplus
;
5659 tree bad_alloc_type_node
= xref_tag
5660 (class_type_node
, get_identifier ("bad_alloc"), NULL_TREE
, 1);
5661 tree newtype
= build_exception_variant
5662 (ptr_ftype_sizetype
, build_tree_list (NULL_TREE
, bad_alloc_type_node
));
5663 tree deltype
= build_exception_variant
5664 (void_ftype_ptr
, build_tree_list (NULL_TREE
, NULL_TREE
));
5665 auto_function (ansi_opname
[(int) NEW_EXPR
], newtype
, NOT_BUILT_IN
);
5666 auto_function (ansi_opname
[(int) VEC_NEW_EXPR
], newtype
, NOT_BUILT_IN
);
5667 auto_function (ansi_opname
[(int) DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
5668 auto_function (ansi_opname
[(int) VEC_DELETE_EXPR
], deltype
, NOT_BUILT_IN
);
5672 = define_function ("__pure_virtual", void_ftype
,
5673 NOT_BUILT_IN
, 0, 0);
5675 /* Perform other language dependent initializations. */
5676 init_class_processing ();
5677 init_init_processing ();
5678 init_search_processing ();
5680 init_rtti_processing ();
5682 if (flag_exceptions
)
5683 init_exception_processing ();
5686 flag_inline_functions
= 0;
5689 if (! supports_one_only ())
5692 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
5693 declare_function_name ();
5695 /* Prepare to check format strings against argument lists. */
5696 init_function_format_info ();
5698 /* Show we use EH for cleanups. */
5699 using_eh_for_cleanups ();
5702 /* initialize type descriptor type node of various rtti type. */
5709 tdecl
= lookup_name (get_identifier ("type_info"), 0);
5710 if (tdecl
== NULL_TREE
)
5712 __t_desc_type_node
= TREE_TYPE (tdecl
);
5714 __tp_desc_type_node
= build_pointer_type (__t_desc_type_node
);
5718 tdecl
= lookup_name (get_identifier ("__baselist_type_info"), 0);
5719 if (tdecl
== NULL_TREE
)
5721 __baselist_desc_type_node
= TREE_TYPE (tdecl
);
5724 tdecl
= lookup_name (get_identifier ("__builtin_type_info"), 0);
5725 if (tdecl
== NULL_TREE
)
5727 __bltn_desc_type_node
= TREE_TYPE (tdecl
);
5729 tdecl
= lookup_name (get_identifier ("__user_type_info"), 0);
5730 if (tdecl
== NULL_TREE
)
5732 __user_desc_type_node
= TREE_TYPE (tdecl
);
5734 tdecl
= lookup_name (get_identifier ("__class_type_info"), 0);
5735 if (tdecl
== NULL_TREE
)
5737 __class_desc_type_node
= TREE_TYPE (tdecl
);
5739 tdecl
= lookup_field (__class_desc_type_node
,
5740 get_identifier ("access_mode"), 0, 0);
5741 if (tdecl
== NULL_TREE
)
5743 __access_mode_type_node
= TREE_TYPE (tdecl
);
5745 tdecl
= lookup_name (get_identifier ("__attr_type_info"), 0);
5746 if (tdecl
== NULL_TREE
)
5748 __attr_desc_type_node
= TREE_TYPE (tdecl
);
5750 tdecl
= lookup_name (get_identifier ("__pointer_type_info"), 0);
5751 if (tdecl
== NULL_TREE
)
5753 __ptr_desc_type_node
= TREE_TYPE (tdecl
);
5755 tdecl
= lookup_name (get_identifier ("__func_type_info"), 0);
5756 if (tdecl
== NULL_TREE
)
5758 __func_desc_type_node
= TREE_TYPE (tdecl
);
5760 tdecl
= lookup_name (get_identifier ("__ptmf_type_info"), 0);
5761 if (tdecl
== NULL_TREE
)
5763 __ptmf_desc_type_node
= TREE_TYPE (tdecl
);
5765 tdecl
= lookup_name (get_identifier ("__ptmd_type_info"), 0);
5766 if (tdecl
== NULL_TREE
)
5768 __ptmd_desc_type_node
= TREE_TYPE (tdecl
);
5772 /* Make a definition for a builtin function named NAME and whose data type
5773 is TYPE. TYPE should be a function type with argument types.
5774 FUNCTION_CODE tells later passes how to compile calls to this function.
5775 See tree.h for its possible values.
5777 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
5778 the name to be called if we can't opencode the function. */
5781 define_function (name
, type
, function_code
, pfn
, library_name
)
5784 enum built_in_function function_code
;
5785 void (*pfn
) PROTO((tree
));
5788 tree decl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), type
);
5789 DECL_EXTERNAL (decl
) = 1;
5790 TREE_PUBLIC (decl
) = 1;
5791 DECL_ARTIFICIAL (decl
) = 1;
5793 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
5794 we cannot change DECL_ASSEMBLER_NAME until we have installed this
5795 function in the namespace. */
5796 if (pfn
) (*pfn
) (decl
);
5798 DECL_ASSEMBLER_NAME (decl
) = get_identifier (library_name
);
5799 make_function_rtl (decl
);
5800 if (function_code
!= NOT_BUILT_IN
)
5802 DECL_BUILT_IN (decl
) = 1;
5803 DECL_FUNCTION_CODE (decl
) = function_code
;
5808 /* Called when a declaration is seen that contains no names to declare.
5809 If its type is a reference to a structure, union or enum inherited
5810 from a containing scope, shadow that tag name for the current scope
5811 with a forward reference.
5812 If its type defines a new named structure or union
5813 or defines an enum, it is valid but we need not do anything here.
5814 Otherwise, it is an error.
5816 C++: may have to grok the declspecs to learn about static,
5817 complain for anonymous unions. */
5820 shadow_tag (declspecs
)
5824 tree ob_modifier
= NULL_TREE
;
5826 register enum tree_code code
, ok_code
= ERROR_MARK
;
5827 register tree t
= NULL_TREE
;
5829 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
5831 register tree value
= TREE_VALUE (link
);
5833 code
= TREE_CODE (value
);
5834 if (IS_AGGR_TYPE_CODE (code
) || code
== ENUMERAL_TYPE
)
5836 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
5838 if (IS_AGGR_TYPE (value
) && CLASSTYPE_USE_TEMPLATE (value
))
5840 if (CLASSTYPE_IMPLICIT_INSTANTIATION (value
)
5841 && TYPE_SIZE (value
) == NULL_TREE
)
5843 SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (value
);
5844 if (processing_template_decl
)
5845 push_template_decl (TYPE_MAIN_DECL (value
));
5847 else if (CLASSTYPE_TEMPLATE_INSTANTIATION (value
))
5848 cp_error ("specialization after instantiation of `%T'", value
);
5855 else if (value
== ridpointers
[(int) RID_STATIC
]
5856 || value
== ridpointers
[(int) RID_EXTERN
]
5857 || value
== ridpointers
[(int) RID_AUTO
]
5858 || value
== ridpointers
[(int) RID_REGISTER
]
5859 || value
== ridpointers
[(int) RID_INLINE
]
5860 || value
== ridpointers
[(int) RID_VIRTUAL
]
5861 || value
== ridpointers
[(int) RID_EXPLICIT
])
5862 ob_modifier
= value
;
5865 /* This is where the variables in an anonymous union are
5866 declared. An anonymous union declaration looks like:
5868 because there is no declarator after the union, the parser
5869 sends that declaration here. */
5870 if (ok_code
== UNION_TYPE
5872 && ((TREE_CODE (TYPE_NAME (t
)) == IDENTIFIER_NODE
5873 && ANON_AGGRNAME_P (TYPE_NAME (t
)))
5874 || (TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
5875 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))))
5877 /* See also grok_x_components. */
5880 /* Wipe out memory of synthesized methods */
5881 TYPE_HAS_CONSTRUCTOR (t
) = 0;
5882 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
5883 TYPE_HAS_INIT_REF (t
) = 0;
5884 TYPE_HAS_CONST_INIT_REF (t
) = 0;
5885 TYPE_HAS_ASSIGN_REF (t
) = 0;
5886 TYPE_HAS_ASSIGNMENT (t
) = 0;
5887 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
5889 q
= &TYPE_METHODS (t
);
5892 if (DECL_ARTIFICIAL (*q
))
5893 *q
= TREE_CHAIN (*q
);
5895 q
= &TREE_CHAIN (*q
);
5898 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
5899 function members. */
5900 if (TYPE_METHODS (t
))
5901 error ("an anonymous union cannot have function members");
5903 if (TYPE_FIELDS (t
))
5905 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
5907 finish_anon_union (decl
);
5912 /* Anonymous unions are objects, that's why we only check for
5913 inappropriate specifiers in this branch. */
5917 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
5918 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
5919 cp_error ("`%D' can only be specified for functions", ob_modifier
);
5920 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
5921 cp_error ("`%D' can only be specified for constructors",
5924 cp_error ("`%D' can only be specified for objects and functions",
5929 pedwarn ("abstract declarator used as declaration");
5930 else if (found_tag
> 1)
5931 pedwarn ("multiple types in one declaration");
5935 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5938 groktypename (typename
)
5941 if (TREE_CODE (typename
) != TREE_LIST
)
5943 return grokdeclarator (TREE_VALUE (typename
),
5944 TREE_PURPOSE (typename
),
5945 TYPENAME
, 0, NULL_TREE
);
5948 /* Decode a declarator in an ordinary declaration or data definition.
5949 This is called as soon as the type information and variable name
5950 have been parsed, before parsing the initializer if any.
5951 Here we create the ..._DECL node, fill in its type,
5952 and put it on the list of decls for the current context.
5953 The ..._DECL node is returned as the value.
5955 Exception: for arrays where the length is not specified,
5956 the type is left null, to be filled in by `cp_finish_decl'.
5958 Function definitions do not come here; they go to start_function
5959 instead. However, external and forward declarations of functions
5960 do go through here. Structure field declarations are done by
5961 grokfield and not through here. */
5963 /* Set this to zero to debug not using the temporary obstack
5964 to parse initializers. */
5965 int debug_temp_inits
= 1;
5968 start_decl (declarator
, declspecs
, initialized
)
5969 tree declarator
, declspecs
;
5973 register tree type
, tem
;
5975 extern int have_extern_spec
;
5976 extern int used_extern_spec
;
5979 /* See code below that used this. */
5980 int init_written
= initialized
;
5983 /* This should only be done once on the top most decl. */
5984 if (have_extern_spec
&& !used_extern_spec
)
5986 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
5988 used_extern_spec
= 1;
5991 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
5993 if (decl
== NULL_TREE
|| decl
== void_type_node
)
5996 type
= TREE_TYPE (decl
);
5998 /* Don't lose if destructors must be executed at file-level. */
5999 if (! processing_template_decl
&& TREE_STATIC (decl
)
6000 && TYPE_NEEDS_DESTRUCTOR (complete_type (type
))
6001 && !TREE_PERMANENT (decl
))
6003 push_obstacks (&permanent_obstack
, &permanent_obstack
);
6004 decl
= copy_node (decl
);
6005 if (TREE_CODE (type
) == ARRAY_TYPE
)
6007 tree itype
= TYPE_DOMAIN (type
);
6008 if (itype
&& ! TREE_PERMANENT (itype
))
6010 itype
= build_index_type (copy_to_permanent (TYPE_MAX_VALUE (itype
)));
6011 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
6012 TREE_TYPE (decl
) = type
;
6019 = (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_VIRTUAL_P (decl
))
6020 ? DECL_CLASS_CONTEXT (decl
)
6021 : DECL_CONTEXT (decl
);
6024 /* Is it valid for this decl to have an initializer at all?
6025 If not, set INITIALIZED to zero, which will indirectly
6026 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6027 switch (TREE_CODE (decl
))
6030 /* typedef foo = bar means give foo the same type as bar.
6031 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6032 Any other case of an initialization in a TYPE_DECL is an error. */
6033 if (pedantic
|| list_length (declspecs
) > 1)
6035 cp_error ("typedef `%D' is initialized", decl
);
6041 cp_error ("function `%#D' is initialized like a variable", decl
);
6046 if (! processing_template_decl
)
6048 if (type
!= error_mark_node
)
6050 if (TYPE_SIZE (type
) != NULL_TREE
6051 && ! TREE_CONSTANT (TYPE_SIZE (type
)))
6054 ("variable-sized object `%D' may not be initialized",
6059 if (TREE_CODE (type
) == ARRAY_TYPE
6060 && TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6063 ("elements of array `%#D' have incomplete type", decl
);
6072 if (! toplevel_bindings_p ()
6073 && DECL_EXTERNAL (decl
))
6074 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6076 DECL_EXTERNAL (decl
) = 0;
6077 if (toplevel_bindings_p ())
6078 TREE_STATIC (decl
) = 1;
6080 /* Tell `pushdecl' this is an initialized decl
6081 even though we don't yet have the initializer expression.
6082 Also tell `cp_finish_decl' it may store the real initializer. */
6083 DECL_INITIAL (decl
) = error_mark_node
;
6086 if (context
&& TYPE_SIZE (complete_type (context
)) != NULL_TREE
)
6088 if (TREE_CODE (decl
) == VAR_DECL
)
6090 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
6091 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
6092 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
6095 if (DECL_CONTEXT (field
) != context
)
6097 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6098 DECL_CONTEXT (field
), DECL_NAME (decl
),
6099 context
, DECL_NAME (decl
));
6100 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
6102 /* Static data member are tricky; an in-class initialization
6103 still doesn't provide a definition, so the in-class
6104 declaration will have DECL_EXTERNAL set, but will have an
6105 initialization. Thus, duplicate_decls won't warn
6106 about this situation, and so we check here. */
6107 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
6108 cp_error ("duplicate initialization of %D", decl
);
6109 if (duplicate_decls (decl
, field
))
6115 tree field
= check_classfn (context
, decl
);
6116 if (field
&& duplicate_decls (decl
, field
))
6120 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6121 if (DECL_LANG_SPECIFIC (decl
))
6122 DECL_IN_AGGR_P (decl
) = 0;
6123 if (DECL_USE_TEMPLATE (decl
) || CLASSTYPE_USE_TEMPLATE (context
))
6124 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
6126 /* Stupid stupid stupid stupid (jason 7/21/95) */
6127 if (pedantic
&& DECL_EXTERNAL (decl
)
6128 && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
6129 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6132 pushclass (context
, 2);
6135 /* Add this decl to the current binding level, but not if it
6136 comes from another scope, e.g. a static member variable.
6137 TEM may equal DECL or it may be a previous decl of the same name. */
6139 if ((TREE_CODE (decl
) != PARM_DECL
&& DECL_CONTEXT (decl
) != NULL_TREE
)
6140 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !global_bindings_p ())
6141 || TREE_CODE (type
) == LANG_TYPE
6142 /* The declaration of template specializations does not affect
6143 the functions available for overload resolution, so we do not
6145 || (TREE_CODE (decl
) == FUNCTION_DECL
6146 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
6149 tem
= pushdecl (decl
);
6151 if (processing_template_decl
)
6153 if (! current_function_decl
)
6154 push_template_decl (tem
);
6155 else if (minimal_parse_mode
)
6157 = build_min_nt (DECL_STMT
, copy_to_permanent (declarator
),
6158 copy_to_permanent (declspecs
),
6163 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6164 /* Tell the back-end to use or not use .common as appropriate. If we say
6165 -fconserve-space, we want this to save .data space, at the expense of
6166 wrong semantics. If we say -fno-conserve-space, we want this to
6167 produce errors about redefs; to do this we force variables into the
6169 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
6172 if (! processing_template_decl
)
6175 /* Corresponding pop_obstacks is done in `cp_finish_decl'. */
6176 push_obstacks_nochange ();
6179 /* We have no way of knowing whether the initializer will need to be
6180 evaluated at run-time or not until we've parsed it, so let's just put
6181 it in the permanent obstack. (jason) */
6183 && ! (TREE_CODE (tem
) == PARM_DECL
6184 || (TREE_READONLY (tem
)
6185 && (TREE_CODE (tem
) == VAR_DECL
6186 || TREE_CODE (tem
) == FIELD_DECL
))))
6188 /* When parsing and digesting the initializer,
6189 use temporary storage. Do this even if we will ignore the value. */
6190 if (toplevel_bindings_p () && debug_temp_inits
)
6192 if (processing_template_decl
6193 || TYPE_NEEDS_CONSTRUCTING (type
)
6194 || TREE_CODE (type
) == REFERENCE_TYPE
)
6195 /* In this case, the initializer must lay down in permanent
6196 storage, since it will be saved until `finish_file' is run. */
6199 temporary_allocation ();
6211 tree type
= TREE_TYPE (decl
);
6212 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
6214 /* If this type of object needs a cleanup, and control may
6215 jump past it, make a new binding level so that it is cleaned
6216 up only when it is initialized first. */
6217 if (TYPE_NEEDS_DESTRUCTOR (type
)
6218 && current_binding_level
->more_cleanups_ok
== 0)
6219 pushlevel_temporary (1);
6222 /* Is it valid for this decl to have an initializer at all?
6223 If not, set INITIALIZED to zero, which will indirectly
6224 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6226 /* Don't allow initializations for incomplete types except for
6227 arrays which might be completed by the initialization. */
6228 if (type
== error_mark_node
)
6229 ; /* Don't complain again. */
6230 else if (TYPE_SIZE (complete_type (type
)) != NULL_TREE
)
6231 ; /* A complete type is ok. */
6232 else if (TREE_CODE (type
) != ARRAY_TYPE
)
6234 cp_error ("variable `%#D' has initializer but incomplete type",
6238 else if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
6240 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
6241 cp_error ("elements of array `%#D' have incomplete type", decl
);
6242 /* else we already gave an error in start_decl. */
6248 && TREE_CODE (decl
) != TYPE_DECL
6249 && TREE_CODE (decl
) != TEMPLATE_DECL
6250 && IS_AGGR_TYPE (type
) && ! DECL_EXTERNAL (decl
))
6252 if ((! processing_template_decl
|| ! uses_template_parms (type
))
6253 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
6255 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6257 /* Change the type so that assemble_variable will give
6258 DECL an rtl we can live with: (mem (const_int 0)). */
6259 TREE_TYPE (decl
) = error_mark_node
;
6260 type
= error_mark_node
;
6264 /* If any base type in the hierarchy of TYPE needs a constructor,
6265 then we set initialized to 1. This way any nodes which are
6266 created for the purposes of initializing this aggregate
6267 will live as long as it does. This is necessary for global
6268 aggregates which do not have their initializers processed until
6269 the end of the file. */
6270 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
6275 /* We don't do this yet for GNU C++. */
6276 /* For a local variable, define the RTL now. */
6277 if (! toplevel_bindings_p ()
6278 /* But not if this is a duplicate decl
6279 and we preserved the rtl from the previous one
6280 (which may or may not happen). */
6281 && DECL_RTL (tem
) == NULL_RTX
)
6283 if (TYPE_SIZE (TREE_TYPE (tem
)) != NULL_TREE
)
6285 else if (TREE_CODE (TREE_TYPE (tem
)) == ARRAY_TYPE
6286 && DECL_INITIAL (tem
) != NULL_TREE
)
6292 DECL_INITIAL (decl
) = NULL_TREE
;
6295 /* Handle initialization of references.
6296 These three arguments from from `cp_finish_decl', and have the
6297 same meaning here that they do there.
6299 Quotes on semantics can be found in ARM 8.4.3. */
6302 grok_reference_init (decl
, type
, init
, cleanupp
)
6303 tree decl
, type
, init
;
6308 if (init
== NULL_TREE
)
6310 if ((DECL_LANG_SPECIFIC (decl
) == 0
6311 || DECL_IN_AGGR_P (decl
) == 0)
6312 && ! DECL_THIS_EXTERN (decl
))
6314 cp_error ("`%D' declared as reference but not initialized", decl
);
6315 if (TREE_CODE (decl
) == VAR_DECL
)
6316 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6321 if (init
== error_mark_node
)
6324 if (TREE_CODE (type
) == REFERENCE_TYPE
6325 && TREE_CODE (init
) == CONSTRUCTOR
)
6327 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl
);
6331 if (TREE_TYPE (init
) && TREE_CODE (TREE_TYPE (init
)) == UNKNOWN_TYPE
)
6332 /* decay_conversion is probably wrong for references to functions. */
6333 init
= decay_conversion (instantiate_type (TREE_TYPE (type
), init
, 1));
6335 if (TREE_CODE (init
) == TREE_LIST
)
6336 init
= build_compound_expr (init
);
6338 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
6339 init
= convert_from_reference (init
);
6341 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
6342 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
6344 /* Note: default conversion is only called in very special cases. */
6345 init
= default_conversion (init
);
6348 tmp
= convert_to_reference
6349 (type
, init
, CONV_IMPLICIT
,
6350 LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
, decl
);
6352 if (tmp
== error_mark_node
)
6354 else if (tmp
!= NULL_TREE
)
6357 DECL_INITIAL (decl
) = save_expr (init
);
6361 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
6365 /* ?? Can this be optimized in some cases to
6366 hand back the DECL_INITIAL slot?? */
6367 if (TYPE_SIZE (TREE_TYPE (type
)))
6369 init
= convert_from_reference (decl
);
6370 if (TREE_PERMANENT (decl
))
6371 init
= copy_to_permanent (init
);
6372 SET_DECL_REFERENCE_SLOT (decl
, init
);
6375 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
6377 expand_static_init (decl
, DECL_INITIAL (decl
));
6378 DECL_INITIAL (decl
) = NULL_TREE
;
6383 if (TREE_CODE (decl
) == VAR_DECL
)
6384 SET_DECL_REFERENCE_SLOT (decl
, error_mark_node
);
6388 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6389 mucking with forces it does not comprehend (i.e. initialization with a
6390 constructor). If we are at global scope and won't go into COMMON, fill
6391 it in with a dummy CONSTRUCTOR to force the variable into .data;
6392 otherwise we can use error_mark_node. */
6395 obscure_complex_init (decl
, init
)
6398 if (! flag_no_inline
&& TREE_STATIC (decl
))
6400 if (extract_init (decl
, init
))
6404 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6405 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
6406 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
6410 DECL_INITIAL (decl
) = error_mark_node
;
6415 /* Finish processing of a declaration;
6416 install its line number and initial value.
6417 If the length of an array type is not known before,
6418 it must be determined now, from the initial value, or it is an error.
6420 Call `pop_obstacks' iff NEED_POP is nonzero.
6422 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
6423 for aggregates that have constructors alive on the permanent obstack,
6424 so that the global initializing functions can be written at the end.
6426 INIT0 holds the value of an initializer that should be allowed to escape
6429 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
6430 if the (init) syntax was used.
6432 For functions that take default parameters, DECL points to its
6433 "maximal" instantiation. `cp_finish_decl' must then also declared its
6434 subsequently lower and lower forms of instantiation, checking for
6435 ambiguity as it goes. This can be sped up later. */
6438 cp_finish_decl (decl
, init
, asmspec_tree
, need_pop
, flags
)
6445 tree cleanup
= NULL_TREE
, ttype
;
6447 int temporary
= allocation_temporary_p ();
6448 char *asmspec
= NULL
;
6449 int was_readonly
= 0;
6450 int already_used
= 0;
6452 /* If this is 0, then we did not change obstacks. */
6456 error ("assignment (not initialization) in declaration");
6460 /* If a name was specified, get the string. */
6462 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6464 /* If the type of the thing we are declaring either has
6465 a constructor, or has a virtual function table pointer,
6466 AND its initialization was accepted by `start_decl',
6467 then we stayed on the permanent obstack through the
6468 declaration, otherwise, changed obstacks as GCC would. */
6470 type
= TREE_TYPE (decl
);
6472 if (type
== error_mark_node
)
6474 if (toplevel_bindings_p () && temporary
)
6475 end_temporary_allocation ();
6480 if (processing_template_decl
)
6482 if (init
&& DECL_INITIAL (decl
))
6483 DECL_INITIAL (decl
) = init
;
6484 if (minimal_parse_mode
&& ! DECL_ARTIFICIAL (decl
))
6486 tree stmt
= DECL_VINDEX (decl
);
6487 /* If the decl is declaring a member of a local class (in a
6488 template function), there will be no associated stmt. */
6489 if (stmt
!= NULL_TREE
)
6491 DECL_VINDEX (decl
) = NULL_TREE
;
6492 TREE_OPERAND (stmt
, 2) = copy_to_permanent (init
);
6499 /* Take care of TYPE_DECLs up front. */
6500 if (TREE_CODE (decl
) == TYPE_DECL
)
6502 if (init
&& DECL_INITIAL (decl
))
6504 /* typedef foo = bar; store the type of bar as the type of foo. */
6505 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
6506 DECL_INITIAL (decl
) = init
= NULL_TREE
;
6508 if (type
!= error_mark_node
6509 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
6511 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6512 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
6513 set_identifier_type_value (DECL_NAME (decl
), type
);
6514 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
6516 GNU_xref_decl (current_function_decl
, decl
);
6518 /* If we have installed this as the canonical typedef for this
6519 type, and that type has not been defined yet, delay emitting
6520 the debug information for it, as we will emit it later. */
6521 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6522 && TYPE_SIZE (TREE_TYPE (decl
)) == NULL_TREE
)
6523 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6525 rest_of_decl_compilation (decl
, NULL_PTR
,
6526 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
6529 if (TREE_CODE (decl
) != FUNCTION_DECL
)
6531 ttype
= target_type (type
);
6534 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
6535 && TYPE_NEEDS_CONSTRUCTING (type
))
6538 /* Currently, GNU C++ puts constants in text space, making them
6539 impossible to initialize. In the future, one would hope for
6540 an operating system which understood the difference between
6541 initialization and the running of a program. */
6543 TREE_READONLY (decl
) = 0;
6546 if (TREE_CODE (decl
) == FIELD_DECL
)
6548 if (init
&& init
!= error_mark_node
)
6549 my_friendly_assert (TREE_PERMANENT (init
), 147);
6553 /* This must override the asm specifier which was placed
6554 by grokclassfn. Lay this out fresh. */
6555 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
6556 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
6557 make_decl_rtl (decl
, asmspec
, 0);
6560 /* If `start_decl' didn't like having an initialization, ignore it now. */
6561 else if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
6563 else if (DECL_EXTERNAL (decl
))
6565 else if (TREE_CODE (type
) == REFERENCE_TYPE
6566 || (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE_REFERENCE (type
)))
6568 if (TREE_STATIC (decl
))
6569 make_decl_rtl (decl
, NULL_PTR
,
6570 toplevel_bindings_p ()
6571 || pseudo_global_level_p ());
6572 grok_reference_init (decl
, type
, init
, &cleanup
);
6576 GNU_xref_decl (current_function_decl
, decl
);
6578 if (TREE_CODE (decl
) == FIELD_DECL
)
6580 else if (TREE_CODE (decl
) == CONST_DECL
)
6582 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
6584 DECL_INITIAL (decl
) = init
;
6586 /* This will keep us from needing to worry about our obstacks. */
6587 my_friendly_assert (init
!= NULL_TREE
, 149);
6592 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
6594 if (TREE_CODE (type
) == ARRAY_TYPE
)
6595 init
= digest_init (type
, init
, (tree
*) 0);
6596 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6598 if (TYPE_NON_AGGREGATE_CLASS (type
))
6600 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
6602 init
= error_mark_node
;
6605 goto dont_use_constructor
;
6610 dont_use_constructor
:
6611 if (TREE_CODE (init
) != TREE_VEC
)
6612 init
= store_init_value (decl
, init
);
6616 /* We must hide the initializer so that expand_decl
6617 won't try to do something it does not understand. */
6618 init
= obscure_complex_init (decl
, init
);
6620 else if (DECL_EXTERNAL (decl
))
6622 else if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't'
6623 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
6626 while (TREE_CODE (ctype
) == ARRAY_TYPE
)
6627 ctype
= TREE_TYPE (ctype
);
6628 if (! TYPE_NEEDS_CONSTRUCTING (ctype
))
6630 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (ctype
))
6631 cp_error ("structure `%D' with uninitialized const members", decl
);
6632 if (CLASSTYPE_REF_FIELDS_NEED_INIT (ctype
))
6633 cp_error ("structure `%D' with uninitialized reference members",
6637 if (TREE_CODE (decl
) == VAR_DECL
6638 && !DECL_INITIAL (decl
)
6639 && !TYPE_NEEDS_CONSTRUCTING (type
)
6640 && (TYPE_READONLY (type
) || TREE_READONLY (decl
)))
6641 cp_error ("uninitialized const `%D'", decl
);
6643 if (TYPE_SIZE (type
) != NULL_TREE
6644 && TYPE_NEEDS_CONSTRUCTING (type
))
6645 init
= obscure_complex_init (decl
, NULL_TREE
);
6647 else if (TREE_CODE (decl
) == VAR_DECL
6648 && TREE_CODE (type
) != REFERENCE_TYPE
6649 && (TYPE_READONLY (type
) || TREE_READONLY (decl
)))
6651 /* ``Unless explicitly declared extern, a const object does not have
6652 external linkage and must be initialized. ($8.4; $12.1)'' ARM 7.1.6
6653 However, if it's `const int foo = 1; const int foo;', don't complain
6654 about the second decl, since it does have an initializer before.
6655 We deliberately don't complain about arrays, because they're
6656 supposed to be initialized by a constructor. */
6657 if (! DECL_INITIAL (decl
)
6658 && TREE_CODE (type
) != ARRAY_TYPE
6659 && (!pedantic
|| !current_class_type
))
6660 cp_error ("uninitialized const `%#D'", decl
);
6663 /* For top-level declaration, the initial value was read in
6664 the temporary obstack. MAXINDEX, rtl, etc. to be made below
6665 must go in the permanent obstack; but don't discard the
6666 temporary data yet. */
6668 if (toplevel_bindings_p () && temporary
)
6669 end_temporary_allocation ();
6671 /* Deduce size of array from initialization, if not already known. */
6673 if (TREE_CODE (type
) == ARRAY_TYPE
6674 && TYPE_DOMAIN (type
) == NULL_TREE
6675 && TREE_CODE (decl
) != TYPE_DECL
)
6678 = (TREE_STATIC (decl
)
6679 /* Even if pedantic, an external linkage array
6680 may have incomplete type at first. */
6681 ? pedantic
&& ! DECL_EXTERNAL (decl
)
6682 : !DECL_EXTERNAL (decl
));
6683 tree initializer
= init
? init
: DECL_INITIAL (decl
);
6684 int failure
= complete_array_type (type
, initializer
, do_default
);
6687 cp_error ("initializer fails to determine size of `%D'", decl
);
6692 cp_error ("array size missing in `%D'", decl
);
6693 /* If a `static' var's size isn't known, make it extern as
6694 well as static, so it does not get allocated. If it's not
6695 `static', then don't mark it extern; finish_incomplete_decl
6696 will give it a default size and it will get allocated. */
6697 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
6698 DECL_EXTERNAL (decl
) = 1;
6701 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
6702 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
6704 cp_error ("zero-size array `%D'", decl
);
6706 layout_decl (decl
, 0);
6709 if (TREE_CODE (decl
) == VAR_DECL
)
6711 if (DECL_SIZE (decl
) == NULL_TREE
6712 && TYPE_SIZE (complete_type (TREE_TYPE (decl
))) != NULL_TREE
)
6713 layout_decl (decl
, 0);
6715 if (TREE_STATIC (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
6717 /* A static variable with an incomplete type:
6718 that is an error if it is initialized.
6719 Otherwise, let it through, but if it is not `extern'
6720 then it may cause an error message later. */
6721 if (DECL_INITIAL (decl
) != NULL_TREE
)
6722 cp_error ("storage size of `%D' isn't known", decl
);
6725 else if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
6727 /* An automatic variable with an incomplete type: that is an error.
6728 Don't talk about array types here, since we took care of that
6729 message in grokdeclarator. */
6730 cp_error ("storage size of `%D' isn't known", decl
);
6731 TREE_TYPE (decl
) = error_mark_node
;
6733 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
6734 /* Let debugger know it should output info for this type. */
6735 note_debug_info_needed (ttype
);
6737 if (TREE_STATIC (decl
) && DECL_CONTEXT (decl
)
6738 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl
))) == 't')
6739 note_debug_info_needed (DECL_CONTEXT (decl
));
6741 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
6742 && DECL_SIZE (decl
) != NULL_TREE
6743 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
6745 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
6746 constant_expression_warning (DECL_SIZE (decl
));
6748 cp_error ("storage size of `%D' isn't constant", decl
);
6751 if (! DECL_EXTERNAL (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
6752 /* Cleanups for static variables are handled by `finish_file'. */
6753 && ! TREE_STATIC (decl
))
6755 int yes
= suspend_momentary ();
6756 cleanup
= maybe_build_cleanup (decl
);
6757 resume_momentary (yes
);
6760 /* PARM_DECLs get cleanups, too. */
6761 else if (TREE_CODE (decl
) == PARM_DECL
&& TYPE_NEEDS_DESTRUCTOR (type
))
6764 end_temporary_allocation ();
6765 cleanup
= maybe_build_cleanup (decl
);
6767 resume_temporary_allocation ();
6770 /* Output the assembler code and/or RTL code for variables and functions,
6771 unless the type is an undefined structure or union.
6772 If not, it will get done when the type is completed. */
6774 was_incomplete
= (DECL_SIZE (decl
) == NULL_TREE
);
6776 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
6777 || TREE_CODE (decl
) == RESULT_DECL
)
6779 /* ??? FIXME: What about nested classes? */
6780 int toplev
= toplevel_bindings_p () || pseudo_global_level_p ();
6782 = (TREE_STATIC (decl
) && TYPE_NEEDS_DESTRUCTOR (type
)
6783 && allocation_temporary_p ());
6786 end_temporary_allocation ();
6788 /* Extern inline function static data has external linkage. */
6789 if (TREE_CODE (decl
) == VAR_DECL
6790 && TREE_STATIC (decl
)
6791 && current_function_decl
6792 && DECL_CONTEXT (decl
) == current_function_decl
6793 && DECL_THIS_INLINE (current_function_decl
)
6794 && TREE_PUBLIC (current_function_decl
))
6796 if (DECL_INTERFACE_KNOWN (current_function_decl
))
6798 TREE_PUBLIC (decl
) = 1;
6799 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
6801 /* We can only do this if we can use common or weak, and we
6802 can't if it has been initialized and we don't support weak. */
6803 else if (DECL_INITIAL (decl
) == NULL_TREE
6804 || DECL_INITIAL (decl
) == error_mark_node
)
6806 TREE_PUBLIC (decl
) = 1;
6807 DECL_COMMON (decl
) = 1;
6810 make_decl_one_only (decl
);
6812 if (TREE_PUBLIC (decl
))
6813 DECL_ASSEMBLER_NAME (decl
)
6814 = build_static_name (current_function_decl
, DECL_NAME (decl
));
6815 else if (! DECL_ARTIFICIAL (decl
))
6816 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
6819 else if (TREE_CODE (decl
) == VAR_DECL
6820 && DECL_LANG_SPECIFIC (decl
)
6821 && DECL_COMDAT (decl
))
6823 /* Dynamically initialized vars go into common. */
6824 if (DECL_INITIAL (decl
) == NULL_TREE
6825 || DECL_INITIAL (decl
) == error_mark_node
)
6826 DECL_COMMON (decl
) = 1;
6827 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
6829 DECL_COMMON (decl
) = 1;
6830 DECL_INITIAL (decl
) = error_mark_node
;
6834 /* Statically initialized vars are weak or comdat, if
6837 make_decl_one_only (decl
);
6840 /* we can't do anything useful; leave vars for explicit
6842 DECL_EXTERNAL (decl
) = 1;
6843 DECL_NOT_REALLY_EXTERN (decl
) = 0;
6848 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VIRTUAL_P (decl
))
6849 make_decl_rtl (decl
, NULL_PTR
, toplev
);
6850 else if (TREE_CODE (decl
) == VAR_DECL
6851 && TREE_READONLY (decl
)
6852 && DECL_INITIAL (decl
) != NULL_TREE
6853 && DECL_INITIAL (decl
) != error_mark_node
6854 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
6856 DECL_INITIAL (decl
) = save_expr (DECL_INITIAL (decl
));
6859 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
6862 && TREE_STATIC (decl
)
6863 && ! TREE_SIDE_EFFECTS (decl
)
6864 && ! TREE_PUBLIC (decl
)
6865 && ! DECL_EXTERNAL (decl
)
6866 && ! TYPE_NEEDS_DESTRUCTOR (type
)
6867 && DECL_MODE (decl
) != BLKmode
)
6869 /* If this variable is really a constant, then fill its DECL_RTL
6870 slot with something which won't take up storage.
6871 If something later should take its address, we can always give
6872 it legitimate RTL at that time. */
6873 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
6874 store_expr (DECL_INITIAL (decl
), DECL_RTL (decl
), 0);
6875 TREE_ASM_WRITTEN (decl
) = 1;
6877 else if (toplev
&& ! TREE_PUBLIC (decl
))
6879 /* If this is a static const, change its apparent linkage
6880 if it belongs to a #pragma interface. */
6881 if (!interface_unknown
)
6883 TREE_PUBLIC (decl
) = 1;
6884 DECL_EXTERNAL (decl
) = interface_only
;
6886 make_decl_rtl (decl
, asmspec
, toplev
);
6889 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
6891 else if (TREE_CODE (decl
) == VAR_DECL
6892 && DECL_LANG_SPECIFIC (decl
)
6893 && DECL_IN_AGGR_P (decl
))
6895 if (TREE_STATIC (decl
))
6897 if (init
== NULL_TREE
6898 #ifdef DEFAULT_STATIC_DEFS
6899 /* If this code is dead, then users must
6900 explicitly declare static member variables
6901 outside the class def'n as well. */
6902 && TYPE_NEEDS_CONSTRUCTING (type
)
6906 DECL_EXTERNAL (decl
) = 1;
6907 make_decl_rtl (decl
, asmspec
, 1);
6910 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
6913 /* Just a constant field. Should not need any rtl. */
6917 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
6920 resume_temporary_allocation ();
6922 if (type
!= error_mark_node
6923 && TYPE_LANG_SPECIFIC (type
)
6924 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
6925 abstract_virtuals_error (decl
, type
);
6926 else if ((TREE_CODE (type
) == FUNCTION_TYPE
6927 || TREE_CODE (type
) == METHOD_TYPE
)
6928 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
6929 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (type
)))
6930 abstract_virtuals_error (decl
, TREE_TYPE (type
));
6932 if (TYPE_LANG_SPECIFIC (type
) && IS_SIGNATURE (type
))
6933 signature_error (decl
, type
);
6934 else if ((TREE_CODE (type
) == FUNCTION_TYPE
6935 || TREE_CODE (type
) == METHOD_TYPE
)
6936 && TYPE_LANG_SPECIFIC (TREE_TYPE (type
))
6937 && IS_SIGNATURE (TREE_TYPE (type
)))
6938 signature_error (decl
, TREE_TYPE (type
));
6940 if (TREE_CODE (decl
) == FUNCTION_DECL
)
6942 else if (DECL_EXTERNAL (decl
)
6943 && ! (DECL_LANG_SPECIFIC (decl
)
6944 && DECL_NOT_REALLY_EXTERN (decl
)))
6947 DECL_INITIAL (decl
) = init
;
6949 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
6951 /* Cleanups for static variables are handled by `finish_file'. */
6952 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
6953 || TYPE_NEEDS_DESTRUCTOR (type
))
6954 expand_static_init (decl
, init
);
6958 /* This is a declared decl which must live until the
6959 end of the binding contour. It may need a cleanup. */
6961 /* Recompute the RTL of a local array now
6962 if it used to be an incomplete type. */
6963 if (was_incomplete
&& ! TREE_STATIC (decl
))
6965 /* If we used it already as memory, it must stay in memory. */
6966 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6967 /* If it's still incomplete now, no init will save it. */
6968 if (DECL_SIZE (decl
) == NULL_TREE
)
6969 DECL_INITIAL (decl
) = NULL_TREE
;
6972 else if (! TREE_ASM_WRITTEN (decl
)
6973 && (TYPE_SIZE (type
) != NULL_TREE
6974 || TREE_CODE (type
) == ARRAY_TYPE
))
6976 /* Do this here, because we did not expand this decl's
6977 rtl in start_decl. */
6978 if (DECL_RTL (decl
) == NULL_RTX
)
6982 /* XXX: Why don't we use decl here? */
6983 /* Ans: Because it was already expanded? */
6984 if (! expand_decl_cleanup (NULL_TREE
, cleanup
))
6985 cp_error ("parser lost in parsing declaration of `%D'",
6987 /* Cleanup used up here. */
6988 cleanup
= NULL_TREE
;
6992 if (current_binding_level
->is_for_scope
)
6994 struct binding_level
*outer
= current_binding_level
->level_chain
;
6996 /* Check to see if the same name is already bound at
6997 the outer level, either because it was directly declared,
6998 or because a dead for-decl got preserved. In either case,
6999 the code would not have been valid under the ARM
7000 scope rules, so clear is_for_scope for the
7001 current_binding_level.
7003 Otherwise, we need to preserve the temp slot for decl
7004 to last into the outer binding level. */
7006 int handling_dead_for_vars
= 0;
7007 tree link
= outer
->names
;
7008 for (; ; link
= TREE_CHAIN (link
))
7010 if (link
== NULL
&& handling_dead_for_vars
== 0)
7012 link
= outer
->dead_vars_from_for
;
7013 handling_dead_for_vars
= 1;
7017 if (DECL_IN_MEMORY_P (decl
))
7018 preserve_temp_slots (DECL_RTL (decl
));
7021 if (DECL_NAME (link
) == DECL_NAME (decl
))
7023 if (handling_dead_for_vars
)
7026 = purpose_member (DECL_NAME (decl
),
7027 current_binding_level
->shadowed
);
7028 if (shadowing
&& TREE_VALUE (shadowing
) == link
)
7029 TREE_VALUE (shadowing
)
7030 = DECL_SHADOWED_FOR_VAR (link
);
7032 current_binding_level
->is_for_scope
= 0;
7038 expand_start_target_temps ();
7040 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7042 /* Compute and store the initial value. */
7043 expand_decl_init (decl
);
7044 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7046 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7048 emit_line_note (DECL_SOURCE_FILE (decl
),
7049 DECL_SOURCE_LINE (decl
));
7050 expand_aggr_init (decl
, init
, 0, flags
);
7053 /* Set this to 0 so we can tell whether an aggregate which
7054 was initialized was ever used. Don't do this if it has a
7055 destructor, so we don't complain about the 'resource
7056 allocation is initialization' idiom. */
7057 /* Now set attribute((unused)) on types so decls of
7058 of that type will be marked used. (see TREE_USED, above.)
7059 This avoids the warning problems this particular code
7060 tried to work around. */
7062 if (TYPE_NEEDS_CONSTRUCTING (type
)
7064 && cleanup
== NULL_TREE
7065 && DECL_NAME (decl
))
7066 TREE_USED (decl
) = 0;
7069 TREE_USED (decl
) = 1;
7072 /* Cleanup any temporaries needed for the initial value. */
7073 expand_end_target_temps ();
7075 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7077 /* Store the cleanup, if there was one. */
7080 if (! expand_decl_cleanup (decl
, cleanup
))
7081 cp_error ("parser lost in parsing declaration of `%D'",
7088 /* Undo call to `pushclass' that was done in `start_decl'
7089 due to initialization of qualified member variable.
7090 I.e., Foo::x = 10; */
7092 tree context
= DECL_REAL_CONTEXT (decl
);
7094 && TREE_CODE_CLASS (TREE_CODE (context
)) == 't'
7095 && (TREE_CODE (decl
) == VAR_DECL
7096 /* We also have a pushclass done that we need to undo here
7097 if we're at top level and declare a method. */
7098 || TREE_CODE (decl
) == FUNCTION_DECL
)
7099 /* If size hasn't been set, we're still defining it,
7100 and therefore inside the class body; don't pop
7101 the binding level.. */
7102 && TYPE_SIZE (context
) != NULL_TREE
7103 && context
== current_class_type
)
7110 /* If requested, warn about definitions of large data objects. */
7112 if (warn_larger_than
7113 && ! processing_template_decl
7114 && (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
7115 && !DECL_EXTERNAL (decl
))
7117 register tree decl_size
= DECL_SIZE (decl
);
7119 if (decl_size
&& TREE_CODE (decl_size
) == INTEGER_CST
)
7121 unsigned units
= TREE_INT_CST_LOW (decl_size
) / BITS_PER_UNIT
;
7123 if (units
> larger_than_size
)
7124 warning_with_decl (decl
, "size of `%s' is %u bytes", units
);
7130 /* Resume permanent allocation, if not within a function. */
7131 /* The corresponding push_obstacks_nochange is in start_decl,
7132 start_method, groktypename, and in grokfield. */
7137 TREE_READONLY (decl
) = 1;
7140 /* This is here for a midend callback from c-common.c */
7143 finish_decl (decl
, init
, asmspec_tree
)
7147 cp_finish_decl (decl
, init
, asmspec_tree
, 1, 0);
7151 expand_static_init (decl
, init
)
7155 tree oldstatic
= value_member (decl
, static_aggregates
);
7159 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
7160 cp_error ("multiple initializations given for `%D'", decl
);
7162 else if (! toplevel_bindings_p () && ! pseudo_global_level_p ())
7164 /* Emit code to perform this initialization but once. */
7167 /* Remember this information until end of file. */
7168 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7170 /* Emit code to perform this initialization but once. */
7171 temp
= get_temp_name (integer_type_node
, 1);
7172 rest_of_decl_compilation (temp
, NULL_PTR
, 0, 0);
7173 expand_start_cond (build_binary_op (EQ_EXPR
, temp
,
7174 integer_zero_node
, 1), 0);
7175 expand_start_target_temps ();
7177 expand_assignment (temp
, integer_one_node
, 0, 0);
7178 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
7179 || (init
&& TREE_CODE (init
) == TREE_LIST
))
7181 expand_aggr_init (decl
, init
, 0, 0);
7182 do_pending_stack_adjust ();
7185 expand_assignment (decl
, init
, 0, 0);
7187 /* Cleanup any temporaries needed for the initial value. */
7188 expand_end_target_temps ();
7190 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7192 tree cleanup
, fcall
;
7193 static tree Atexit
= 0;
7196 tree atexit_fndecl
, PFV
, pfvlist
;
7197 /* Remember this information until end of file. */
7198 push_obstacks (&permanent_obstack
, &permanent_obstack
);
7199 PFV
= build_pointer_type (build_function_type
7200 (void_type_node
, void_list_node
));
7202 pfvlist
= tree_cons (NULL_TREE
, PFV
, void_list_node
);
7204 push_lang_context (lang_name_c
);
7206 = builtin_function ("atexit",
7207 build_function_type (void_type_node
,
7209 NOT_BUILT_IN
, NULL_PTR
);
7210 assemble_external (atexit_fndecl
);
7211 Atexit
= default_conversion (atexit_fndecl
);
7212 pop_lang_context ();
7216 cleanup
= start_anon_func ();
7217 expand_expr_stmt (build_cleanup (decl
));
7219 mark_addressable (cleanup
);
7220 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
7221 fcall
= build_function_call (Atexit
, expr_tree_cons (NULL_TREE
, cleanup
, NULL_TREE
));
7222 expand_expr_stmt (fcall
);
7226 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl
)))
7228 static_aggregates
= perm_tree_cons (temp
, decl
, static_aggregates
);
7229 TREE_STATIC (static_aggregates
) = 1;
7232 /* Resume old (possibly temporary) allocation. */
7237 /* This code takes into account memory allocation
7238 policy of `start_decl'. Namely, if TYPE_NEEDS_CONSTRUCTING
7239 does not hold for this object, then we must make permanent
7240 the storage currently in the temporary obstack. */
7241 if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
7242 preserve_initializer ();
7243 static_aggregates
= perm_tree_cons (init
, decl
, static_aggregates
);
7247 /* Make TYPE a complete type based on INITIAL_VALUE.
7248 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7249 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
7252 complete_array_type (type
, initial_value
, do_default
)
7253 tree type
, initial_value
;
7256 register tree maxindex
= NULL_TREE
;
7261 /* Note MAXINDEX is really the maximum index,
7262 one less than the size. */
7263 if (TREE_CODE (initial_value
) == STRING_CST
)
7266 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
7267 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
7270 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7272 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
7273 maxindex
= size_binop (MINUS_EXPR
, integer_zero_node
, size_one_node
);
7274 for (; elts
; elts
= TREE_CHAIN (elts
))
7276 if (TREE_PURPOSE (elts
))
7277 maxindex
= TREE_PURPOSE (elts
);
7279 maxindex
= size_binop (PLUS_EXPR
, maxindex
, size_one_node
);
7281 maxindex
= copy_node (maxindex
);
7285 /* Make an error message unless that happened already. */
7286 if (initial_value
!= error_mark_node
)
7289 /* Prevent further error messages. */
7290 maxindex
= build_int_2 (0, 0);
7297 maxindex
= build_int_2 (0, 0);
7305 TYPE_DOMAIN (type
) = build_index_type (maxindex
);
7306 if (! TREE_TYPE (maxindex
))
7307 TREE_TYPE (maxindex
) = TYPE_DOMAIN (type
);
7309 itype
= TREE_TYPE (initial_value
);
7312 if (itype
&& !TYPE_DOMAIN (itype
))
7313 TYPE_DOMAIN (itype
) = TYPE_DOMAIN (type
);
7314 /* The type of the main variant should never be used for arrays
7315 of different sizes. It should only ever be completed with the
7316 size of the array. */
7317 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
7318 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = TYPE_DOMAIN (type
);
7321 /* Lay out the type now that we can get the real answer. */
7328 /* Return zero if something is declared to be a member of type
7329 CTYPE when in the context of CUR_TYPE. STRING is the error
7330 message to print in that case. Otherwise, quietly return 1. */
7333 member_function_or_else (ctype
, cur_type
, string
)
7334 tree ctype
, cur_type
;
7337 if (ctype
&& ctype
!= cur_type
)
7339 error (string
, TYPE_NAME_STRING (ctype
));
7345 /* Subroutine of `grokdeclarator'. */
7347 /* Generate errors possibly applicable for a given set of specifiers.
7348 This is for ARM $7.1.2. */
7351 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
7354 int virtualp
, quals
, friendp
, raises
, inlinep
;
7357 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
7359 cp_error ("`%D' declared as an `inline' %s", object
, type
);
7361 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
7364 cp_error_at ("invalid friend declaration", object
);
7366 cp_error_at ("invalid exception specifications", object
);
7369 /* CTYPE is class type, or null if non-class.
7370 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7372 DECLARATOR is the function's name.
7373 VIRTUALP is truthvalue of whether the function is virtual or not.
7374 FLAGS are to be passed through to `grokclassfn'.
7375 QUALS are qualifiers indicating whether the function is `const'
7377 RAISES is a list of exceptions that this function can raise.
7378 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7379 not look, and -1 if we should not call `grokclassfn' at all. */
7382 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
7383 raises
, attrlist
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
7387 tree orig_declarator
;
7389 enum overload_flags flags
;
7390 tree quals
, raises
, attrlist
;
7391 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
7394 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7398 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
7399 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
7405 type
= build_exception_variant (type
, raises
);
7408 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7409 /* propagate volatile out from type to decl */
7410 if (TYPE_VOLATILE (type
))
7411 TREE_THIS_VOLATILE (decl
) = 1;
7413 /* Should probably propagate const out from type to decl I bet (mrs). */
7416 DECL_STATIC_FUNCTION_P (decl
) = 1;
7417 DECL_CONTEXT (decl
) = ctype
;
7421 DECL_CLASS_CONTEXT (decl
) = ctype
;
7423 if (ctype
== NULL_TREE
&& ! strcmp (IDENTIFIER_POINTER (declarator
), "main"))
7426 error ("cannot declare `main' to be inline");
7428 error ("cannot declare `main' to be static");
7433 TREE_PUBLIC (decl
) = publicp
;
7436 DECL_INTERFACE_KNOWN (decl
) = 1;
7437 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7441 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
7443 DECL_EXTERNAL (decl
) = 1;
7444 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
7446 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
7447 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
7451 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
7452 grok_op_properties (decl
, virtualp
, check
< 0);
7454 if (ctype
&& hack_decl_function_context (decl
))
7455 DECL_NO_STATIC_CHAIN (decl
) = 1;
7457 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7458 if (TREE_PURPOSE (t
)
7459 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7461 add_defarg_fn (decl
);
7466 TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7467 /* A friend declaration of the form friend void f<>(). */
7468 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7470 /* Caller will do the rest of this. */
7474 if (check
&& funcdef_flag
)
7475 DECL_INITIAL (decl
) = error_mark_node
;
7477 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
7480 /* Just handle constructors here. We could do this
7481 inside the following if stmt, but I think
7482 that the code is more legible by breaking this
7483 case out. See comments below for what each of
7484 the following calls is supposed to do. */
7485 DECL_CONSTRUCTOR_P (decl
) = 1;
7487 grokclassfn (ctype
, declarator
, decl
, flags
, quals
);
7489 decl
= check_explicit_specialization (orig_declarator
, decl
,
7496 tmp
= check_classfn (ctype
, decl
);
7498 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
7499 tmp
= DECL_TEMPLATE_RESULT(tmp
);
7501 if (tmp
&& DECL_ARTIFICIAL (tmp
))
7502 cp_error ("definition of implicitly-declared `%D'", tmp
);
7503 if (tmp
&& duplicate_decls (decl
, tmp
))
7506 if (! grok_ctor_properties (ctype
, decl
))
7509 if (check
== 0 && ! current_function_decl
)
7511 tmp
= IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl
));
7512 if (tmp
== NULL_TREE
)
7513 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl
)) = decl
;
7514 else if (TREE_CODE (tmp
) != TREE_CODE (decl
))
7515 cp_error ("inconsistent declarations for `%D'", decl
);
7518 duplicate_decls (decl
, tmp
);
7520 /* avoid creating circularities. */
7521 DECL_CHAIN (decl
) = NULL_TREE
;
7523 make_decl_rtl (decl
, NULL_PTR
, 1);
7530 /* Function gets the ugly name, field gets the nice one.
7531 This call may change the type of the function (because
7532 of default parameters)! */
7533 if (ctype
!= NULL_TREE
)
7534 grokclassfn (ctype
, cname
, decl
, flags
, quals
);
7536 decl
= check_explicit_specialization (orig_declarator
, decl
,
7541 if (ctype
!= NULL_TREE
&& check
)
7543 tmp
= check_classfn (ctype
, decl
);
7545 if (tmp
&& TREE_CODE (tmp
) == TEMPLATE_DECL
)
7546 tmp
= DECL_TEMPLATE_RESULT (tmp
);
7548 if (tmp
&& DECL_STATIC_FUNCTION_P (tmp
)
7549 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7551 /* Remove the `this' parm added by grokclassfn.
7552 XXX Isn't this done in start_function, too? */
7553 revert_static_member_fn (&decl
, NULL
, NULL
);
7554 last_function_parms
= TREE_CHAIN (last_function_parms
);
7556 if (tmp
&& DECL_ARTIFICIAL (tmp
))
7557 cp_error ("definition of implicitly-declared `%D'", tmp
);
7560 if (!duplicate_decls (decl
, tmp
))
7561 my_friendly_abort (892);
7566 if (ctype
== NULL_TREE
|| check
)
7569 /* Now install the declaration of this function so that others may
7570 find it (esp. its DECL_FRIENDLIST). Don't do this for local class
7572 if (! current_function_decl
)
7574 if (!DECL_TEMPLATE_SPECIALIZATION (decl
))
7576 /* We don't do this for specializations since the
7577 equivalent checks will be done later. Also, at this
7578 point the DECL_ASSEMBLER_NAME is not yet fully
7581 /* FIXME: this should only need to look at
7582 IDENTIFIER_GLOBAL_VALUE. */
7583 tmp
= lookup_name (DECL_ASSEMBLER_NAME (decl
), 0);
7584 if (tmp
== NULL_TREE
)
7585 IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (decl
)) = decl
;
7586 else if (TREE_CODE (tmp
) != TREE_CODE (decl
))
7587 cp_error ("inconsistent declarations for `%D'", decl
);
7590 duplicate_decls (decl
, tmp
);
7592 /* avoid creating circularities. */
7593 DECL_CHAIN (decl
) = NULL_TREE
;
7598 cplus_decl_attributes (decl
, TREE_PURPOSE (attrlist
),
7599 TREE_VALUE (attrlist
));
7600 make_decl_rtl (decl
, NULL_PTR
, 1);
7604 DECL_VIRTUAL_P (decl
) = 1;
7605 if (DECL_VINDEX (decl
) == NULL_TREE
)
7606 DECL_VINDEX (decl
) = error_mark_node
;
7607 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
7614 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
)
7617 RID_BIT_TYPE
*specbits_in
;
7622 RID_BIT_TYPE specbits
;
7624 specbits
= *specbits_in
;
7626 if (TREE_CODE (type
) == OFFSET_TYPE
)
7628 /* If you declare a static member so that it
7629 can be initialized, the code will reach here. */
7630 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
7631 type
= TREE_TYPE (type
);
7632 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
7633 DECL_CONTEXT (decl
) = basetype
;
7634 DECL_CLASS_CONTEXT (decl
) = basetype
;
7635 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
, declarator
);
7638 decl
= build_decl (VAR_DECL
, declarator
, complete_type (type
));
7640 DECL_ASSEMBLER_NAME (decl
) = current_namespace_id (DECL_ASSEMBLER_NAME (decl
));
7642 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
7644 DECL_THIS_EXTERN (decl
) = 1;
7645 DECL_EXTERNAL (decl
) = !initialized
;
7648 /* In class context, static means one per class,
7649 public access, and static storage. */
7650 if (DECL_FIELD_CONTEXT (decl
) != NULL_TREE
7651 && IS_AGGR_TYPE (DECL_FIELD_CONTEXT (decl
)))
7653 TREE_PUBLIC (decl
) = 1;
7654 TREE_STATIC (decl
) = 1;
7655 DECL_EXTERNAL (decl
) = 0;
7657 /* At top level, either `static' or no s.c. makes a definition
7658 (perhaps tentative), and absence of `static' makes it public. */
7659 else if (toplevel_bindings_p ())
7661 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
7662 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7663 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7665 /* Not at top level, only `static' makes a static definition. */
7668 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
7669 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7674 /* Create a canonical pointer to member function type. */
7677 build_ptrmemfunc_type (type
)
7684 /* If a canonical type already exists for this type, use it. We use
7685 this method instead of type_hash_canon, because it only does a
7686 simple equality check on the list of field members. */
7688 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
7691 push_obstacks (TYPE_OBSTACK (type
), TYPE_OBSTACK (type
));
7693 u
= make_lang_type (UNION_TYPE
);
7694 IS_AGGR_TYPE (u
) = 0;
7695 fields
[0] = build_lang_field_decl (FIELD_DECL
, pfn_identifier
, type
);
7696 fields
[1] = build_lang_field_decl (FIELD_DECL
, delta2_identifier
,
7698 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
7699 TYPE_NAME (u
) = NULL_TREE
;
7701 t
= make_lang_type (RECORD_TYPE
);
7703 /* Let the front-end know this is a pointer to member function. */
7704 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
7705 /* and not really an aggregate. */
7706 IS_AGGR_TYPE (t
) = 0;
7708 fields
[0] = build_lang_field_decl (FIELD_DECL
, delta_identifier
,
7710 fields
[1] = build_lang_field_decl (FIELD_DECL
, index_identifier
,
7712 fields
[2] = build_lang_field_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
7713 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
7717 /* Zap out the name so that the back-end will give us the debugging
7718 information for this anonymous RECORD_TYPE. */
7719 TYPE_NAME (t
) = NULL_TREE
;
7721 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
7723 /* Seems to be wanted. */
7724 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
7728 /* Given declspecs and a declarator,
7729 determine the name and type of the object declared
7730 and construct a ..._DECL node for it.
7731 (In one case we can return a ..._TYPE node instead.
7732 For invalid input we sometimes return 0.)
7734 DECLSPECS is a chain of tree_list nodes whose value fields
7735 are the storage classes and type specifiers.
7737 DECL_CONTEXT says which syntactic context this declaration is in:
7738 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7739 FUNCDEF for a function definition. Like NORMAL but a few different
7740 error messages in each case. Return value may be zero meaning
7741 this definition is too screwy to try to parse.
7742 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7743 handle member functions (which have FIELD context).
7744 Return value may be zero meaning this definition is too screwy to
7746 PARM for a parameter declaration (either within a function prototype
7747 or before a function body). Make a PARM_DECL, or return void_type_node.
7748 CATCHPARM for a parameter declaration before a catch clause.
7749 TYPENAME if for a typename (in a cast or sizeof).
7750 Don't make a DECL node; just return the ..._TYPE node.
7751 FIELD for a struct or union field; make a FIELD_DECL.
7752 BITFIELD for a field with specified width.
7753 INITIALIZED is 1 if the decl has an initializer.
7755 In the TYPENAME case, DECLARATOR is really an absolute declarator.
7756 It may also be so in the PARM case, for a prototype where the
7757 argument type is specified but not the name.
7759 This function is where the complicated C meanings of `static'
7760 and `extern' are interpreted.
7762 For C++, if there is any monkey business to do, the function which
7763 calls this one must do it, i.e., prepending instance variables,
7764 renaming overloaded function names, etc.
7766 Note that for this C++, it is an error to define a method within a class
7767 which does not belong to that class.
7769 Except in the case where SCOPE_REFs are implicitly known (such as
7770 methods within a class being redundantly qualified),
7771 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
7772 (class_name::decl_name). The caller must also deal with this.
7774 If a constructor or destructor is seen, and the context is FIELD,
7775 then the type gains the attribute TREE_HAS_x. If such a declaration
7776 is erroneous, NULL_TREE is returned.
7778 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
7779 function, these are the qualifiers to give to the `this' pointer.
7781 May return void_type_node if the declarator turned out to be a friend.
7782 See grokfield for details. */
7784 enum return_types
{ return_normal
, return_ctor
, return_dtor
, return_conversion
};
7787 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
7790 enum decl_context decl_context
;
7794 RID_BIT_TYPE specbits
;
7797 tree type
= NULL_TREE
;
7801 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
7802 int explicit_int
= 0;
7803 int explicit_char
= 0;
7804 int defaulted_int
= 0;
7805 int opaque_typedef
= 0;
7806 tree typedef_decl
= NULL_TREE
;
7808 tree typedef_type
= NULL_TREE
;
7809 int funcdef_flag
= 0;
7810 enum tree_code innermost_code
= ERROR_MARK
;
7813 /* See the code below that used this. */
7814 tree decl_machine_attr
= NULL_TREE
;
7816 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
7817 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
7818 tree init
= NULL_TREE
;
7820 /* Keep track of what sort of function is being processed
7821 so that we can warn about default return values, or explicit
7822 return values which do not match prescribed defaults. */
7823 enum return_types return_type
= return_normal
;
7825 tree dname
= NULL_TREE
;
7826 tree ctype
= current_class_type
;
7827 tree ctor_return_type
= NULL_TREE
;
7828 enum overload_flags flags
= NO_SPECIAL
;
7829 tree quals
= NULL_TREE
;
7830 tree raises
= NULL_TREE
;
7831 int template_count
= 0;
7833 RIDBIT_RESET_ALL (specbits
);
7834 if (decl_context
== FUNCDEF
)
7835 funcdef_flag
= 1, decl_context
= NORMAL
;
7836 else if (decl_context
== MEMFUNCDEF
)
7837 funcdef_flag
= -1, decl_context
= FIELD
;
7838 else if (decl_context
== BITFIELD
)
7839 bitfield
= 1, decl_context
= FIELD
;
7841 /* Look inside a declarator for the name being declared
7842 and get it as a string, for an error message. */
7844 tree
*next
= &declarator
;
7848 while (next
&& *next
)
7851 switch (TREE_CODE (decl
))
7855 next
= &TREE_OPERAND (decl
, 0);
7858 case BIT_NOT_EXPR
: /* for C++ destructors! */
7860 tree name
= TREE_OPERAND (decl
, 0);
7861 tree rename
= NULL_TREE
;
7863 my_friendly_assert (flags
== NO_SPECIAL
, 152);
7865 return_type
= return_dtor
;
7866 if (TREE_CODE (name
) == TYPE_DECL
)
7867 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
7868 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
7869 if (ctype
== NULL_TREE
)
7871 if (current_class_type
== NULL_TREE
)
7873 error ("destructors must be member functions");
7878 tree t
= constructor_name (current_class_name
);
7885 tree t
= constructor_name (ctype
);
7892 cp_error ("destructor `%T' must match class name `%T'",
7894 TREE_OPERAND (decl
, 0) = rename
;
7900 case ADDR_EXPR
: /* C++ reference declaration */
7905 innermost_code
= TREE_CODE (decl
);
7906 next
= &TREE_OPERAND (decl
, 0);
7910 if (parmlist_is_exprlist (TREE_OPERAND (decl
, 1)))
7912 /* This is actually a variable declaration using constructor
7913 syntax. We need to call start_decl and cp_finish_decl so we
7914 can get the variable initialized... */
7916 *next
= TREE_OPERAND (decl
, 0);
7917 init
= TREE_OPERAND (decl
, 1);
7919 decl
= start_decl (declarator
, declspecs
, 1);
7920 /* Look for __unused__ attribute */
7921 if (TREE_USED (TREE_TYPE (decl
)))
7922 TREE_USED (decl
) = 1;
7923 finish_decl (decl
, init
, NULL_TREE
);
7926 innermost_code
= TREE_CODE (decl
);
7927 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
7928 ctype
= current_class_type
;
7930 && TREE_OPERAND (decl
, 0)
7931 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
7932 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
7933 == constructor_name_full (ctype
))
7934 || (DECL_NAME (TREE_OPERAND (decl
, 0))
7935 == constructor_name (ctype
)))))
7936 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
7937 next
= &TREE_OPERAND (decl
, 0);
7939 if (ctype
!= NULL_TREE
7940 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
7941 && decl
== constructor_name (ctype
))
7943 return_type
= return_ctor
;
7944 ctor_return_type
= ctype
;
7949 case TEMPLATE_ID_EXPR
:
7951 tree fns
= TREE_OPERAND (decl
, 0);
7953 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
7954 fns
= TREE_OPERAND (fns
, 0);
7956 if (TREE_CODE (fns
) == IDENTIFIER_NODE
)
7958 else if (really_overloaded_fn (fns
))
7959 dname
= DECL_NAME (get_first_fn (fns
));
7961 dname
= DECL_NAME (fns
);
7965 case IDENTIFIER_NODE
:
7966 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
7973 cp_error ("declarator-id missing; using reserved word `%D'",
7975 name
= IDENTIFIER_POINTER (dname
);
7977 if (! IDENTIFIER_OPNAME_P (dname
)
7978 /* GNU/Linux headers use '__op'. Arrgh. */
7979 || IDENTIFIER_TYPENAME_P (dname
) && ! TREE_TYPE (dname
))
7980 name
= IDENTIFIER_POINTER (dname
);
7983 if (IDENTIFIER_TYPENAME_P (dname
))
7985 my_friendly_assert (flags
== NO_SPECIAL
, 154);
7986 flags
= TYPENAME_FLAG
;
7987 ctor_return_type
= TREE_TYPE (dname
);
7988 return_type
= return_conversion
;
7990 name
= operator_name_string (dname
);
7997 /* Perform error checking, and decide on a ctype. */
7998 tree cname
= TREE_OPERAND (decl
, 0);
7999 if (cname
== NULL_TREE
)
8001 else if (! is_aggr_type (cname
, 1))
8002 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8003 /* Must test TREE_OPERAND (decl, 1), in case user gives
8004 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
8005 else if (TREE_OPERAND (decl
, 1)
8006 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
8008 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
8009 || TREE_CODE (cname
) == TEMPLATE_TEMPLATE_PARM
)
8011 cp_error ("`%T::%D' is not a valid declarator", cname
,
8012 TREE_OPERAND (decl
, 1));
8013 cp_error (" perhaps you want `typename %T::%D' to make it a type",
8014 cname
, TREE_OPERAND (decl
, 1));
8015 return void_type_node
;
8017 else if (ctype
== NULL_TREE
)
8019 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
8020 TREE_OPERAND (decl
, 0) = ctype
;
8023 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
8025 cp_error ("type `%T' is not derived from type `%T'",
8027 TREE_OPERAND (decl
, 0) = NULL_TREE
;
8033 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
8034 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
8035 == constructor_name_full (ctype
))
8036 || (DECL_NAME (TREE_OPERAND (decl
, 1))
8037 == constructor_name (ctype
))))
8038 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
8039 next
= &TREE_OPERAND (decl
, 1);
8043 if (TREE_CODE (decl
) == IDENTIFIER_NODE
8044 && constructor_name (ctype
) == decl
)
8046 return_type
= return_ctor
;
8047 ctor_return_type
= ctype
;
8049 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
8050 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
8051 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
8052 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
8054 return_type
= return_dtor
;
8055 ctor_return_type
= ctype
;
8057 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
8058 next
= &TREE_OPERAND (decl
, 0);
8069 /* Parse error puts this typespec where
8070 a declarator should go. */
8071 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
8072 if (TREE_TYPE (decl
) == current_class_type
)
8073 cp_error (" perhaps you want `%T' for a constructor",
8074 current_class_name
);
8075 dname
= DECL_NAME (decl
);
8076 name
= IDENTIFIER_POINTER (dname
);
8078 /* Avoid giving two errors for this. */
8079 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
8081 declspecs
= temp_tree_cons (NULL_TREE
, integer_type_node
,
8088 cp_compiler_error ("`%D' as declarator", decl
);
8089 return 0; /* We used to do a 155 abort here. */
8096 /* A function definition's declarator must have the form of
8097 a function declarator. */
8099 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
8102 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8103 && innermost_code
!= CALL_EXPR
8104 && ! (ctype
&& declspecs
== NULL_TREE
))
8106 cp_error ("declaration of `%D' as non-function", dname
);
8107 return void_type_node
;
8110 /* Anything declared one level down from the top level
8111 must be one of the parameters of a function
8112 (because the body is at least two levels down). */
8114 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8115 by not allowing C++ class definitions to specify their parameters
8116 with xdecls (must be spec.d in the parmlist).
8118 Since we now wait to push a class scope until we are sure that
8119 we are in a legitimate method context, we must set oldcname
8120 explicitly (since current_class_name is not yet alive).
8122 We also want to avoid calling this a PARM if it is in a namespace. */
8124 if (decl_context
== NORMAL
&& ! namespace_bindings_p ()
8125 && ! pseudo_global_level_p ())
8127 struct binding_level
*b
= current_binding_level
;
8128 current_binding_level
= b
->level_chain
;
8129 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8130 decl_context
= PARM
;
8131 current_binding_level
= b
;
8134 /* Look through the decl specs and record which ones appear.
8135 Some typespecs are defined as built-in typenames.
8136 Others, the ones that are modifiers of other types,
8137 are represented by bits in SPECBITS: set the bits for
8138 the modifiers that appear. Storage class keywords are also in SPECBITS.
8140 If there is a typedef name or a type, store the type in TYPE.
8141 This includes builtin typedefs such as `int'.
8143 Set EXPLICIT_INT if the type is `int' or `char' and did not
8144 come from a user typedef.
8146 Set LONGLONG if `long' is mentioned twice.
8148 For C++, constructors and destructors have their own fast treatment. */
8150 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
8155 /* Certain parse errors slip through. For example,
8156 `int class;' is not caught by the parser. Try
8157 weakly to recover here. */
8158 if (TREE_CODE (spec
) != TREE_LIST
)
8161 id
= TREE_VALUE (spec
);
8163 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8165 if (id
== ridpointers
[(int) RID_INT
]
8166 || id
== ridpointers
[(int) RID_CHAR
]
8167 || id
== ridpointers
[(int) RID_BOOL
]
8168 || id
== ridpointers
[(int) RID_WCHAR
])
8172 if (id
== ridpointers
[(int) RID_BOOL
])
8173 error ("`bool' is now a keyword");
8175 cp_error ("extraneous `%T' ignored", id
);
8179 if (id
== ridpointers
[(int) RID_INT
])
8181 else if (id
== ridpointers
[(int) RID_CHAR
])
8183 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
8187 /* C++ aggregate types. */
8188 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
8191 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
8193 type
= IDENTIFIER_TYPE_VALUE (id
);
8197 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
8199 if (ridpointers
[i
] == id
)
8201 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
8203 if (pedantic
&& ! in_system_header
)
8204 pedwarn ("ANSI C++ does not support `long long'");
8206 error ("`long long long' is too long for GCC");
8210 else if (RIDBIT_SETP (i
, specbits
))
8211 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
8212 RIDBIT_SET (i
, specbits
);
8217 /* C++ aggregate types. */
8218 else if (TREE_CODE (id
) == TYPE_DECL
|| TREE_CODE (id
) == TEMPLATE_DECL
)
8221 cp_error ("multiple declarations `%T' and `%T'", type
,
8225 type
= TREE_TYPE (id
);
8226 TREE_VALUE (spec
) = type
;
8231 error ("two or more data types in declaration of `%s'", name
);
8232 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
8234 register tree t
= lookup_name (id
, 1);
8235 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
8236 error ("`%s' fails to be a typedef or built in type",
8237 IDENTIFIER_POINTER (id
));
8240 type
= TREE_TYPE (t
);
8242 /* See the code below that used this. */
8243 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
8248 else if (id
!= error_mark_node
)
8249 /* Can't change CLASS nodes into RECORD nodes here! */
8255 typedef_type
= type
;
8257 /* No type at all: default to `int', and set DEFAULTED_INT
8258 because it was not a user-defined typedef.
8259 Except when we have a `typedef' inside a signature, in
8260 which case the type defaults to `unknown type' and is
8261 instantiated when assigning to a signature pointer or ref. */
8263 if (type
== NULL_TREE
8264 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
8265 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
8266 || RIDBIT_SETP (RID_LONG
, specbits
)
8267 || RIDBIT_SETP (RID_SHORT
, specbits
)))
8269 /* These imply 'int'. */
8270 type
= integer_type_node
;
8274 if (type
== NULL_TREE
)
8277 if (return_type
== return_dtor
)
8278 type
= void_type_node
;
8279 else if (return_type
== return_ctor
)
8280 type
= build_pointer_type (ctor_return_type
);
8281 else if (return_type
== return_conversion
)
8282 type
= ctor_return_type
;
8283 else if (current_class_type
8284 && IS_SIGNATURE (current_class_type
)
8285 && RIDBIT_SETP (RID_TYPEDEF
, specbits
)
8286 && (decl_context
== FIELD
|| decl_context
== NORMAL
))
8290 type
= copy_node (opaque_type_node
);
8296 if (warn_return_type
8297 && return_type
== return_normal
)
8298 /* Save warning until we know what is really going on. */
8299 warn_about_return_type
= 1;
8301 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
8302 pedwarn ("ANSI C++ forbids typedef which does not specify a type");
8303 else if (innermost_code
!= CALL_EXPR
|| pedantic
8304 || (warn_return_type
&& return_type
== return_normal
))
8306 if (innermost_code
== CALL_EXPR
)
8307 cp_pedwarn ("return-type of `%D' defaults to `int'", dname
);
8309 cp_pedwarn ("ANSI C++ forbids declaration `%D' with no type",
8312 type
= integer_type_node
;
8315 else if (return_type
== return_dtor
)
8317 error ("return type specification for destructor invalid");
8318 type
= void_type_node
;
8320 else if (return_type
== return_ctor
)
8322 error ("return type specification for constructor invalid");
8323 type
= build_pointer_type (ctor_return_type
);
8325 else if (return_type
== return_conversion
)
8327 if (comptypes (type
, ctor_return_type
, 1) == 0)
8328 cp_error ("operator `%T' declared to return `%T'",
8329 ctor_return_type
, type
);
8331 cp_pedwarn ("return type specified for `operator %T'",
8334 type
= ctor_return_type
;
8339 /* Now process the modifiers that were specified
8340 and check for invalid combinations. */
8342 /* Long double is a special combination. */
8344 if (RIDBIT_SETP (RID_LONG
, specbits
)
8345 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
8347 RIDBIT_RESET (RID_LONG
, specbits
);
8348 type
= build_type_variant (long_double_type_node
, TYPE_READONLY (type
),
8349 TYPE_VOLATILE (type
));
8352 /* Check all other uses of type modifiers. */
8354 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
8355 || RIDBIT_SETP (RID_SIGNED
, specbits
)
8356 || RIDBIT_SETP (RID_LONG
, specbits
)
8357 || RIDBIT_SETP (RID_SHORT
, specbits
))
8361 if (TREE_CODE (type
) == REAL_TYPE
)
8362 error ("short, signed or unsigned invalid for `%s'", name
);
8363 else if (TREE_CODE (type
) != INTEGER_TYPE
)
8364 error ("long, short, signed or unsigned invalid for `%s'", name
);
8365 else if (RIDBIT_SETP (RID_LONG
, specbits
)
8366 && RIDBIT_SETP (RID_SHORT
, specbits
))
8367 error ("long and short specified together for `%s'", name
);
8368 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
8369 || RIDBIT_SETP (RID_SHORT
, specbits
))
8371 error ("long or short specified with char for `%s'", name
);
8372 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
8373 || RIDBIT_SETP (RID_SHORT
, specbits
))
8374 && TREE_CODE (type
) == REAL_TYPE
)
8375 error ("long or short specified with floating type for `%s'", name
);
8376 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
8377 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
8378 error ("signed and unsigned given together for `%s'", name
);
8382 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
8384 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
8386 if (flag_pedantic_errors
)
8391 /* Discard the type modifiers if they are invalid. */
8394 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
8395 RIDBIT_RESET (RID_SIGNED
, specbits
);
8396 RIDBIT_RESET (RID_LONG
, specbits
);
8397 RIDBIT_RESET (RID_SHORT
, specbits
);
8402 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
8403 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
8405 error ("complex invalid for `%s'", name
);
8406 RIDBIT_RESET (RID_COMPLEX
, specbits
);
8409 /* Decide whether an integer type is signed or not.
8410 Optionally treat bitfields as signed by default. */
8411 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
8412 || (bitfield
&& ! flag_signed_bitfields
8413 && (explicit_int
|| defaulted_int
|| explicit_char
8414 /* A typedef for plain `int' without `signed'
8415 can be controlled just like plain `int'. */
8416 || ! (typedef_decl
!= NULL_TREE
8417 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
8418 && TREE_CODE (type
) != ENUMERAL_TYPE
8419 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)))
8422 type
= long_long_unsigned_type_node
;
8423 else if (RIDBIT_SETP (RID_LONG
, specbits
))
8424 type
= long_unsigned_type_node
;
8425 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
8426 type
= short_unsigned_type_node
;
8427 else if (type
== char_type_node
)
8428 type
= unsigned_char_type_node
;
8429 else if (typedef_decl
)
8430 type
= unsigned_type (type
);
8432 type
= unsigned_type_node
;
8434 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
8435 && type
== char_type_node
)
8436 type
= signed_char_type_node
;
8438 type
= long_long_integer_type_node
;
8439 else if (RIDBIT_SETP (RID_LONG
, specbits
))
8440 type
= long_integer_type_node
;
8441 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
8442 type
= short_integer_type_node
;
8444 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
8446 /* If we just have "complex", it is equivalent to
8447 "complex double", but if any modifiers at all are specified it is
8448 the complex form of TYPE. E.g, "complex short" is
8449 "complex short int". */
8451 if (defaulted_int
&& ! longlong
8452 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
8453 || RIDBIT_SETP (RID_SHORT
, specbits
)
8454 || RIDBIT_SETP (RID_SIGNED
, specbits
)
8455 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
8456 type
= complex_double_type_node
;
8457 else if (type
== integer_type_node
)
8458 type
= complex_integer_type_node
;
8459 else if (type
== float_type_node
)
8460 type
= complex_float_type_node
;
8461 else if (type
== double_type_node
)
8462 type
= complex_double_type_node
;
8463 else if (type
== long_double_type_node
)
8464 type
= complex_long_double_type_node
;
8466 type
= build_complex_type (type
);
8469 /* Set CONSTP if this declaration is `const', whether by
8470 explicit specification or via a typedef.
8471 Likewise for VOLATILEP. */
8473 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + TYPE_READONLY (type
);
8474 volatilep
= !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + TYPE_VOLATILE (type
);
8476 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
8477 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
8478 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
8479 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
8480 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
8482 if (RIDBIT_SETP (RID_STATIC
, specbits
))
8483 staticp
= 1 + (decl_context
== FIELD
);
8485 if (virtualp
&& staticp
== 2)
8487 cp_error ("member `%D' cannot be declared both virtual and static",
8491 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
8492 RIDBIT_RESET (RID_FRIEND
, specbits
);
8494 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
8496 if (decl_context
== PARM
)
8498 error ("non-member `%s' cannot be declared `mutable'", name
);
8499 RIDBIT_RESET (RID_MUTABLE
, specbits
);
8501 else if (friendp
|| decl_context
== TYPENAME
)
8503 error ("non-object member `%s' cannot be declared `mutable'", name
);
8504 RIDBIT_RESET (RID_MUTABLE
, specbits
);
8508 /* Warn if two storage classes are given. Default to `auto'. */
8510 if (RIDBIT_ANY_SET (specbits
))
8512 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
8513 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
8514 if (decl_context
== PARM
&& nclasses
> 0)
8515 error ("storage class specifiers invalid in parameter declarations");
8516 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
8518 if (decl_context
== PARM
)
8519 error ("typedef declaration invalid in parameter declaration");
8522 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
8523 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
8526 /* Give error if `virtual' is used outside of class declaration. */
8528 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
8530 error ("virtual outside class declaration");
8533 if (current_class_name
== NULL_TREE
&& RIDBIT_SETP (RID_MUTABLE
, specbits
))
8535 error ("only members can be declared mutable");
8536 RIDBIT_RESET (RID_MUTABLE
, specbits
);
8539 /* Static anonymous unions are dealt with here. */
8540 if (staticp
&& decl_context
== TYPENAME
8541 && TREE_CODE (declspecs
) == TREE_LIST
8542 && TREE_CODE (TREE_VALUE (declspecs
)) == UNION_TYPE
8543 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (TREE_VALUE (declspecs
))))
8544 decl_context
= FIELD
;
8546 /* Give error if `const,' `volatile,' `inline,' `friend,' or `virtual'
8547 is used in a signature member function declaration. */
8548 if (decl_context
== FIELD
8549 && IS_SIGNATURE (current_class_type
)
8550 && RIDBIT_NOTSETP (RID_TYPEDEF
, specbits
))
8554 error ("`const' specified for signature member function `%s'", name
);
8559 error ("`volatile' specified for signature member function `%s'",
8565 error ("`inline' specified for signature member function `%s'", name
);
8566 /* Later, we'll make signature member functions inline. */
8571 error ("`friend' declaration in signature definition");
8576 error ("`virtual' specified for signature member function `%s'",
8578 /* Later, we'll make signature member functions virtual. */
8583 /* Warn about storage classes that are invalid for certain
8584 kinds of declarations (parameters, typenames, etc.). */
8587 error ("multiple storage classes in declaration of `%s'", name
);
8588 else if (decl_context
!= NORMAL
&& nclasses
> 0)
8590 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
8591 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
8592 || RIDBIT_SETP (RID_AUTO
, specbits
)))
8594 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
8596 else if (decl_context
== FIELD
8597 && ! IS_SIGNATURE (current_class_type
)
8598 /* C++ allows static class elements */
8599 && RIDBIT_SETP (RID_STATIC
, specbits
))
8600 /* C++ also allows inlines and signed and unsigned elements,
8601 but in those cases we don't come in here. */
8605 if (decl_context
== FIELD
)
8607 tree tmp
= NULL_TREE
;
8608 register int op
= 0;
8612 /* Avoid trying to get an operand off an identifier node. */
8613 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
8616 tmp
= TREE_OPERAND (declarator
, 0);
8617 op
= IDENTIFIER_OPNAME_P (tmp
);
8619 error ("storage class specified for %s `%s'",
8620 IS_SIGNATURE (current_class_type
)
8622 ? "signature member operator"
8623 : "signature member function")
8624 : (op
? "member operator" : "field"),
8625 op
? operator_name_string (tmp
) : name
);
8628 error (((decl_context
== PARM
|| decl_context
== CATCHPARM
)
8629 ? "storage class specified for parameter `%s'"
8630 : "storage class specified for typename"), name
);
8631 RIDBIT_RESET (RID_REGISTER
, specbits
);
8632 RIDBIT_RESET (RID_AUTO
, specbits
);
8633 RIDBIT_RESET (RID_EXTERN
, specbits
);
8635 if (decl_context
== FIELD
&& IS_SIGNATURE (current_class_type
))
8637 RIDBIT_RESET (RID_STATIC
, specbits
);
8642 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
8644 if (toplevel_bindings_p ())
8646 /* It's common practice (and completely valid) to have a const
8647 be initialized and declared extern. */
8649 warning ("`%s' initialized and declared `extern'", name
);
8652 error ("`%s' has both `extern' and initializer", name
);
8654 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
8655 && ! toplevel_bindings_p ())
8656 error ("nested function `%s' declared `extern'", name
);
8657 else if (toplevel_bindings_p ())
8659 if (RIDBIT_SETP (RID_AUTO
, specbits
))
8660 error ("top-level declaration of `%s' specifies `auto'", name
);
8663 if (nclasses
> 0 && friendp
)
8664 error ("storage class specifiers invalid in friend function declarations");
8666 /* Now figure out the structure of the declarator proper.
8667 Descend through it, creating more complex types, until we reach
8668 the declared identifier (or NULL_TREE, in an absolute declarator). */
8670 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
8671 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
8673 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
8674 an INDIRECT_REF (for *...),
8675 a CALL_EXPR (for ...(...)),
8676 an identifier (for the name being declared)
8677 or a null pointer (for the place in an absolute declarator
8678 where the name was omitted).
8679 For the last two cases, we have just exited the loop.
8681 For C++ it could also be
8682 a SCOPE_REF (for class :: ...). In this case, we have converted
8683 sensible names to types, and those are the values we use to
8684 qualify the member name.
8685 an ADDR_EXPR (for &...),
8686 a BIT_NOT_EXPR (for destructors)
8688 At this point, TYPE is the type of elements of an array,
8689 or for a function to return, or for a pointer to point to.
8690 After this sequence of ifs, TYPE is the type of the
8691 array or function or pointer, and DECLARATOR has had its
8692 outermost layer removed. */
8694 if (type
== error_mark_node
)
8696 if (TREE_CODE (declarator
) == SCOPE_REF
)
8697 declarator
= TREE_OPERAND (declarator
, 1);
8699 declarator
= TREE_OPERAND (declarator
, 0);
8702 if (quals
!= NULL_TREE
8703 && (declarator
== NULL_TREE
8704 || TREE_CODE (declarator
) != SCOPE_REF
))
8706 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
8707 ctype
= TYPE_METHOD_BASETYPE (type
);
8708 if (ctype
!= NULL_TREE
)
8710 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
8711 ctype
= grok_method_quals (ctype
, dummy
, quals
);
8712 type
= TREE_TYPE (dummy
);
8716 switch (TREE_CODE (declarator
))
8720 register tree itype
= NULL_TREE
;
8721 register tree size
= TREE_OPERAND (declarator
, 1);
8722 /* The index is a signed object `sizetype' bits wide. */
8723 tree index_type
= signed_type (sizetype
);
8725 declarator
= TREE_OPERAND (declarator
, 0);
8727 /* Check for some types that there cannot be arrays of. */
8729 if (TYPE_MAIN_VARIANT (type
) == void_type_node
)
8731 cp_error ("declaration of `%D' as array of voids", dname
);
8732 type
= error_mark_node
;
8735 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8737 cp_error ("declaration of `%D' as array of functions", dname
);
8738 type
= error_mark_node
;
8741 /* ARM $8.4.3: Since you can't have a pointer to a reference,
8742 you can't have arrays of references. If we allowed them,
8743 then we'd be saying x[i] is valid for an array x, but
8744 then you'd have to ask: what does `*(x + i)' mean? */
8745 if (TREE_CODE (type
) == REFERENCE_TYPE
)
8747 if (decl_context
== TYPENAME
)
8748 cp_error ("cannot make arrays of references");
8750 cp_error ("declaration of `%D' as array of references",
8752 type
= error_mark_node
;
8755 if (TREE_CODE (type
) == OFFSET_TYPE
)
8757 cp_error ("declaration of `%D' as array of data members",
8759 type
= error_mark_node
;
8762 if (TREE_CODE (type
) == METHOD_TYPE
)
8764 cp_error ("declaration of `%D' as array of function members",
8766 type
= error_mark_node
;
8769 if (size
== error_mark_node
)
8770 type
= error_mark_node
;
8772 if (type
== error_mark_node
)
8777 /* Must suspend_momentary here because the index
8778 type may need to live until the end of the function.
8779 For example, it is used in the declaration of a
8780 variable which requires destructing at the end of
8781 the function; then build_vec_delete will need this
8783 int yes
= suspend_momentary ();
8784 /* might be a cast */
8785 if (TREE_CODE (size
) == NOP_EXPR
8786 && TREE_TYPE (size
) == TREE_TYPE (TREE_OPERAND (size
, 0)))
8787 size
= TREE_OPERAND (size
, 0);
8789 /* If this involves a template parameter, it'll be
8790 constant, but we don't know what the value is yet. */
8791 if (processing_template_decl
)
8793 itype
= make_node (INTEGER_TYPE
);
8794 TYPE_MIN_VALUE (itype
) = size_zero_node
;
8795 TYPE_MAX_VALUE (itype
) = build_min
8796 (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8797 goto dont_grok_size
;
8800 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
8801 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
)
8803 cp_error ("size of array `%D' has non-integer type",
8805 size
= integer_one_node
;
8807 if (TREE_READONLY_DECL_P (size
))
8808 size
= decl_constant_value (size
);
8809 if (pedantic
&& integer_zerop (size
))
8810 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", dname
);
8811 if (TREE_CONSTANT (size
))
8813 int old_flag_pedantic_errors
= flag_pedantic_errors
;
8814 int old_pedantic
= pedantic
;
8815 pedantic
= flag_pedantic_errors
= 1;
8816 /* Always give overflow errors on array subscripts. */
8817 constant_expression_warning (size
);
8818 pedantic
= old_pedantic
;
8819 flag_pedantic_errors
= old_flag_pedantic_errors
;
8820 if (INT_CST_LT (size
, integer_zero_node
))
8822 cp_error ("size of array `%D' is negative", dname
);
8823 size
= integer_one_node
;
8831 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8834 cp_pedwarn ("ANSI C++ forbids variable-size array");
8839 = fold (build_binary_op (MINUS_EXPR
,
8840 cp_convert (index_type
, size
),
8841 cp_convert (index_type
,
8842 integer_one_node
), 1));
8843 if (! TREE_CONSTANT (itype
))
8844 itype
= variable_size (itype
);
8845 else if (TREE_OVERFLOW (itype
))
8847 error ("overflow in array dimension");
8848 TREE_OVERFLOW (itype
) = 0;
8851 /* If we're a parm, we need to have a permanent type so
8852 mangling checks for re-use will work right. If both the
8853 element and index types are permanent, the array type
8855 if (decl_context
== PARM
8856 && allocation_temporary_p () && TREE_PERMANENT (type
))
8858 push_obstacks (&permanent_obstack
, &permanent_obstack
);
8859 itype
= build_index_type (itype
);
8863 itype
= build_index_type (itype
);
8866 resume_momentary (yes
);
8869 /* Build the array type itself, then merge any constancy or
8870 volatility into the target type. We must do it in this order
8871 to ensure that the TYPE_MAIN_VARIANT field of the array type
8872 is set correctly. */
8874 type
= build_cplus_array_type (type
, itype
);
8875 if (constp
|| volatilep
)
8876 type
= cp_build_type_variant (type
, constp
, volatilep
);
8886 tree inner_parms
= TREE_OPERAND (declarator
, 1);
8887 tree inner_decl
= TREE_OPERAND (declarator
, 0);
8889 /* Declaring a function type.
8890 Make sure we have a valid type for the function to return. */
8892 /* Is this an error? Should they be merged into TYPE here? */
8893 if (pedantic
&& (constp
|| volatilep
))
8894 pedwarn ("function declared to return const or volatile result");
8896 /* Merge any constancy or volatility into the function return
8899 if (constp
|| volatilep
)
8901 type
= cp_build_type_variant (type
, constp
, volatilep
);
8902 if (IS_AGGR_TYPE (type
))
8903 build_pointer_type (type
);
8909 /* Warn about some types functions can't return. */
8911 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8913 error ("`%s' declared as function returning a function", name
);
8914 type
= integer_type_node
;
8916 if (TREE_CODE (type
) == ARRAY_TYPE
)
8918 error ("`%s' declared as function returning an array", name
);
8919 type
= integer_type_node
;
8922 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
8923 inner_decl
= TREE_OPERAND (inner_decl
, 1);
8925 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
8928 /* Pick up type qualifiers which should be applied to `this'. */
8929 quals
= TREE_OPERAND (declarator
, 2);
8931 /* Pick up the exception specifications. */
8932 raises
= TREE_TYPE (declarator
);
8934 /* Say it's a definition only for the CALL_EXPR
8935 closest to the identifier. */
8938 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
8939 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
8940 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
8942 if (ctype
== NULL_TREE
8943 && decl_context
== FIELD
8945 && (friendp
== 0 || dname
== current_class_name
))
8946 ctype
= current_class_type
;
8948 if (ctype
&& return_type
== return_conversion
)
8949 TYPE_HAS_CONVERSION (ctype
) = 1;
8950 if (ctype
&& constructor_name (ctype
) == dname
)
8952 /* We are within a class's scope. If our declarator name
8953 is the same as the class name, and we are defining
8954 a function, then it is a constructor/destructor, and
8955 therefore returns a void type. */
8957 if (flags
== DTOR_FLAG
)
8959 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
8960 not be declared const or volatile. A destructor
8961 may not be static. */
8963 error ("destructor cannot be static member function");
8966 error ("destructors cannot be declared `const' or `volatile'");
8967 return void_type_node
;
8969 if (decl_context
== FIELD
)
8971 if (! member_function_or_else (ctype
, current_class_type
,
8972 "destructor for alien class `%s' cannot be a member"))
8973 return void_type_node
;
8976 else /* it's a constructor. */
8980 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
8981 not be declared const or volatile. A constructor may
8982 not be virtual. A constructor may not be static. */
8984 error ("constructor cannot be static member function");
8987 pedwarn ("constructors cannot be declared virtual");
8992 error ("constructors cannot be declared `const' or `volatile'");
8993 return void_type_node
;
8996 RID_BIT_TYPE tmp_bits
;
8997 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
8998 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
8999 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
9000 if (RIDBIT_ANY_SET (tmp_bits
))
9001 error ("return value type specifier for constructor ignored");
9003 type
= build_pointer_type (ctype
);
9004 if (decl_context
== FIELD
9005 && IS_SIGNATURE (current_class_type
))
9007 error ("constructor not allowed in signature");
9008 return void_type_node
;
9010 else if (decl_context
== FIELD
)
9012 if (! member_function_or_else (ctype
, current_class_type
,
9013 "constructor for alien class `%s' cannot be member"))
9014 return void_type_node
;
9015 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
9016 if (return_type
!= return_ctor
)
9020 if (decl_context
== FIELD
)
9026 error ("can't initialize friend function `%s'", name
);
9029 /* Cannot be both friend and virtual. */
9030 error ("virtual functions cannot be friends");
9031 RIDBIT_RESET (RID_FRIEND
, specbits
);
9034 if (decl_context
== NORMAL
)
9035 error ("friend declaration not in class definition");
9036 if (current_function_decl
&& funcdef_flag
)
9037 cp_error ("can't define friend function `%s' in a local class definition",
9041 /* Construct the function type and go to the next
9042 inner layer of declarator. */
9044 declarator
= TREE_OPERAND (declarator
, 0);
9046 /* FIXME: This is where default args should be fully
9049 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
9053 /* Get past destructors, etc.
9054 We know we have one because FLAGS will be non-zero.
9056 Complain about improper parameter lists here. */
9057 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
9059 declarator
= TREE_OPERAND (declarator
, 0);
9061 if (strict_prototype
== 0 && arg_types
== NULL_TREE
)
9062 arg_types
= void_list_node
;
9063 else if (arg_types
== NULL_TREE
9064 || arg_types
!= void_list_node
)
9066 error ("destructors cannot be specified with parameters");
9067 arg_types
= void_list_node
;
9072 /* ANSI says that `const int foo ();'
9073 does not make the function foo const. */
9074 type
= build_function_type (type
, arg_types
);
9078 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
9079 if (TREE_PURPOSE (t
)
9080 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
9082 add_defarg_fn (type
);
9091 /* Filter out pointers-to-references and references-to-references.
9092 We can get these if a TYPE_DECL is used. */
9094 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9096 error ("cannot declare %s to references",
9097 TREE_CODE (declarator
) == ADDR_EXPR
9098 ? "references" : "pointers");
9099 declarator
= TREE_OPERAND (declarator
, 0);
9103 if (TREE_CODE (type
) == OFFSET_TYPE
9104 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
9105 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
9107 cp_error ("cannot declare pointer to `%#T' member",
9109 type
= TREE_TYPE (type
);
9112 /* Merge any constancy or volatility into the target type
9115 if (constp
|| volatilep
)
9117 /* A const or volatile signature pointer/reference is
9118 pointing to a const or volatile object, i.e., the
9119 `optr' is const or volatile, respectively, not the
9120 signature pointer/reference itself. */
9121 if (! IS_SIGNATURE (type
))
9123 type
= cp_build_type_variant (type
, constp
, volatilep
);
9124 if (IS_AGGR_TYPE (type
))
9125 build_pointer_type (type
);
9131 if (IS_SIGNATURE (type
))
9133 if (TREE_CODE (declarator
) == ADDR_EXPR
)
9135 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9136 && TYPE_SIZE (type
))
9137 cp_warning ("empty signature `%T' used in signature reference declaration",
9140 type
= build_signature_reference_type (type
,
9143 sorry ("signature reference");
9149 if (CLASSTYPE_METHOD_VEC (type
) == NULL_TREE
9150 && TYPE_SIZE (type
))
9151 cp_warning ("empty signature `%T' used in signature pointer declaration",
9153 type
= build_signature_pointer_type (type
,
9159 else if (TREE_CODE (declarator
) == ADDR_EXPR
)
9161 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9163 error ("cannot declare references to functions; use pointer to function instead");
9164 type
= build_pointer_type (type
);
9168 if (TYPE_MAIN_VARIANT (type
) == void_type_node
)
9169 error ("invalid type: `void &'");
9171 type
= build_reference_type (type
);
9174 else if (TREE_CODE (type
) == METHOD_TYPE
)
9176 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9179 type
= build_pointer_type (type
);
9181 /* Process a list of type modifier keywords (such as
9182 const or volatile) that were given inside the `*' or `&'. */
9184 if (TREE_TYPE (declarator
))
9186 register tree typemodlist
;
9188 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
9189 typemodlist
= TREE_CHAIN (typemodlist
))
9191 if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_CONST
])
9193 else if (TREE_VALUE (typemodlist
) == ridpointers
[(int) RID_VOLATILE
])
9198 error ("invalid type modifier within %s declarator",
9199 TREE_CODE (declarator
) == ADDR_EXPR
9200 ? "reference" : "pointer");
9204 pedwarn ("duplicate `const'");
9206 pedwarn ("duplicate `volatile'");
9207 if (TREE_CODE (declarator
) == ADDR_EXPR
9208 && (constp
|| volatilep
))
9211 pedwarn ("discarding `const' applied to a reference");
9213 pedwarn ("discarding `volatile' applied to a reference");
9214 constp
= volatilep
= 0;
9217 declarator
= TREE_OPERAND (declarator
, 0);
9223 /* We have converted type names to NULL_TREE if the
9224 name was bogus, or to a _TYPE node, if not.
9226 The variable CTYPE holds the type we will ultimately
9227 resolve to. The code here just needs to build
9228 up appropriate member types. */
9229 tree sname
= TREE_OPERAND (declarator
, 1);
9232 /* Destructors can have their visibilities changed as well. */
9233 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
9234 sname
= TREE_OPERAND (sname
, 0);
9236 if (TREE_COMPLEXITY (declarator
) == 0)
9237 /* This needs to be here, in case we are called
9238 multiple times. */ ;
9239 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
9240 /* don't fall out into global scope. Hides real bug? --eichin */ ;
9241 else if (! IS_AGGR_TYPE_CODE
9242 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
9244 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
9246 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
9247 that refer to ctype. They couldn't be resolved earlier
9248 because we hadn't pushed into the class yet.
9249 Example: resolve 'B<T>::type' in
9250 'B<typename B<T>::type> B<T>::f () { }'. */
9251 if (current_template_parms
9252 && uses_template_parms (type
)
9253 && uses_template_parms (current_class_type
))
9255 tree args
= current_template_args ();
9256 type
= tsubst (type
, args
,
9257 TREE_VEC_LENGTH (TREE_VEC_ELT
9262 /* This pop_nested_class corresponds to the
9263 push_nested_class used to push into class scope for
9264 parsing the argument list of a function decl, in
9266 pop_nested_class (1);
9267 TREE_COMPLEXITY (declarator
) = current_class_depth
;
9270 my_friendly_abort (16);
9272 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
9274 /* We had a reference to a global decl, or
9275 perhaps we were given a non-aggregate typedef,
9276 in which case we cleared this out, and should just
9277 keep going as though it wasn't there. */
9281 ctype
= TREE_OPERAND (declarator
, 0);
9284 while (t
!= NULL_TREE
)
9286 if (CLASSTYPE_TEMPLATE_INFO (t
) &&
9287 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t
))
9288 template_count
+= 1;
9289 t
= TYPE_MAIN_DECL (t
);
9290 if (DECL_LANG_SPECIFIC (t
))
9291 t
= DECL_CLASS_CONTEXT (t
);
9296 if (sname
== NULL_TREE
)
9299 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
9301 /* This is the `standard' use of the scoping operator:
9302 basetype :: member . */
9304 if (ctype
== current_class_type
)
9310 Is this ill-formed? */
9313 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
9316 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9318 if (current_class_type
== NULL_TREE
9320 type
= build_cplus_method_type (build_type_variant (ctype
, constp
, volatilep
),
9321 TREE_TYPE (type
), TYPE_ARG_TYPES (type
));
9324 cp_error ("cannot declare member function `%T::%s' within `%T'",
9325 ctype
, name
, current_class_type
);
9326 return void_type_node
;
9329 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
9330 || TYPE_SIZE (complete_type (ctype
)) != NULL_TREE
)
9332 /* have to move this code elsewhere in this function.
9333 this code is used for i.e., typedef int A::M; M *pm;
9335 It is? How? jason 10/2/94 */
9337 if (current_class_type
)
9339 cp_error ("cannot declare member `%T::%s' within `%T'",
9340 ctype
, name
, current_class_type
);
9341 return void_type_node
;
9343 type
= build_offset_type (ctype
, type
);
9345 else if (uses_template_parms (ctype
))
9347 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9349 = build_cplus_method_type (build_type_variant (ctype
,
9353 TYPE_ARG_TYPES (type
));
9357 cp_error ("structure `%T' not yet defined", ctype
);
9358 return error_mark_node
;
9363 else if (TREE_CODE (sname
) == SCOPE_REF
)
9364 my_friendly_abort (17);
9368 declarator
= TREE_OPERAND (declarator
, 1);
9369 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
9370 /* In this case, we will deal with it later. */
9374 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9375 type
= build_cplus_method_type (build_type_variant (ctype
, constp
, volatilep
), TREE_TYPE (type
), TYPE_ARG_TYPES (type
));
9377 type
= build_offset_type (ctype
, type
);
9384 declarator
= TREE_OPERAND (declarator
, 0);
9390 declarator
= NULL_TREE
;
9394 declarator
= NULL_TREE
;
9398 my_friendly_abort (158);
9404 error ("only constructors can be declared `explicit'");
9408 /* Now TYPE has the actual type. */
9410 /* If this is declaring a typedef name, return a TYPE_DECL. */
9412 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9416 error ("const `%s' cannot be declared `mutable'", name
);
9417 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9421 error ("static `%s' cannot be declared `mutable'", name
);
9422 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9426 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
9430 /* Note that the grammar rejects storage classes
9431 in typenames, fields or parameters. */
9432 if (constp
|| volatilep
)
9433 type
= cp_build_type_variant (type
, constp
, volatilep
);
9435 if (decl_context
== FIELD
)
9437 if (declarator
== current_class_name
)
9438 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
9440 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
9441 if (IS_SIGNATURE (current_class_type
) && opaque_typedef
)
9442 SIGNATURE_HAS_OPAQUE_TYPEDECLS (current_class_type
) = 1;
9445 decl
= build_decl (TYPE_DECL
, declarator
, type
);
9447 /* If the user declares "struct {...} foo" then `foo' will have
9448 an anonymous name. Fill that name in now. Nothing can
9449 refer to it, so nothing needs know about the name change.
9450 The TYPE_NAME field was filled in by build_struct_xref. */
9451 if (type
!= error_mark_node
9453 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
9454 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
9456 /* replace the anonymous name with the real name everywhere. */
9457 lookup_tag_reverse (type
, declarator
);
9458 TYPE_NAME (type
) = decl
;
9460 if (TYPE_LANG_SPECIFIC (type
))
9461 TYPE_WAS_ANONYMOUS (type
) = 1;
9463 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
9464 DECL_ASSEMBLER_NAME (decl
)
9465 = get_identifier (build_overload_name (type
, 1, 1));
9468 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
9470 cp_error_at ("typedef name may not be class-qualified", decl
);
9475 if (ctype
== NULL_TREE
)
9477 if (TREE_CODE (type
) != METHOD_TYPE
)
9478 cp_error_at ("invalid type qualifier for non-method type", decl
);
9480 ctype
= TYPE_METHOD_BASETYPE (type
);
9482 if (ctype
!= NULL_TREE
)
9483 grok_method_quals (ctype
, decl
, quals
);
9486 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
9487 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9488 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
9490 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9492 error ("non-object member `%s' cannot be declared mutable", name
);
9495 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
9496 inlinep
, friendp
, raises
!= NULL_TREE
);
9499 error ("typedef declaration includes an initializer");
9504 /* Detect the case of an array type of unspecified size
9505 which came, as such, direct from a typedef name.
9506 We must copy the type, so that each identifier gets
9507 a distinct type, so that each identifier's size can be
9508 controlled separately by its own initializer. */
9510 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
9511 && TYPE_DOMAIN (type
) == NULL_TREE
)
9513 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
9516 /* If this is a type name (such as, in a cast or sizeof),
9517 compute the type and return it now. */
9519 if (decl_context
== TYPENAME
)
9521 /* Note that the grammar rejects storage classes
9522 in typenames, fields or parameters. */
9523 if (constp
|| volatilep
)
9524 if (IS_SIGNATURE (type
))
9525 error ("`const' or `volatile' specified with signature type");
9527 type
= cp_build_type_variant (type
, constp
, volatilep
);
9529 /* Special case: "friend class foo" looks like a TYPENAME context. */
9534 cp_error ("`volatile' specified for friend class declaration");
9539 cp_error ("`inline' specified for friend class declaration");
9543 /* Only try to do this stuff if we didn't already give up. */
9544 if (type
!= integer_type_node
)
9546 /* A friendly class? */
9547 if (current_class_type
)
9548 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
9550 error ("trying to make class `%s' a friend of global scope",
9551 TYPE_NAME_STRING (type
));
9552 type
= void_type_node
;
9557 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
9558 if (ctype
== NULL_TREE
)
9560 my_friendly_assert (TREE_CODE (type
) == METHOD_TYPE
, 159);
9561 ctype
= TYPE_METHOD_BASETYPE (type
);
9563 grok_method_quals (ctype
, dummy
, quals
);
9564 type
= TREE_TYPE (dummy
);
9569 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
9570 && decl_context
!= CATCHPARM
9571 && TREE_CODE (type
) != UNION_TYPE
9574 cp_error ("abstract declarator `%T' used as declaration", type
);
9575 declarator
= make_anon_name ();
9578 /* `void' at top level (not within pointer)
9579 is allowed only in typedefs or type names.
9580 We don't complain about parms either, but that is because
9581 a better error message can be made later. */
9583 if (TYPE_MAIN_VARIANT (type
) == void_type_node
&& decl_context
!= PARM
)
9586 error ("unnamed variable or field declared void");
9587 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
9589 if (IDENTIFIER_OPNAME_P (declarator
))
9590 my_friendly_abort (356);
9592 error ("variable or field `%s' declared void", name
);
9595 error ("variable or field declared void");
9596 type
= integer_type_node
;
9599 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9600 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9605 if (decl_context
== PARM
)
9608 error ("cannot use `::' in parameter declaration");
9610 /* A parameter declared as an array of T is really a pointer to T.
9611 One declared as a function is really a pointer to a function.
9612 One declared as a member is really a pointer to member. */
9614 if (TREE_CODE (type
) == ARRAY_TYPE
)
9616 /* Transfer const-ness of array into that of type pointed to. */
9617 type
= build_pointer_type
9618 (cp_build_type_variant (TREE_TYPE (type
), constp
, volatilep
));
9619 volatilep
= constp
= 0;
9621 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9622 type
= build_pointer_type (type
);
9623 else if (TREE_CODE (type
) == OFFSET_TYPE
)
9624 type
= build_pointer_type (type
);
9625 else if (type
== void_type_node
&& declarator
)
9627 error ("declaration of `%s' as void", name
);
9631 decl
= build_decl (PARM_DECL
, declarator
, complete_type (type
));
9633 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
9634 inlinep
, friendp
, raises
!= NULL_TREE
);
9635 if (current_class_type
9636 && IS_SIGNATURE (current_class_type
))
9639 error ("parameter of signature member function declared `inline'");
9640 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9641 error ("parameter of signature member function declared `auto'");
9642 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
9643 error ("parameter of signature member function declared `register'");
9646 /* Compute the type actually passed in the parmlist,
9647 for the case where there is no prototype.
9648 (For example, shorts and chars are passed as ints.)
9649 When there is a prototype, this is overridden later. */
9651 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
9653 else if (decl_context
== FIELD
)
9655 if (type
== error_mark_node
)
9657 /* Happens when declaring arrays of sizes which
9658 are error_mark_node, for example. */
9661 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9664 tree function_context
;
9666 /* We catch the others as conflicts with the builtin
9668 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
9670 cp_error ("function `%D' cannot be declared friend",
9677 if (ctype
== NULL_TREE
)
9678 ctype
= current_class_type
;
9680 if (ctype
== NULL_TREE
)
9682 cp_error ("can't make `%D' into a method -- not in a class",
9684 return void_type_node
;
9687 /* ``A union may [ ... ] not [ have ] virtual functions.''
9689 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
9691 cp_error ("function `%D' declared virtual inside a union",
9693 return void_type_node
;
9696 if (declarator
== ansi_opname
[(int) NEW_EXPR
]
9697 || declarator
== ansi_opname
[(int) VEC_NEW_EXPR
]
9698 || declarator
== ansi_opname
[(int) DELETE_EXPR
]
9699 || declarator
== ansi_opname
[(int) VEC_DELETE_EXPR
])
9703 cp_error ("`%D' cannot be declared virtual, since it is always static",
9708 else if (staticp
< 2)
9709 type
= build_cplus_method_type (build_type_variant (ctype
, constp
, volatilep
),
9710 TREE_TYPE (type
), TYPE_ARG_TYPES (type
));
9713 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9714 function_context
= (ctype
!= NULL_TREE
) ?
9715 hack_decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
9716 publicp
= (! friendp
|| ! staticp
)
9717 && function_context
== NULL_TREE
;
9718 decl
= grokfndecl (ctype
, type
,
9719 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
9720 ? declarator
: dname
,
9722 virtualp
, flags
, quals
, raises
, attrlist
,
9723 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
9724 funcdef_flag
, template_count
);
9725 if (decl
== NULL_TREE
)
9728 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9729 /* The decl and setting of decl_machine_attr is also turned off. */
9730 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
9734 DECL_NONCONVERTING_P (decl
) = 1;
9736 else if (TREE_CODE (type
) == METHOD_TYPE
)
9738 /* We only get here for friend declarations of
9739 members of other classes. */
9740 /* All method decls are public, so tell grokfndecl to set
9741 TREE_PUBLIC, also. */
9742 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
9743 virtualp
, flags
, quals
, raises
, attrlist
,
9744 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
9746 if (decl
== NULL_TREE
)
9749 else if (!staticp
&& ! processing_template_decl
9750 && TYPE_SIZE (complete_type (type
)) == NULL_TREE
9751 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
9754 cp_error ("field `%D' has incomplete type", declarator
);
9756 cp_error ("name `%T' has incomplete type", type
);
9758 /* If we're instantiating a template, tell them which
9759 instantiation made the field's type be incomplete. */
9760 if (current_class_type
9761 && TYPE_NAME (current_class_type
)
9762 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
9763 && declspecs
&& TREE_VALUE (declspecs
)
9764 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
9765 cp_error (" in instantiation of template `%T'",
9766 current_class_type
);
9768 type
= error_mark_node
;
9775 error ("`%s' is neither function nor method; cannot be declared friend",
9776 IDENTIFIER_POINTER (declarator
));
9784 /* Friends are treated specially. */
9785 if (ctype
== current_class_type
)
9786 warning ("member functions are implicitly friends of their class");
9790 if (decl
&& DECL_NAME (decl
))
9791 t
= do_friend (ctype
, declarator
, decl
,
9792 last_function_parms
, flags
, quals
,
9794 if (t
&& funcdef_flag
)
9797 return void_type_node
;
9801 /* Structure field. It may not be a function, except for C++ */
9803 if (decl
== NULL_TREE
)
9807 /* Motion 10 at San Diego: If a static const integral data
9808 member is initialized with an integral constant
9809 expression, the initializer may appear either in the
9810 declaration (within the class), or in the definition,
9811 but not both. If it appears in the class, the member is
9812 a member constant. The file-scope definition is always
9819 cp_pedwarn ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
9822 else if (! INTEGRAL_TYPE_P (type
))
9823 cp_pedwarn ("ANSI C++ forbids member constant `%D' of non-integral type `%T'", declarator
, type
);
9827 /* Note that initialization of const members is prohibited
9828 by the draft ANSI standard, though it appears to be in
9829 common practice. 12.6.2: The argument list is used to
9830 initialize the named nonstatic member.... This (or an
9831 initializer list) is the only way to initialize
9832 nonstatic const and reference members. */
9833 else if (pedantic
|| ! constp
)
9834 cp_pedwarn ("ANSI C++ forbids initialization of %s `%D'",
9835 constp
? "const member" : "member", declarator
);
9838 if (staticp
|| (constp
&& initialized
))
9840 /* ANSI C++ Apr '95 wp 9.2 */
9841 if (staticp
&& declarator
== current_class_name
)
9842 cp_pedwarn ("ANSI C++ forbids static member `%D' with same name as enclosing class",
9845 /* C++ allows static class members.
9846 All other work for this is done by grokfield.
9847 This VAR_DECL is built by build_lang_field_decl.
9848 All other VAR_DECLs are built by build_decl. */
9849 decl
= build_lang_field_decl (VAR_DECL
, declarator
, type
);
9850 TREE_STATIC (decl
) = 1;
9851 /* In class context, 'static' means public access. */
9852 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = !!staticp
;
9856 decl
= build_lang_field_decl (FIELD_DECL
, declarator
, type
);
9857 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
9859 DECL_MUTABLE_P (decl
) = 1;
9860 RIDBIT_RESET (RID_MUTABLE
, specbits
);
9864 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
9865 inlinep
, friendp
, raises
!= NULL_TREE
);
9868 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
9876 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
9877 original_name
= dname
;
9879 original_name
= declarator
;
9881 if (RIDBIT_SETP (RID_AUTO
, specbits
))
9882 error ("storage class `auto' invalid for function `%s'", name
);
9883 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
9884 error ("storage class `register' invalid for function `%s'", name
);
9886 /* Function declaration not at top level.
9887 Storage classes other than `extern' are not allowed
9888 and `extern' makes no difference. */
9889 if (! toplevel_bindings_p ()
9890 && (RIDBIT_SETP (RID_STATIC
, specbits
)
9891 || RIDBIT_SETP (RID_INLINE
, specbits
))
9894 if (RIDBIT_SETP (RID_STATIC
, specbits
))
9895 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
9897 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
9900 if (ctype
== NULL_TREE
)
9904 error ("virtual non-class function `%s'", name
);
9908 if (current_lang_name
== lang_name_cplusplus
9909 && ! processing_template_decl
9910 && ! (IDENTIFIER_LENGTH (original_name
) == 4
9911 && IDENTIFIER_POINTER (original_name
)[0] == 'm'
9912 && strcmp (IDENTIFIER_POINTER (original_name
), "main") == 0)
9913 && ! (IDENTIFIER_LENGTH (original_name
) > 10
9914 && IDENTIFIER_POINTER (original_name
)[0] == '_'
9915 && IDENTIFIER_POINTER (original_name
)[1] == '_'
9916 && strncmp (IDENTIFIER_POINTER (original_name
)+2, "builtin_", 8) == 0))
9917 /* Plain overloading: will not be grok'd by grokclassfn. */
9918 if (name_mangling_version
< 1
9919 || TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
9920 declarator
= build_decl_overload (dname
, TYPE_ARG_TYPES (type
), 0);
9922 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
9923 type
= build_cplus_method_type (build_type_variant (ctype
, constp
, volatilep
),
9924 TREE_TYPE (type
), TYPE_ARG_TYPES (type
));
9926 /* Record presence of `static'. */
9927 publicp
= (ctype
!= NULL_TREE
9928 || RIDBIT_SETP (RID_EXTERN
, specbits
)
9929 || !RIDBIT_SETP (RID_STATIC
, specbits
));
9931 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
9932 virtualp
, flags
, quals
, raises
, attrlist
,
9934 publicp
, inlinep
, funcdef_flag
,
9936 if (decl
== NULL_TREE
)
9939 if (ctype
== NULL_TREE
&& DECL_LANGUAGE (decl
) != lang_c
9940 && (!DECL_TEMPLATE_SPECIALIZATION (decl
) ||
9941 name_mangling_version
< 1))
9942 DECL_ASSEMBLER_NAME (decl
) = current_namespace_id (declarator
);
9946 int illegal_static
= 0;
9948 /* Don't allow a static member function in a class, and forbid
9949 declaring main to be static. */
9950 if (TREE_CODE (type
) == METHOD_TYPE
)
9952 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
9955 else if (current_function_decl
)
9957 /* FIXME need arm citation */
9958 error ("cannot declare static function inside another function");
9965 RIDBIT_RESET (RID_STATIC
, specbits
);
9971 /* It's a variable. */
9973 if (decl_context
== CATCHPARM
)
9978 error ("cannot use `::' in parameter declaration");
9981 /* A parameter declared as an array of T is really a pointer to T.
9982 One declared as a function is really a pointer to a function.
9983 One declared as a member is really a pointer to member. */
9985 if (TREE_CODE (type
) == ARRAY_TYPE
)
9987 /* Transfer const-ness of array into that of type
9989 type
= build_pointer_type
9990 (cp_build_type_variant (TREE_TYPE (type
), constp
, volatilep
));
9991 volatilep
= constp
= 0;
9993 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9994 type
= build_pointer_type (type
);
9995 else if (TREE_CODE (type
) == OFFSET_TYPE
)
9996 type
= build_pointer_type (type
);
9999 /* An uninitialized decl with `extern' is a reference. */
10000 decl
= grokvardecl (type
, declarator
, &specbits
, initialized
, constp
);
10001 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
10002 inlinep
, friendp
, raises
!= NULL_TREE
);
10006 DECL_CONTEXT (decl
) = ctype
;
10009 cp_pedwarn ("static member `%D' re-declared as static", decl
);
10011 RIDBIT_RESET (RID_STATIC
, specbits
);
10013 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
10015 cp_error ("static member `%D' declared `register'", decl
);
10016 RIDBIT_RESET (RID_REGISTER
, specbits
);
10018 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
10020 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
10022 RIDBIT_RESET (RID_EXTERN
, specbits
);
10027 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10029 error ("`%s' cannot be declared mutable", name
);
10032 /* Record `register' declaration for warnings on &
10033 and in case doing stupid register allocation. */
10035 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
10036 DECL_REGISTER (decl
) = 1;
10038 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
10039 DECL_THIS_EXTERN (decl
) = 1;
10041 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10042 DECL_THIS_STATIC (decl
) = 1;
10044 /* Record constancy and volatility. */
10047 TREE_READONLY (decl
) = TREE_CODE (type
) != REFERENCE_TYPE
;
10050 TREE_SIDE_EFFECTS (decl
) = 1;
10051 TREE_THIS_VOLATILE (decl
) = 1;
10058 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
10059 An empty exprlist is a parmlist. An exprlist which
10060 contains only identifiers at the global level
10061 is a parmlist. Otherwise, it is an exprlist. */
10064 parmlist_is_exprlist (exprs
)
10067 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
10070 if (toplevel_bindings_p ())
10072 /* At the global level, if these are all identifiers,
10073 then it is a parmlist. */
10076 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
10078 exprs
= TREE_CHAIN (exprs
);
10085 /* Subroutine of `grokparms'. In a fcn definition, arg types must
10088 C++: also subroutine of `start_function'. */
10091 require_complete_types_for_parms (parms
)
10094 if (processing_template_decl
)
10099 tree type
= TREE_TYPE (parms
);
10100 if (TYPE_SIZE (complete_type (type
)) == NULL_TREE
)
10102 if (DECL_NAME (parms
))
10103 error ("parameter `%s' has incomplete type",
10104 IDENTIFIER_POINTER (DECL_NAME (parms
)));
10106 error ("parameter has incomplete type");
10107 TREE_TYPE (parms
) = error_mark_node
;
10110 /* If the arg types are incomplete in a declaration,
10111 they must include undefined tags.
10112 These tags can never be defined in the scope of the declaration,
10113 so the types can never be completed,
10114 and no call can be compiled successfully. */
10115 /* This is not the right behavior for C++, but not having
10116 it is also probably wrong. */
10119 /* Now warn if is a pointer to an incomplete type. */
10120 while (TREE_CODE (type
) == POINTER_TYPE
10121 || TREE_CODE (type
) == REFERENCE_TYPE
)
10122 type
= TREE_TYPE (type
);
10123 type
= TYPE_MAIN_VARIANT (type
);
10124 if (TYPE_SIZE (type
) == NULL_TREE
)
10126 if (DECL_NAME (parm
) != NULL_TREE
)
10127 warning ("parameter `%s' points to incomplete type",
10128 IDENTIFIER_POINTER (DECL_NAME (parm
)));
10130 warning ("parameter points to incomplete type");
10134 parms
= TREE_CHAIN (parms
);
10138 /* Decode the list of parameter types for a function type.
10139 Given the list of things declared inside the parens,
10140 return a list of types.
10142 The list we receive can have three kinds of elements:
10143 an IDENTIFIER_NODE for names given without types,
10144 a TREE_LIST node for arguments given as typespecs or names with typespecs,
10145 or void_type_node, to mark the end of an argument list
10146 when additional arguments are not permitted (... was not used).
10148 FUNCDEF_FLAG is nonzero for a function definition, 0 for
10149 a mere declaration. A nonempty identifier-list gets an error message
10150 when FUNCDEF_FLAG is zero.
10151 If FUNCDEF_FLAG is 1, then parameter types must be complete.
10152 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
10154 If all elements of the input list contain types,
10155 we return a list of the types.
10156 If all elements contain no type (except perhaps a void_type_node
10157 at the end), we return a null list.
10158 If some have types and some do not, it is an error, and we
10159 return a null list.
10161 Also set last_function_parms to either
10162 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
10163 A list of names is converted to a chain of PARM_DECLs
10164 by store_parm_decls so that ultimately it is always a chain of decls.
10166 Note that in C++, parameters can take default values. These default
10167 values are in the TREE_PURPOSE field of the TREE_LIST. It is
10168 an error to specify default values which are followed by parameters
10169 that have no default values, or an ELLIPSES. For simplicities sake,
10170 only parameters which are specified with their types can take on
10174 grokparms (first_parm
, funcdef_flag
)
10178 tree result
= NULL_TREE
;
10179 tree decls
= NULL_TREE
;
10181 if (first_parm
!= NULL_TREE
10182 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
10184 if (! funcdef_flag
)
10185 pedwarn ("parameter names (without types) in function declaration");
10186 last_function_parms
= first_parm
;
10189 else if (first_parm
!= NULL_TREE
10190 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
10191 && TREE_VALUE (first_parm
) != void_type_node
)
10192 my_friendly_abort (145);
10195 /* Types were specified. This is a list of declarators
10196 each represented as a TREE_LIST node. */
10197 register tree parm
, chain
;
10198 int any_init
= 0, any_error
= 0;
10200 if (first_parm
!= NULL_TREE
)
10202 tree last_result
= NULL_TREE
;
10203 tree last_decl
= NULL_TREE
;
10205 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
10207 tree type
, list_node
= parm
;
10208 register tree decl
= TREE_VALUE (parm
);
10209 tree init
= TREE_PURPOSE (parm
);
10211 chain
= TREE_CHAIN (parm
);
10212 /* @@ weak defense against parse errors. */
10213 if (decl
!= void_type_node
&& TREE_CODE (decl
) != TREE_LIST
)
10215 /* Give various messages as the need arises. */
10216 if (TREE_CODE (decl
) == STRING_CST
)
10217 cp_error ("invalid string constant `%E'", decl
);
10218 else if (TREE_CODE (decl
) == INTEGER_CST
)
10219 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
10223 if (decl
!= void_type_node
)
10225 decl
= grokdeclarator (TREE_VALUE (decl
),
10226 TREE_PURPOSE (decl
),
10227 PARM
, init
!= NULL_TREE
,
10231 type
= TREE_TYPE (decl
);
10232 if (TYPE_MAIN_VARIANT (type
) == void_type_node
)
10233 decl
= void_type_node
;
10234 else if (TREE_CODE (type
) == METHOD_TYPE
)
10236 if (DECL_NAME (decl
))
10237 /* Cannot use the decl here because
10238 we don't have DECL_CONTEXT set up yet. */
10239 cp_error ("parameter `%D' invalidly declared method type",
10242 error ("parameter invalidly declared method type");
10243 type
= build_pointer_type (type
);
10244 TREE_TYPE (decl
) = type
;
10246 else if (TREE_CODE (type
) == OFFSET_TYPE
)
10248 if (DECL_NAME (decl
))
10249 cp_error ("parameter `%D' invalidly declared offset type",
10252 error ("parameter invalidly declared offset type");
10253 type
= build_pointer_type (type
);
10254 TREE_TYPE (decl
) = type
;
10256 else if (TREE_CODE (type
) == RECORD_TYPE
10257 && TYPE_LANG_SPECIFIC (type
)
10258 && CLASSTYPE_ABSTRACT_VIRTUALS (type
))
10260 abstract_virtuals_error (decl
, type
);
10261 any_error
= 1; /* seems like a good idea */
10263 else if (TREE_CODE (type
) == RECORD_TYPE
10264 && TYPE_LANG_SPECIFIC (type
)
10265 && IS_SIGNATURE (type
))
10267 signature_error (decl
, type
);
10268 any_error
= 1; /* seems like a good idea */
10272 if (decl
== void_type_node
)
10274 if (result
== NULL_TREE
)
10276 result
= void_list_node
;
10277 last_result
= result
;
10281 TREE_CHAIN (last_result
) = void_list_node
;
10282 last_result
= void_list_node
;
10285 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
10286 error ("`void' in parameter list must be entire list");
10290 /* Since there is a prototype, args are passed in their own types. */
10291 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
10292 #ifdef PROMOTE_PROTOTYPES
10293 if ((TREE_CODE (type
) == INTEGER_TYPE
10294 || TREE_CODE (type
) == ENUMERAL_TYPE
)
10295 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
10296 DECL_ARG_TYPE (decl
) = integer_type_node
;
10303 if (TREE_CODE (init
) == SAVE_EXPR
)
10304 PARM_DECL_EXPR (init
) = 1;
10305 else if (processing_template_decl
)
10307 /* Unparsed default arg from in-class decl. */
10308 else if (TREE_CODE (init
) == DEFAULT_ARG
)
10310 else if (TREE_CODE (init
) == VAR_DECL
10311 || TREE_CODE (init
) == PARM_DECL
)
10313 if (IDENTIFIER_LOCAL_VALUE (DECL_NAME (init
)))
10315 /* ``Local variables may not be used in default
10316 argument expressions.'' dpANSI C++ 8.2.6 */
10317 /* If extern int i; within a function is not
10318 considered a local variable, then this code is
10320 cp_error ("local variable `%D' may not be used as a default argument", init
);
10323 else if (TREE_READONLY_DECL_P (init
))
10324 init
= decl_constant_value (init
);
10327 init
= require_instantiated_type (type
, init
, integer_zero_node
);
10328 if (! processing_template_decl
10329 && TREE_CODE (init
) != DEFAULT_ARG
10330 && ! can_convert_arg (type
, TREE_TYPE (init
), init
))
10331 cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
10332 TREE_TYPE (init
), decl
);
10338 if (decls
== NULL_TREE
)
10345 TREE_CHAIN (last_decl
) = decl
;
10348 if (! current_function_decl
&& TREE_PERMANENT (list_node
))
10350 TREE_PURPOSE (list_node
) = init
;
10351 TREE_VALUE (list_node
) = type
;
10352 TREE_CHAIN (list_node
) = NULL_TREE
;
10355 list_node
= saveable_tree_cons (init
, type
, NULL_TREE
);
10356 if (result
== NULL_TREE
)
10358 result
= list_node
;
10359 last_result
= result
;
10363 TREE_CHAIN (last_result
) = list_node
;
10364 last_result
= list_node
;
10368 TREE_CHAIN (last_result
) = NULL_TREE
;
10369 /* If there are no parameters, and the function does not end
10370 with `...', then last_decl will be NULL_TREE. */
10371 if (last_decl
!= NULL_TREE
)
10372 TREE_CHAIN (last_decl
) = NULL_TREE
;
10376 last_function_parms
= decls
;
10378 /* In a fcn definition, arg types must be complete. */
10379 if (funcdef_flag
> 0)
10380 require_complete_types_for_parms (last_function_parms
);
10385 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
10386 FUNCTION_TYPE with the newly parsed version of its default argument, which
10387 was previously digested as text. See snarf_defarg et al in lex.c. */
10390 replace_defarg (arg
, init
)
10393 if (! processing_template_decl
10394 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
10395 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
10396 TREE_TYPE (init
), TREE_VALUE (arg
));
10397 TREE_PURPOSE (arg
) = init
;
10404 tree t
= FUNCTION_ARG_CHAIN (d
);
10405 if (DECL_CONSTRUCTOR_P (d
)
10406 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d
)))
10407 t
= TREE_CHAIN (t
);
10408 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
10409 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
10410 == DECL_CLASS_CONTEXT (d
))
10411 && (TREE_CHAIN (t
) == NULL_TREE
10412 || TREE_CHAIN (t
) == void_list_node
10413 || TREE_PURPOSE (TREE_CHAIN (t
))))
10418 /* These memoizing functions keep track of special properties which
10419 a class may have. `grok_ctor_properties' notices whether a class
10420 has a constructor of the form X(X&), and also complains
10421 if the class has a constructor of the form X(X).
10422 `grok_op_properties' takes notice of the various forms of
10423 operator= which are defined, as well as what sorts of type conversion
10424 may apply. Both functions take a FUNCTION_DECL as an argument. */
10427 grok_ctor_properties (ctype
, decl
)
10430 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
10431 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
10433 /* When a type has virtual baseclasses, a magical first int argument is
10434 added to any ctor so we can tell if the class has been initialized
10435 yet. This could screw things up in this function, so we deliberately
10436 ignore the leading int if we're in that situation. */
10438 && TREE_VALUE (parmtypes
) == integer_type_node
10439 && TYPE_USES_VIRTUAL_BASECLASSES (ctype
))
10441 parmtypes
= TREE_CHAIN (parmtypes
);
10442 parmtype
= TREE_VALUE (parmtypes
);
10445 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
10446 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
)
10448 if (TREE_CHAIN (parmtypes
) == NULL_TREE
10449 || TREE_CHAIN (parmtypes
) == void_list_node
10450 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
10452 TYPE_HAS_INIT_REF (ctype
) = 1;
10453 if (TYPE_READONLY (TREE_TYPE (parmtype
)))
10454 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
10457 TYPE_GETS_INIT_AGGR (ctype
) = 1;
10459 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
)
10461 if (TREE_CHAIN (parmtypes
) != NULL_TREE
10462 && TREE_CHAIN (parmtypes
) == void_list_node
)
10464 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
10466 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
10471 TYPE_GETS_INIT_AGGR (ctype
) = 1;
10473 else if (TREE_CODE (parmtype
) == VOID_TYPE
10474 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
10475 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
10480 /* An operator with this name can be either unary or binary. */
10486 return (name
== ansi_opname
[(int) INDIRECT_REF
]
10487 || name
== ansi_opname
[(int) ADDR_EXPR
]
10488 || name
== ansi_opname
[(int) NEGATE_EXPR
]
10489 || name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
10490 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]
10491 || name
== ansi_opname
[(int) CONVERT_EXPR
]);
10494 /* An operator with this name can only be unary. */
10500 return (name
== ansi_opname
[(int) TRUTH_NOT_EXPR
]
10501 || name
== ansi_opname
[(int) BIT_NOT_EXPR
]
10502 || name
== ansi_opname
[(int) COMPONENT_REF
]
10503 || OPERATOR_TYPENAME_P (name
));
10506 /* Do a little sanity-checking on how they declared their operator. */
10509 grok_op_properties (decl
, virtualp
, friendp
)
10511 int virtualp
, friendp
;
10513 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
10514 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
10515 tree name
= DECL_NAME (decl
);
10517 if (current_class_type
== NULL_TREE
)
10522 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
10523 TYPE_HAS_ASSIGNMENT (current_class_type
) = 1;
10524 else if (name
== ansi_opname
[(int) CALL_EXPR
])
10525 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
10526 else if (name
== ansi_opname
[(int) ARRAY_REF
])
10527 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
10528 else if (name
== ansi_opname
[(int) COMPONENT_REF
]
10529 || name
== ansi_opname
[(int) MEMBER_REF
])
10530 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
10531 else if (name
== ansi_opname
[(int) NEW_EXPR
])
10532 TYPE_GETS_NEW (current_class_type
) |= 1;
10533 else if (name
== ansi_opname
[(int) DELETE_EXPR
])
10534 TYPE_GETS_DELETE (current_class_type
) |= 1;
10535 else if (name
== ansi_opname
[(int) VEC_NEW_EXPR
])
10536 TYPE_GETS_NEW (current_class_type
) |= 2;
10537 else if (name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10538 TYPE_GETS_DELETE (current_class_type
) |= 2;
10541 if (name
== ansi_opname
[(int) NEW_EXPR
]
10542 || name
== ansi_opname
[(int) VEC_NEW_EXPR
])
10544 /* When the compiler encounters the definition of A::operator new, it
10545 doesn't look at the class declaration to find out if it's static. */
10547 revert_static_member_fn (&decl
, NULL
, NULL
);
10549 /* Take care of function decl if we had syntax errors. */
10550 if (argtypes
== NULL_TREE
)
10552 = build_function_type (ptr_type_node
,
10553 hash_tree_chain (integer_type_node
,
10556 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
10558 else if (name
== ansi_opname
[(int) DELETE_EXPR
]
10559 || name
== ansi_opname
[(int) VEC_DELETE_EXPR
])
10562 revert_static_member_fn (&decl
, NULL
, NULL
);
10564 if (argtypes
== NULL_TREE
)
10566 = build_function_type (void_type_node
,
10567 hash_tree_chain (ptr_type_node
,
10571 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
10573 if (! friendp
&& name
== ansi_opname
[(int) VEC_DELETE_EXPR
]
10574 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)))
10575 != void_list_node
))
10576 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type
) = 1;
10581 /* An operator function must either be a non-static member function
10582 or have at least one parameter of a class, a reference to a class,
10583 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10584 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
10586 if (OPERATOR_TYPENAME_P (name
)
10587 || name
== ansi_opname
[(int) CALL_EXPR
]
10588 || name
== ansi_opname
[(int) MODIFY_EXPR
]
10589 || name
== ansi_opname
[(int) COMPONENT_REF
]
10590 || name
== ansi_opname
[(int) ARRAY_REF
])
10591 cp_error ("`%D' must be a nonstatic member function", decl
);
10596 if (DECL_STATIC_FUNCTION_P (decl
))
10597 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
10600 for (; TREE_VALUE (p
) != void_type_node
; p
= TREE_CHAIN (p
))
10602 tree arg
= TREE_VALUE (p
);
10603 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
10604 arg
= TREE_TYPE (arg
);
10606 /* This lets bad template code slip through. */
10607 if (IS_AGGR_TYPE (arg
)
10608 || TREE_CODE (arg
) == ENUMERAL_TYPE
10609 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
10610 || TREE_CODE (arg
) == TEMPLATE_TEMPLATE_PARM
)
10614 ("`%D' must have an argument of class or enumerated type",
10621 if (name
== ansi_opname
[(int) CALL_EXPR
]
10622 || name
== ansi_opname
[(int) METHOD_CALL_EXPR
])
10623 return; /* no restrictions on args */
10625 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
10627 tree t
= TREE_TYPE (name
);
10628 if (TREE_CODE (t
) == VOID_TYPE
)
10629 pedwarn ("void is not a valid type conversion operator");
10630 else if (! friendp
)
10632 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
10635 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
10637 if (t
== current_class_type
)
10638 what
= "the same type";
10639 /* Don't force t to be complete here. */
10640 else if (IS_AGGR_TYPE (t
)
10642 && DERIVED_FROM_P (t
, current_class_type
))
10643 what
= "a base class";
10646 warning ("conversion to %s%s will never use a type conversion operator",
10647 ref
? "a reference to " : "", what
);
10651 if (name
== ansi_opname
[(int) MODIFY_EXPR
])
10655 if (list_length (argtypes
) != 3 && methodp
)
10657 cp_error ("`%D' must take exactly one argument", decl
);
10660 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
10662 if (copy_assignment_arg_p (parmtype
, virtualp
)
10665 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
10666 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
10667 || TYPE_READONLY (TREE_TYPE (parmtype
)))
10668 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
10671 else if (name
== ansi_opname
[(int) COND_EXPR
])
10674 pedwarn ("ANSI C++ prohibits overloading operator ?:");
10675 if (list_length (argtypes
) != 4)
10676 cp_error ("`%D' must take exactly three arguments", decl
);
10678 else if (ambi_op_p (name
))
10680 if (list_length (argtypes
) == 2)
10682 else if (list_length (argtypes
) == 3)
10684 if ((name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
10685 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
10686 && ! processing_template_decl
10687 && TREE_VALUE (TREE_CHAIN (argtypes
)) != integer_type_node
)
10690 cp_error ("postfix `%D' must take `int' as its argument",
10694 ("postfix `%D' must take `int' as its second argument",
10701 cp_error ("`%D' must take either zero or one argument", decl
);
10703 cp_error ("`%D' must take either one or two arguments", decl
);
10706 /* More Effective C++ rule 6. */
10708 && (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
10709 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
]))
10711 tree arg
= TREE_VALUE (argtypes
);
10712 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
10713 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
10714 arg
= TREE_TYPE (arg
);
10715 arg
= TYPE_MAIN_VARIANT (arg
);
10716 if (list_length (argtypes
) == 2)
10718 if (TREE_CODE (ret
) != REFERENCE_TYPE
10719 || !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
10721 cp_warning ("prefix `%D' should return `%T'", decl
,
10722 build_reference_type (arg
));
10726 if (!comptypes (TYPE_MAIN_VARIANT (ret
), arg
, 1))
10727 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
10731 else if (unary_op_p (name
))
10733 if (list_length (argtypes
) != 2)
10736 cp_error ("`%D' must take `void'", decl
);
10738 cp_error ("`%D' must take exactly one argument", decl
);
10741 else /* if (binary_op_p (name)) */
10743 if (list_length (argtypes
) != 3)
10746 cp_error ("`%D' must take exactly one argument", decl
);
10748 cp_error ("`%D' must take exactly two arguments", decl
);
10751 /* More Effective C++ rule 7. */
10753 && (name
== ansi_opname
[TRUTH_ANDIF_EXPR
]
10754 || name
== ansi_opname
[TRUTH_ORIF_EXPR
]
10755 || name
== ansi_opname
[COMPOUND_EXPR
]))
10756 cp_warning ("user-defined `%D' always evaluates both arguments",
10760 /* Effective C++ rule 23. */
10762 && list_length (argtypes
) == 3
10763 && (name
== ansi_opname
[PLUS_EXPR
]
10764 || name
== ansi_opname
[MINUS_EXPR
]
10765 || name
== ansi_opname
[TRUNC_DIV_EXPR
]
10766 || name
== ansi_opname
[MULT_EXPR
])
10767 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
10768 cp_warning ("`%D' should return by value", decl
);
10772 for (; argtypes
!= void_list_node
; argtypes
= TREE_CHAIN (argtypes
))
10773 if (TREE_PURPOSE (argtypes
))
10775 TREE_PURPOSE (argtypes
) = NULL_TREE
;
10776 if (name
== ansi_opname
[(int) POSTINCREMENT_EXPR
]
10777 || name
== ansi_opname
[(int) POSTDECREMENT_EXPR
])
10780 cp_pedwarn ("`%D' cannot have default arguments", decl
);
10783 cp_error ("`%D' cannot have default arguments", decl
);
10788 /* Get the struct, enum or union (CODE says which) with tag NAME.
10789 Define the tag as a forward-reference if it is not defined.
10791 C++: If a class derivation is given, process it here, and report
10792 an error if multiple derivation declarations are not identical.
10794 If this is a definition, come in through xref_tag and only look in
10795 the current frame for the name (since C++ allows new names in any
10799 xref_tag (code_type_node
, name
, binfo
, globalize
)
10800 tree code_type_node
;
10804 enum tag_types tag_code
;
10805 enum tree_code code
;
10807 register tree ref
, t
;
10808 struct binding_level
*b
= inner_binding_level
;
10811 tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
10816 case signature_type
:
10817 code
= RECORD_TYPE
;
10823 code
= ENUMERAL_TYPE
;
10826 my_friendly_abort (18);
10829 /* If a cross reference is requested, look up the type
10830 already defined for this tag and return it. */
10831 if (TREE_CODE_CLASS (TREE_CODE (name
)) == 't')
10834 name
= TYPE_IDENTIFIER (t
);
10838 t
= IDENTIFIER_TYPE_VALUE (name
);
10839 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
10840 && TREE_CODE (t
) != TEMPLATE_TEMPLATE_PARM
)
10845 if (pedantic
&& t
&& (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
10846 || TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
))
10848 cp_pedwarn ("redeclaration of template type-parameter `%T'", name
);
10849 cp_pedwarn_at (" previously declared here", t
);
10851 if (t
&& TYPE_CONTEXT (t
) && got_type
)
10855 /* If we know we are defining this tag, only look it up in
10856 this scope and don't try to find it as a type. */
10857 ref
= lookup_tag (code
, name
, b
, 1);
10865 ref
= lookup_tag (code
, name
, b
, 0);
10869 /* Try finding it as a type declaration. If that wins, use it. */
10870 ref
= lookup_name (name
, 1);
10871 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
10872 && TREE_CODE (TREE_TYPE (ref
)) == code
)
10873 ref
= TREE_TYPE (ref
);
10879 push_obstacks_nochange ();
10883 /* If no such tag is yet defined, create a forward-reference node
10884 and record it as the "definition".
10885 When a real declaration of this type is found,
10886 the forward-reference will be altered into a real type. */
10888 /* In C++, since these migrate into the global scope, we must
10889 build them on the permanent obstack. */
10891 temp
= allocation_temporary_p ();
10893 end_temporary_allocation ();
10895 if (code
== ENUMERAL_TYPE
)
10897 cp_error ("use of enum `%#D' without previous declaration", name
);
10899 ref
= make_node (ENUMERAL_TYPE
);
10901 /* Give the type a default layout like unsigned int
10902 to avoid crashing if it does not get defined. */
10903 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
10904 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
10905 TREE_UNSIGNED (ref
) = 1;
10906 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
10907 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
10908 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
10910 /* Enable us to recognize when a type is created in class context.
10911 To do nested classes correctly, this should probably be cleared
10912 out when we leave this classes scope. Currently this in only
10913 done in `start_enum'. */
10915 pushtag (name
, ref
, globalize
);
10919 struct binding_level
*old_b
= class_binding_level
;
10921 ref
= make_lang_type (code
);
10923 if (tag_code
== signature_type
)
10925 SET_SIGNATURE (ref
);
10926 /* Since a signature type will be turned into the type
10927 of signature tables, it's not only an interface. */
10928 CLASSTYPE_INTERFACE_ONLY (ref
) = 0;
10929 SET_CLASSTYPE_INTERFACE_KNOWN (ref
);
10930 /* A signature doesn't have a vtable. */
10931 CLASSTYPE_VTABLE_NEEDS_WRITING (ref
) = 0;
10934 #ifdef NONNESTED_CLASSES
10935 /* Class types don't nest the way enums do. */
10936 class_binding_level
= (struct binding_level
*)0;
10938 pushtag (name
, ref
, globalize
);
10939 class_binding_level
= old_b
;
10944 /* If it no longer looks like a nested type, make sure it's
10945 in global scope. */
10946 if (b
== global_binding_level
&& !class_binding_level
10947 && IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
)
10948 IDENTIFIER_GLOBAL_VALUE (name
) = TYPE_NAME (ref
);
10952 xref_basetypes (code_type_node
, name
, ref
, binfo
);
10956 /* Until the type is defined, tentatively accept whatever
10957 structure tag the user hands us. */
10958 if (TYPE_SIZE (ref
) == NULL_TREE
10959 && ref
!= current_class_type
10960 /* Have to check this, in case we have contradictory tag info. */
10961 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
10963 if (tag_code
== class_type
)
10964 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
10965 else if (tag_code
== record_type
|| tag_code
== signature_type
)
10966 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
10975 xref_tag_from_type (old
, id
, globalize
)
10979 tree code_type_node
;
10981 if (TREE_CODE (old
) == RECORD_TYPE
)
10982 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
10983 ? class_type_node
: record_type_node
);
10985 code_type_node
= union_type_node
;
10987 if (id
== NULL_TREE
)
10988 id
= TYPE_IDENTIFIER (old
);
10990 return xref_tag (code_type_node
, id
, NULL_TREE
, globalize
);
10994 xref_basetypes (code_type_node
, name
, ref
, binfo
)
10995 tree code_type_node
;
10999 /* In the declaration `A : X, Y, ... Z' we mark all the types
11000 (A, X, Y, ..., Z) so we can check for duplicates. */
11003 enum tag_types tag_code
= (enum tag_types
) TREE_INT_CST_LOW (code_type_node
);
11005 if (tag_code
== union_type
)
11007 cp_error ("derived union `%T' invalid", ref
);
11011 len
= list_length (binfo
);
11012 push_obstacks (TYPE_OBSTACK (ref
), TYPE_OBSTACK (ref
));
11014 SET_CLASSTYPE_MARKED (ref
);
11015 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
11017 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
11019 /* The base of a derived struct is public by default. */
11021 = (TREE_PURPOSE (binfo
) == access_public_node
11022 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11023 || (tag_code
!= class_type
11024 && (TREE_PURPOSE (binfo
) == access_default_node
11025 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
11026 int via_protected
= TREE_PURPOSE (binfo
) == access_protected_node
;
11028 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
11029 || TREE_PURPOSE (binfo
) == access_public_virtual_node
11030 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
11031 tree basetype
= TREE_VALUE (binfo
);
11034 GNU_xref_hier (IDENTIFIER_POINTER (name
),
11035 IDENTIFIER_POINTER (TREE_VALUE (binfo
)),
11036 via_public
, via_virtual
, 0);
11038 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
11039 basetype
= TREE_TYPE (basetype
);
11041 || (TREE_CODE (basetype
) != RECORD_TYPE
11042 && TREE_CODE (basetype
) != TYPENAME_TYPE
11043 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
11044 && TREE_CODE (basetype
) != TEMPLATE_TEMPLATE_PARM
))
11046 cp_error ("base type `%T' fails to be a struct or class type",
11047 TREE_VALUE (binfo
));
11051 /* This code replaces similar code in layout_basetypes. */
11052 else if (! (current_template_parms
&& uses_template_parms (basetype
))
11053 && TYPE_SIZE (complete_type (basetype
)) == NULL_TREE
)
11055 cp_error ("base class `%T' has incomplete type", basetype
);
11061 if (CLASSTYPE_MARKED (basetype
))
11063 if (basetype
== ref
)
11064 cp_error ("recursive type `%T' undefined", basetype
);
11066 cp_error ("duplicate base type `%T' invalid", basetype
);
11070 /* Note that the BINFO records which describe individual
11071 inheritances are *not* shared in the lattice! They
11072 cannot be shared because a given baseclass may be
11073 inherited with different `accessibility' by different
11074 derived classes. (Each BINFO record describing an
11075 individual inheritance contains flags which say what
11076 the `accessibility' of that particular inheritance is.) */
11078 base_binfo
= make_binfo (integer_zero_node
, basetype
,
11079 TYPE_BINFO_VTABLE (basetype
),
11080 TYPE_BINFO_VIRTUALS (basetype
), NULL_TREE
);
11082 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
11083 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
11084 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
11085 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
11086 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
11088 SET_CLASSTYPE_MARKED (basetype
);
11090 /* We are free to modify these bits because they are meaningless
11091 at top level, and BASETYPE is a top-level type. */
11092 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
11094 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
11095 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11098 TYPE_OVERLOADS_METHOD_CALL_EXPR (ref
) |= TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype
);
11099 TYPE_GETS_NEW (ref
) |= TYPE_GETS_NEW (basetype
);
11100 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
11101 CLASSTYPE_LOCAL_TYPEDECLS (ref
) |= CLASSTYPE_LOCAL_TYPEDECLS (basetype
);
11106 TREE_VEC_LENGTH (binfos
) = i
;
11108 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
11111 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
11113 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
11114 = TYPE_USES_MULTIPLE_INHERITANCE (BINFO_TYPE (TREE_VEC_ELT (binfos
, 0)));
11115 if (TYPE_USES_MULTIPLE_INHERITANCE (ref
))
11116 TYPE_USES_COMPLEX_INHERITANCE (ref
) = 1;
11118 /* Unmark all the types. */
11120 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
11121 CLEAR_CLASSTYPE_MARKED (ref
);
11127 tree current_local_enum
= NULL_TREE
;
11129 /* Begin compiling the definition of an enumeration type.
11130 NAME is its name (or null if anonymous).
11131 Returns the type object, as yet incomplete.
11132 Also records info about it so that build_enumerator
11133 may be used to declare the individual values as they are read. */
11139 register tree enumtype
= NULL_TREE
;
11140 struct binding_level
*b
= inner_binding_level
;
11142 if (processing_template_decl
&& current_function_decl
)
11143 end_temporary_allocation ();
11145 /* If this is the real definition for a previous forward reference,
11146 fill in the contents in the same object that used to be the
11147 forward reference. */
11149 if (name
!= NULL_TREE
)
11150 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
11152 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
11153 cp_error ("multiple definition of `%#T'", enumtype
);
11156 enumtype
= make_node (ENUMERAL_TYPE
);
11157 pushtag (name
, enumtype
, 0);
11160 if (b
->pseudo_global
)
11161 cp_error ("template declaration of `%#T'", enumtype
);
11163 if (current_class_type
)
11164 TREE_ADDRESSABLE (b
->tags
) = 1;
11166 current_local_enum
= NULL_TREE
;
11168 /* We don't copy this value because build_enumerator needs to do it. */
11169 enum_next_value
= integer_zero_node
;
11172 GNU_xref_decl (current_function_decl
, enumtype
);
11176 /* After processing and defining all the values of an enumeration type,
11177 install their decls in the enumeration type and finish it off.
11178 ENUMTYPE is the type object and VALUES a list of name-value pairs.
11179 Returns ENUMTYPE. */
11182 finish_enum (enumtype
, values
)
11183 register tree enumtype
, values
;
11185 register tree minnode
, maxnode
;
11186 /* Calculate the maximum value of any enumerator in this type. */
11190 register tree pair
;
11191 register tree value
= DECL_INITIAL (TREE_VALUE (values
));
11193 if (! processing_template_decl
)
11195 /* Speed up the main loop by performing some precalculations */
11196 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
11197 TREE_TYPE (value
) = enumtype
;
11198 minnode
= maxnode
= value
;
11200 TREE_VALUE (values
) = value
;
11202 for (pair
= TREE_CHAIN (values
); pair
; pair
= TREE_CHAIN (pair
))
11204 value
= DECL_INITIAL (TREE_VALUE (pair
));
11205 if (! processing_template_decl
)
11207 TREE_TYPE (TREE_VALUE (pair
)) = enumtype
;
11208 TREE_TYPE (value
) = enumtype
;
11209 if (tree_int_cst_lt (maxnode
, value
))
11211 else if (tree_int_cst_lt (value
, minnode
))
11214 TREE_VALUE (pair
) = value
;
11218 maxnode
= minnode
= integer_zero_node
;
11220 TYPE_VALUES (enumtype
) = nreverse (values
);
11222 if (processing_template_decl
)
11224 if (current_function_decl
)
11226 add_tree (build_min (TAG_DEFN
, enumtype
));
11227 resume_temporary_allocation ();
11233 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
11234 int lowprec
= min_precision (minnode
, unsignedp
);
11235 int highprec
= min_precision (maxnode
, unsignedp
);
11236 int precision
= MAX (lowprec
, highprec
);
11238 TYPE_SIZE (enumtype
) = NULL_TREE
;
11240 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
11242 TYPE_PRECISION (enumtype
) = precision
;
11244 fixup_unsigned_type (enumtype
);
11246 fixup_signed_type (enumtype
);
11248 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
11249 /* Use the width of the narrowest normal C type which is wide enough. */
11250 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
11253 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
11255 TYPE_SIZE (enumtype
) = 0;
11256 layout_type (enumtype
);
11262 /* Fix up all variant types of this enum type. */
11263 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
11264 tem
= TYPE_NEXT_VARIANT (tem
))
11266 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
11267 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
11268 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
11269 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
11270 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
11271 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
11272 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
11273 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
11277 /* Finish debugging output for this type. */
11278 rest_of_type_compilation (enumtype
, global_bindings_p ());
11283 /* Build and install a CONST_DECL for one value of the
11284 current enumeration type (one that was begun with start_enum).
11285 Return a tree-list containing the name and its value.
11286 Assignment of sequential values by default is handled here. */
11289 build_enumerator (name
, value
)
11294 /* Remove no-op casts from the value. */
11296 STRIP_TYPE_NOPS (value
);
11298 if (! processing_template_decl
)
11300 /* Validate and default VALUE. */
11301 if (value
!= NULL_TREE
)
11303 if (TREE_READONLY_DECL_P (value
))
11304 value
= decl_constant_value (value
);
11306 if (TREE_CODE (value
) == INTEGER_CST
)
11308 value
= default_conversion (value
);
11309 constant_expression_warning (value
);
11313 cp_error ("enumerator value for `%D' not integer constant", name
);
11318 /* Default based on previous value. */
11319 if (value
== NULL_TREE
&& ! processing_template_decl
)
11321 value
= enum_next_value
;
11323 cp_error ("overflow in enumeration values at `%D'", name
);
11326 /* Remove no-op casts from the value. */
11328 STRIP_TYPE_NOPS (value
);
11330 /* We have to always copy here; not all INTEGER_CSTs are unshared,
11331 and there's no wedding ring. Look at size_int()...*/
11332 value
= copy_node (value
);
11334 /* To fix MAX_VAL enum consts. (bkoz) */
11335 TREE_TYPE (value
) = integer_type_node
;
11339 /* C++ associates enums with global, function, or class declarations. */
11341 decl
= current_scope ();
11342 if (decl
&& decl
== current_class_type
)
11344 /* This enum declaration is local to the class, so we must put
11345 it in that class's list of decls. */
11346 decl
= build_lang_field_decl (CONST_DECL
, name
, integer_type_node
);
11347 DECL_INITIAL (decl
) = value
;
11348 TREE_READONLY (decl
) = 1;
11349 pushdecl_class_level (decl
);
11350 TREE_CHAIN (decl
) = current_local_enum
;
11351 current_local_enum
= decl
;
11355 /* It's a global enum, or it's local to a function. (Note local to
11356 a function could mean local to a class method. */
11357 decl
= build_decl (CONST_DECL
, name
, integer_type_node
);
11358 DECL_INITIAL (decl
) = value
;
11359 TREE_READONLY (decl
) = 1;
11362 GNU_xref_decl (current_function_decl
, decl
);
11365 if (! processing_template_decl
)
11367 /* Set basis for default for next value. */
11368 enum_next_value
= build_binary_op_nodefault (PLUS_EXPR
, value
,
11369 integer_one_node
, PLUS_EXPR
);
11370 enum_overflow
= tree_int_cst_lt (enum_next_value
, value
);
11373 result
= saveable_tree_cons (name
, decl
, NULL_TREE
);
11378 grok_enum_decls (decl
)
11381 tree d
= current_local_enum
;
11383 if (d
== NULL_TREE
)
11388 if (TREE_CHAIN (d
) == NULL_TREE
)
11390 TREE_CHAIN (d
) = decl
;
11393 d
= TREE_CHAIN (d
);
11396 decl
= current_local_enum
;
11397 current_local_enum
= NULL_TREE
;
11402 static int function_depth
;
11404 /* Create the FUNCTION_DECL for a function definition.
11405 DECLSPECS and DECLARATOR are the parts of the declaration;
11406 they describe the function's name and the type it returns,
11407 but twisted together in a fashion that parallels the syntax of C.
11409 This function creates a binding context for the function body
11410 as well as setting up the FUNCTION_DECL in current_function_decl.
11412 Returns 1 on success. If the DECLARATOR is not suitable for a function
11413 (it defines a datum instead), we return 0, which tells
11414 yyparse to report a parse error.
11416 For C++, we must first check whether that datum makes any sense.
11417 For example, "class A local_a(1,2);" means that variable local_a
11418 is an aggregate of type A, which should have a constructor
11419 applied to it with the argument list [1, 2].
11421 @@ There is currently no way to retrieve the storage
11422 @@ allocated to FUNCTION (or all of its parms) if we return
11423 @@ something we had previously. */
11426 start_function (declspecs
, declarator
, attrs
, pre_parsed_p
)
11427 tree declspecs
, declarator
, attrs
;
11431 tree ctype
= NULL_TREE
;
11434 extern int have_extern_spec
;
11435 extern int used_extern_spec
;
11436 int doing_friend
= 0;
11438 /* Sanity check. */
11439 my_friendly_assert (TREE_VALUE (void_list_node
) == void_type_node
, 160);
11440 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
11442 /* Assume, until we see it does. */
11443 current_function_returns_value
= 0;
11444 current_function_returns_null
= 0;
11445 warn_about_return_type
= 0;
11447 shadowed_labels
= 0;
11448 current_function_assigns_this
= 0;
11449 current_function_just_assigned_this
= 0;
11450 current_function_parms_stored
= 0;
11451 original_result_rtx
= NULL_RTX
;
11452 base_init_expr
= NULL_TREE
;
11453 current_base_init_list
= NULL_TREE
;
11454 current_member_init_list
= NULL_TREE
;
11455 ctor_label
= dtor_label
= NULL_TREE
;
11456 static_labelno
= 0;
11458 clear_temp_name ();
11460 /* This should only be done once on the top most decl. */
11461 if (have_extern_spec
&& !used_extern_spec
)
11463 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
11464 used_extern_spec
= 1;
11469 decl1
= declarator
;
11471 if (! DECL_ARGUMENTS (decl1
)
11472 && !DECL_STATIC_FUNCTION_P (decl1
)
11473 && DECL_CONTEXT (decl1
)
11474 && TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))
11475 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (DECL_CONTEXT (decl1
))))
11477 cp_error ("redeclaration of `%#D'", decl1
);
11478 if (IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)))
11479 cp_error_at ("previous declaration here", IDENTIFIER_CLASS_VALUE (DECL_NAME (decl1
)));
11480 else if (IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1
)))
11481 cp_error_at ("previous declaration here", IDENTIFIER_GLOBAL_VALUE (DECL_NAME (decl1
)));
11484 fntype
= TREE_TYPE (decl1
);
11485 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11486 ctype
= TYPE_METHOD_BASETYPE (fntype
);
11488 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
11489 class is in the (lexical) scope of the class in which it is
11491 if (!ctype
&& DECL_FRIEND_P (decl1
))
11493 ctype
= DECL_CLASS_CONTEXT (decl1
);
11495 /* CTYPE could be null here if we're dealing with a template;
11496 for example, `inline friend float foo()' inside a template
11497 will have no CTYPE set. */
11498 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
11504 /* In a fcn definition, arg types must be complete. */
11505 require_complete_types_for_parms (DECL_ARGUMENTS (decl1
));
11507 /* In case some arg types were completed since the declaration was
11508 parsed, fix up the decls. */
11510 tree t
= DECL_ARGUMENTS (decl1
);
11511 for (; t
; t
= TREE_CHAIN (t
))
11512 layout_decl (t
, 0);
11515 last_function_parms
= DECL_ARGUMENTS (decl1
);
11516 last_function_parm_tags
= NULL_TREE
;
11520 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
11521 /* If the declarator is not suitable for a function definition,
11522 cause a syntax error. */
11523 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
11525 fntype
= TREE_TYPE (decl1
);
11527 restype
= TREE_TYPE (fntype
);
11528 if (IS_AGGR_TYPE (restype
) && ! TYPE_PTRMEMFUNC_P (restype
)
11529 && ! CLASSTYPE_GOT_SEMICOLON (restype
))
11531 cp_error ("semicolon missing after declaration of `%#T'", restype
);
11532 shadow_tag (build_expr_list (NULL_TREE
, restype
));
11533 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
11534 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
11535 fntype
= build_function_type (integer_type_node
,
11536 TYPE_ARG_TYPES (fntype
));
11538 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
11540 TYPE_ARG_TYPES (fntype
));
11541 TREE_TYPE (decl1
) = fntype
;
11544 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11545 ctype
= TYPE_METHOD_BASETYPE (fntype
);
11546 else if (IDENTIFIER_LENGTH (DECL_NAME (decl1
)) == 4
11547 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (decl1
)), "main")
11548 && DECL_CONTEXT (decl1
) == NULL_TREE
)
11550 /* If this doesn't return integer_type, complain. */
11551 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
11553 if (pedantic
|| warn_return_type
)
11554 pedwarn ("return type for `main' changed to `int'");
11555 TREE_TYPE (decl1
) = fntype
= default_function_type
;
11557 warn_about_return_type
= 0;
11561 /* Warn if function was previously implicitly declared
11562 (but not if we warned then). */
11563 if (! warn_implicit
11564 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
11565 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
11567 current_function_decl
= decl1
;
11568 /* Save the parm names or decls from this function's declarator
11569 where store_parm_decls will find them. */
11570 current_function_parms
= last_function_parms
;
11571 current_function_parm_tags
= last_function_parm_tags
;
11573 announce_function (decl1
);
11575 if (! processing_template_decl
)
11577 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype
))) == NULL_TREE
)
11579 cp_error ("return-type `%#T' is an incomplete type",
11580 TREE_TYPE (fntype
));
11582 /* Make it return void instead, but don't change the
11583 type of the DECL_RESULT, in case we have a named return value. */
11586 = build_cplus_method_type (build_type_variant (ctype
,
11587 TREE_READONLY (decl1
),
11588 TREE_SIDE_EFFECTS (decl1
)),
11590 FUNCTION_ARG_CHAIN (decl1
));
11593 = build_function_type (void_type_node
,
11594 TYPE_ARG_TYPES (TREE_TYPE (decl1
)));
11595 DECL_RESULT (decl1
)
11596 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)));
11597 TREE_READONLY (DECL_RESULT (decl1
)) = TYPE_READONLY (TREE_TYPE (fntype
));
11598 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = TYPE_VOLATILE (TREE_TYPE (fntype
));
11601 if (TYPE_LANG_SPECIFIC (TREE_TYPE (fntype
))
11602 && CLASSTYPE_ABSTRACT_VIRTUALS (TREE_TYPE (fntype
)))
11603 abstract_virtuals_error (decl1
, TREE_TYPE (fntype
));
11606 if (warn_about_return_type
)
11607 pedwarn ("return-type defaults to `int'");
11609 /* Effective C++ rule 15. See also c_expand_return. */
11611 && DECL_NAME (decl1
) == ansi_opname
[(int) MODIFY_EXPR
]
11612 && TREE_TYPE (fntype
) == void_type_node
)
11613 cp_warning ("`operator=' should return a reference to `*this'");
11615 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11616 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11617 DECL_INITIAL (decl1
) = error_mark_node
;
11619 /* This function exists in static storage.
11620 (This does not mean `static' in the C sense!) */
11621 TREE_STATIC (decl1
) = 1;
11623 /* Record the decl so that the function name is defined.
11624 If we already have a decl for this name, and it is a FUNCTION_DECL,
11625 use the old decl. */
11627 if (processing_template_decl
)
11628 push_template_decl (decl1
);
11629 else if (pre_parsed_p
== 0)
11631 /* A specialization is not used to guide overload resolution. */
11632 if (flag_guiding_decls
11633 || !DECL_TEMPLATE_SPECIALIZATION (decl1
))
11634 decl1
= pushdecl (decl1
);
11635 DECL_MAIN_VARIANT (decl1
) = decl1
;
11636 fntype
= TREE_TYPE (decl1
);
11639 current_function_decl
= decl1
;
11641 if (DECL_INTERFACE_KNOWN (decl1
))
11643 tree ctx
= hack_decl_function_context (decl1
);
11645 if (DECL_NOT_REALLY_EXTERN (decl1
))
11646 DECL_EXTERNAL (decl1
) = 0;
11648 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
11649 && TREE_PUBLIC (ctx
))
11650 /* This is a function in a local class in an extern inline
11652 comdat_linkage (decl1
);
11654 /* If this function belongs to an interface, it is public.
11655 If it belongs to someone else's interface, it is also external.
11656 It doesn't matter whether it's inline or not. */
11657 else if (interface_unknown
== 0
11658 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
11659 || flag_alt_external_templates
))
11661 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
11662 || processing_template_decl
)
11663 DECL_EXTERNAL (decl1
)
11665 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
));
11667 DECL_EXTERNAL (decl1
) = 0;
11668 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
11669 DECL_INTERFACE_KNOWN (decl1
) = 1;
11673 /* This is a definition, not a reference.
11674 So clear DECL_EXTERNAL. */
11675 DECL_EXTERNAL (decl1
) = 0;
11677 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
11678 && ! DECL_INTERFACE_KNOWN (decl1
)
11679 /* Don't try to defer nested functions for now. */
11680 && ! hack_decl_function_context (decl1
))
11681 DECL_DEFER_OUTPUT (decl1
) = 1;
11683 DECL_INTERFACE_KNOWN (decl1
) = 1;
11686 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
))
11688 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11689 TREE_TYPE (decl1
) = fntype
11690 = build_function_type (TREE_TYPE (fntype
),
11691 TREE_CHAIN (TYPE_ARG_TYPES (fntype
)));
11692 current_function_parms
= TREE_CHAIN (current_function_parms
);
11693 DECL_ARGUMENTS (decl1
) = current_function_parms
;
11696 restype
= TREE_TYPE (fntype
);
11700 push_nested_class (ctype
, 1);
11702 /* If we're compiling a friend function, neither of the variables
11703 current_class_ptr nor current_class_type will have values. */
11704 if (! doing_friend
)
11706 /* We know that this was set up by `grokclassfn'.
11707 We do not wait until `store_parm_decls', since evil
11708 parse errors may never get us to that point. Here
11709 we keep the consistency between `current_class_type'
11710 and `current_class_ptr'. */
11711 tree t
= current_function_parms
;
11713 my_friendly_assert (t
!= NULL_TREE
11714 && TREE_CODE (t
) == PARM_DECL
, 162);
11716 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
11718 int i
= suspend_momentary ();
11720 /* Fool build_indirect_ref. */
11721 current_class_ptr
= NULL_TREE
;
11722 current_class_ref
= build_indirect_ref (t
, NULL_PTR
);
11723 current_class_ptr
= t
;
11724 resume_momentary (i
);
11727 /* We're having a signature pointer here. */
11728 current_class_ref
= current_class_ptr
= t
;
11734 if (DECL_STATIC_FUNCTION_P (decl1
))
11735 push_nested_class (DECL_CONTEXT (decl1
), 2);
11737 push_memoized_context (0, 1);
11738 current_class_ptr
= current_class_ref
= NULL_TREE
;
11742 current_binding_level
->parm_flag
= 1;
11744 GNU_xref_function (decl1
, current_function_parms
);
11747 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
11748 make_function_rtl (decl1
);
11750 /* Promote the value to int before returning it. */
11751 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
11752 restype
= type_promotes_to (restype
);
11754 /* If this fcn was already referenced via a block-scope `extern' decl
11755 (or an implicit decl), propagate certain information about the usage. */
11756 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
11757 TREE_ADDRESSABLE (decl1
) = 1;
11759 if (DECL_RESULT (decl1
) == NULL_TREE
)
11761 DECL_RESULT (decl1
)
11762 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
11763 TREE_READONLY (DECL_RESULT (decl1
)) = TYPE_READONLY (restype
);
11764 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = TYPE_VOLATILE (restype
);
11767 /* Allocate further tree nodes temporarily during compilation
11768 of this function only. Tiemann moved up here from bottom of fn. */
11769 temporary_allocation ();
11771 if (processing_template_decl
)
11773 ++minimal_parse_mode
;
11774 last_tree
= DECL_SAVED_TREE (decl1
)
11775 = build_nt (EXPR_STMT
, void_zero_node
);
11780 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1
))
11781 && DECL_LANGUAGE (decl1
) == lang_cplusplus
)
11783 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
11784 ctor_label
= NULL_TREE
;
11788 dtor_label
= NULL_TREE
;
11789 if (DECL_CONSTRUCTOR_P (decl1
))
11790 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
11796 /* Called after store_parm_decls for a function-try-block. We need to update
11797 last_parm_cleanup_insn so that the base initializers for a constructor
11798 are run within this block, not before it. */
11801 expand_start_early_try_stmts ()
11803 expand_start_try_stmts ();
11804 last_parm_cleanup_insn
= get_last_insn ();
11807 /* Store the parameter declarations into the current function declaration.
11808 This is called after parsing the parameter declarations, before
11809 digesting the body of the function.
11811 Also install to binding contour return value identifier, if any. */
11814 store_parm_decls ()
11816 register tree fndecl
= current_function_decl
;
11817 register tree parm
;
11818 int parms_have_cleanups
= 0;
11819 tree cleanups
= NULL_TREE
;
11821 /* This is either a chain of PARM_DECLs (when a prototype is used). */
11822 tree specparms
= current_function_parms
;
11824 /* This is a list of types declared among parms in a prototype. */
11825 tree parmtags
= current_function_parm_tags
;
11827 /* This is a chain of any other decls that came in among the parm
11828 declarations. If a parm is declared with enum {foo, bar} x;
11829 then CONST_DECLs for foo and bar are put here. */
11830 tree nonparms
= NULL_TREE
;
11832 if (toplevel_bindings_p ())
11833 fatal ("parse errors have confused me too much");
11835 /* Initialize RTL machinery. */
11836 init_function_start (fndecl
, input_filename
, lineno
);
11838 /* Declare __FUNCTION__ and __PRETTY_FUNCTION__ for this function. */
11839 declare_function_name ();
11841 /* Create a binding level for the parms. */
11842 expand_start_bindings (0);
11844 if (specparms
!= NULL_TREE
)
11846 /* This case is when the function was defined with an ANSI prototype.
11847 The parms already have decls, so we need not do anything here
11848 except record them as in effect
11849 and complain if any redundant old-style parm decls were written. */
11851 register tree next
;
11853 /* Must clear this because it might contain TYPE_DECLs declared
11855 storedecls (NULL_TREE
);
11857 for (parm
= nreverse (specparms
); parm
; parm
= next
)
11859 next
= TREE_CHAIN (parm
);
11860 if (TREE_CODE (parm
) == PARM_DECL
)
11863 if (DECL_NAME (parm
) == NULL_TREE
)
11867 else if (TYPE_MAIN_VARIANT (TREE_TYPE (parm
)) == void_type_node
)
11868 cp_error ("parameter `%D' declared void", parm
);
11871 /* Now fill in DECL_REFERENCE_SLOT for any of the parm decls.
11872 A parameter is assumed not to have any side effects.
11873 If this should change for any reason, then this
11874 will have to wrap the bashed reference type in a save_expr.
11876 Also, if the parameter type is declared to be an X
11877 and there is an X(X&) constructor, we cannot lay it
11878 into the stack (any more), so we make this parameter
11879 look like it is really of reference type. Functions
11880 which pass parameters to this function will know to
11881 create a temporary in their frame, and pass a reference
11884 if (TREE_CODE (TREE_TYPE (parm
)) == REFERENCE_TYPE
11885 && TYPE_SIZE (TREE_TYPE (TREE_TYPE (parm
))))
11886 SET_DECL_REFERENCE_SLOT (parm
, convert_from_reference (parm
));
11890 if (! processing_template_decl
11891 && (cleanup
= maybe_build_cleanup (parm
), cleanup
))
11893 expand_decl (parm
);
11894 parms_have_cleanups
= 1;
11896 /* Keep track of the cleanups. */
11897 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
11902 /* If we find an enum constant or a type tag,
11903 put it aside for the moment. */
11904 TREE_CHAIN (parm
) = NULL_TREE
;
11905 nonparms
= chainon (nonparms
, parm
);
11909 /* Get the decls in their original chain order
11910 and record in the function. This is all and only the
11911 PARM_DECLs that were pushed into scope by the loop above. */
11912 DECL_ARGUMENTS (fndecl
) = getdecls ();
11914 storetags (chainon (parmtags
, gettags ()));
11917 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
11919 /* Now store the final chain of decls for the arguments
11920 as the decl-chain of the current lexical scope.
11921 Put the enumerators in as well, at the front so that
11922 DECL_ARGUMENTS is not modified. */
11924 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
11926 /* Initialize the RTL code for the function. */
11927 DECL_SAVED_INSNS (fndecl
) = NULL_RTX
;
11928 if (! processing_template_decl
)
11929 expand_function_start (fndecl
, parms_have_cleanups
);
11931 current_function_parms_stored
= 1;
11933 /* If this function is `main', emit a call to `__main'
11934 to run global initializers, etc. */
11935 if (DECL_NAME (fndecl
)
11936 && IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) == 4
11937 && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl
)), "main") == 0
11938 && DECL_CONTEXT (fndecl
) == NULL_TREE
)
11940 expand_main_function ();
11943 /* Now that we have initialized the parms, we can start their
11944 cleanups. We cannot do this before, since expand_decl_cleanup
11945 should not be called before the parm can be used. */
11947 && ! processing_template_decl
)
11949 for (cleanups
= nreverse (cleanups
); cleanups
; cleanups
= TREE_CHAIN (cleanups
))
11951 if (! expand_decl_cleanup (TREE_PURPOSE (cleanups
), TREE_VALUE (cleanups
)))
11952 cp_error ("parser lost in parsing declaration of `%D'",
11953 TREE_PURPOSE (cleanups
));
11957 /* Create a binding contour which can be used to catch
11958 cleanup-generated temporaries. Also, if the return value needs or
11959 has initialization, deal with that now. */
11960 if (parms_have_cleanups
)
11963 expand_start_bindings (0);
11966 if (! processing_template_decl
&& flag_exceptions
)
11968 /* Do the starting of the exception specifications, if we have any. */
11969 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
11970 expand_start_eh_spec ();
11973 last_parm_cleanup_insn
= get_last_insn ();
11974 last_dtor_insn
= get_last_insn ();
11977 /* Bind a name and initialization to the return value of
11978 the current function. */
11981 store_return_init (return_id
, init
)
11982 tree return_id
, init
;
11984 tree decl
= DECL_RESULT (current_function_decl
);
11987 /* Give this error as many times as there are occurrences,
11988 so that users can use Emacs compilation buffers to find
11989 and fix all such places. */
11990 pedwarn ("ANSI C++ does not permit named return values");
11992 if (return_id
!= NULL_TREE
)
11994 if (DECL_NAME (decl
) == NULL_TREE
)
11996 DECL_NAME (decl
) = return_id
;
11997 DECL_ASSEMBLER_NAME (decl
) = return_id
;
12000 cp_error ("return identifier `%D' already in place", decl
);
12003 /* Can't let this happen for constructors. */
12004 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12006 error ("can't redefine default return value for constructors");
12010 /* If we have a named return value, put that in our scope as well. */
12011 if (DECL_NAME (decl
) != NULL_TREE
)
12013 /* If this named return value comes in a register,
12014 put it in a pseudo-register. */
12015 if (DECL_REGISTER (decl
))
12017 original_result_rtx
= DECL_RTL (decl
);
12018 DECL_RTL (decl
) = gen_reg_rtx (DECL_MODE (decl
));
12021 /* Let `cp_finish_decl' know that this initializer is ok. */
12022 DECL_INITIAL (decl
) = init
;
12025 if (minimal_parse_mode
)
12026 add_tree (build_min_nt (RETURN_INIT
, return_id
,
12027 copy_to_permanent (init
)));
12029 cp_finish_decl (decl
, init
, NULL_TREE
, 0, 0);
12034 /* Finish up a function declaration and compile that function
12035 all the way to assembler language output. The free the storage
12036 for the function definition.
12038 This is called after parsing the body of the function definition.
12039 LINENO is the current line number.
12041 C++: CALL_POPLEVEL is non-zero if an extra call to poplevel
12042 (and expand_end_bindings) must be made to take care of the binding
12043 contour for the base initializers. This is only relevant for
12046 NESTED is nonzero if we were in the middle of compiling another function
12047 when we started on this one. */
12050 finish_function (lineno
, call_poplevel
, nested
)
12055 register tree fndecl
= current_function_decl
;
12056 tree fntype
, ctype
= NULL_TREE
;
12057 rtx last_parm_insn
, insns
;
12058 /* Label to use if this function is supposed to return a value. */
12059 tree no_return_label
= NULL_TREE
;
12060 tree decls
= NULL_TREE
;
12062 /* When we get some parse errors, we can end up without a
12063 current_function_decl, so cope. */
12064 if (fndecl
== NULL_TREE
)
12067 if (! nested
&& function_depth
> 1)
12070 fntype
= TREE_TYPE (fndecl
);
12072 /* TREE_READONLY (fndecl) = 1;
12073 This caused &foo to be of type ptr-to-const-function
12074 which then got a warning when stored in a ptr-to-function variable. */
12076 /* This happens on strange parse errors. */
12077 if (! current_function_parms_stored
)
12080 store_parm_decls ();
12083 if (processing_template_decl
)
12085 if (DECL_CONSTRUCTOR_P (fndecl
) && call_poplevel
)
12087 decls
= getdecls ();
12088 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
12089 poplevel (decls
!= NULL_TREE
, 0, 0);
12094 if (write_symbols
!= NO_DEBUG
/*&& TREE_CODE (fntype) != METHOD_TYPE*/)
12096 tree ttype
= target_type (fntype
);
12099 if (IS_AGGR_TYPE (ttype
))
12100 /* Let debugger know it should output info for this type. */
12101 note_debug_info_needed (ttype
);
12103 for (parmdecl
= DECL_ARGUMENTS (fndecl
); parmdecl
; parmdecl
= TREE_CHAIN (parmdecl
))
12105 ttype
= target_type (TREE_TYPE (parmdecl
));
12106 if (IS_AGGR_TYPE (ttype
))
12107 /* Let debugger know it should output info for this type. */
12108 note_debug_info_needed (ttype
);
12112 /* Clean house because we will need to reorder insns here. */
12113 do_pending_stack_adjust ();
12117 tree binfo
= TYPE_BINFO (current_class_type
);
12118 tree cond
= integer_one_node
;
12120 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
12122 int ok_to_optimize_dtor
= 0;
12123 int empty_dtor
= get_last_insn () == last_dtor_insn
;
12125 if (current_function_assigns_this
)
12126 cond
= build (NE_EXPR
, boolean_type_node
,
12127 current_class_ptr
, integer_zero_node
);
12130 int n_baseclasses
= CLASSTYPE_N_BASECLASSES (current_class_type
);
12132 /* If this destructor is empty, then we don't need to check
12133 whether `this' is NULL in some cases. */
12134 if ((flag_this_is_variable
& 1) == 0)
12135 ok_to_optimize_dtor
= 1;
12136 else if (empty_dtor
)
12137 ok_to_optimize_dtor
12138 = (n_baseclasses
== 0
12139 || (n_baseclasses
== 1
12140 && TYPE_HAS_DESTRUCTOR (TYPE_BINFO_BASETYPE (current_class_type
, 0))));
12143 /* These initializations might go inline. Protect
12144 the binding level of the parms. */
12146 expand_start_bindings (0);
12148 if (current_function_assigns_this
)
12150 current_function_assigns_this
= 0;
12151 current_function_just_assigned_this
= 0;
12154 /* Generate the code to call destructor on base class.
12155 If this destructor belongs to a class with virtual
12156 functions, then set the virtual function table
12157 pointer to represent the type of our base class. */
12159 /* This side-effect makes call to `build_delete' generate the
12160 code we have to have at the end of this destructor. */
12161 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
12163 /* These are two cases where we cannot delegate deletion. */
12164 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)
12165 || TYPE_GETS_REG_DELETE (current_class_type
))
12166 exprstmt
= build_delete (current_class_type
, current_class_ref
, integer_zero_node
,
12167 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
12169 exprstmt
= build_delete (current_class_type
, current_class_ref
, in_charge_node
,
12170 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
, 0);
12172 /* If we did not assign to this, then `this' is non-zero at
12173 the end of a destructor. As a special optimization, don't
12174 emit test if this is an empty destructor. If it does nothing,
12175 it does nothing. If it calls a base destructor, the base
12176 destructor will perform the test. */
12178 if (exprstmt
!= error_mark_node
12179 && (TREE_CODE (exprstmt
) != NOP_EXPR
12180 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
12181 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
12183 expand_label (dtor_label
);
12184 if (cond
!= integer_one_node
)
12185 expand_start_cond (cond
, 0);
12186 if (exprstmt
!= void_zero_node
)
12187 /* Don't call `expand_expr_stmt' if we're not going to do
12188 anything, since -Wall will give a diagnostic. */
12189 expand_expr_stmt (exprstmt
);
12191 /* Run destructor on all virtual baseclasses. */
12192 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
12194 tree vbases
= nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type
)));
12195 expand_start_cond (build (BIT_AND_EXPR
, integer_type_node
,
12196 in_charge_node
, integer_two_node
), 0);
12199 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases
)))
12201 tree vb
= get_vbase
12202 (BINFO_TYPE (vbases
),
12203 TYPE_BINFO (current_class_type
));
12205 (build_scoped_method_call
12206 (current_class_ref
, vb
, dtor_identifier
,
12207 build_expr_list (NULL_TREE
, integer_zero_node
)));
12209 vbases
= TREE_CHAIN (vbases
);
12211 expand_end_cond ();
12214 do_pending_stack_adjust ();
12215 if (cond
!= integer_one_node
)
12216 expand_end_cond ();
12219 TYPE_HAS_DESTRUCTOR (current_class_type
) = 1;
12221 virtual_size
= c_sizeof (current_class_type
);
12223 /* At the end, call delete if that's what's requested. */
12224 if (TYPE_GETS_REG_DELETE (current_class_type
))
12225 /* This NOP_EXPR means we are in a static call context. */
12227 = build_method_call (build_indirect_ref (build1 (NOP_EXPR
,
12228 build_pointer_type (current_class_type
),
12231 ansi_opname
[(int) DELETE_EXPR
],
12232 expr_tree_cons (NULL_TREE
, current_class_ptr
,
12233 build_expr_list (NULL_TREE
, virtual_size
)),
12234 NULL_TREE
, LOOKUP_NORMAL
);
12235 else if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
12236 exprstmt
= build_x_delete (ptr_type_node
, current_class_ptr
, 0,
12239 exprstmt
= NULL_TREE
;
12243 cond
= build (BIT_AND_EXPR
, integer_type_node
,
12244 in_charge_node
, integer_one_node
);
12245 expand_start_cond (cond
, 0);
12246 expand_expr_stmt (exprstmt
);
12247 expand_end_cond ();
12250 /* End of destructor. */
12251 expand_end_bindings (NULL_TREE
, getdecls () != NULL_TREE
, 0);
12252 poplevel (2, 0, 0); /* XXX change to 1 */
12254 /* Back to the top of destructor. */
12255 /* Don't execute destructor code if `this' is NULL. */
12259 /* If the dtor is empty, and we know there is not possible way we
12260 could use any vtable entries, before they are possibly set by
12261 a base class dtor, we don't have to setup the vtables, as we
12262 know that any base class dtoring will set up any vtables it
12263 needs. We avoid MI, because one base class dtor can do a
12264 virtual dispatch to an overridden function that would need to
12265 have a non-related vtable set up, we cannot avoid setting up
12266 vtables in that case. We could change this to see if there is
12267 just one vtable. */
12268 if (! empty_dtor
|| TYPE_USES_COMPLEX_INHERITANCE (current_class_type
))
12270 /* Make all virtual function table pointers in non-virtual base
12271 classes point to CURRENT_CLASS_TYPE's virtual function
12273 expand_direct_vtbls_init (binfo
, binfo
, 1, 0, current_class_ptr
);
12275 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
12276 expand_indirect_vtbls_init (binfo
, current_class_ref
, current_class_ptr
);
12279 if (! ok_to_optimize_dtor
)
12281 cond
= build_binary_op (NE_EXPR
,
12282 current_class_ptr
, integer_zero_node
, 1);
12283 expand_start_cond (cond
, 0);
12286 insns
= get_insns ();
12289 last_parm_insn
= get_first_nonparm_insn ();
12290 if (last_parm_insn
== NULL_RTX
)
12291 last_parm_insn
= get_last_insn ();
12293 last_parm_insn
= previous_insn (last_parm_insn
);
12295 emit_insns_after (insns
, last_parm_insn
);
12297 if (! ok_to_optimize_dtor
)
12298 expand_end_cond ();
12300 else if (current_function_assigns_this
)
12302 /* Does not need to call emit_base_init, because
12303 that is done (if needed) just after assignment to this
12306 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12308 end_protect_partials ();
12309 expand_label (ctor_label
);
12310 ctor_label
= NULL_TREE
;
12314 decls
= getdecls ();
12315 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
12316 poplevel (decls
!= NULL_TREE
, 0, 0);
12318 c_expand_return (current_class_ptr
);
12320 else if (TYPE_MAIN_VARIANT (TREE_TYPE (
12321 DECL_RESULT (current_function_decl
))) != void_type_node
12322 && return_label
!= NULL_RTX
)
12323 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12325 current_function_assigns_this
= 0;
12326 current_function_just_assigned_this
= 0;
12327 base_init_expr
= NULL_TREE
;
12329 else if (DECL_CONSTRUCTOR_P (fndecl
))
12331 tree cond
, thenclause
;
12332 /* Allow constructor for a type to get a new instance of the object
12333 using `build_new'. */
12334 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
);
12335 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = NULL_TREE
;
12337 DECL_RETURNS_FIRST_ARG (fndecl
) = 1;
12339 if (flag_this_is_variable
> 0)
12341 cond
= build_binary_op (EQ_EXPR
,
12342 current_class_ptr
, integer_zero_node
, 1);
12343 thenclause
= build_modify_expr (current_class_ptr
, NOP_EXPR
,
12344 build_new (NULL_TREE
, current_class_type
, void_type_node
, 0));
12347 CLASSTYPE_ABSTRACT_VIRTUALS (current_class_type
) = abstract_virtuals
;
12351 if (flag_this_is_variable
> 0)
12353 expand_start_cond (cond
, 0);
12354 expand_expr_stmt (thenclause
);
12355 expand_end_cond ();
12358 /* Emit insns from `emit_base_init' which sets up virtual
12359 function table pointer(s). */
12360 if (base_init_expr
)
12362 expand_expr_stmt (base_init_expr
);
12363 base_init_expr
= NULL_TREE
;
12366 insns
= get_insns ();
12369 /* This is where the body of the constructor begins. */
12371 emit_insns_after (insns
, last_parm_cleanup_insn
);
12373 end_protect_partials ();
12375 /* This is where the body of the constructor ends. */
12376 expand_label (ctor_label
);
12377 ctor_label
= NULL_TREE
;
12381 decls
= getdecls ();
12382 expand_end_bindings (decls
, decls
!= NULL_TREE
, 0);
12383 poplevel (decls
!= NULL_TREE
, 1, 0);
12386 c_expand_return (current_class_ptr
);
12388 current_function_assigns_this
= 0;
12389 current_function_just_assigned_this
= 0;
12391 else if (IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) == 4
12392 && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl
)), "main")
12393 && DECL_CONTEXT (fndecl
) == NULL_TREE
)
12395 /* Make it so that `main' always returns 0 by default. */
12397 c_expand_return (integer_one_node
);
12399 c_expand_return (integer_zero_node
);
12402 else if (return_label
!= NULL_RTX
12403 && current_function_return_value
== NULL_TREE
12404 && ! DECL_NAME (DECL_RESULT (current_function_decl
)))
12405 no_return_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12407 if (flag_exceptions
)
12408 expand_exception_blocks ();
12410 /* If this function is supposed to return a value, ensure that
12411 we do not fall into the cleanups by mistake. The end of our
12412 function will look like this:
12414 user code (may have return stmt somewhere)
12415 goto no_return_label
12420 NOTE_INSN_FUNCTION_END
12424 If the user omits a return stmt in the USER CODE section, we
12425 will have a control path which reaches NOTE_INSN_FUNCTION_END.
12426 Otherwise, we won't. */
12427 if (no_return_label
)
12429 DECL_CONTEXT (no_return_label
) = fndecl
;
12430 DECL_INITIAL (no_return_label
) = error_mark_node
;
12431 DECL_SOURCE_FILE (no_return_label
) = input_filename
;
12432 DECL_SOURCE_LINE (no_return_label
) = lineno
;
12433 expand_goto (no_return_label
);
12438 /* remove the binding contour which is used
12439 to catch cleanup-generated temporaries. */
12440 expand_end_bindings (0, 0, 0);
12441 poplevel (0, 0, 0);
12443 /* Emit label at beginning of cleanup code for parameters. */
12444 emit_label (cleanup_label
);
12447 /* Get return value into register if that's where it's supposed to be. */
12448 if (original_result_rtx
)
12449 fixup_result_decl (DECL_RESULT (fndecl
), original_result_rtx
);
12451 /* Finish building code that will trigger warnings if users forget
12452 to make their functions return values. */
12453 if (no_return_label
|| cleanup_label
)
12454 emit_jump (return_label
);
12455 if (no_return_label
)
12457 /* We don't need to call `expand_*_return' here because we
12458 don't need any cleanups here--this path of code is only
12459 for error checking purposes. */
12460 expand_label (no_return_label
);
12463 /* Generate rtl for function exit. */
12464 expand_function_end (input_filename
, lineno
, 1);
12467 /* This must come after expand_function_end because cleanups might
12468 have declarations (from inline functions) that need to go into
12469 this function's blocks. */
12470 if (current_binding_level
->parm_flag
!= 1)
12471 my_friendly_abort (122);
12472 poplevel (1, 0, 1);
12474 /* reset scope for C++: if we were in the scope of a class,
12475 then when we finish this function, we are not longer so.
12476 This cannot be done until we know for sure that no more
12477 class members will ever be referenced in this function
12478 (i.e., calls to destructors). */
12479 if (current_class_name
)
12481 ctype
= current_class_type
;
12482 pop_nested_class (1);
12485 pop_memoized_context (1);
12487 /* Must mark the RESULT_DECL as being in this function. */
12488 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
12490 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12491 to the FUNCTION_DECL node itself. */
12492 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
12494 if (! processing_template_decl
)
12496 int saved_flag_keep_inline_functions
=
12497 flag_keep_inline_functions
;
12499 /* So we can tell if jump_optimize sets it to 1. */
12502 if (DECL_CONTEXT (fndecl
) != NULL_TREE
12503 && hack_decl_function_context (fndecl
))
12504 /* Trick rest_of_compilation into not deferring output of this
12505 function, even if it is inline, since the rtl_obstack for
12506 this function is the function_obstack of the enclosing
12507 function and will be deallocated when the enclosing
12508 function is gone. See save_tree_status. */
12509 flag_keep_inline_functions
= 1;
12511 /* Run the optimizers and output the assembler code for this
12514 if (DECL_ARTIFICIAL (fndecl
))
12516 /* Do we really *want* to inline this synthesized method? */
12518 int save_fif
= flag_inline_functions
;
12519 flag_inline_functions
= 1;
12521 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
12522 will check our size. */
12523 DECL_INLINE (fndecl
) = 0;
12525 rest_of_compilation (fndecl
);
12526 flag_inline_functions
= save_fif
;
12529 rest_of_compilation (fndecl
);
12531 flag_keep_inline_functions
= saved_flag_keep_inline_functions
;
12533 if (DECL_SAVED_INSNS (fndecl
) && ! TREE_ASM_WRITTEN (fndecl
))
12535 /* Set DECL_EXTERNAL so that assemble_external will be called as
12536 necessary. We'll clear it again in finish_file. */
12537 if (! DECL_EXTERNAL (fndecl
))
12538 DECL_NOT_REALLY_EXTERN (fndecl
) = 1;
12539 DECL_EXTERNAL (fndecl
) = 1;
12540 mark_inline_for_output (fndecl
);
12543 if (ctype
&& TREE_ASM_WRITTEN (fndecl
))
12544 note_debug_info_needed (ctype
);
12546 current_function_returns_null
|= can_reach_end
;
12548 /* Since we don't normally go through c_expand_return for constructors,
12549 this normally gets the wrong value.
12550 Also, named return values have their return codes emitted after
12551 NOTE_INSN_FUNCTION_END, confusing jump.c. */
12552 if (DECL_CONSTRUCTOR_P (fndecl
)
12553 || DECL_NAME (DECL_RESULT (fndecl
)) != NULL_TREE
)
12554 current_function_returns_null
= 0;
12556 if (TREE_THIS_VOLATILE (fndecl
) && current_function_returns_null
)
12557 cp_warning ("`noreturn' function `%D' does return", fndecl
);
12558 else if ((warn_return_type
|| pedantic
)
12559 && current_function_returns_null
12560 && TYPE_MAIN_VARIANT (TREE_TYPE (fntype
)) != void_type_node
)
12562 /* If this function returns non-void and control can drop through,
12564 cp_warning ("control reaches end of non-void function `%D'", fndecl
);
12566 /* With just -W, complain only if function returns both with
12567 and without a value. */
12568 else if (extra_warnings
12569 && current_function_returns_value
&& current_function_returns_null
)
12570 warning ("this function may return with or without a value");
12575 /* Free all the tree nodes making up this function. */
12576 /* Switch back to allocating nodes permanently
12577 until we start another function. */
12578 if (processing_template_decl
)
12580 --minimal_parse_mode
;
12581 DECL_SAVED_TREE (fndecl
) = TREE_CHAIN (DECL_SAVED_TREE (fndecl
));
12585 permanent_allocation (1);
12587 if (DECL_SAVED_INSNS (fndecl
) == NULL_RTX
)
12591 /* Stop pointing to the local nodes about to be freed. */
12592 /* But DECL_INITIAL must remain nonzero so we know this
12593 was an actual function definition. */
12594 DECL_INITIAL (fndecl
) = error_mark_node
;
12595 for (t
= DECL_ARGUMENTS (fndecl
); t
; t
= TREE_CHAIN (t
))
12596 DECL_RTL (t
) = DECL_INCOMING_RTL (t
) = NULL_RTX
;
12599 if (DECL_STATIC_CONSTRUCTOR (fndecl
))
12600 static_ctors
= perm_tree_cons (NULL_TREE
, fndecl
, static_ctors
);
12601 if (DECL_STATIC_DESTRUCTOR (fndecl
))
12602 static_dtors
= perm_tree_cons (NULL_TREE
, fndecl
, static_dtors
);
12606 /* Let the error reporting routines know that we're outside a
12607 function. For a nested function, this value is used in
12608 pop_cp_function_context and then reset via pop_function_context. */
12609 current_function_decl
= NULL_TREE
;
12612 named_label_uses
= NULL
;
12613 current_class_ptr
= NULL_TREE
;
12614 current_class_ref
= NULL_TREE
;
12617 /* Create the FUNCTION_DECL for a function definition.
12618 LINE1 is the line number that the definition absolutely begins on.
12619 LINE2 is the line number that the name of the function appears on.
12620 DECLSPECS and DECLARATOR are the parts of the declaration;
12621 they describe the return type and the name of the function,
12622 but twisted together in a fashion that parallels the syntax of C.
12624 This function creates a binding context for the function body
12625 as well as setting up the FUNCTION_DECL in current_function_decl.
12627 Returns a FUNCTION_DECL on success.
12629 If the DECLARATOR is not suitable for a function (it defines a datum
12630 instead), we return 0, which tells yyparse to report a parse error.
12632 May return void_type_node indicating that this method is actually
12633 a friend. See grokfield for more details.
12635 Came here with a `.pushlevel' .
12637 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12638 CHANGES TO CODE IN `grokfield'. */
12641 start_method (declspecs
, declarator
)
12642 tree declarator
, declspecs
;
12644 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
12647 /* Something too ugly to handle. */
12648 if (fndecl
== NULL_TREE
)
12651 /* Pass friends other than inline friend functions back. */
12652 if (TYPE_MAIN_VARIANT (fndecl
) == void_type_node
)
12655 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
12656 /* Not a function, tell parser to report parse error. */
12659 if (IS_SIGNATURE (current_class_type
))
12660 IS_DEFAULT_IMPLEMENTATION (fndecl
) = 1;
12662 if (DECL_IN_AGGR_P (fndecl
))
12664 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
12666 if (DECL_CONTEXT (fndecl
))
12667 cp_error ("`%D' is already defined in class %s", fndecl
,
12668 TYPE_NAME_STRING (DECL_CONTEXT (fndecl
)));
12670 return void_type_node
;
12673 DECL_THIS_INLINE (fndecl
) = 1;
12675 if (flag_default_inline
)
12676 DECL_INLINE (fndecl
) = 1;
12678 if (processing_template_decl
)
12679 push_template_decl (fndecl
);
12681 /* We read in the parameters on the maybepermanent_obstack,
12682 but we won't be getting back to them until after we
12683 may have clobbered them. So the call to preserve_data
12684 will keep them safe. */
12687 if (! DECL_FRIEND_P (fndecl
))
12689 if (DECL_CHAIN (fndecl
) != NULL_TREE
)
12691 /* Need a fresh node here so that we don't get circularity
12692 when we link these together. If FNDECL was a friend, then
12693 `pushdecl' does the right thing, which is nothing wrt its
12694 current value of DECL_CHAIN. */
12695 fndecl
= copy_node (fndecl
);
12697 if (TREE_CHAIN (fndecl
))
12699 fndecl
= copy_node (fndecl
);
12700 TREE_CHAIN (fndecl
) = NULL_TREE
;
12703 if (DECL_CONSTRUCTOR_P (fndecl
))
12705 if (! grok_ctor_properties (current_class_type
, fndecl
))
12706 return void_type_node
;
12708 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
12709 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
12712 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0, 0);
12714 /* Make a place for the parms */
12716 current_binding_level
->parm_flag
= 1;
12718 DECL_IN_AGGR_P (fndecl
) = 1;
12722 /* Go through the motions of finishing a function definition.
12723 We don't compile this method until after the whole class has
12726 FINISH_METHOD must return something that looks as though it
12727 came from GROKFIELD (since we are defining a method, after all).
12729 This is called after parsing the body of the function definition.
12730 STMTS is the chain of statements that makes up the function body.
12732 DECL is the ..._DECL that `start_method' provided. */
12735 finish_method (decl
)
12738 register tree fndecl
= decl
;
12741 register tree link
;
12743 if (TYPE_MAIN_VARIANT (decl
) == void_type_node
)
12746 old_initial
= DECL_INITIAL (fndecl
);
12748 /* Undo the level for the parms (from start_method).
12749 This is like poplevel, but it causes nothing to be
12750 saved. Saving information here confuses symbol-table
12751 output routines. Besides, this information will
12752 be correctly output when this method is actually
12755 /* Clear out the meanings of the local variables of this level;
12756 also record in each decl which block it belongs to. */
12758 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
12760 if (DECL_NAME (link
) != NULL_TREE
)
12761 IDENTIFIER_LOCAL_VALUE (DECL_NAME (link
)) = 0;
12762 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
12763 DECL_CONTEXT (link
) = NULL_TREE
;
12766 /* Restore all name-meanings of the outer levels
12767 that were shadowed by this level. */
12769 for (link
= current_binding_level
->shadowed
; link
; link
= TREE_CHAIN (link
))
12770 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
12771 for (link
= current_binding_level
->class_shadowed
;
12772 link
; link
= TREE_CHAIN (link
))
12773 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
12774 for (link
= current_binding_level
->type_shadowed
;
12775 link
; link
= TREE_CHAIN (link
))
12776 IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
)) = TREE_VALUE (link
);
12778 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
12779 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
12780 current_binding_level
->parm_flag
,
12781 current_binding_level
->keep
);
12783 poplevel (0, 0, 0);
12785 DECL_INITIAL (fndecl
) = old_initial
;
12787 /* We used to check if the context of FNDECL was different from
12788 current_class_type as another way to get inside here. This didn't work
12789 for String.cc in libg++. */
12790 if (DECL_FRIEND_P (fndecl
))
12792 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
12793 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
12794 decl
= void_type_node
;
12800 /* Called when a new struct TYPE is defined.
12801 If this structure or union completes the type of any previous
12802 variable declaration, lay it out and output its rtl. */
12805 hack_incomplete_structures (type
)
12810 if (current_binding_level
->incomplete
== NULL_TREE
)
12813 if (!type
) /* Don't do this for class templates. */
12816 for (list
= ¤t_binding_level
->incomplete
; *list
; )
12818 tree decl
= TREE_VALUE (*list
);
12819 if (decl
&& TREE_TYPE (decl
) == type
12820 || (TREE_TYPE (decl
)
12821 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
12822 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
12824 int toplevel
= toplevel_bindings_p ();
12825 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
12826 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
12827 layout_type (TREE_TYPE (decl
));
12828 layout_decl (decl
, 0);
12829 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
12833 expand_decl (decl
);
12834 cleanup
= maybe_build_cleanup (decl
);
12835 expand_decl_init (decl
);
12836 if (! expand_decl_cleanup (decl
, cleanup
))
12837 cp_error ("parser lost in parsing declaration of `%D'",
12840 *list
= TREE_CHAIN (*list
);
12843 list
= &TREE_CHAIN (*list
);
12847 /* If DECL is of a type which needs a cleanup, build that cleanup here.
12848 See build_delete for information about AUTO_DELETE.
12850 Don't build these on the momentary obstack; they must live
12851 the life of the binding contour. */
12854 maybe_build_cleanup_1 (decl
, auto_delete
)
12855 tree decl
, auto_delete
;
12857 tree type
= TREE_TYPE (decl
);
12858 if (TYPE_NEEDS_DESTRUCTOR (type
))
12860 int temp
= 0, flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
12863 if (TREE_CODE (decl
) != PARM_DECL
)
12864 temp
= suspend_momentary ();
12866 if (TREE_CODE (type
) == ARRAY_TYPE
)
12870 mark_addressable (decl
);
12871 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
12874 /* Optimize for space over speed here. */
12875 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
12876 || flag_expensive_optimizations
)
12877 flags
|= LOOKUP_NONVIRTUAL
;
12879 rval
= build_delete (TREE_TYPE (rval
), rval
, auto_delete
, flags
, 0);
12881 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
12882 && ! TYPE_HAS_DESTRUCTOR (type
))
12883 rval
= build_compound_expr (expr_tree_cons (NULL_TREE
, rval
,
12884 build_expr_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
12886 if (TREE_CODE (decl
) != PARM_DECL
)
12887 resume_momentary (temp
);
12894 /* If DECL is of a type which needs a cleanup, build that cleanup
12895 here. The cleanup does free the storage with a call to delete. */
12898 maybe_build_cleanup_and_delete (decl
)
12901 return maybe_build_cleanup_1 (decl
, integer_three_node
);
12904 /* If DECL is of a type which needs a cleanup, build that cleanup
12905 here. The cleanup does not free the storage with a call a delete. */
12908 maybe_build_cleanup (decl
)
12911 return maybe_build_cleanup_1 (decl
, integer_two_node
);
12914 /* Expand a C++ expression at the statement level.
12915 This is needed to ferret out nodes which have UNKNOWN_TYPE.
12916 The C++ type checker should get all of these out when
12917 expressions are combined with other, type-providing, expressions,
12918 leaving only orphan expressions, such as:
12920 &class::bar; / / takes its address, but does nothing with it. */
12923 cplus_expand_expr_stmt (exp
)
12926 if (processing_template_decl
)
12928 add_tree (build_min_nt (EXPR_STMT
, exp
));
12932 /* Arrange for all temps to disappear. */
12933 expand_start_target_temps ();
12935 if (TREE_TYPE (exp
) == unknown_type_node
)
12937 if (TREE_CODE (exp
) == ADDR_EXPR
|| TREE_CODE (exp
) == TREE_LIST
)
12938 error ("address of overloaded function with no contextual type information");
12939 else if (TREE_CODE (exp
) == COMPONENT_REF
)
12940 warning ("useless reference to a member function name, did you forget the ()?");
12944 if (TREE_CODE (exp
) == FUNCTION_DECL
)
12946 cp_warning ("reference, not call, to function `%D'", exp
);
12947 warning ("at this point in file");
12951 /* We should do this eventually, but right now this causes regex.o from
12952 libg++ to miscompile, and tString to core dump. */
12953 exp
= build1 (CLEANUP_POINT_EXPR
, TREE_TYPE (exp
), exp
);
12955 /* If we don't do this, we end up down inside expand_expr
12956 trying to do TYPE_MODE on the ERROR_MARK, and really
12957 go outside the bounds of the type. */
12958 if (exp
!= error_mark_node
)
12959 expand_expr_stmt (break_out_cleanups (exp
));
12962 /* Clean up any pending cleanups. This happens when a function call
12963 returns a cleanup-needing value that nobody uses. */
12964 expand_end_target_temps ();
12967 /* When a stmt has been parsed, this function is called.
12969 Currently, this function only does something within a
12970 constructor's scope: if a stmt has just assigned to this,
12971 and we are in a derived class, we call `emit_base_init'. */
12976 extern struct nesting
*cond_stack
, *loop_stack
, *case_stack
;
12979 if (current_function_assigns_this
12980 || ! current_function_just_assigned_this
)
12982 if (DECL_CONSTRUCTOR_P (current_function_decl
))
12984 /* Constructors must wait until we are out of control
12985 zones before calling base constructors. */
12986 if (cond_stack
|| loop_stack
|| case_stack
)
12988 expand_expr_stmt (base_init_expr
);
12989 check_base_init (current_class_type
);
12991 current_function_assigns_this
= 1;
12994 /* Change a static member function definition into a FUNCTION_TYPE, instead
12995 of the METHOD_TYPE that we create when it's originally parsed.
12997 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
12998 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
12999 other decls. Either pass the addresses of local variables or NULL. */
13002 revert_static_member_fn (decl
, fn
, argtypes
)
13003 tree
*decl
, *fn
, *argtypes
;
13006 tree function
= fn
? *fn
: TREE_TYPE (*decl
);
13007 tree args
= argtypes
? *argtypes
: TYPE_ARG_TYPES (function
);
13009 if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (args
))))
13010 cp_error ("static member function `%#D' declared const", *decl
);
13011 if (TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (args
))))
13012 cp_error ("static member function `%#D' declared volatile", *decl
);
13014 args
= TREE_CHAIN (args
);
13015 tmp
= build_function_type (TREE_TYPE (function
), args
);
13016 tmp
= build_type_variant (tmp
, TYPE_READONLY (function
),
13017 TYPE_VOLATILE (function
));
13018 tmp
= build_exception_variant (tmp
,
13019 TYPE_RAISES_EXCEPTIONS (function
));
13020 TREE_TYPE (*decl
) = tmp
;
13021 if (DECL_ARGUMENTS (*decl
))
13022 DECL_ARGUMENTS (*decl
) = TREE_CHAIN (DECL_ARGUMENTS (*decl
));
13023 DECL_STATIC_FUNCTION_P (*decl
) = 1;
13031 id_in_current_class (id
)
13034 return !!purpose_member (id
, class_binding_level
->class_shadowed
);
13041 int warn_about_return_type
;
13043 int just_assigned_this
;
13045 int temp_name_counter
;
13047 tree shadowed_labels
;
13050 rtx last_dtor_insn
;
13051 rtx last_parm_cleanup_insn
;
13052 tree base_init_list
;
13053 tree member_init_list
;
13054 tree base_init_expr
;
13055 tree current_class_ptr
;
13056 tree current_class_ref
;
13058 struct cp_function
*next
;
13059 struct binding_level
*binding_level
;
13060 int static_labelno
;
13063 static struct cp_function
*cp_function_chain
;
13065 extern int temp_name_counter
;
13067 /* Save and reinitialize the variables
13068 used during compilation of a C++ function. */
13071 push_cp_function_context (context
)
13074 struct cp_function
*p
13075 = (struct cp_function
*) xmalloc (sizeof (struct cp_function
));
13077 push_function_context_to (context
);
13079 p
->next
= cp_function_chain
;
13080 cp_function_chain
= p
;
13082 p
->named_labels
= named_labels
;
13083 p
->shadowed_labels
= shadowed_labels
;
13084 p
->returns_value
= current_function_returns_value
;
13085 p
->returns_null
= current_function_returns_null
;
13086 p
->warn_about_return_type
= warn_about_return_type
;
13087 p
->binding_level
= current_binding_level
;
13088 p
->ctor_label
= ctor_label
;
13089 p
->dtor_label
= dtor_label
;
13090 p
->last_dtor_insn
= last_dtor_insn
;
13091 p
->last_parm_cleanup_insn
= last_parm_cleanup_insn
;
13092 p
->assigns_this
= current_function_assigns_this
;
13093 p
->just_assigned_this
= current_function_just_assigned_this
;
13094 p
->parms_stored
= current_function_parms_stored
;
13095 p
->result_rtx
= original_result_rtx
;
13096 p
->base_init_expr
= base_init_expr
;
13097 p
->temp_name_counter
= temp_name_counter
;
13098 p
->base_init_list
= current_base_init_list
;
13099 p
->member_init_list
= current_member_init_list
;
13100 p
->current_class_ptr
= current_class_ptr
;
13101 p
->current_class_ref
= current_class_ref
;
13102 p
->static_labelno
= static_labelno
;
13105 /* Restore the variables used during compilation of a C++ function. */
13108 pop_cp_function_context (context
)
13111 struct cp_function
*p
= cp_function_chain
;
13114 /* Bring back all the labels that were shadowed. */
13115 for (link
= shadowed_labels
; link
; link
= TREE_CHAIN (link
))
13116 if (DECL_NAME (TREE_VALUE (link
)) != 0)
13117 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link
)),
13118 TREE_VALUE (link
));
13120 pop_function_context_from (context
);
13122 cp_function_chain
= p
->next
;
13124 named_labels
= p
->named_labels
;
13125 shadowed_labels
= p
->shadowed_labels
;
13126 current_function_returns_value
= p
->returns_value
;
13127 current_function_returns_null
= p
->returns_null
;
13128 warn_about_return_type
= p
->warn_about_return_type
;
13129 current_binding_level
= p
->binding_level
;
13130 ctor_label
= p
->ctor_label
;
13131 dtor_label
= p
->dtor_label
;
13132 last_dtor_insn
= p
->last_dtor_insn
;
13133 last_parm_cleanup_insn
= p
->last_parm_cleanup_insn
;
13134 current_function_assigns_this
= p
->assigns_this
;
13135 current_function_just_assigned_this
= p
->just_assigned_this
;
13136 current_function_parms_stored
= p
->parms_stored
;
13137 original_result_rtx
= p
->result_rtx
;
13138 base_init_expr
= p
->base_init_expr
;
13139 temp_name_counter
= p
->temp_name_counter
;
13140 current_base_init_list
= p
->base_init_list
;
13141 current_member_init_list
= p
->member_init_list
;
13142 current_class_ptr
= p
->current_class_ptr
;
13143 current_class_ref
= p
->current_class_ref
;
13144 static_labelno
= p
->static_labelno
;
13152 return function_depth
!= 0;
13155 /* FSF LOCAL dje prefix attributes */
13156 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
13157 This function is used by the parser when a rule will accept attributes
13158 in a particular position, but we don't want to support that just yet.
13160 A warning is issued for every ignored attribute. */
13163 strip_attrs (specs_attrs
)
13168 split_specs_attrs (specs_attrs
, &specs
, &attrs
);
13172 warning ("`%s' attribute ignored",
13173 IDENTIFIER_POINTER (TREE_PURPOSE (attrs
)));
13174 attrs
= TREE_CHAIN (attrs
);
13179 /* END FSF LOCAL */