1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* Process declarations and symbol lookup for C front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
47 extern int current_class_depth
;
49 extern tree global_namespace
;
51 extern int (*valid_lang_attribute
) PARAMS ((tree
, tree
, tree
, tree
));
53 #ifndef BOOL_TYPE_SIZE
54 #ifdef SLOW_BYTE_ACCESS
55 /* In the new ABI, `bool' has size and alignment `1', on all
57 #define BOOL_TYPE_SIZE \
58 ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
60 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
64 /* We let tm.h override the types used here, to handle trivial differences
65 such as the choice of unsigned int or long unsigned int for size_t.
66 When machines start needing nontrivial differences in the size type,
67 it would be best to do something here to figure out automatically
68 from other information what type to use. */
71 #define SIZE_TYPE "long unsigned int"
75 #define PTRDIFF_TYPE "long int"
79 #define WCHAR_TYPE "int"
83 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
85 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
91 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
93 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
94 ? "long unsigned int" \
95 : "long long unsigned int"))
98 static tree grokparms
PARAMS ((tree
, int));
99 static const char *redeclaration_error_message
PARAMS ((tree
, tree
));
101 static void push_binding_level
PARAMS ((struct binding_level
*, int,
103 static void pop_binding_level
PARAMS ((void));
104 static void suspend_binding_level
PARAMS ((void));
105 static void resume_binding_level
PARAMS ((struct binding_level
*));
106 static struct binding_level
*make_binding_level
PARAMS ((void));
107 static void declare_namespace_level
PARAMS ((void));
108 static int decl_jump_unsafe
PARAMS ((tree
));
109 static void storedecls
PARAMS ((tree
));
110 static void require_complete_types_for_parms
PARAMS ((tree
));
111 static int ambi_op_p
PARAMS ((enum tree_code
));
112 static int unary_op_p
PARAMS ((enum tree_code
));
113 static tree store_bindings
PARAMS ((tree
, tree
));
114 static tree lookup_tag_reverse
PARAMS ((tree
, tree
));
115 static tree obscure_complex_init
PARAMS ((tree
, tree
));
116 static tree lookup_name_real
PARAMS ((tree
, int, int, int));
117 static void warn_extern_redeclared_static
PARAMS ((tree
, tree
));
118 static void grok_reference_init
PARAMS ((tree
, tree
, tree
));
119 static tree grokfndecl
PARAMS ((tree
, tree
, tree
, tree
, int,
120 enum overload_flags
, tree
,
121 tree
, int, int, int, int, int, int, tree
));
122 static tree grokvardecl
PARAMS ((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
123 static tree lookup_tag
PARAMS ((enum tree_code
, tree
,
124 struct binding_level
*, int));
125 static void set_identifier_type_value_with_scope
126 PARAMS ((tree
, tree
, struct binding_level
*));
127 static void record_builtin_type
PARAMS ((enum rid
, const char *, tree
));
128 static void record_unknown_type
PARAMS ((tree
, const char *));
129 static tree build_library_fn_1
PARAMS ((tree
, enum tree_code
, tree
));
130 static int member_function_or_else
PARAMS ((tree
, tree
, enum overload_flags
));
131 static void bad_specifiers
PARAMS ((tree
, const char *, int, int, int, int,
133 static tree maybe_process_template_type_declaration
PARAMS ((tree
, int, struct binding_level
*));
134 static void check_for_uninitialized_const_var
PARAMS ((tree
));
135 static unsigned long typename_hash
PARAMS ((hash_table_key
));
136 static boolean typename_compare
PARAMS ((hash_table_key
, hash_table_key
));
137 static void push_binding
PARAMS ((tree
, tree
, struct binding_level
*));
138 static int add_binding
PARAMS ((tree
, tree
));
139 static void pop_binding
PARAMS ((tree
, tree
));
140 static tree local_variable_p_walkfn
PARAMS ((tree
*, int *, void *));
141 static tree find_binding
PARAMS ((tree
, tree
));
142 static tree select_decl
PARAMS ((tree
, int));
143 static int lookup_flags
PARAMS ((int, int));
144 static tree qualify_lookup
PARAMS ((tree
, int));
145 static tree record_builtin_java_type
PARAMS ((const char *, int));
146 static const char *tag_name
PARAMS ((enum tag_types code
));
147 static void find_class_binding_level
PARAMS ((void));
148 static struct binding_level
*innermost_nonclass_level
PARAMS ((void));
149 static void warn_about_implicit_typename_lookup
PARAMS ((tree
, tree
));
150 static int walk_namespaces_r
PARAMS ((tree
, walk_namespaces_fn
, void *));
151 static int walk_globals_r
PARAMS ((tree
, void *));
152 static void add_decl_to_level
PARAMS ((tree
, struct binding_level
*));
153 static tree make_label_decl
PARAMS ((tree
, int));
154 static void use_label
PARAMS ((tree
));
155 static void check_previous_goto_1
PARAMS ((tree
, struct binding_level
*, tree
,
157 static void check_previous_goto
PARAMS ((struct named_label_use_list
*));
158 static void check_switch_goto
PARAMS ((struct binding_level
*));
159 static void check_previous_gotos
PARAMS ((tree
));
160 static void pop_label
PARAMS ((tree
, tree
));
161 static void pop_labels
PARAMS ((tree
));
162 static void maybe_deduce_size_from_array_init
PARAMS ((tree
, tree
));
163 static void layout_var_decl
PARAMS ((tree
));
164 static void maybe_commonize_var
PARAMS ((tree
));
165 static tree check_initializer
PARAMS ((tree
, tree
));
166 static void make_rtl_for_nonlocal_decl
PARAMS ((tree
, tree
, const char *));
167 static void push_cp_function_context
PARAMS ((struct function
*));
168 static void pop_cp_function_context
PARAMS ((struct function
*));
169 static void mark_binding_level
PARAMS ((void *));
170 static void mark_named_label_lists
PARAMS ((void *, void *));
171 static void mark_cp_function_context
PARAMS ((struct function
*));
172 static void mark_saved_scope
PARAMS ((void *));
173 static void mark_lang_function
PARAMS ((struct cp_language_function
*));
174 static void save_function_data
PARAMS ((tree
));
175 static void check_function_type
PARAMS ((tree
, tree
));
176 static void destroy_local_var
PARAMS ((tree
));
177 static void finish_constructor_body
PARAMS ((void));
178 static void finish_destructor_body
PARAMS ((void));
179 static tree create_array_type_for_decl
PARAMS ((tree
, tree
, tree
));
180 static tree get_atexit_node
PARAMS ((void));
181 static tree get_dso_handle_node
PARAMS ((void));
182 static tree start_cleanup_fn
PARAMS ((void));
183 static void end_cleanup_fn
PARAMS ((void));
184 static tree cp_make_fname_decl
PARAMS ((tree
, const char *, int));
185 static void initialize_predefined_identifiers
PARAMS ((void));
186 static tree check_special_function_return_type
187 PARAMS ((special_function_kind
, tree
, tree
, tree
));
188 static tree push_cp_library_fn
PARAMS ((enum tree_code
, tree
));
189 static tree build_cp_library_fn
PARAMS ((tree
, enum tree_code
, tree
));
190 static void store_parm_decls
PARAMS ((tree
));
192 #if defined (DEBUG_CP_BINDING_LEVELS)
193 static void indent
PARAMS ((void));
196 /* Erroneous argument lists can use this *IFF* they do not modify it. */
197 tree error_mark_list
;
199 /* The following symbols are subsumed in the cp_global_trees array, and
200 listed here individually for documentation purposes.
203 tree wchar_decl_node;
205 tree vtable_entry_type;
206 tree delta_type_node;
209 tree __baselist_desc_type_node;
210 tree __i_desc_type_node, __m_desc_type_node;
211 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
213 tree __t_desc_type_node;
215 tree __tp_desc_type_node;
217 tree ti_desc_type_node;
218 tree bltn_desc_type_node, ptr_desc_type_node;
219 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
220 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
221 tree ptm_desc_type_node;
222 tree base_desc_type_node;
224 Not needed yet? May be needed one day?
225 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
226 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
227 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
230 tree class_type_node, record_type_node, union_type_node, enum_type_node;
231 tree unknown_type_node;
233 Array type `vtable_entry_type[]'
236 tree vtbl_ptr_type_node;
243 A FUNCTION_DECL which can call `abort'. Not necessarily the
244 one that the user will declare, but sufficient to be called
245 by routines that want to abort the program.
249 The FUNCTION_DECL for the default `::operator delete'.
251 tree global_delete_fndecl;
254 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
259 tree cp_global_trees
[CPTI_MAX
];
261 /* Indicates that there is a type value in some namespace, although
262 that is not necessarily in scope at the moment. */
264 static tree global_type_node
;
269 /* Expect only namespace names now. */
270 static int only_namespace_names
;
272 /* Used only for jumps to as-yet undefined labels, since jumps to
273 defined labels can have their validity checked immediately. */
275 struct named_label_use_list
277 struct binding_level
*binding_level
;
280 const char *filename_o_goto
;
282 struct named_label_use_list
*next
;
285 #define named_label_uses cp_function_chain->x_named_label_uses
287 /* A list of objects which have constructors or destructors
288 which reside in the global scope. The decl is stored in
289 the TREE_VALUE slot and the initializer is stored
290 in the TREE_PURPOSE slot. */
291 tree static_aggregates
;
295 /* A node for the integer constants 2, and 3. */
297 tree integer_two_node
, integer_three_node
;
299 /* Parsing a function declarator leaves here a chain of structure
300 and enum types declared in the parmlist. */
302 static tree last_function_parm_tags
;
304 /* Similar, for last_function_parm_tags. */
305 tree last_function_parms
;
306 static tree current_function_parm_tags
;
308 /* A list of all LABEL_DECLs in the function that have names. Here so
309 we can clear out their names' definitions at the end of the
310 function, and so we can check the validity of jumps to these labels. */
312 struct named_label_list
314 struct binding_level
*binding_level
;
320 struct named_label_list
*next
;
323 #define named_labels cp_function_chain->x_named_labels
325 /* Set to 0 at beginning of a function definition, and whenever
326 a label (case or named) is defined. Set to value of expression
327 returned from function when that value can be transformed into
328 a named return value. */
330 tree current_function_return_value
;
332 /* Nonzero means use the ISO C94 dialect of C. */
336 /* Nonzero means use the ISO C99 dialect of C. */
340 /* Nonzero means we are a hosted implementation for code shared with C. */
344 /* Nonzero means add default format_arg attributes for functions not
347 int flag_noniso_default_format_attributes
= 1;
349 /* Nonzero means give `double' the same size as `float'. */
351 extern int flag_short_double
;
353 /* Nonzero means don't recognize any builtin functions. */
355 extern int flag_no_builtin
;
357 /* Nonzero means don't recognize the non-ANSI builtin functions.
360 extern int flag_no_nonansi_builtin
;
362 /* Nonzero if we want to conserve space in the .o files. We do this
363 by putting uninitialized data and runtime initialized data into
364 .common instead of .data at the expense of not flagging multiple
366 extern int flag_conserve_space
;
368 /* C and C++ flags are in decl2.c. */
370 /* Flag used when debugging spew.c */
372 extern int spew_debug
;
374 /* A expression of value 0 with the same precision as a sizetype
376 tree signed_size_zero_node
;
378 /* The name of the anonymous namespace, throughout this translation
380 tree anonymous_namespace_name
;
382 /* The number of function bodies which we are currently processing.
383 (Zero if we are at namespace scope, one inside the body of a
384 function, two inside the body of a function in a local class, etc.) */
387 /* For each binding contour we allocate a binding_level structure
388 which records the names defined in that contour.
391 1) one for each function definition,
392 where internal declarations of the parameters appear.
393 2) one for each compound statement,
394 to record its declarations.
396 The current meaning of a name can be found by searching the levels
397 from the current one out to the global one.
399 Off to the side, may be the class_binding_level. This exists only
400 to catch class-local declarations. It is otherwise nonexistent.
402 Also there may be binding levels that catch cleanups that must be
403 run when exceptions occur. Thus, to see whether a name is bound in
404 the current scope, it is not enough to look in the
405 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
408 /* Note that the information in the `names' component of the global contour
409 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
413 /* A chain of _DECL nodes for all variables, constants, functions,
414 and typedef types. These are in the reverse of the order
415 supplied. There may be OVERLOADs on this list, too, but they
416 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
419 /* A list of structure, union and enum definitions, for looking up
421 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
422 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
423 or ENUMERAL_TYPE node.
425 C++: the TREE_VALUE nodes can be simple types for
426 component_bindings. */
429 /* A list of USING_DECL nodes. */
432 /* A list of used namespaces. PURPOSE is the namespace,
433 VALUE the common ancestor with this binding_level's namespace. */
434 tree using_directives
;
436 /* If this binding level is the binding level for a class, then
437 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
438 is the name of an entity bound in the class; the TREE_VALUE is
439 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
440 when leaving class scope, we can restore the
441 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
442 the DECL bound by this name in the class. */
445 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
446 is used for all binding levels. */
449 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
450 label in this scope. The TREE_PURPOSE is the previous value of
451 the IDENTIFIER_LABEL VALUE. */
452 tree shadowed_labels
;
454 /* For each level (except not the global one),
455 a chain of BLOCK nodes for all the levels
456 that were entered and exited one level down. */
459 /* The _TYPE node for this level, if parm_flag == 2. */
462 /* The binding level which this one is contained in (inherits from). */
463 struct binding_level
*level_chain
;
465 /* List of decls in `names' that have incomplete
466 structure or union types. */
469 /* List of VAR_DECLS saved from a previous for statement.
470 These would be dead in ISO-conforming code, but might
471 be referenced in ARM-era code. These are stored in a
472 TREE_LIST; the TREE_VALUE is the actual declaration. */
473 tree dead_vars_from_for
;
475 /* 1 for the level that holds the parameters of a function.
476 2 for the level that holds a class declaration. */
477 unsigned parm_flag
: 2;
479 /* 1 means make a BLOCK for this level regardless of all else.
480 2 for temporary binding contours created by the compiler. */
483 /* Nonzero if this level "doesn't exist" for tags. */
484 unsigned tag_transparent
: 1;
486 /* Nonzero if this level can safely have additional
487 cleanup-needing variables added to it. */
488 unsigned more_cleanups_ok
: 1;
489 unsigned have_cleanups
: 1;
491 /* Nonzero if this scope is for storing the decls for template
492 parameters and generic decls; these decls will be discarded and
493 replaced with a TEMPLATE_DECL. */
494 unsigned template_parms_p
: 1;
496 /* Nonzero if this scope corresponds to the `<>' in a
497 `template <>' clause. Whenever this flag is set,
498 TEMPLATE_PARMS_P will be set as well. */
499 unsigned template_spec_p
: 1;
501 /* This is set for a namespace binding level. */
502 unsigned namespace_p
: 1;
504 /* True if this level is that of a for-statement where we need to
505 worry about ambiguous (ARM or ISO) scope rules. */
506 unsigned is_for_scope
: 1;
508 /* True if this level corresponds to an EH region, as for a try block.
509 Currently this information is only available while building the
511 unsigned eh_region
: 1;
513 /* Four bits left for this word. */
515 #if defined(DEBUG_CP_BINDING_LEVELS)
516 /* Binding depth at which this level began. */
517 unsigned binding_depth
;
518 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
521 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
523 /* The binding level currently in effect. */
525 #define current_binding_level \
527 ? cp_function_chain->bindings \
528 : scope_chain->bindings)
530 /* The binding level of the current class, if any. */
532 #define class_binding_level scope_chain->class_bindings
534 /* A chain of binding_level structures awaiting reuse. */
536 static struct binding_level
*free_binding_level
;
538 /* The outermost binding level, for names of file scope.
539 This is created when the compiler is started and exists
540 through the entire run. */
542 static struct binding_level
*global_binding_level
;
544 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
546 static int keep_next_level_flag
;
548 #if defined(DEBUG_CP_BINDING_LEVELS)
549 static int binding_depth
= 0;
550 static int is_class_level
= 0;
557 for (i
= 0; i
< binding_depth
*2; i
++)
560 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
562 static tree pushdecl_with_scope
PARAMS ((tree
, struct binding_level
*));
565 push_binding_level (newlevel
, tag_transparent
, keep
)
566 struct binding_level
*newlevel
;
567 int tag_transparent
, keep
;
569 /* Add this level to the front of the chain (stack) of levels that
571 bzero ((char*) newlevel
, sizeof (struct binding_level
));
572 newlevel
->level_chain
= current_binding_level
;
573 current_binding_level
= newlevel
;
574 newlevel
->tag_transparent
= tag_transparent
;
575 newlevel
->more_cleanups_ok
= 1;
577 newlevel
->keep
= keep
;
578 #if defined(DEBUG_CP_BINDING_LEVELS)
579 newlevel
->binding_depth
= binding_depth
;
581 fprintf (stderr
, "push %s level 0x%08x line %d\n",
582 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
585 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
588 /* Find the innermost enclosing class scope, and reset
589 CLASS_BINDING_LEVEL appropriately. */
592 find_class_binding_level ()
594 struct binding_level
*level
= current_binding_level
;
596 while (level
&& level
->parm_flag
!= 2)
597 level
= level
->level_chain
;
598 if (level
&& level
->parm_flag
== 2)
599 class_binding_level
= level
;
601 class_binding_level
= 0;
607 if (global_binding_level
)
609 /* Cannot pop a level, if there are none left to pop. */
610 if (current_binding_level
== global_binding_level
)
611 my_friendly_abort (123);
613 /* Pop the current level, and free the structure for reuse. */
614 #if defined(DEBUG_CP_BINDING_LEVELS)
617 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
618 (is_class_level
) ? "class" : "block",
619 current_binding_level
, lineno
);
620 if (is_class_level
!= (current_binding_level
== class_binding_level
))
623 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
626 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
628 register struct binding_level
*level
= current_binding_level
;
629 current_binding_level
= current_binding_level
->level_chain
;
630 level
->level_chain
= free_binding_level
;
631 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
632 if (level
->binding_depth
!= binding_depth
)
634 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
635 free_binding_level
= level
;
636 find_class_binding_level ();
641 suspend_binding_level ()
643 if (class_binding_level
)
644 current_binding_level
= class_binding_level
;
646 if (global_binding_level
)
648 /* Cannot suspend a level, if there are none left to suspend. */
649 if (current_binding_level
== global_binding_level
)
650 my_friendly_abort (123);
652 /* Suspend the current level. */
653 #if defined(DEBUG_CP_BINDING_LEVELS)
656 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
657 (is_class_level
) ? "class" : "block",
658 current_binding_level
, lineno
);
659 if (is_class_level
!= (current_binding_level
== class_binding_level
))
662 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
665 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
666 current_binding_level
= current_binding_level
->level_chain
;
667 find_class_binding_level ();
671 resume_binding_level (b
)
672 struct binding_level
*b
;
674 /* Resuming binding levels is meant only for namespaces,
675 and those cannot nest into classes. */
676 my_friendly_assert(!class_binding_level
, 386);
677 /* Also, resuming a non-directly nested namespace is a no-no. */
678 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
679 current_binding_level
= b
;
680 #if defined(DEBUG_CP_BINDING_LEVELS)
681 b
->binding_depth
= binding_depth
;
683 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
684 (is_class_level
) ? "class" : "block", b
, lineno
);
687 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
690 /* Create a new `struct binding_level'. */
693 struct binding_level
*
694 make_binding_level ()
697 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
700 /* Nonzero if we are currently in the global binding level. */
705 return current_binding_level
== global_binding_level
;
708 /* Return the innermost binding level that is not for a class scope. */
710 static struct binding_level
*
711 innermost_nonclass_level ()
713 struct binding_level
*b
;
715 b
= current_binding_level
;
716 while (b
->parm_flag
== 2)
722 /* Nonzero if we are currently in a toplevel binding level. This
723 means either the global binding level or a namespace in a toplevel
724 binding level. Since there are no non-toplevel namespace levels,
725 this really means any namespace or template parameter level. We
726 also include a class whose context is toplevel. */
729 toplevel_bindings_p ()
731 struct binding_level
*b
= innermost_nonclass_level ();
733 return b
->namespace_p
|| b
->template_parms_p
;
736 /* Nonzero if this is a namespace scope, or if we are defining a class
737 which is itself at namespace scope, or whose enclosing class is
738 such a class, etc. */
741 namespace_bindings_p ()
743 struct binding_level
*b
= innermost_nonclass_level ();
745 return b
->namespace_p
;
748 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
749 unconditionally. Otherwise, use the normal logic to decide whether
750 or not to create a BLOCK. */
753 keep_next_level (keep
)
756 keep_next_level_flag
= keep
;
759 /* Nonzero if the current level needs to have a BLOCK made. */
764 return (current_binding_level
->blocks
!= NULL_TREE
765 || current_binding_level
->keep
766 || current_binding_level
->names
!= NULL_TREE
767 || (current_binding_level
->tags
!= NULL_TREE
768 && !current_binding_level
->tag_transparent
));
772 declare_namespace_level ()
774 current_binding_level
->namespace_p
= 1;
777 /* Returns non-zero if this scope was created to store template
781 template_parm_scope_p ()
783 return current_binding_level
->template_parms_p
;
786 /* Returns the kind of template specialization we are currently
787 processing, given that it's declaration contained N_CLASS_SCOPES
788 explicit scope qualifications. */
791 current_tmpl_spec_kind (n_class_scopes
)
794 int n_template_parm_scopes
= 0;
795 int seen_specialization_p
= 0;
796 int innermost_specialization_p
= 0;
797 struct binding_level
*b
;
799 /* Scan through the template parameter scopes. */
800 for (b
= current_binding_level
; b
->template_parms_p
; b
= b
->level_chain
)
802 /* If we see a specialization scope inside a parameter scope,
803 then something is wrong. That corresponds to a declaration
806 template <class T> template <> ...
808 which is always illegal since [temp.expl.spec] forbids the
809 specialization of a class member template if the enclosing
810 class templates are not explicitly specialized as well. */
811 if (b
->template_spec_p
)
813 if (n_template_parm_scopes
== 0)
814 innermost_specialization_p
= 1;
816 seen_specialization_p
= 1;
818 else if (seen_specialization_p
== 1)
819 return tsk_invalid_member_spec
;
821 ++n_template_parm_scopes
;
824 /* Handle explicit instantiations. */
825 if (processing_explicit_instantiation
)
827 if (n_template_parm_scopes
!= 0)
828 /* We've seen a template parameter list during an explicit
829 instantiation. For example:
831 template <class T> template void f(int);
833 This is erroneous. */
834 return tsk_invalid_expl_inst
;
836 return tsk_expl_inst
;
839 if (n_template_parm_scopes
< n_class_scopes
)
840 /* We've not seen enough template headers to match all the
841 specialized classes present. For example:
843 template <class T> void R<T>::S<T>::f(int);
845 This is illegal; there needs to be one set of template
846 parameters for each class. */
847 return tsk_insufficient_parms
;
848 else if (n_template_parm_scopes
== n_class_scopes
)
849 /* We're processing a non-template declaration (even though it may
850 be a member of a template class.) For example:
852 template <class T> void S<T>::f(int);
854 The `class T' maches the `S<T>', leaving no template headers
855 corresponding to the `f'. */
857 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
858 /* We've got too many template headers. For example:
860 template <> template <class T> void f (T);
862 There need to be more enclosing classes. */
863 return tsk_excessive_parms
;
865 /* This must be a template. It's of the form:
867 template <class T> template <class U> void S<T>::f(U);
869 This is a specialization if the innermost level was a
870 specialization; otherwise it's just a definition of the
872 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
876 set_class_shadows (shadows
)
879 class_binding_level
->class_shadowed
= shadows
;
882 /* Enter a new binding level.
883 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
884 not for that of tags. */
887 pushlevel (tag_transparent
)
890 struct binding_level
*newlevel
;
892 if (cfun
&& !doing_semantic_analysis_p ())
895 /* Reuse or create a struct for this binding level. */
896 #if defined(DEBUG_CP_BINDING_LEVELS)
898 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
899 if (free_binding_level
)
900 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
902 newlevel
= free_binding_level
;
903 free_binding_level
= free_binding_level
->level_chain
;
906 newlevel
= make_binding_level ();
908 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
909 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
910 keep_next_level_flag
= 0;
913 /* Enter a new scope. The KIND indicates what kind of scope is being
924 case sk_template_spec
:
925 current_binding_level
->template_spec_p
= 1;
928 case sk_template_parms
:
929 current_binding_level
->template_parms_p
= 1;
933 my_friendly_abort (20000309);
937 /* Exit the current scope. */
946 note_level_for_for ()
948 current_binding_level
->is_for_scope
= 1;
951 /* Record that the current binding level represents a try block. */
956 current_binding_level
->eh_region
= 1;
959 /* For a binding between a name and an entity at a block scope,
960 this is the `struct binding_level' for the block. */
961 #define BINDING_LEVEL(NODE) \
962 (((struct tree_binding*)NODE)->scope.level)
964 /* Make DECL the innermost binding for ID. The LEVEL is the binding
965 level at which this declaration is being bound. */
968 push_binding (id
, decl
, level
)
971 struct binding_level
* level
;
975 binding
= make_node (CPLUS_BINDING
);
977 /* Now, fill in the binding information. */
978 BINDING_VALUE (binding
) = decl
;
979 BINDING_TYPE (binding
) = NULL_TREE
;
980 BINDING_LEVEL (binding
) = level
;
981 INHERITED_VALUE_BINDING_P (binding
) = 0;
982 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
983 BINDING_HAS_LEVEL_P (binding
) = 1;
985 /* And put it on the front of the list of bindings for ID. */
986 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
987 IDENTIFIER_BINDING (id
) = binding
;
990 /* ID is already bound in the current scope. But, DECL is an
991 additional binding for ID in the same scope. This is the `struct
992 stat' hack whereby a non-typedef class-name or enum-name can be
993 bound at the same level as some other kind of entity. It's the
994 responsibility of the caller to check that inserting this name is
995 legal here. Returns nonzero if the new binding was successful. */
997 add_binding (id
, decl
)
1001 tree binding
= IDENTIFIER_BINDING (id
);
1004 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
1005 /* The new name is the type name. */
1006 BINDING_TYPE (binding
) = decl
;
1007 else if (!BINDING_VALUE (binding
))
1008 /* This situation arises when push_class_level_binding moves an
1009 inherited type-binding out of the way to make room for a new
1011 BINDING_VALUE (binding
) = decl
;
1012 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1013 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
1015 /* The old binding was a type name. It was placed in
1016 BINDING_VALUE because it was thought, at the point it was
1017 declared, to be the only entity with such a name. Move the
1018 type name into the type slot; it is now hidden by the new
1020 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
1021 BINDING_VALUE (binding
) = decl
;
1022 INHERITED_VALUE_BINDING_P (binding
) = 0;
1024 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1025 && TREE_CODE (decl
) == TYPE_DECL
1026 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1027 && same_type_p (TREE_TYPE (decl
),
1028 TREE_TYPE (BINDING_VALUE (binding
))))
1029 /* We have two typedef-names, both naming the same type to have
1030 the same name. This is OK because of:
1034 In a given scope, a typedef specifier can be used to redefine
1035 the name of any type declared in that scope to refer to the
1036 type to which it already refers. */
1038 /* There can be two block-scope declarations of the same variable,
1039 so long as they are `extern' declarations. */
1040 else if (TREE_CODE (decl
) == VAR_DECL
1041 && TREE_CODE (BINDING_VALUE (binding
)) == VAR_DECL
1042 && DECL_EXTERNAL (decl
)
1043 && DECL_EXTERNAL (BINDING_VALUE (binding
)))
1045 duplicate_decls (decl
, BINDING_VALUE (binding
));
1050 cp_error ("declaration of `%#D'", decl
);
1051 cp_error_at ("conflicts with previous declaration `%#D'",
1052 BINDING_VALUE (binding
));
1059 /* Add DECL to the list of things declared in B. */
1062 add_decl_to_level (decl
, b
)
1064 struct binding_level
*b
;
1066 /* We build up the list in reverse order, and reverse it later if
1068 TREE_CHAIN (decl
) = b
->names
;
1072 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1073 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1074 doesn't really belong to this binding level, that it got here
1075 through a using-declaration. */
1078 push_local_binding (id
, decl
, flags
)
1083 struct binding_level
*b
;
1085 /* Skip over any local classes. This makes sense if we call
1086 push_local_binding with a friend decl of a local class. */
1087 b
= current_binding_level
;
1088 while (b
->parm_flag
== 2)
1091 if (lookup_name_current_level (id
))
1093 /* Supplement the existing binding. */
1094 if (!add_binding (id
, decl
))
1095 /* It didn't work. Something else must be bound at this
1096 level. Do not add DECL to the list of things to pop
1101 /* Create a new binding. */
1102 push_binding (id
, decl
, b
);
1104 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1105 /* We must put the OVERLOAD into a TREE_LIST since the
1106 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1107 decls that got here through a using-declaration. */
1108 decl
= build_tree_list (NULL_TREE
, decl
);
1110 /* And put DECL on the list of things declared by the current
1112 add_decl_to_level (decl
, b
);
1115 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1116 binding was successful. */
1119 push_class_binding (id
, decl
)
1124 tree binding
= IDENTIFIER_BINDING (id
);
1127 /* Note that we declared this value so that we can issue an error if
1128 this an illegal redeclaration of a name already used for some
1130 note_name_declared_in_class (id
, decl
);
1132 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1133 /* Supplement the existing binding. */
1134 result
= add_binding (id
, decl
);
1136 /* Create a new binding. */
1137 push_binding (id
, decl
, class_binding_level
);
1139 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1140 class-level declaration. Note that we do not use DECL here
1141 because of the possibility of the `struct stat' hack; if DECL is
1142 a class-name or enum-name we might prefer a field-name, or some
1144 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1146 /* If this is a binding from a base class, mark it as such. */
1147 binding
= IDENTIFIER_BINDING (id
);
1148 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1150 /* Any implicit typename must be from a base-class. The
1151 context for an implicit typename declaration is always
1152 the derived class in which the lookup was done, so the checks
1153 based on the context of DECL below will not trigger. */
1154 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1155 INHERITED_VALUE_BINDING_P (binding
) = 1;
1158 if (TREE_CODE (decl
) == OVERLOAD
)
1159 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
1162 my_friendly_assert (DECL_P (decl
), 0);
1163 context
= CP_DECL_CONTEXT (decl
);
1166 if (is_properly_derived_from (current_class_type
, context
))
1167 INHERITED_VALUE_BINDING_P (binding
) = 1;
1169 INHERITED_VALUE_BINDING_P (binding
) = 0;
1172 else if (BINDING_VALUE (binding
) == decl
)
1173 /* We only encounter a TREE_LIST when push_class_decls detects an
1174 ambiguity. Such an ambiguity can be overridden by a definition
1176 INHERITED_VALUE_BINDING_P (binding
) = 1;
1181 /* Remove the binding for DECL which should be the innermost binding
1185 pop_binding (id
, decl
)
1191 if (id
== NULL_TREE
)
1192 /* It's easiest to write the loops that call this function without
1193 checking whether or not the entities involved have names. We
1194 get here for such an entity. */
1197 /* Get the innermost binding for ID. */
1198 binding
= IDENTIFIER_BINDING (id
);
1200 /* The name should be bound. */
1201 my_friendly_assert (binding
!= NULL_TREE
, 0);
1203 /* The DECL will be either the ordinary binding or the type
1204 binding for this identifier. Remove that binding. */
1205 if (BINDING_VALUE (binding
) == decl
)
1206 BINDING_VALUE (binding
) = NULL_TREE
;
1207 else if (BINDING_TYPE (binding
) == decl
)
1208 BINDING_TYPE (binding
) = NULL_TREE
;
1210 my_friendly_abort (0);
1212 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1213 /* We're completely done with the innermost binding for this
1214 identifier. Unhook it from the list of bindings. */
1215 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1218 /* When a label goes out of scope, check to see if that label was used
1219 in a valid manner, and issue any appropriate warnings or errors. */
1222 pop_label (label
, old_value
)
1226 if (!processing_template_decl
&& doing_semantic_analysis_p ())
1228 if (DECL_INITIAL (label
) == NULL_TREE
)
1230 cp_error_at ("label `%D' used but not defined", label
);
1231 /* Avoid crashing later. */
1232 define_label (input_filename
, 1, DECL_NAME (label
));
1234 else if (warn_unused_label
&& !TREE_USED (label
))
1235 cp_warning_at ("label `%D' defined but not used", label
);
1238 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
1241 /* At the end of a function, all labels declared within the function
1242 go out of scope. BLOCK is the top-level block for the
1249 struct named_label_list
*link
;
1251 /* Clear out the definitions of all label names, since their scopes
1253 for (link
= named_labels
; link
; link
= link
->next
)
1255 pop_label (link
->label_decl
, link
->old_value
);
1256 /* Put the labels into the "variables" of the top-level block,
1257 so debugger can see them. */
1258 TREE_CHAIN (link
->label_decl
) = BLOCK_VARS (block
);
1259 BLOCK_VARS (block
) = link
->label_decl
;
1262 named_labels
= NULL
;
1265 /* Exit a binding level.
1266 Pop the level off, and restore the state of the identifier-decl mappings
1267 that were in effect when this level was entered.
1269 If KEEP == 1, this level had explicit declarations, so
1270 and create a "block" (a BLOCK node) for the level
1271 to record its declarations and subblocks for symbol table output.
1273 If FUNCTIONBODY is nonzero, this level is the body of a function,
1274 so create a block as if KEEP were set and also clear out all
1277 If REVERSE is nonzero, reverse the order of decls before putting
1278 them into the BLOCK. */
1281 poplevel (keep
, reverse
, functionbody
)
1287 /* The chain of decls was accumulated in reverse order.
1288 Put it into forward order, just for cleanliness. */
1290 int tmp
= functionbody
;
1291 int real_functionbody
;
1294 tree block
= NULL_TREE
;
1296 int leaving_for_scope
;
1298 if (cfun
&& !doing_semantic_analysis_p ())
1301 my_friendly_assert (current_binding_level
->parm_flag
!= 2,
1304 real_functionbody
= (current_binding_level
->keep
== 2
1305 ? ((functionbody
= 0), tmp
) : functionbody
);
1306 tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1307 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1309 my_friendly_assert (!current_binding_level
->class_shadowed
,
1312 /* We used to use KEEP == 2 to indicate that the new block should go
1313 at the beginning of the list of blocks at this binding level,
1314 rather than the end. This hack is no longer used. */
1315 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1317 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1318 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1319 current_binding_level
->parm_flag
,
1320 current_binding_level
->keep
);
1322 if (current_binding_level
->keep
== 1)
1325 /* Any uses of undefined labels, and any defined labels, now operate
1326 under constraints of next binding contour. */
1327 if (cfun
&& !functionbody
)
1329 struct binding_level
*level_chain
;
1330 level_chain
= current_binding_level
->level_chain
;
1333 struct named_label_use_list
*uses
;
1334 struct named_label_list
*labels
;
1335 for (labels
= named_labels
; labels
; labels
= labels
->next
)
1336 if (labels
->binding_level
== current_binding_level
)
1339 if (current_binding_level
->eh_region
)
1340 labels
->eh_region
= 1;
1341 for (decl
= labels
->names_in_scope
; decl
;
1342 decl
= TREE_CHAIN (decl
))
1343 if (decl_jump_unsafe (decl
))
1344 labels
->bad_decls
= tree_cons (NULL_TREE
, decl
,
1346 labels
->binding_level
= level_chain
;
1347 labels
->names_in_scope
= level_chain
->names
;
1350 for (uses
= named_label_uses
; uses
; uses
= uses
->next
)
1351 if (uses
->binding_level
== current_binding_level
)
1353 uses
->binding_level
= level_chain
;
1354 uses
->names_in_scope
= level_chain
->names
;
1359 /* Get the decls in the order they were written.
1360 Usually current_binding_level->names is in reverse order.
1361 But parameter decls were previously put in forward order. */
1364 current_binding_level
->names
1365 = decls
= nreverse (current_binding_level
->names
);
1367 decls
= current_binding_level
->names
;
1369 /* Output any nested inline functions within this block
1370 if they weren't already output. */
1371 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1372 if (TREE_CODE (decl
) == FUNCTION_DECL
1373 && ! TREE_ASM_WRITTEN (decl
)
1374 && DECL_INITIAL (decl
) != NULL_TREE
1375 && TREE_ADDRESSABLE (decl
)
1376 && decl_function_context (decl
) == current_function_decl
)
1378 /* If this decl was copied from a file-scope decl
1379 on account of a block-scope extern decl,
1380 propagate TREE_ADDRESSABLE to the file-scope decl. */
1381 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1382 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1385 push_function_context ();
1386 output_inline_function (decl
);
1387 pop_function_context ();
1391 /* When not in function-at-a-time mode, expand_end_bindings will
1392 warn about unused variables. But, in function-at-a-time mode
1393 expand_end_bindings is not passed the list of variables in the
1394 current scope, and therefore no warning is emitted. So, we
1395 explicitly warn here. */
1396 if (!processing_template_decl
)
1397 warn_about_unused_variables (getdecls ());
1399 /* If there were any declarations or structure tags in that level,
1400 or if this level is a function body,
1401 create a BLOCK to record them for the life of this function. */
1403 if (keep
== 1 || functionbody
)
1404 block
= make_node (BLOCK
);
1405 if (block
!= NULL_TREE
)
1407 BLOCK_VARS (block
) = decls
;
1408 BLOCK_SUBBLOCKS (block
) = subblocks
;
1411 /* In each subblock, record that this is its superior. */
1413 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1414 BLOCK_SUPERCONTEXT (link
) = block
;
1416 /* We still support the old for-scope rules, whereby the variables
1417 in a for-init statement were in scope after the for-statement
1418 ended. We only use the new rules in flag_new_for_scope is
1421 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1423 /* Remove declarations for all the DECLs in this level. */
1424 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1426 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
1427 && DECL_NAME (link
))
1430 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1434 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1436 ns_binding
= NULL_TREE
;
1439 && (BINDING_LEVEL (outer_binding
)
1440 == current_binding_level
->level_chain
))
1441 /* We have something like:
1446 and we are leaving the `for' scope. There's no reason to
1447 keep the binding of the inner `i' in this case. */
1448 pop_binding (DECL_NAME (link
), link
);
1449 else if ((outer_binding
1450 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1453 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1454 /* Here, we have something like:
1462 We must pop the for-scope binding so we know what's a
1463 type and what isn't. */
1464 pop_binding (DECL_NAME (link
), link
);
1467 /* Mark this VAR_DECL as dead so that we can tell we left it
1468 there only for backward compatibility. */
1469 DECL_DEAD_FOR_LOCAL (link
) = 1;
1471 /* Keep track of what should of have happenned when we
1472 popped the binding. */
1473 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1474 DECL_SHADOWED_FOR_VAR (link
)
1475 = BINDING_VALUE (outer_binding
);
1477 /* Add it to the list of dead variables in the next
1478 outermost binding to that we can remove these when we
1479 leave that binding. */
1480 current_binding_level
->level_chain
->dead_vars_from_for
1481 = tree_cons (NULL_TREE
, link
,
1482 current_binding_level
->level_chain
->
1483 dead_vars_from_for
);
1485 /* Although we don't pop the CPLUS_BINDING, we do clear
1486 its BINDING_LEVEL since the level is going away now. */
1487 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1493 /* Remove the binding. */
1495 if (TREE_CODE (decl
) == TREE_LIST
)
1496 decl
= TREE_VALUE (decl
);
1498 pop_binding (DECL_NAME (decl
), decl
);
1499 else if (TREE_CODE (decl
) == OVERLOAD
)
1500 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1502 my_friendly_abort (0);
1506 /* Remove declarations for any `for' variables from inner scopes
1507 that we kept around. */
1508 for (link
= current_binding_level
->dead_vars_from_for
;
1509 link
; link
= TREE_CHAIN (link
))
1510 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1512 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1513 for (link
= current_binding_level
->type_shadowed
;
1514 link
; link
= TREE_CHAIN (link
))
1515 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1517 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1518 for (link
= current_binding_level
->shadowed_labels
;
1520 link
= TREE_CHAIN (link
))
1521 pop_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
1523 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1524 list if a `using' declaration put them there. The debugging
1525 back-ends won't understand OVERLOAD, so we remove them here.
1526 Because the BLOCK_VARS are (temporarily) shared with
1527 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1528 popped all the bindings. */
1533 for (d
= &BLOCK_VARS (block
); *d
; )
1535 if (TREE_CODE (*d
) == TREE_LIST
)
1536 *d
= TREE_CHAIN (*d
);
1538 d
= &TREE_CHAIN (*d
);
1542 /* If the level being exited is the top level of a function,
1543 check over all the labels. */
1546 /* Since this is the top level block of a function, the vars are
1547 the function's parameters. Don't leave them in the BLOCK
1548 because they are found in the FUNCTION_DECL instead. */
1549 BLOCK_VARS (block
) = 0;
1553 tmp
= current_binding_level
->keep
;
1555 pop_binding_level ();
1557 DECL_INITIAL (current_function_decl
) = block
;
1559 current_binding_level
->blocks
1560 = chainon (current_binding_level
->blocks
, block
);
1562 /* If we did not make a block for the level just exited,
1563 any blocks made for inner levels
1564 (since they cannot be recorded as subblocks in that level)
1565 must be carried forward so they will later become subblocks
1566 of something else. */
1568 current_binding_level
->blocks
1569 = chainon (current_binding_level
->blocks
, subblocks
);
1571 /* Each and every BLOCK node created here in `poplevel' is important
1572 (e.g. for proper debugging information) so if we created one
1573 earlier, mark it as "used". */
1575 TREE_USED (block
) = 1;
1577 /* Take care of compiler's internal binding structures. */
1583 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1586 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts
)) = block
;
1587 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts
)) = block
;
1590 block
= poplevel (keep
, reverse
, functionbody
);
1596 /* Delete the node BLOCK from the current binding level.
1597 This is used for the block inside a stmt expr ({...})
1598 so that the block can be reinserted where appropriate. */
1601 delete_block (block
)
1605 if (current_binding_level
->blocks
== block
)
1606 current_binding_level
->blocks
= TREE_CHAIN (block
);
1607 for (t
= current_binding_level
->blocks
; t
;)
1609 if (TREE_CHAIN (t
) == block
)
1610 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1614 TREE_CHAIN (block
) = NULL_TREE
;
1615 /* Clear TREE_USED which is always set by poplevel.
1616 The flag is set again if insert_block is called. */
1617 TREE_USED (block
) = 0;
1620 /* Insert BLOCK at the end of the list of subblocks of the
1621 current binding level. This is used when a BIND_EXPR is expanded,
1622 to handle the BLOCK node inside the BIND_EXPR. */
1625 insert_block (block
)
1628 TREE_USED (block
) = 1;
1629 current_binding_level
->blocks
1630 = chainon (current_binding_level
->blocks
, block
);
1633 /* Set the BLOCK node for the innermost scope
1634 (the one we are currently in). */
1638 tree block ATTRIBUTE_UNUSED
;
1640 /* The RTL expansion machinery requires us to provide this callback,
1641 but it is not applicable in function-at-a-time mode. */
1642 my_friendly_assert (cfun
&& !doing_semantic_analysis_p (), 20000911);
1645 /* Do a pushlevel for class declarations. */
1650 register struct binding_level
*newlevel
;
1652 /* Reuse or create a struct for this binding level. */
1653 #if defined(DEBUG_CP_BINDING_LEVELS)
1655 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1656 if (free_binding_level
)
1657 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1659 newlevel
= free_binding_level
;
1660 free_binding_level
= free_binding_level
->level_chain
;
1663 newlevel
= make_binding_level ();
1665 #if defined(DEBUG_CP_BINDING_LEVELS)
1667 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1669 push_binding_level (newlevel
, 0, 0);
1671 class_binding_level
= current_binding_level
;
1672 class_binding_level
->parm_flag
= 2;
1673 class_binding_level
->this_class
= current_class_type
;
1676 /* ...and a poplevel for class declarations. */
1681 register struct binding_level
*level
= class_binding_level
;
1684 my_friendly_assert (level
!= 0, 354);
1686 /* If we're leaving a toplevel class, don't bother to do the setting
1687 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1688 shouldn't even be used when current_class_type isn't set, and second,
1689 if we don't touch it here, we're able to use the cache effect if the
1690 next time we're entering a class scope, it is the same class. */
1691 if (current_class_depth
!= 1)
1693 struct binding_level
* b
;
1695 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1696 for (shadowed
= level
->class_shadowed
;
1698 shadowed
= TREE_CHAIN (shadowed
))
1699 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1701 /* Find the next enclosing class, and recreate
1702 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1703 b
= level
->level_chain
;
1704 while (b
&& b
->parm_flag
!= 2)
1708 for (shadowed
= b
->class_shadowed
;
1710 shadowed
= TREE_CHAIN (shadowed
))
1714 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1715 while (t
&& BINDING_LEVEL (t
) != b
)
1719 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1720 = BINDING_VALUE (t
);
1724 /* Remember to save what IDENTIFIER's were bound in this scope so we
1725 can recover from cache misses. */
1727 previous_class_type
= current_class_type
;
1728 previous_class_values
= class_binding_level
->class_shadowed
;
1730 for (shadowed
= level
->type_shadowed
;
1732 shadowed
= TREE_CHAIN (shadowed
))
1733 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1735 /* Remove the bindings for all of the class-level declarations. */
1736 for (shadowed
= level
->class_shadowed
;
1738 shadowed
= TREE_CHAIN (shadowed
))
1739 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1741 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1742 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1743 class_binding_level
->parm_flag
,
1744 class_binding_level
->keep
);
1746 /* Now, pop out of the binding level which we created up in the
1747 `pushlevel_class' routine. */
1748 #if defined(DEBUG_CP_BINDING_LEVELS)
1750 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1752 pop_binding_level ();
1755 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1756 for any names in enclosing classes. */
1759 clear_identifier_class_values ()
1763 if (!class_binding_level
)
1766 for (t
= class_binding_level
->class_shadowed
;
1769 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1772 /* Returns non-zero if T is a virtual function table. */
1775 vtable_decl_p (t
, data
)
1777 void *data ATTRIBUTE_UNUSED
;
1779 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1782 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1786 vtype_decl_p (t
, data
)
1788 void *data ATTRIBUTE_UNUSED
;
1790 return (TREE_CODE (t
) == TYPE_DECL
1791 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
1792 && TYPE_POLYMORPHIC_P (TREE_TYPE (t
)));
1795 /* Return the declarations that are members of the namespace NS. */
1798 cp_namespace_decls (ns
)
1801 return NAMESPACE_LEVEL (ns
)->names
;
1804 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1805 itself, calling F for each. The DATA is passed to F as well. */
1808 walk_namespaces_r (namespace, f
, data
)
1810 walk_namespaces_fn f
;
1816 result
|= (*f
) (namespace, data
);
1818 for (current
= cp_namespace_decls (namespace);
1820 current
= TREE_CHAIN (current
))
1822 if (TREE_CODE (current
) != NAMESPACE_DECL
1823 || DECL_NAMESPACE_ALIAS (current
))
1825 if (!DECL_LANG_SPECIFIC (current
))
1828 my_friendly_assert (current
== std_node
, 393);
1832 /* We found a namespace. */
1833 result
|= walk_namespaces_r (current
, f
, data
);
1839 /* Walk all the namespaces, calling F for each. The DATA is passed to
1843 walk_namespaces (f
, data
)
1844 walk_namespaces_fn f
;
1847 return walk_namespaces_r (global_namespace
, f
, data
);
1850 struct walk_globals_data
{
1851 walk_globals_pred p
;
1856 /* Walk the global declarations in NAMESPACE. Whenever one is found
1857 for which P returns non-zero, call F with its address. If any call
1858 to F returns a non-zero value, return a non-zero value. */
1861 walk_globals_r (namespace, data
)
1865 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1866 walk_globals_pred p
= wgd
->p
;
1867 walk_globals_fn f
= wgd
->f
;
1868 void *d
= wgd
->data
;
1872 t
= &NAMESPACE_LEVEL (namespace)->names
;
1879 result
|= (*f
) (t
, d
);
1881 /* If F changed *T, then *T still points at the next item to
1884 t
= &TREE_CHAIN (*t
);
1890 /* Walk the global declarations. Whenever one is found for which P
1891 returns non-zero, call F with its address. If any call to F
1892 returns a non-zero value, return a non-zero value. */
1895 walk_globals (p
, f
, data
)
1896 walk_globals_pred p
;
1900 struct walk_globals_data wgd
;
1905 return walk_namespaces (walk_globals_r
, &wgd
);
1908 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1909 DATA is non-NULL, this is the last time we will call
1910 wrapup_global_declarations for this NAMESPACE. */
1913 wrapup_globals_for_namespace (namespace, data
)
1917 tree globals
= cp_namespace_decls (namespace);
1918 int len
= list_length (globals
);
1919 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1923 int last_time
= (data
!= 0);
1925 if (last_time
&& namespace == global_namespace
)
1926 /* Let compile_file handle the global namespace. */
1929 /* Process the decls in reverse order--earliest first.
1930 Put them into VEC from back to front, then take out from front. */
1932 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1934 /* Pretend we've output an unused static variable. This ensures
1935 that the toplevel __FUNCTION__ etc won't be emitted, unless
1937 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_ARTIFICIAL (decl
)
1938 && !TREE_PUBLIC (decl
) && !TREE_USED (decl
))
1940 TREE_ASM_WRITTEN (decl
) = 1;
1941 DECL_IGNORED_P (decl
) = 1;
1943 vec
[len
- i
- 1] = decl
;
1948 check_global_declarations (vec
, len
);
1952 /* Temporarily mark vtables as external. That prevents
1953 wrapup_global_declarations from writing them out; we must process
1954 them ourselves in finish_vtable_vardecl. */
1955 for (i
= 0; i
< len
; ++i
)
1956 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1958 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1959 DECL_EXTERNAL (vec
[i
]) = 1;
1962 /* Write out any globals that need to be output. */
1963 result
= wrapup_global_declarations (vec
, len
);
1965 /* Undo the hack to DECL_EXTERNAL above. */
1966 for (i
= 0; i
< len
; ++i
)
1967 if (vtable_decl_p (vec
[i
], /*data=*/0)
1968 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1970 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1971 DECL_EXTERNAL (vec
[i
]) = 0;
1978 /* Mark ARG (which is really a struct binding_level **) for GC. */
1981 mark_binding_level (arg
)
1984 struct binding_level
*lvl
= *(struct binding_level
**)arg
;
1986 for (; lvl
; lvl
= lvl
->level_chain
)
1988 ggc_mark_tree (lvl
->names
);
1989 ggc_mark_tree (lvl
->tags
);
1990 ggc_mark_tree (lvl
->usings
);
1991 ggc_mark_tree (lvl
->using_directives
);
1992 ggc_mark_tree (lvl
->class_shadowed
);
1993 ggc_mark_tree (lvl
->type_shadowed
);
1994 ggc_mark_tree (lvl
->shadowed_labels
);
1995 ggc_mark_tree (lvl
->blocks
);
1996 ggc_mark_tree (lvl
->this_class
);
1997 ggc_mark_tree (lvl
->incomplete
);
1998 ggc_mark_tree (lvl
->dead_vars_from_for
);
2003 mark_named_label_lists (labs
, uses
)
2007 struct named_label_list
*l
= *(struct named_label_list
**)labs
;
2008 struct named_label_use_list
*u
= *(struct named_label_use_list
**)uses
;
2010 for (; l
; l
= l
->next
)
2013 mark_binding_level (l
->binding_level
);
2014 ggc_mark_tree (l
->old_value
);
2015 ggc_mark_tree (l
->label_decl
);
2016 ggc_mark_tree (l
->bad_decls
);
2019 for (; u
; u
= u
->next
)
2023 /* For debugging. */
2024 static int no_print_functions
= 0;
2025 static int no_print_builtins
= 0;
2028 print_binding_level (lvl
)
2029 struct binding_level
*lvl
;
2033 fprintf (stderr
, " blocks=");
2034 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
2035 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
2036 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
2037 if (lvl
->tag_transparent
)
2038 fprintf (stderr
, " tag-transparent");
2039 if (lvl
->more_cleanups_ok
)
2040 fprintf (stderr
, " more-cleanups-ok");
2041 if (lvl
->have_cleanups
)
2042 fprintf (stderr
, " have-cleanups");
2043 fprintf (stderr
, "\n");
2046 fprintf (stderr
, " names:\t");
2047 /* We can probably fit 3 names to a line? */
2048 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2050 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2052 if (no_print_builtins
2053 && (TREE_CODE (t
) == TYPE_DECL
)
2054 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2057 /* Function decls tend to have longer names. */
2058 if (TREE_CODE (t
) == FUNCTION_DECL
)
2065 fprintf (stderr
, "\n\t");
2068 print_node_brief (stderr
, "", t
, 0);
2069 if (t
== error_mark_node
)
2073 fprintf (stderr
, "\n");
2077 fprintf (stderr
, " tags:\t");
2079 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2081 if (TREE_PURPOSE (t
) == NULL_TREE
)
2083 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2090 fprintf (stderr
, "\n\t");
2093 if (TREE_PURPOSE (t
) == NULL_TREE
)
2095 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2096 fprintf (stderr
, ">");
2098 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2099 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2102 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2103 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2104 fprintf (stderr
, ">");
2108 fprintf (stderr
, "\n");
2110 if (lvl
->class_shadowed
)
2112 fprintf (stderr
, " class-shadowed:");
2113 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2115 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2117 fprintf (stderr
, "\n");
2119 if (lvl
->type_shadowed
)
2121 fprintf (stderr
, " type-shadowed:");
2122 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2124 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2126 fprintf (stderr
, "\n");
2131 print_other_binding_stack (stack
)
2132 struct binding_level
*stack
;
2134 struct binding_level
*level
;
2135 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2137 fprintf (stderr
, "binding level ");
2138 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2139 fprintf (stderr
, "\n");
2140 print_binding_level (level
);
2145 print_binding_stack ()
2147 struct binding_level
*b
;
2148 fprintf (stderr
, "current_binding_level=");
2149 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2150 fprintf (stderr
, "\nclass_binding_level=");
2151 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2152 fprintf (stderr
, "\nglobal_binding_level=");
2153 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2154 fprintf (stderr
, "\n");
2155 if (class_binding_level
)
2157 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2158 if (b
== current_binding_level
)
2161 b
= class_binding_level
;
2163 b
= current_binding_level
;
2166 b
= current_binding_level
;
2167 print_other_binding_stack (b
);
2168 fprintf (stderr
, "global:\n");
2169 print_binding_level (global_binding_level
);
2172 /* Namespace binding access routines: The namespace_bindings field of
2173 the identifier is polymorphic, with three possible values:
2174 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2175 indicating the BINDING_VALUE of global_namespace. */
2177 /* Check whether the a binding for the name to scope is known.
2178 Assumes that the bindings of the name are already a list
2179 of bindings. Returns the binding found, or NULL_TREE. */
2182 find_binding (name
, scope
)
2186 tree iter
, prev
= NULL_TREE
;
2188 scope
= ORIGINAL_NAMESPACE (scope
);
2190 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2191 iter
= TREE_CHAIN (iter
))
2193 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2194 if (BINDING_SCOPE (iter
) == scope
)
2196 /* Move binding found to the front of the list, so
2197 subsequent lookups will find it faster. */
2200 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2201 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2202 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2211 /* Always returns a binding for name in scope. If the
2212 namespace_bindings is not a list, convert it to one first.
2213 If no binding is found, make a new one. */
2216 binding_for_name (name
, scope
)
2220 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2223 scope
= ORIGINAL_NAMESPACE (scope
);
2225 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2227 /* Get rid of optimization for global scope. */
2228 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2229 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2230 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2232 if (b
&& (result
= find_binding (name
, scope
)))
2234 /* Not found, make a new one. */
2235 result
= make_node (CPLUS_BINDING
);
2236 TREE_CHAIN (result
) = b
;
2237 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2238 BINDING_SCOPE (result
) = scope
;
2239 BINDING_TYPE (result
) = NULL_TREE
;
2240 BINDING_VALUE (result
) = NULL_TREE
;
2244 /* Return the binding value for name in scope, considering that
2245 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2248 namespace_binding (name
, scope
)
2252 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2255 if (scope
== NULL_TREE
)
2256 scope
= global_namespace
;
2257 if (TREE_CODE (b
) != CPLUS_BINDING
)
2258 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2259 name
= find_binding (name
,scope
);
2260 if (name
== NULL_TREE
)
2262 return BINDING_VALUE (name
);
2265 /* Set the binding value for name in scope. If modifying the binding
2266 of global_namespace is attempted, try to optimize it. */
2269 set_namespace_binding (name
, scope
, val
)
2276 if (scope
== NULL_TREE
)
2277 scope
= global_namespace
;
2279 if (scope
== global_namespace
)
2281 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2282 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2284 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2288 b
= binding_for_name (name
, scope
);
2289 BINDING_VALUE (b
) = val
;
2292 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2293 select a name that is unique to this compilation unit. */
2296 push_namespace (name
)
2301 int implicit_use
= 0;
2303 if (!global_namespace
)
2305 /* This must be ::. */
2306 my_friendly_assert (name
== get_identifier ("::"), 377);
2311 /* The name of anonymous namespace is unique for the translation
2313 if (!anonymous_namespace_name
)
2314 anonymous_namespace_name
= get_file_function_name ('N');
2315 name
= anonymous_namespace_name
;
2316 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2318 /* Reopening anonymous namespace. */
2322 else if (current_namespace
== global_namespace
2323 && name
== DECL_NAME (std_node
))
2330 /* Check whether this is an extended namespace definition. */
2331 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2332 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2335 if (DECL_NAMESPACE_ALIAS (d
))
2337 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2338 d
, DECL_NAMESPACE_ALIAS (d
));
2339 d
= DECL_NAMESPACE_ALIAS (d
);
2346 /* Make a new namespace, binding the name to it. */
2347 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2348 /* The global namespace is not pushed, and the global binding
2349 level is set elsewhere. */
2352 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2355 declare_namespace_level ();
2356 NAMESPACE_LEVEL (d
) = current_binding_level
;
2360 resume_binding_level (NAMESPACE_LEVEL (d
));
2363 do_using_directive (d
);
2364 /* Enter the name space. */
2365 current_namespace
= d
;
2368 /* Pop from the scope of the current namespace. */
2373 if (current_namespace
== global_namespace
)
2375 my_friendly_assert (in_std
>0, 980421);
2379 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2380 /* The binding level is not popped, as it might be re-opened later. */
2381 suspend_binding_level ();
2384 /* Push into the scope of the namespace NS, even if it is deeply
2385 nested within another namespace. */
2388 push_nested_namespace (ns
)
2391 if (ns
== global_namespace
)
2392 push_to_top_level ();
2395 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2396 push_namespace (DECL_NAME (ns
));
2400 /* Pop back from the scope of the namespace NS, which was previously
2401 entered with push_nested_namespace. */
2404 pop_nested_namespace (ns
)
2407 while (ns
!= global_namespace
)
2410 ns
= CP_DECL_CONTEXT (ns
);
2413 pop_from_top_level ();
2417 /* Subroutines for reverting temporarily to top-level for instantiation
2418 of templates and such. We actually need to clear out the class- and
2419 local-value slots of all identifiers, so that only the global values
2420 are at all visible. Simply setting current_binding_level to the global
2421 scope isn't enough, because more binding levels may be pushed. */
2422 struct saved_scope
*scope_chain
;
2424 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2427 mark_saved_scope (arg
)
2430 struct saved_scope
*t
= *(struct saved_scope
**)arg
;
2433 mark_binding_level (&t
->class_bindings
);
2434 ggc_mark_tree (t
->old_bindings
);
2435 ggc_mark_tree (t
->old_namespace
);
2436 ggc_mark_tree (t
->class_name
);
2437 ggc_mark_tree (t
->class_type
);
2438 ggc_mark_tree (t
->access_specifier
);
2439 ggc_mark_tree (t
->function_decl
);
2441 ggc_mark_tree_varray (t
->lang_base
);
2442 ggc_mark_tree (t
->lang_name
);
2443 ggc_mark_tree (t
->template_parms
);
2444 ggc_mark_tree (t
->x_previous_class_type
);
2445 ggc_mark_tree (t
->x_previous_class_values
);
2446 ggc_mark_tree (t
->x_saved_tree
);
2447 ggc_mark_tree (t
->incomplete
);
2448 ggc_mark_tree (t
->lookups
);
2450 mark_stmt_tree (&t
->x_stmt_tree
);
2451 mark_binding_level (&t
->bindings
);
2457 store_bindings (names
, old_bindings
)
2458 tree names
, old_bindings
;
2461 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2463 tree binding
, t1
, id
;
2465 if (TREE_CODE (t
) == TREE_LIST
)
2466 id
= TREE_PURPOSE (t
);
2471 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2472 we have no IDENTIFIER_BINDING if we have left the class
2473 scope, but cached the class-level declarations. */
2474 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2477 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2478 if (TREE_VEC_ELT (t1
, 0) == id
)
2481 binding
= make_tree_vec (4);
2485 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2486 TREE_VEC_ELT (binding
, 0) = id
;
2487 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2488 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2489 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2490 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2491 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2493 TREE_CHAIN (binding
) = old_bindings
;
2494 old_bindings
= binding
;
2498 return old_bindings
;
2502 maybe_push_to_top_level (pseudo
)
2505 struct saved_scope
*s
;
2506 struct binding_level
*b
;
2510 s
= (struct saved_scope
*) xcalloc (1, sizeof (struct saved_scope
));
2512 b
= scope_chain
? current_binding_level
: 0;
2514 /* If we're in the middle of some function, save our state. */
2518 push_function_context_to (NULL_TREE
);
2523 old_bindings
= NULL_TREE
;
2524 if (scope_chain
&& previous_class_type
)
2525 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2527 /* Have to include global_binding_level, because class-level decls
2528 aren't listed anywhere useful. */
2529 for (; b
; b
= b
->level_chain
)
2533 /* Template IDs are inserted into the global level. If they were
2534 inserted into namespace level, finish_file wouldn't find them
2535 when doing pending instantiations. Therefore, don't stop at
2536 namespace level, but continue until :: . */
2537 if (b
== global_binding_level
|| (pseudo
&& b
->template_parms_p
))
2540 old_bindings
= store_bindings (b
->names
, old_bindings
);
2541 /* We also need to check class_shadowed to save class-level type
2542 bindings, since pushclass doesn't fill in b->names. */
2543 if (b
->parm_flag
== 2)
2544 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2546 /* Unwind type-value slots back to top level. */
2547 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2548 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2550 s
->prev
= scope_chain
;
2551 s
->old_bindings
= old_bindings
;
2553 s
->need_pop_function_context
= need_pop
;
2554 s
->function_decl
= current_function_decl
;
2557 current_function_decl
= NULL_TREE
;
2558 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
2559 current_lang_stack
= &VARRAY_TREE (current_lang_base
, 0);
2560 current_lang_name
= lang_name_cplusplus
;
2561 current_namespace
= global_namespace
;
2565 push_to_top_level ()
2567 maybe_push_to_top_level (0);
2571 pop_from_top_level ()
2573 struct saved_scope
*s
= scope_chain
;
2576 /* Clear out class-level bindings cache. */
2577 if (previous_class_type
)
2578 invalidate_class_lookup_cache ();
2580 VARRAY_FREE (current_lang_base
);
2582 scope_chain
= s
->prev
;
2583 for (t
= s
->old_bindings
; t
; t
= TREE_CHAIN (t
))
2585 tree id
= TREE_VEC_ELT (t
, 0);
2588 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2589 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2590 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2594 /* If we were in the middle of compiling a function, restore our
2596 if (s
->need_pop_function_context
)
2597 pop_function_context_from (NULL_TREE
);
2598 current_function_decl
= s
->function_decl
;
2603 /* Push a definition of struct, union or enum tag "name".
2604 into binding_level "b". "type" should be the type node,
2605 We assume that the tag "name" is not already defined.
2607 Note that the definition may really be just a forward reference.
2608 In that case, the TYPE_SIZE will be a NULL_TREE.
2610 C++ gratuitously puts all these tags in the name space. */
2612 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2613 record the shadowed value for this binding contour. TYPE is
2614 the type that ID maps to. */
2617 set_identifier_type_value_with_scope (id
, type
, b
)
2620 struct binding_level
*b
;
2622 if (!b
->namespace_p
)
2624 /* Shadow the marker, not the real thing, so that the marker
2625 gets restored later. */
2626 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2628 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2632 tree binding
= binding_for_name (id
, current_namespace
);
2633 BINDING_TYPE (binding
) = type
;
2634 /* Store marker instead of real type. */
2635 type
= global_type_node
;
2637 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2640 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2643 set_identifier_type_value (id
, type
)
2647 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2650 /* Return the type associated with id. */
2653 identifier_type_value (id
)
2656 /* There is no type with that name, anywhere. */
2657 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2659 /* This is not the type marker, but the real thing. */
2660 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2661 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2662 /* Have to search for it. It must be on the global level, now.
2663 Ask lookup_name not to return non-types. */
2664 id
= lookup_name_real (id
, 2, 1, 0);
2666 return TREE_TYPE (id
);
2670 /* Pop off extraneous binding levels left over due to syntax errors.
2672 We don't pop past namespaces, as they might be valid. */
2677 #ifdef DEBUG_CP_BINDING_LEVELS
2678 fprintf (stderr
, "XXX entering pop_everything ()\n");
2680 while (!toplevel_bindings_p ())
2682 if (current_binding_level
->parm_flag
== 2)
2683 pop_nested_class ();
2687 #ifdef DEBUG_CP_BINDING_LEVELS
2688 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2692 /* The type TYPE is being declared. If it is a class template, or a
2693 specialization of a class template, do any processing required and
2694 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2695 being declared a friend. B is the binding level at which this TYPE
2698 Returns the TYPE_DECL for TYPE, which may have been altered by this
2702 maybe_process_template_type_declaration (type
, globalize
, b
)
2705 struct binding_level
* b
;
2707 tree decl
= TYPE_NAME (type
);
2709 if (processing_template_parmlist
)
2710 /* You can't declare a new template type in a template parameter
2711 list. But, you can declare a non-template type:
2713 template <class A*> struct S;
2715 is a forward-declaration of `A'. */
2719 maybe_check_template_type (type
);
2721 my_friendly_assert (IS_AGGR_TYPE (type
)
2722 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2725 if (processing_template_decl
)
2727 /* This may change after the call to
2728 push_template_decl_real, but we want the original value. */
2729 tree name
= DECL_NAME (decl
);
2731 decl
= push_template_decl_real (decl
, globalize
);
2732 /* If the current binding level is the binding level for the
2733 template parameters (see the comment in
2734 begin_template_parm_list) and the enclosing level is a class
2735 scope, and we're not looking at a friend, push the
2736 declaration of the member class into the class scope. In the
2737 friend case, push_template_decl will already have put the
2738 friend into global scope, if appropriate. */
2739 if (TREE_CODE (type
) != ENUMERAL_TYPE
2740 && !globalize
&& b
->template_parms_p
2741 && b
->level_chain
->parm_flag
== 2)
2743 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2744 /* Put this tag on the list of tags for the class, since
2745 that won't happen below because B is not the class
2746 binding level, but is instead the pseudo-global level. */
2747 b
->level_chain
->tags
=
2748 tree_cons (name
, type
, b
->level_chain
->tags
);
2749 if (!COMPLETE_TYPE_P (current_class_type
))
2750 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2758 /* In C++, you don't have to write `struct S' to refer to `S'; you
2759 can just use `S'. We accomplish this by creating a TYPE_DECL as
2760 if the user had written `typedef struct S S'. Create and return
2761 the TYPE_DECL for TYPE. */
2764 create_implicit_typedef (name
, type
)
2770 decl
= build_decl (TYPE_DECL
, name
, type
);
2771 DECL_ARTIFICIAL (decl
) = 1;
2772 /* There are other implicit type declarations, like the one *within*
2773 a class that allows you to write `S::S'. We must distinguish
2775 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2776 TYPE_NAME (type
) = decl
;
2781 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2782 Normally put it into the inner-most non-tag-transparent scope,
2783 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2784 The latter is needed for implicit declarations. */
2787 pushtag (name
, type
, globalize
)
2791 register struct binding_level
*b
;
2793 b
= current_binding_level
;
2794 while (b
->tag_transparent
2795 || (globalize
&& b
->parm_flag
== 2))
2798 b
->tags
= tree_cons (name
, type
, b
->tags
);
2802 /* Do C++ gratuitous typedefing. */
2803 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2805 register tree d
= NULL_TREE
;
2807 tree context
= TYPE_CONTEXT (type
);
2811 tree cs
= current_scope ();
2815 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
2816 /* When declaring a friend class of a local class, we want
2817 to inject the newly named class into the scope
2818 containing the local class, not the namespace scope. */
2819 context
= decl_function_context (get_type_decl (cs
));
2822 context
= current_namespace
;
2824 if ((b
->template_parms_p
&& b
->level_chain
->parm_flag
== 2)
2825 || b
->parm_flag
== 2)
2828 if (current_lang_name
== lang_name_java
)
2829 TYPE_FOR_JAVA (type
) = 1;
2831 d
= create_implicit_typedef (name
, type
);
2832 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2834 set_identifier_type_value_with_scope (name
, type
, b
);
2836 d
= maybe_process_template_type_declaration (type
,
2839 if (b
->parm_flag
== 2)
2841 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2842 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2843 class. But if it's a member template class, we
2844 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2846 finish_member_declaration (d
);
2848 pushdecl_class_level (d
);
2851 d
= pushdecl_with_scope (d
, b
);
2853 if (ANON_AGGRNAME_P (name
))
2854 DECL_IGNORED_P (d
) = 1;
2856 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2857 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2859 /* If this is a local class, keep track of it. We need this
2860 information for name-mangling, and so that it is possible to find
2861 all function definitions in a translation unit in a convenient
2862 way. (It's otherwise tricky to find a member function definition
2863 it's only pointed to from within a local class.) */
2864 if (TYPE_CONTEXT (type
)
2865 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
2866 && !processing_template_decl
)
2867 VARRAY_PUSH_TREE (local_classes
, type
);
2869 if (!uses_template_parms (type
))
2872 DECL_ASSEMBLER_NAME (d
) = mangle_type (type
);
2874 DECL_ASSEMBLER_NAME (d
)
2875 = get_identifier (build_overload_name (type
, 1, 1));
2878 if (b
->parm_flag
== 2)
2880 if (!COMPLETE_TYPE_P (current_class_type
))
2881 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2885 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2886 /* Use the canonical TYPE_DECL for this node. */
2887 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2890 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2891 will be the tagged type we just added to the current
2892 binding level. This fake NULL-named TYPE_DECL node helps
2893 dwarfout.c to know when it needs to output a
2894 representation of a tagged type, and it also gives us a
2895 convenient place to record the "scope start" address for
2898 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2899 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2903 /* Counter used to create anonymous type names. */
2905 static int anon_cnt
= 0;
2907 /* Return an IDENTIFIER which can be used as a name for
2908 anonymous structs and unions. */
2915 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2916 return get_identifier (buf
);
2919 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2920 This keeps dbxout from getting confused. */
2925 register struct binding_level
*b
;
2927 static int last_cnt
= 0;
2929 /* Fast out if no new anon names were declared. */
2930 if (last_cnt
== anon_cnt
)
2933 b
= current_binding_level
;
2934 while (b
->tag_transparent
)
2939 /* A NULL purpose means we have already processed all tags
2940 from here to the end of the list. */
2941 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2943 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2944 TREE_PURPOSE (tags
) = NULL_TREE
;
2945 tags
= TREE_CHAIN (tags
);
2947 last_cnt
= anon_cnt
;
2950 /* Subroutine of duplicate_decls: return truthvalue of whether
2951 or not types of these decls match.
2953 For C++, we must compare the parameter list so that `int' can match
2954 `int&' in a parameter position, but `int&' is not confused with
2958 decls_match (newdecl
, olddecl
)
2959 tree newdecl
, olddecl
;
2963 if (newdecl
== olddecl
)
2966 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2967 /* If the two DECLs are not even the same kind of thing, we're not
2968 interested in their types. */
2971 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2973 tree f1
= TREE_TYPE (newdecl
);
2974 tree f2
= TREE_TYPE (olddecl
);
2975 tree p1
= TYPE_ARG_TYPES (f1
);
2976 tree p2
= TYPE_ARG_TYPES (f2
);
2978 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
2979 && ! (DECL_EXTERN_C_P (newdecl
)
2980 && DECL_EXTERN_C_P (olddecl
)))
2983 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2986 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2988 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
2989 && (DECL_BUILT_IN (olddecl
)
2990 #ifndef NO_IMPLICIT_EXTERN_C
2991 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
2992 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
2996 types_match
= self_promoting_args_p (p1
);
2997 if (p1
== void_list_node
)
2998 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3000 #ifndef NO_IMPLICIT_EXTERN_C
3001 else if (p1
== NULL_TREE
3002 && (DECL_EXTERN_C_P (olddecl
)
3003 && DECL_IN_SYSTEM_HEADER (olddecl
)
3004 && !DECL_CLASS_SCOPE_P (olddecl
))
3005 && (DECL_EXTERN_C_P (newdecl
)
3006 && DECL_IN_SYSTEM_HEADER (newdecl
)
3007 && !DECL_CLASS_SCOPE_P (newdecl
)))
3009 types_match
= self_promoting_args_p (p2
);
3010 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3014 types_match
= compparms (p1
, p2
);
3019 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3021 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3022 DECL_TEMPLATE_PARMS (olddecl
)))
3025 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
3026 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
3029 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3032 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
3033 DECL_TEMPLATE_RESULT (newdecl
));
3037 if (TREE_TYPE (newdecl
) == error_mark_node
)
3038 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3039 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3040 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3041 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3044 types_match
= comptypes (TREE_TYPE (newdecl
),
3045 TREE_TYPE (olddecl
),
3046 COMPARE_REDECLARATION
);
3052 /* If NEWDECL is `static' and an `extern' was seen previously,
3053 warn about it. OLDDECL is the previous declaration.
3055 Note that this does not apply to the C++ case of declaring
3056 a variable `extern const' and then later `const'.
3058 Don't complain about built-in functions, since they are beyond
3059 the user's control. */
3062 warn_extern_redeclared_static (newdecl
, olddecl
)
3063 tree newdecl
, olddecl
;
3065 static const char *explicit_extern_static_warning
3066 = "`%D' was declared `extern' and later `static'";
3067 static const char *implicit_extern_static_warning
3068 = "`%D' was declared implicitly `extern' and later `static'";
3072 if (TREE_CODE (newdecl
) == TYPE_DECL
3073 || TREE_CODE (newdecl
) == TEMPLATE_DECL
3074 || TREE_CODE (newdecl
) == CONST_DECL
)
3077 /* Don't get confused by static member functions; that's a different
3079 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3080 && DECL_STATIC_FUNCTION_P (newdecl
))
3083 /* If the old declaration was `static', or the new one isn't, then
3084 then everything is OK. */
3085 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
3088 /* It's OK to declare a builtin function as `static'. */
3089 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3090 && DECL_ARTIFICIAL (olddecl
))
3093 name
= DECL_ASSEMBLER_NAME (newdecl
);
3094 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3095 ? implicit_extern_static_warning
3096 : explicit_extern_static_warning
, newdecl
);
3097 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3100 /* Handle when a new declaration NEWDECL has the same name as an old
3101 one OLDDECL in the same binding contour. Prints an error message
3104 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3105 Otherwise, return 0. */
3108 duplicate_decls (newdecl
, olddecl
)
3109 tree newdecl
, olddecl
;
3111 unsigned olddecl_uid
= DECL_UID (olddecl
);
3112 int olddecl_friend
= 0, types_match
= 0;
3113 int new_defines_function
= 0;
3115 if (newdecl
== olddecl
)
3118 types_match
= decls_match (newdecl
, olddecl
);
3120 /* If either the type of the new decl or the type of the old decl is an
3121 error_mark_node, then that implies that we have already issued an
3122 error (earlier) for some bogus type specification, and in that case,
3123 it is rather pointless to harass the user with yet more error message
3124 about the same declaration, so just pretend the types match here. */
3125 if (TREE_TYPE (newdecl
) == error_mark_node
3126 || TREE_TYPE (olddecl
) == error_mark_node
)
3129 /* Check for redeclaration and other discrepancies. */
3130 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3131 && DECL_ARTIFICIAL (olddecl
))
3133 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3135 /* If you declare a built-in or predefined function name as static,
3136 the old definition is overridden, but optionally warn this was a
3137 bad choice of name. */
3138 if (! TREE_PUBLIC (newdecl
))
3141 cp_warning ("shadowing %s function `%#D'",
3142 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3144 /* Discard the old built-in function. */
3147 /* If the built-in is not ansi, then programs can override
3148 it even globally without an error. */
3149 else if (! DECL_BUILT_IN (olddecl
))
3150 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3154 cp_error ("declaration of `%#D'", newdecl
);
3155 cp_error ("conflicts with built-in declaration `%#D'",
3160 else if (!types_match
)
3162 if ((DECL_EXTERN_C_P (newdecl
)
3163 && DECL_EXTERN_C_P (olddecl
))
3164 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3165 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3167 /* A near match; override the builtin. */
3169 if (TREE_PUBLIC (newdecl
))
3171 cp_warning ("new declaration `%#D'", newdecl
);
3172 cp_warning ("ambiguates built-in declaration `%#D'",
3175 else if (warn_shadow
)
3176 cp_warning ("shadowing %s function `%#D'",
3177 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3181 /* Discard the old built-in function. */
3185 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
3187 /* If a builtin function is redeclared as `static', merge
3188 the declarations, but make the original one static. */
3189 DECL_THIS_STATIC (olddecl
) = 1;
3190 TREE_PUBLIC (olddecl
) = 0;
3192 /* Make the old declaration consistent with the new one so
3193 that all remnants of the builtin-ness of this function
3194 will be banished. */
3195 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3196 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3197 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3198 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl
),
3202 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3204 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3205 && TREE_CODE (newdecl
) != TYPE_DECL
3206 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3207 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3208 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3209 && TREE_CODE (olddecl
) != TYPE_DECL
3210 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3211 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3214 /* We do nothing special here, because C++ does such nasty
3215 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3216 get shadowed, and know that if we need to find a TYPE_DECL
3217 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3218 slot of the identifier. */
3222 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3223 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3224 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3225 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3228 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3229 if (TREE_CODE (olddecl
) == TREE_LIST
)
3230 olddecl
= TREE_VALUE (olddecl
);
3231 cp_error_at ("previous declaration of `%#D'", olddecl
);
3233 /* New decl is completely inconsistent with the old one =>
3234 tell caller to replace the old one. */
3238 else if (!types_match
)
3240 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
3241 /* These are certainly not duplicate declarations; they're
3242 from different scopes. */
3245 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3247 /* The name of a class template may not be declared to refer to
3248 any other template, class, function, object, namespace, value,
3249 or type in the same scope. */
3250 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3251 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3253 cp_error ("declaration of template `%#D'", newdecl
);
3254 cp_error_at ("conflicts with previous declaration `%#D'",
3257 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3258 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3259 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3260 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3261 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3262 DECL_TEMPLATE_PARMS (olddecl
)))
3264 cp_error ("new declaration `%#D'", newdecl
);
3265 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3269 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3271 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
3273 cp_error ("declaration of C function `%#D' conflicts with",
3275 cp_error_at ("previous declaration `%#D' here", olddecl
);
3277 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3278 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3280 cp_error ("new declaration `%#D'", newdecl
);
3281 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3287 /* Already complained about this, so don't do so again. */
3288 else if (current_class_type
== NULL_TREE
3289 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3291 cp_error ("conflicting types for `%#D'", newdecl
);
3292 cp_error_at ("previous declaration as `%#D'", olddecl
);
3295 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3296 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3297 && (!DECL_TEMPLATE_INFO (newdecl
)
3298 || (DECL_TI_TEMPLATE (newdecl
)
3299 != DECL_TI_TEMPLATE (olddecl
))))
3300 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3301 && (!DECL_TEMPLATE_INFO (olddecl
)
3302 || (DECL_TI_TEMPLATE (olddecl
)
3303 != DECL_TI_TEMPLATE (newdecl
))))))
3304 /* It's OK to have a template specialization and a non-template
3305 with the same type, or to have specializations of two
3306 different templates with the same type. Note that if one is a
3307 specialization, and the other is an instantiation of the same
3308 template, that we do not exit at this point. That situation
3309 can occur if we instantiate a template class, and then
3310 specialize one of its methods. This situation is legal, but
3311 the declarations must be merged in the usual way. */
3313 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3314 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3315 && !DECL_USE_TEMPLATE (newdecl
))
3316 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3317 && !DECL_USE_TEMPLATE (olddecl
))))
3318 /* One of the declarations is a template instantiation, and the
3319 other is not a template at all. That's OK. */
3321 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3322 && DECL_NAMESPACE_ALIAS (newdecl
)
3323 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3324 /* Redeclaration of namespace alias, ignore it. */
3328 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3331 cp_error (errmsg
, newdecl
);
3332 if (DECL_NAME (olddecl
) != NULL_TREE
)
3333 cp_error_at ((DECL_INITIAL (olddecl
)
3334 && namespace_bindings_p ())
3335 ? "`%#D' previously defined here"
3336 : "`%#D' previously declared here", olddecl
);
3338 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3339 && DECL_INITIAL (olddecl
) != NULL_TREE
3340 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3341 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3343 /* Prototype decl follows defn w/o prototype. */
3344 cp_warning_at ("prototype for `%#D'", newdecl
);
3345 cp_warning_at ("follows non-prototype definition here", olddecl
);
3347 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3348 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3350 /* extern "C" int foo ();
3351 int foo () { bar (); }
3353 if (current_lang_stack
3354 == &VARRAY_TREE (current_lang_base
, 0))
3355 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3358 cp_error_at ("previous declaration of `%#D' with %L linkage",
3359 olddecl
, DECL_LANGUAGE (olddecl
));
3360 cp_error ("conflicts with new declaration with %L linkage",
3361 DECL_LANGUAGE (newdecl
));
3365 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3367 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3369 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3370 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3373 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3374 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3376 for (; t1
&& t1
!= void_list_node
;
3377 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3378 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3380 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3385 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3387 cp_pedwarn_at ("after previous specification in `%#D'",
3393 cp_error ("default argument given for parameter %d of `%#D'",
3395 cp_error_at ("after previous specification in `%#D'",
3400 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3401 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3403 cp_warning ("`%#D' was used before it was declared inline",
3405 cp_warning_at ("previous non-inline declaration here",
3411 /* If new decl is `static' and an `extern' was seen previously,
3413 warn_extern_redeclared_static (newdecl
, olddecl
);
3415 /* We have committed to returning 1 at this point. */
3416 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3418 /* Now that functions must hold information normally held
3419 by field decls, there is extra work to do so that
3420 declaration information does not get destroyed during
3422 if (DECL_VINDEX (olddecl
))
3423 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3424 if (DECL_VIRTUAL_CONTEXT (olddecl
))
3425 DECL_VIRTUAL_CONTEXT (newdecl
) = DECL_VIRTUAL_CONTEXT (olddecl
);
3426 if (DECL_CONTEXT (olddecl
))
3427 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3428 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
3429 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3430 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3431 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3432 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
3433 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3434 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3435 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
3436 DECL_LANG_SPECIFIC (newdecl
)->u2
= DECL_LANG_SPECIFIC (olddecl
)->u2
;
3437 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3439 /* Optionally warn about more than one declaration for the same
3440 name, but don't warn about a function declaration followed by a
3442 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3443 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3444 /* Don't warn about extern decl followed by definition. */
3445 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3446 /* Don't warn about friends, let add_friend take care of it. */
3447 && ! DECL_FRIEND_P (newdecl
))
3449 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3450 cp_warning_at ("previous declaration of `%D'", olddecl
);
3454 /* Deal with C++: must preserve virtual function table size. */
3455 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3457 register tree newtype
= TREE_TYPE (newdecl
);
3458 register tree oldtype
= TREE_TYPE (olddecl
);
3460 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3461 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3463 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3464 CLASSTYPE_FRIEND_CLASSES (newtype
)
3465 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3468 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
3471 /* Copy all the DECL_... slots specified in the new decl
3472 except for any that we copy here from the old type. */
3473 DECL_MACHINE_ATTRIBUTES (newdecl
)
3474 = merge_machine_decl_attributes (olddecl
, newdecl
);
3476 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3478 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3479 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3480 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3481 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3488 /* Automatically handles default parameters. */
3489 tree oldtype
= TREE_TYPE (olddecl
);
3492 /* Merge the data types specified in the two decls. */
3493 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3495 /* If common_type produces a non-typedef type, just use the old type. */
3496 if (TREE_CODE (newdecl
) == TYPE_DECL
3497 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
3500 if (TREE_CODE (newdecl
) == VAR_DECL
)
3501 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3502 /* Do this after calling `common_type' so that default
3503 parameters don't confuse us. */
3504 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3505 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3506 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3508 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3509 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3510 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3511 TYPE_RAISES_EXCEPTIONS (oldtype
));
3513 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3514 && DECL_SOURCE_LINE (olddecl
) != 0
3516 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3517 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3519 cp_error ("declaration of `%F' throws different exceptions",
3521 cp_error_at ("than previous declaration `%F'", olddecl
);
3524 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3526 /* Lay the type out, unless already done. */
3527 if (! same_type_p (newtype
, oldtype
)
3528 && TREE_TYPE (newdecl
) != error_mark_node
3529 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3530 layout_type (TREE_TYPE (newdecl
));
3532 if ((TREE_CODE (newdecl
) == VAR_DECL
3533 || TREE_CODE (newdecl
) == PARM_DECL
3534 || TREE_CODE (newdecl
) == RESULT_DECL
3535 || TREE_CODE (newdecl
) == FIELD_DECL
3536 || TREE_CODE (newdecl
) == TYPE_DECL
)
3537 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3538 layout_decl (newdecl
, 0);
3540 /* Merge the type qualifiers. */
3541 if (TREE_READONLY (newdecl
))
3542 TREE_READONLY (olddecl
) = 1;
3543 if (TREE_THIS_VOLATILE (newdecl
))
3544 TREE_THIS_VOLATILE (olddecl
) = 1;
3546 /* Merge the initialization information. */
3547 if (DECL_INITIAL (newdecl
) == NULL_TREE
3548 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3550 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3551 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3552 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3553 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3554 && DECL_LANG_SPECIFIC (newdecl
)
3555 && DECL_LANG_SPECIFIC (olddecl
))
3556 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3559 /* Merge the section attribute.
3560 We want to issue an error if the sections conflict but that must be
3561 done later in decl_attributes since we are called before attributes
3563 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3564 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3566 /* Keep the old rtl since we can safely use it. */
3567 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3569 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3571 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
3572 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
3573 DECL_NO_CHECK_MEMORY_USAGE (newdecl
)
3574 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl
);
3575 DECL_NO_LIMIT_STACK (newdecl
)
3576 |= DECL_NO_LIMIT_STACK (olddecl
);
3579 /* If cannot merge, then use the new type and qualifiers,
3580 and don't preserve the old rtl. */
3583 /* Clean out any memory we had of the old declaration. */
3584 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3586 TREE_VALUE (oldstatic
) = error_mark_node
;
3588 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3589 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3590 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3591 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3594 /* Merge the storage class information. */
3595 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3596 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3597 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
3598 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3599 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3600 if (! DECL_EXTERNAL (olddecl
))
3601 DECL_EXTERNAL (newdecl
) = 0;
3603 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3605 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3606 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3607 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3608 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3609 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3610 /* Don't really know how much of the language-specific
3611 values we should copy from old to new. */
3612 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3613 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3614 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3615 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3616 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3618 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3619 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3620 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3621 DECL_BEFRIENDING_CLASSES (newdecl
)
3622 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3623 DECL_BEFRIENDING_CLASSES (olddecl
));
3626 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3628 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3629 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3631 /* If newdecl is not a specialization, then it is not a
3632 template-related function at all. And that means that we
3633 shoud have exited above, returning 0. */
3634 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3637 if (TREE_USED (olddecl
))
3638 /* From [temp.expl.spec]:
3640 If a template, a member template or the member of a class
3641 template is explicitly specialized then that
3642 specialization shall be declared before the first use of
3643 that specialization that would cause an implicit
3644 instantiation to take place, in every translation unit in
3645 which such a use occurs. */
3646 cp_error ("explicit specialization of %D after first use",
3649 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3651 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3653 /* If either decl says `inline', this fn is inline, unless its
3654 definition was passed already. */
3655 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3656 DECL_INLINE (olddecl
) = 1;
3657 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3661 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3662 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3663 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3665 if (! types_match
|| new_defines_function
)
3667 /* These need to be copied so that the names are available.
3668 Note that if the types do match, we'll preserve inline
3669 info and other bits, but if not, we won't. */
3670 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3671 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3673 if (new_defines_function
)
3674 /* If defining a function declared with other language
3675 linkage, use the previously declared language linkage. */
3676 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3677 else if (types_match
)
3679 /* If redeclaring a builtin function, and not a definition,
3680 it stays built in. */
3681 if (DECL_BUILT_IN (olddecl
))
3683 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
3684 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3685 /* If we're keeping the built-in definition, keep the rtl,
3686 regardless of declaration matches. */
3687 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3690 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3692 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3693 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3694 /* Previously saved insns go together with
3695 the function's previous definition. */
3696 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3697 /* Don't clear out the arguments if we're redefining a function. */
3698 if (DECL_ARGUMENTS (olddecl
))
3699 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3703 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3705 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3708 /* Now preserve various other info from the definition. */
3709 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3710 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3711 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3712 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3714 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3718 function_size
= sizeof (struct tree_decl
);
3720 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3721 (char *) olddecl
+ sizeof (struct tree_common
),
3722 function_size
- sizeof (struct tree_common
));
3724 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3726 /* If newdecl is a template instantiation, it is possible that
3727 the following sequence of events has occurred:
3729 o A friend function was declared in a class template. The
3730 class template was instantiated.
3732 o The instantiation of the friend declaration was
3733 recorded on the instantiation list, and is newdecl.
3735 o Later, however, instantiate_class_template called pushdecl
3736 on the newdecl to perform name injection. But, pushdecl in
3737 turn called duplicate_decls when it discovered that another
3738 declaration of a global function with the same name already
3741 o Here, in duplicate_decls, we decided to clobber newdecl.
3743 If we're going to do that, we'd better make sure that
3744 olddecl, and not newdecl, is on the list of
3745 instantiations so that if we try to do the instantiation
3746 again we won't get the clobbered declaration. */
3748 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3749 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3751 for (; decls
; decls
= TREE_CHAIN (decls
))
3752 if (TREE_VALUE (decls
) == newdecl
)
3753 TREE_VALUE (decls
) = olddecl
;
3758 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3759 (char *) olddecl
+ sizeof (struct tree_common
),
3760 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3761 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3764 DECL_UID (olddecl
) = olddecl_uid
;
3766 DECL_FRIEND_P (olddecl
) = 1;
3768 /* NEWDECL contains the merged attribute lists.
3769 Update OLDDECL to be the same. */
3770 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3775 /* Record a decl-node X as belonging to the current lexical scope.
3776 Check for errors (such as an incompatible declaration for the same
3777 name already seen in the same scope).
3779 Returns either X or an old decl for the same name.
3780 If an old decl is returned, it may have been smashed
3781 to agree with what X says. */
3789 int need_new_binding
;
3791 /* We shouldn't be calling pushdecl when we're generating RTL for a
3792 function that we already did semantic analysis on previously. */
3793 my_friendly_assert (!cfun
|| doing_semantic_analysis_p (),
3796 need_new_binding
= 1;
3798 if (DECL_TEMPLATE_PARM_P (x
))
3799 /* Template parameters have no context; they are not X::T even
3800 when declared within a class or namespace. */
3804 if (current_function_decl
&& x
!= current_function_decl
3805 /* A local declaration for a function doesn't constitute
3807 && !(TREE_CODE (x
) == FUNCTION_DECL
&& !DECL_INITIAL (x
))
3808 /* A local declaration for an `extern' variable is in the
3809 scope of the current namespace, not the current
3811 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
3812 && !DECL_CONTEXT (x
))
3813 DECL_CONTEXT (x
) = current_function_decl
;
3815 /* If this is the declaration for a namespace-scope function,
3816 but the declaration itself is in a local scope, mark the
3818 if (TREE_CODE (x
) == FUNCTION_DECL
3819 && DECL_NAMESPACE_SCOPE_P (x
)
3820 && current_function_decl
3821 && x
!= current_function_decl
)
3822 DECL_LOCAL_FUNCTION_P (x
) = 1;
3825 name
= DECL_NAME (x
);
3828 int different_binding_level
= 0;
3830 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3831 name
= TREE_OPERAND (name
, 0);
3833 /* In case this decl was explicitly namespace-qualified, look it
3834 up in its namespace context. */
3835 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
)
3836 && namespace_bindings_p ())
3837 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3839 t
= lookup_name_current_level (name
);
3841 /* [basic.link] If there is a visible declaration of an entity
3842 with linkage having the same name and type, ignoring entities
3843 declared outside the innermost enclosing namespace scope, the
3844 block scope declaration declares that same entity and
3845 receives the linkage of the previous declaration. */
3846 if (! t
&& current_function_decl
&& x
!= current_function_decl
3847 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
3848 && DECL_EXTERNAL (x
))
3850 /* Look in block scope. */
3851 t
= IDENTIFIER_VALUE (name
);
3852 /* Or in the innermost namespace. */
3854 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3855 /* Does it have linkage? */
3856 if (t
&& ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
3859 different_binding_level
= 1;
3862 /* If we are declaring a function, and the result of name-lookup
3863 was an OVERLOAD, look for an overloaded instance that is
3864 actually the same as the function we are declaring. (If
3865 there is one, we have to merge our declaration with the
3866 previous declaration.) */
3867 if (t
&& TREE_CODE (t
) == OVERLOAD
)
3871 if (TREE_CODE (x
) == FUNCTION_DECL
)
3872 for (match
= t
; match
; match
= OVL_NEXT (match
))
3874 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t
))
3875 == DECL_ASSEMBLER_NAME (x
))
3879 /* Just choose one. */
3883 t
= OVL_CURRENT (match
);
3888 if (t
== error_mark_node
)
3890 /* error_mark_node is 0 for a while during initialization! */
3892 cp_error_at ("`%#D' used prior to declaration", x
);
3894 else if (t
!= NULL_TREE
)
3896 if (different_binding_level
)
3898 if (decls_match (x
, t
))
3899 /* The standard only says that the local extern
3900 inherits linkage from the previous decl; in
3901 particular, default args are not shared. It would
3902 be nice to propagate inlining info, though. FIXME. */
3903 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
3905 else if (TREE_CODE (t
) == PARM_DECL
)
3907 if (DECL_CONTEXT (t
) == NULL_TREE
)
3908 fatal ("parse errors have confused me too much");
3910 /* Check for duplicate params. */
3911 if (duplicate_decls (x
, t
))
3914 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
3915 || DECL_FUNCTION_TEMPLATE_P (x
))
3916 && is_overloaded_fn (t
))
3917 /* Don't do anything just yet. */;
3918 else if (t
== wchar_decl_node
)
3920 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3921 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3923 /* Throw away the redeclaration. */
3926 else if (TREE_CODE (t
) != TREE_CODE (x
))
3928 if (duplicate_decls (x
, t
))
3931 else if (duplicate_decls (x
, t
))
3933 if (TREE_CODE (t
) == TYPE_DECL
)
3934 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3935 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3936 check_default_args (t
);
3940 else if (DECL_MAIN_P (x
))
3942 /* A redeclaration of main, but not a duplicate of the
3947 This function shall not be overloaded. */
3948 cp_error_at ("invalid redeclaration of `%D'", t
);
3949 cp_error ("as `%D'", x
);
3950 /* We don't try to push this declaration since that
3956 check_template_shadow (x
);
3958 /* If this is a function conjured up by the backend, massage it
3959 so it looks friendly. */
3960 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
3962 retrofit_lang_decl (x
);
3963 DECL_LANGUAGE (x
) = lang_c
;
3966 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
3968 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3971 if (!namespace_bindings_p ())
3972 /* We do not need to create a binding for this name;
3973 push_overloaded_decl will have already done so if
3975 need_new_binding
= 0;
3977 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3979 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
3981 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
3985 /* If declaring a type as a typedef, copy the type (unless we're
3986 at line 0), and install this TYPE_DECL as the new type's typedef
3987 name. See the extensive comment in ../c-decl.c (pushdecl). */
3988 if (TREE_CODE (x
) == TYPE_DECL
)
3990 tree type
= TREE_TYPE (x
);
3991 if (DECL_SOURCE_LINE (x
) == 0)
3993 if (TYPE_NAME (type
) == 0)
3994 TYPE_NAME (type
) = x
;
3996 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3997 /* We don't want to copy the type when all we're
3998 doing is making a TYPE_DECL for the purposes of
4000 && (!TYPE_NAME (type
)
4001 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
4003 DECL_ORIGINAL_TYPE (x
) = type
;
4004 type
= build_type_copy (type
);
4005 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
4006 TYPE_NAME (type
) = x
;
4007 TREE_TYPE (x
) = type
;
4010 if (type
!= error_mark_node
4012 && TYPE_IDENTIFIER (type
))
4013 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
4014 current_binding_level
);
4018 /* Multiple external decls of the same identifier ought to match.
4020 We get warnings about inline functions where they are defined.
4021 We get warnings about other functions from push_overloaded_decl.
4023 Avoid duplicate warnings where they are used. */
4024 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
4028 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
4029 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
4030 decl
= OVL_FUNCTION (decl
);
4032 if (decl
&& decl
!= error_mark_node
4033 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
4034 /* If different sort of thing, we already gave an error. */
4035 && TREE_CODE (decl
) == TREE_CODE (x
)
4036 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4038 cp_pedwarn ("type mismatch with previous external decl", x
);
4039 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4043 /* This name is new in its binding level.
4044 Install the new declaration and return it. */
4045 if (namespace_bindings_p ())
4047 /* Install a global value. */
4049 /* If the first global decl has external linkage,
4050 warn if we later see static one. */
4051 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4052 TREE_PUBLIC (name
) = 1;
4054 /* Bind the mangled name for the entity. In the future, we
4055 should not need to do this; mangled names are an
4056 implementation detail of which the front-end should not
4057 need to be aware. */
4058 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4060 /* For an ordinary function, we create a binding from
4061 the mangled name (i.e., NAME) to the DECL. But, for
4062 an `extern "C"' function, the mangled name and the
4063 ordinary name are the same so we need not do this. */
4064 && !DECL_EXTERN_C_FUNCTION_P (x
))
4068 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
4069 || TREE_CODE (x
) == NAMESPACE_DECL
)
4070 mangled_name
= name
;
4072 mangled_name
= DECL_ASSEMBLER_NAME (x
);
4074 if (TREE_CODE (x
) == FUNCTION_DECL
)
4076 ((IDENTIFIER_GLOBAL_VALUE (mangled_name
) == NULL_TREE
)
4077 || (IDENTIFIER_GLOBAL_VALUE (mangled_name
) == x
), 378);
4078 SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name
, x
);
4081 /* Don't forget if the function was used via an implicit decl. */
4082 if (IDENTIFIER_IMPLICIT_DECL (name
)
4083 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4086 /* Don't forget if its address was taken in that way. */
4087 if (IDENTIFIER_IMPLICIT_DECL (name
)
4088 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4089 TREE_ADDRESSABLE (x
) = 1;
4091 /* Warn about mismatches against previous implicit decl. */
4092 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4093 /* If this real decl matches the implicit, don't complain. */
4094 && ! (TREE_CODE (x
) == FUNCTION_DECL
4095 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4097 ("`%D' was previously implicitly declared to return `int'", x
);
4099 /* If new decl is `static' and an `extern' was seen previously,
4101 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4102 warn_extern_redeclared_static (x
, t
);
4106 /* Here to install a non-global value. */
4107 tree oldlocal
= IDENTIFIER_VALUE (name
);
4108 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4110 if (need_new_binding
)
4112 push_local_binding (name
, x
, 0);
4113 /* Because push_local_binding will hook X on to the
4114 current_binding_level's name list, we don't want to
4115 do that again below. */
4116 need_new_binding
= 0;
4119 /* If this is a TYPE_DECL, push it into the type value slot. */
4120 if (TREE_CODE (x
) == TYPE_DECL
)
4121 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4122 current_binding_level
);
4124 /* Clear out any TYPE_DECL shadowed by a namespace so that
4125 we won't think this is a type. The C struct hack doesn't
4126 go through namespaces. */
4127 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4128 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4129 current_binding_level
);
4136 && TREE_CODE (oldlocal
) == VAR_DECL
4137 && DECL_DEAD_FOR_LOCAL (oldlocal
))
4138 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
4140 if (oldlocal
== NULL_TREE
)
4141 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
4144 /* If this is an extern function declaration, see if we
4145 have a global definition or declaration for the function. */
4146 if (oldlocal
== NULL_TREE
4147 && DECL_EXTERNAL (x
)
4148 && oldglobal
!= NULL_TREE
4149 && TREE_CODE (x
) == FUNCTION_DECL
4150 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4152 /* We have one. Their types must agree. */
4153 if (decls_match (x
, oldglobal
))
4157 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4158 cp_warning_at ("global declaration `%#D'", oldglobal
);
4161 /* If we have a local external declaration,
4162 and no file-scope declaration has yet been seen,
4163 then if we later have a file-scope decl it must not be static. */
4164 if (oldlocal
== NULL_TREE
4165 && oldglobal
== NULL_TREE
4166 && DECL_EXTERNAL (x
)
4168 TREE_PUBLIC (name
) = 1;
4170 /* Warn if shadowing an argument at the top level of the body. */
4171 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4172 /* Inline decls shadow nothing. */
4173 && !DECL_FROM_INLINE (x
)
4174 && TREE_CODE (oldlocal
) == PARM_DECL
4175 /* Don't complain if it's from an enclosing function. */
4176 && DECL_CONTEXT (oldlocal
) == current_function_decl
4177 && TREE_CODE (x
) != PARM_DECL
)
4179 /* Go to where the parms should be and see if we
4181 struct binding_level
*b
= current_binding_level
->level_chain
;
4187 if (b
->parm_flag
== 1)
4188 cp_error ("declaration of `%#D' shadows a parameter", name
);
4191 /* Maybe warn if shadowing something else. */
4192 if (warn_shadow
&& !DECL_EXTERNAL (x
)
4193 /* Inline decls shadow nothing. */
4194 && !DECL_FROM_INLINE (x
)
4195 /* No shadow warnings for internally generated vars. */
4196 && ! DECL_ARTIFICIAL (x
)
4197 /* No shadow warnings for vars made for inlining. */
4198 && ! DECL_FROM_INLINE (x
))
4200 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4201 warning ("declaration of `%s' shadows a parameter",
4202 IDENTIFIER_POINTER (name
));
4203 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4204 && current_class_ptr
4205 && !TREE_STATIC (name
))
4206 warning ("declaration of `%s' shadows a member of `this'",
4207 IDENTIFIER_POINTER (name
));
4208 else if (oldlocal
!= NULL_TREE
)
4209 warning ("declaration of `%s' shadows previous local",
4210 IDENTIFIER_POINTER (name
));
4211 else if (oldglobal
!= NULL_TREE
)
4212 /* XXX shadow warnings in outer-more namespaces */
4213 warning ("declaration of `%s' shadows global declaration",
4214 IDENTIFIER_POINTER (name
));
4218 if (TREE_CODE (x
) == FUNCTION_DECL
)
4219 check_default_args (x
);
4221 /* Keep count of variables in this level with incomplete type. */
4222 if (TREE_CODE (x
) == VAR_DECL
4223 && TREE_TYPE (x
) != error_mark_node
4224 && ((!COMPLETE_TYPE_P (TREE_TYPE (x
))
4225 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4226 /* RTTI TD entries are created while defining the type_info. */
4227 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4228 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4230 if (namespace_bindings_p ())
4231 namespace_scope_incomplete
4232 = tree_cons (NULL_TREE
, x
, namespace_scope_incomplete
);
4234 current_binding_level
->incomplete
4235 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4239 if (need_new_binding
)
4240 add_decl_to_level (x
,
4241 DECL_NAMESPACE_SCOPE_P (x
)
4242 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
4243 : current_binding_level
);
4248 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4249 caller to set DECL_CONTEXT properly. */
4252 pushdecl_with_scope (x
, level
)
4254 struct binding_level
*level
;
4256 register struct binding_level
*b
;
4257 tree function_decl
= current_function_decl
;
4259 current_function_decl
= NULL_TREE
;
4260 if (level
->parm_flag
== 2)
4262 b
= class_binding_level
;
4263 class_binding_level
= level
;
4264 pushdecl_class_level (x
);
4265 class_binding_level
= b
;
4269 b
= current_binding_level
;
4270 current_binding_level
= level
;
4272 current_binding_level
= b
;
4274 current_function_decl
= function_decl
;
4278 /* Like pushdecl, only it places X in the current namespace,
4282 pushdecl_namespace_level (x
)
4285 register struct binding_level
*b
= current_binding_level
;
4288 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4290 /* Now, the type_shadowed stack may screw us. Munge it so it does
4292 if (TREE_CODE (x
) == TYPE_DECL
)
4294 tree name
= DECL_NAME (x
);
4296 tree
*ptr
= (tree
*)0;
4297 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4299 tree shadowed
= b
->type_shadowed
;
4300 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4301 if (TREE_PURPOSE (shadowed
) == name
)
4303 ptr
= &TREE_VALUE (shadowed
);
4304 /* Can't break out of the loop here because sometimes
4305 a binding level will have duplicate bindings for
4306 PT names. It's gross, but I haven't time to fix it. */
4309 newval
= TREE_TYPE (x
);
4310 if (ptr
== (tree
*)0)
4312 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4313 up here if this is changed to an assertion. --KR */
4314 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4324 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4328 pushdecl_top_level (x
)
4331 push_to_top_level ();
4332 x
= pushdecl_namespace_level (x
);
4333 pop_from_top_level ();
4337 /* Make the declaration of X appear in CLASS scope. */
4340 pushdecl_class_level (x
)
4343 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4344 scope looks for the pre-mangled name. */
4347 if (TREE_CODE (x
) == OVERLOAD
)
4348 x
= OVL_CURRENT (x
);
4349 name
= DECL_NAME (x
);
4353 push_class_level_binding (name
, x
);
4354 if (TREE_CODE (x
) == TYPE_DECL
)
4355 set_identifier_type_value (name
, TREE_TYPE (x
));
4357 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4361 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4364 pushdecl_class_level (f
);
4368 /* Enter DECL into the symbol table, if that's appropriate. Returns
4369 DECL, or a modified version thereof. */
4372 maybe_push_decl (decl
)
4375 tree type
= TREE_TYPE (decl
);
4377 /* Add this decl to the current binding level, but not if it comes
4378 from another scope, e.g. a static member variable. TEM may equal
4379 DECL or it may be a previous decl of the same name. */
4380 if (decl
== error_mark_node
4381 || (TREE_CODE (decl
) != PARM_DECL
4382 && DECL_CONTEXT (decl
) != NULL_TREE
4383 /* Definitions of namespace members outside their namespace are
4385 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4386 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4387 || TREE_CODE (type
) == UNKNOWN_TYPE
4388 /* The declaration of a template specialization does not affect
4389 the functions available for overload resolution, so we do not
4391 || (TREE_CODE (decl
) == FUNCTION_DECL
4392 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4395 return pushdecl (decl
);
4398 /* Make the declaration(s) of X appear in CLASS scope
4399 under the name NAME. */
4402 push_class_level_binding (name
, x
)
4407 /* The class_binding_level will be NULL if x is a template
4408 parameter name in a member template. */
4409 if (!class_binding_level
)
4412 /* Make sure that this new member does not have the same name
4413 as a template parameter. */
4414 if (TYPE_BEING_DEFINED (current_class_type
))
4415 check_template_shadow (x
);
4417 /* If this declaration shadows a declaration from an enclosing
4418 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4419 we leave this class. Record the shadowed declaration here. */
4420 binding
= IDENTIFIER_BINDING (name
);
4422 && ((TREE_CODE (x
) == OVERLOAD
4423 && BINDING_VALUE (binding
)
4424 && is_overloaded_fn (BINDING_VALUE (binding
)))
4425 || INHERITED_VALUE_BINDING_P (binding
)))
4430 /* If the old binding was from a base class, and was for a tag
4431 name, slide it over to make room for the new binding. The
4432 old binding is still visible if explicitly qualified with a
4434 if (INHERITED_VALUE_BINDING_P (binding
)
4435 && BINDING_VALUE (binding
)
4436 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4437 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4438 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4440 old_decl
= BINDING_TYPE (binding
);
4441 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4442 BINDING_VALUE (binding
) = NULL_TREE
;
4443 INHERITED_VALUE_BINDING_P (binding
) = 0;
4446 old_decl
= BINDING_VALUE (binding
);
4448 /* There was already a binding for X containing fewer
4449 functions than are named in X. Find the previous
4450 declaration of X on the class-shadowed list, and update it. */
4451 for (shadow
= class_binding_level
->class_shadowed
;
4453 shadow
= TREE_CHAIN (shadow
))
4454 if (TREE_PURPOSE (shadow
) == name
4455 && TREE_TYPE (shadow
) == old_decl
)
4457 BINDING_VALUE (binding
) = x
;
4458 INHERITED_VALUE_BINDING_P (binding
) = 0;
4459 TREE_TYPE (shadow
) = x
;
4464 /* If we didn't replace an existing binding, put the binding on the
4465 stack of bindings for the identifier, and update
4466 IDENTIFIER_CLASS_VALUE. */
4467 if (push_class_binding (name
, x
))
4469 class_binding_level
->class_shadowed
4470 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4471 class_binding_level
->class_shadowed
);
4472 /* Record the value we are binding NAME to so that we can know
4473 what to pop later. */
4474 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4478 /* Insert another USING_DECL into the current binding level, returning
4479 this declaration. If this is a redeclaration, do nothing, and
4480 return NULL_TREE if this not in namespace scope (in namespace
4481 scope, a using decl might extend any previous bindings). */
4484 push_using_decl (scope
, name
)
4490 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4491 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4492 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4493 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4496 return namespace_bindings_p () ? decl
: NULL_TREE
;
4497 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4498 DECL_INITIAL (decl
) = scope
;
4499 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4500 current_binding_level
->usings
= decl
;
4504 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4505 changed (i.e. there was already a directive), or the fresh
4506 TREE_LIST otherwise. */
4509 push_using_directive (used
)
4512 tree ud
= current_binding_level
->using_directives
;
4513 tree iter
, ancestor
;
4515 /* Check if we already have this. */
4516 if (purpose_member (used
, ud
) != NULL_TREE
)
4519 /* Recursively add all namespaces used. */
4520 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4521 push_using_directive (TREE_PURPOSE (iter
));
4523 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4524 ud
= current_binding_level
->using_directives
;
4525 ud
= tree_cons (used
, ancestor
, ud
);
4526 current_binding_level
->using_directives
= ud
;
4530 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4531 other definitions already in place. We get around this by making
4532 the value of the identifier point to a list of all the things that
4533 want to be referenced by that name. It is then up to the users of
4534 that name to decide what to do with that list.
4536 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4537 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4539 FLAGS is a bitwise-or of the following values:
4540 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4542 PUSH_USING: DECL is being pushed as the result of a using
4545 The value returned may be a previous declaration if we guessed wrong
4546 about what language DECL should belong to (C or C++). Otherwise,
4547 it's always DECL (and never something that's not a _DECL). */
4550 push_overloaded_decl (decl
, flags
)
4554 tree name
= DECL_NAME (decl
);
4557 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4560 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4562 old
= lookup_name_current_level (name
);
4566 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4568 tree t
= TREE_TYPE (old
);
4569 if (IS_AGGR_TYPE (t
) && warn_shadow
4570 && (! DECL_IN_SYSTEM_HEADER (decl
)
4571 || ! DECL_IN_SYSTEM_HEADER (old
)))
4572 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4575 else if (is_overloaded_fn (old
))
4579 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4581 tree fn
= OVL_CURRENT (tmp
);
4583 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4584 && !(flags
& PUSH_USING
)
4585 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4586 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4587 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4590 if (duplicate_decls (decl
, fn
))
4594 else if (old
== error_mark_node
)
4595 /* Ignore the undefined symbol marker. */
4599 cp_error_at ("previous non-function declaration `%#D'", old
);
4600 cp_error ("conflicts with function declaration `%#D'", decl
);
4605 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4607 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4608 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4610 new_binding
= ovl_cons (decl
, old
);
4611 if (flags
& PUSH_USING
)
4612 OVL_USED (new_binding
) = 1;
4615 /* NAME is not ambiguous. */
4619 set_namespace_binding (name
, current_namespace
, new_binding
);
4622 /* We only create an OVERLOAD if there was a previous binding at
4623 this level, or if decl is a template. In the former case, we
4624 need to remove the old binding and replace it with the new
4625 binding. We must also run through the NAMES on the binding
4626 level where the name was bound to update the chain. */
4628 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4632 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4634 d
= &TREE_CHAIN (*d
))
4636 || (TREE_CODE (*d
) == TREE_LIST
4637 && TREE_VALUE (*d
) == old
))
4639 if (TREE_CODE (*d
) == TREE_LIST
)
4640 /* Just replace the old binding with the new. */
4641 TREE_VALUE (*d
) = new_binding
;
4643 /* Build a TREE_LIST to wrap the OVERLOAD. */
4644 *d
= tree_cons (NULL_TREE
, new_binding
,
4647 /* And update the CPLUS_BINDING node. */
4648 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4653 /* We should always find a previous binding in this case. */
4654 my_friendly_abort (0);
4657 /* Install the new binding. */
4658 push_local_binding (name
, new_binding
, flags
);
4664 /* Generate an implicit declaration for identifier FUNCTIONID
4665 as a function of type int (). Print a warning if appropriate. */
4668 implicitly_declare (functionid
)
4673 /* We used to reuse an old implicit decl here,
4674 but this loses with inline functions because it can clobber
4675 the saved decl chains. */
4676 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4678 DECL_EXTERNAL (decl
) = 1;
4679 TREE_PUBLIC (decl
) = 1;
4681 /* ISO standard says implicit declarations are in the innermost block.
4682 So we record the decl in the standard fashion. */
4684 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4687 /* Only one warning per identifier. */
4688 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4690 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4693 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4698 /* Return zero if the declaration NEWDECL is valid
4699 when the declaration OLDDECL (assumed to be for the same name)
4700 has already been seen.
4701 Otherwise return an error message format string with a %s
4702 where the identifier should go. */
4705 redeclaration_error_message (newdecl
, olddecl
)
4706 tree newdecl
, olddecl
;
4708 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4710 /* Because C++ can put things into name space for free,
4711 constructs like "typedef struct foo { ... } foo"
4712 would look like an erroneous redeclaration. */
4713 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4716 return "redefinition of `%#D'";
4718 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4720 /* If this is a pure function, its olddecl will actually be
4721 the original initialization to `0' (which we force to call
4722 abort()). Don't complain about redefinition in this case. */
4723 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
))
4726 /* If both functions come from different namespaces, this is not
4727 a redeclaration - this is a conflict with a used function. */
4728 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4729 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4730 return "`%D' conflicts with used function";
4732 /* We'll complain about linkage mismatches in
4733 warn_extern_redeclared_static. */
4735 /* Defining the same name twice is no good. */
4736 if (DECL_INITIAL (olddecl
) != NULL_TREE
4737 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4739 if (DECL_NAME (olddecl
) == NULL_TREE
)
4740 return "`%#D' not declared in class";
4742 return "redefinition of `%#D'";
4746 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4748 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4749 && (DECL_TEMPLATE_RESULT (newdecl
)
4750 != DECL_TEMPLATE_RESULT (olddecl
))
4751 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4752 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4753 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4754 && COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
4755 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
))))
4756 return "redefinition of `%#D'";
4759 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
4761 /* Objects declared at top level: */
4762 /* If at least one is a reference, it's ok. */
4763 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4765 /* Reject two definitions. */
4766 return "redefinition of `%#D'";
4770 /* Objects declared with block scope: */
4771 /* Reject two definitions, and reject a definition
4772 together with an external reference. */
4773 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4774 return "redeclaration of `%#D'";
4779 /* Create a new label, named ID. */
4782 make_label_decl (id
, local_p
)
4788 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4790 /* Make sure every label has an rtx. */
4793 DECL_CONTEXT (decl
) = current_function_decl
;
4794 DECL_MODE (decl
) = VOIDmode
;
4795 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4797 /* Say where one reference is to the label, for the sake of the
4798 error if it is not defined. */
4799 DECL_SOURCE_LINE (decl
) = lineno
;
4800 DECL_SOURCE_FILE (decl
) = input_filename
;
4802 /* Record the fact that this identifier is bound to this label. */
4803 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4808 /* Record this label on the list of used labels so that we can check
4809 at the end of the function to see whether or not the label was
4810 actually defined, and so we can check when the label is defined whether
4811 this use is valid. */
4817 if (named_label_uses
== NULL
4818 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4819 || named_label_uses
->label_decl
!= decl
)
4821 struct named_label_use_list
*new_ent
;
4822 new_ent
= ((struct named_label_use_list
*)
4823 ggc_alloc (sizeof (struct named_label_use_list
)));
4824 new_ent
->label_decl
= decl
;
4825 new_ent
->names_in_scope
= current_binding_level
->names
;
4826 new_ent
->binding_level
= current_binding_level
;
4827 new_ent
->lineno_o_goto
= lineno
;
4828 new_ent
->filename_o_goto
= input_filename
;
4829 new_ent
->next
= named_label_uses
;
4830 named_label_uses
= new_ent
;
4834 /* Look for a label named ID in the current function. If one cannot
4835 be found, create one. (We keep track of used, but undefined,
4836 labels, and complain about them at the end of a function.) */
4843 struct named_label_list
*ent
;
4845 /* You can't use labels at global scope. */
4846 if (current_function_decl
== NULL_TREE
)
4848 error ("label `%s' referenced outside of any function",
4849 IDENTIFIER_POINTER (id
));
4853 /* See if we've already got this label. */
4854 decl
= IDENTIFIER_LABEL_VALUE (id
);
4855 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4858 /* Record this label on the list of labels used in this function.
4859 We do this before calling make_label_decl so that we get the
4860 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4861 ent
= ((struct named_label_list
*)
4862 ggc_alloc_cleared (sizeof (struct named_label_list
)));
4863 ent
->old_value
= IDENTIFIER_LABEL_VALUE (id
);
4864 ent
->next
= named_labels
;
4867 /* We need a new label. */
4868 decl
= make_label_decl (id
, /*local_p=*/0);
4870 /* Now fill in the information we didn't have before. */
4871 ent
->label_decl
= decl
;
4876 /* Declare a local label named ID. */
4879 declare_local_label (id
)
4884 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4885 this scope we can restore the old value of
4886 IDENTIFIER_TYPE_VALUE. */
4887 current_binding_level
->shadowed_labels
4888 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4889 current_binding_level
->shadowed_labels
);
4890 /* Look for the label. */
4891 decl
= make_label_decl (id
, /*local_p=*/1);
4892 /* Now fill in the information we didn't have before. */
4893 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4898 /* Returns nonzero if it is ill-formed to jump past the declaration of
4899 DECL. Returns 2 if it's also a real problem. */
4902 decl_jump_unsafe (decl
)
4905 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
4908 if (DECL_INITIAL (decl
) == NULL_TREE
4909 && pod_type_p (TREE_TYPE (decl
)))
4912 /* This is really only important if we're crossing an initialization.
4913 The POD stuff is just pedantry; why should it matter if the class
4914 contains a field of pointer to member type? */
4915 if (DECL_INITIAL (decl
)
4916 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
4921 /* Check that a single previously seen jump to a newly defined label
4922 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4923 the jump context; NAMES are the names in scope in LEVEL at the jump
4924 context; FILE and LINE are the source position of the jump or 0. */
4927 check_previous_goto_1 (decl
, level
, names
, file
, line
)
4929 struct binding_level
*level
;
4936 struct binding_level
*b
= current_binding_level
;
4937 for (; b
; b
= b
->level_chain
)
4939 tree new_decls
= b
->names
;
4940 tree old_decls
= (b
== level
? names
: NULL_TREE
);
4941 for (; new_decls
!= old_decls
;
4942 new_decls
= TREE_CHAIN (new_decls
))
4944 int problem
= decl_jump_unsafe (new_decls
);
4951 cp_pedwarn ("jump to label `%D'", decl
);
4953 pedwarn ("jump to case label");
4956 pedwarn_with_file_and_line (file
, line
, " from here");
4960 if (problem
> 1 && DECL_ARTIFICIAL (new_decls
))
4961 /* Can't skip init of __exception_info. */
4962 cp_error_at (" enters catch block", new_decls
);
4963 else if (problem
> 1)
4964 cp_error_at (" crosses initialization of `%#D'",
4967 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4973 if (b
->eh_region
&& ! saw_eh
)
4978 cp_pedwarn ("jump to label `%D'", decl
);
4980 pedwarn ("jump to case label");
4983 pedwarn_with_file_and_line (file
, line
, " from here");
4986 error (" enters try block");
4993 check_previous_goto (use
)
4994 struct named_label_use_list
*use
;
4996 check_previous_goto_1 (use
->label_decl
, use
->binding_level
,
4997 use
->names_in_scope
, use
->filename_o_goto
,
4998 use
->lineno_o_goto
);
5002 check_switch_goto (level
)
5003 struct binding_level
*level
;
5005 check_previous_goto_1 (NULL_TREE
, level
, level
->names
, NULL
, 0);
5008 /* Check that any previously seen jumps to a newly defined label DECL
5009 are OK. Called by define_label. */
5012 check_previous_gotos (decl
)
5015 struct named_label_use_list
**usep
;
5017 if (! TREE_USED (decl
))
5020 for (usep
= &named_label_uses
; *usep
; )
5022 struct named_label_use_list
*use
= *usep
;
5023 if (use
->label_decl
== decl
)
5025 check_previous_goto (use
);
5029 usep
= &(use
->next
);
5033 /* Check that a new jump to a label DECL is OK. Called by
5034 finish_goto_stmt. */
5042 struct named_label_list
*lab
;
5044 /* We can't know where a computed goto is jumping. So we assume
5046 if (! DECL_P (decl
))
5049 /* If the label hasn't been defined yet, defer checking. */
5050 if (! DECL_INITIAL (decl
))
5056 for (lab
= named_labels
; lab
; lab
= lab
->next
)
5057 if (decl
== lab
->label_decl
)
5060 /* If the label is not on named_labels it's a gcc local label, so
5061 it must be in an outer scope, so jumping to it is always OK. */
5065 if ((lab
->eh_region
|| lab
->bad_decls
) && !identified
)
5067 cp_pedwarn_at ("jump to label `%D'", decl
);
5068 pedwarn (" from here");
5072 for (bad
= lab
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
5074 tree b
= TREE_VALUE (bad
);
5075 int u
= decl_jump_unsafe (b
);
5077 if (u
> 1 && DECL_ARTIFICIAL (b
))
5078 /* Can't skip init of __exception_info. */
5079 cp_error_at (" enters catch block", b
);
5081 cp_error_at (" skips initialization of `%#D'", b
);
5083 cp_pedwarn_at (" enters scope of non-POD `%#D'", b
);
5087 error (" enters try block");
5090 /* Define a label, specifying the location in the source file.
5091 Return the LABEL_DECL node for the label, if the definition is valid.
5092 Otherwise return 0. */
5095 define_label (filename
, line
, name
)
5096 const char *filename
;
5100 tree decl
= lookup_label (name
);
5101 struct named_label_list
*ent
;
5103 for (ent
= named_labels
; ent
; ent
= ent
->next
)
5104 if (ent
->label_decl
== decl
)
5107 /* After labels, make any new cleanups go into their
5108 own new (temporary) binding contour. */
5109 current_binding_level
->more_cleanups_ok
= 0;
5111 if (name
== get_identifier ("wchar_t"))
5112 cp_pedwarn ("label named wchar_t");
5114 if (DECL_INITIAL (decl
) != NULL_TREE
)
5116 cp_error ("duplicate label `%D'", decl
);
5121 /* Mark label as having been defined. */
5122 DECL_INITIAL (decl
) = error_mark_node
;
5123 /* Say where in the source. */
5124 DECL_SOURCE_FILE (decl
) = filename
;
5125 DECL_SOURCE_LINE (decl
) = line
;
5128 ent
->names_in_scope
= current_binding_level
->names
;
5129 ent
->binding_level
= current_binding_level
;
5131 check_previous_gotos (decl
);
5132 current_function_return_value
= NULL_TREE
;
5139 struct binding_level
*level
;
5140 struct cp_switch
*next
;
5141 /* The SWITCH_STMT being built. */
5143 /* A splay-tree mapping the low element of a case range to the high
5144 element, or NULL_TREE if there is no high element. Used to
5145 determine whether or not a new case label duplicates an old case
5146 label. We need a tree, rather than simply a hash table, because
5147 of the GNU case range extension. */
5151 /* A stack of the currently active switch statements. The innermost
5152 switch statement is on the top of the stack. There is no need to
5153 mark the stack for garbage collection because it is only active
5154 during the processing of the body of a function, and we never
5155 collect at that point. */
5157 static struct cp_switch
*switch_stack
;
5159 /* Called right after a switch-statement condition is parsed.
5160 SWITCH_STMT is the switch statement being parsed. */
5163 push_switch (switch_stmt
)
5167 = (struct cp_switch
*) xmalloc (sizeof (struct cp_switch
));
5168 p
->level
= current_binding_level
;
5169 p
->next
= switch_stack
;
5170 p
->switch_stmt
= switch_stmt
;
5171 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
5178 struct cp_switch
*cs
;
5181 splay_tree_delete (cs
->cases
);
5182 switch_stack
= switch_stack
->next
;
5186 /* Note that we've seen a definition of a case label, and complain if this
5187 is a bad place for one. */
5190 finish_case_label (low_value
, high_value
)
5199 error ("case label not within a switch statement");
5201 cp_error ("case label `%E' not within a switch statement",
5204 error ("`default' label not within a switch statement");
5208 if (processing_template_decl
)
5212 /* For templates, just add the case label; we'll do semantic
5213 analysis at instantiation-time. */
5214 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5215 add_stmt (build_case_label (low_value
, high_value
, label
));
5219 /* Find the condition on which this switch statement depends. */
5220 cond
= SWITCH_COND (switch_stack
->switch_stmt
);
5221 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
5222 cond
= TREE_VALUE (cond
);
5224 c_add_case_label (switch_stack
->cases
, cond
, low_value
, high_value
);
5226 check_switch_goto (switch_stack
->level
);
5228 /* After labels, make any new cleanups go into their
5229 own new (temporary) binding contour. */
5230 current_binding_level
->more_cleanups_ok
= 0;
5231 current_function_return_value
= NULL_TREE
;
5234 /* Return the list of declarations of the current level.
5235 Note that this list is in reverse order unless/until
5236 you nreverse it; and when you do nreverse it, you must
5237 store the result back using `storedecls' or you will lose. */
5242 return current_binding_level
->names
;
5245 /* Return the list of type-tags (for structs, etc) of the current level. */
5250 return current_binding_level
->tags
;
5253 /* Store the list of declarations of the current level.
5254 This is done for the parameter declarations of a function being defined,
5255 after they are modified in the light of any missing parameters. */
5261 current_binding_level
->names
= decls
;
5264 /* Similarly, store the list of tags of the current level. */
5270 current_binding_level
->tags
= tags
;
5273 /* Given NAME, an IDENTIFIER_NODE,
5274 return the structure (or union or enum) definition for that name.
5275 Searches binding levels from BINDING_LEVEL up to the global level.
5276 If THISLEVEL_ONLY is nonzero, searches only the specified context
5277 (but skips any tag-transparent contexts to find one that is
5278 meaningful for tags).
5279 FORM says which kind of type the caller wants;
5280 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5281 If the wrong kind of type is found, and it's not a template, an error is
5285 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5286 enum tree_code form
;
5288 struct binding_level
*binding_level
;
5291 register struct binding_level
*level
;
5292 /* Non-zero if, we should look past a template parameter level, even
5293 if THISLEVEL_ONLY. */
5294 int allow_template_parms_p
= 1;
5296 for (level
= binding_level
; level
; level
= level
->level_chain
)
5299 if (ANON_AGGRNAME_P (name
))
5300 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5302 /* There's no need for error checking here, because
5303 anon names are unique throughout the compilation. */
5304 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5305 return TREE_VALUE (tail
);
5307 else if (level
->namespace_p
)
5308 /* Do namespace lookup. */
5309 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5311 tree old
= binding_for_name (name
, tail
);
5313 /* If we just skipped past a template parameter level,
5314 even though THISLEVEL_ONLY, and we find a template
5315 class declaration, then we use the _TYPE node for the
5316 template. See the example below. */
5317 if (thislevel_only
&& !allow_template_parms_p
5318 && old
&& BINDING_VALUE (old
)
5319 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5320 old
= TREE_TYPE (BINDING_VALUE (old
));
5322 old
= BINDING_TYPE (old
);
5324 /* If it has an original type, it is a typedef, and we
5325 should not return it. */
5326 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5328 if (old
&& TREE_CODE (old
) != form
5329 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5331 cp_error ("`%#D' redeclared as %C", old
, form
);
5336 if (thislevel_only
|| tail
== global_namespace
)
5340 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5342 if (TREE_PURPOSE (tail
) == name
)
5344 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5345 /* Should tighten this up; it'll probably permit
5346 UNION_TYPE and a struct template, for example. */
5348 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5350 /* Definition isn't the kind we were looking for. */
5351 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5355 return TREE_VALUE (tail
);
5358 if (thislevel_only
&& ! level
->tag_transparent
)
5360 if (level
->template_parms_p
&& allow_template_parms_p
)
5362 /* We must deal with cases like this:
5364 template <class T> struct S;
5365 template <class T> struct S {};
5367 When looking up `S', for the second declaration, we
5368 would like to find the first declaration. But, we
5369 are in the pseudo-global level created for the
5370 template parameters, rather than the (surrounding)
5371 namespace level. Thus, we keep going one more level,
5372 even though THISLEVEL_ONLY is non-zero. */
5373 allow_template_parms_p
= 0;
5385 set_current_level_tags_transparency (tags_transparent
)
5386 int tags_transparent
;
5388 current_binding_level
->tag_transparent
= tags_transparent
;
5392 /* Given a type, find the tag that was defined for it and return the tag name.
5393 Otherwise return 0. However, the value can never be 0
5394 in the cases in which this is used.
5396 C++: If NAME is non-zero, this is the new name to install. This is
5397 done when replacing anonymous tags with real tag names. */
5400 lookup_tag_reverse (type
, name
)
5404 register struct binding_level
*level
;
5406 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5409 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5411 if (TREE_VALUE (tail
) == type
)
5414 TREE_PURPOSE (tail
) = name
;
5415 return TREE_PURPOSE (tail
);
5422 /* Look up NAME in the NAMESPACE. */
5425 lookup_namespace_name (namespace, name
)
5426 tree
namespace, name
;
5429 tree template_id
= NULL_TREE
;
5431 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5433 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5434 /* This happens for A::B<int> when B is a namespace. */
5436 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5438 /* This happens for A::B where B is a template, and there are no
5439 template arguments. */
5440 cp_error ("invalid use of `%D'", name
);
5441 return error_mark_node
;
5444 namespace = ORIGINAL_NAMESPACE (namespace);
5446 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5449 name
= TREE_OPERAND (name
, 0);
5450 if (TREE_CODE (name
) == OVERLOAD
)
5451 name
= DECL_NAME (OVL_CURRENT (name
));
5452 else if (DECL_P (name
))
5453 name
= DECL_NAME (name
);
5456 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5458 val
= make_node (CPLUS_BINDING
);
5459 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5460 return error_mark_node
;
5462 if (BINDING_VALUE (val
))
5464 val
= BINDING_VALUE (val
);
5468 if (DECL_CLASS_TEMPLATE_P (val
))
5469 val
= lookup_template_class (val
,
5470 TREE_OPERAND (template_id
, 1),
5471 /*in_decl=*/NULL_TREE
,
5472 /*context=*/NULL_TREE
,
5473 /*entering_scope=*/0);
5474 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5475 || TREE_CODE (val
) == OVERLOAD
)
5476 val
= lookup_template_function (val
,
5477 TREE_OPERAND (template_id
, 1));
5480 cp_error ("`%D::%D' is not a template",
5482 return error_mark_node
;
5486 /* If we have a single function from a using decl, pull it out. */
5487 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5488 val
= OVL_FUNCTION (val
);
5492 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5493 return error_mark_node
;
5496 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5498 static unsigned long
5506 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5507 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5512 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5515 typename_compare (k1
, k2
)
5526 d1
= TYPE_NAME (t1
);
5527 d2
= TYPE_NAME (t2
);
5529 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5530 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5531 && ((TREE_TYPE (t1
) != NULL_TREE
)
5532 == (TREE_TYPE (t2
) != NULL_TREE
))
5533 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5534 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5537 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5538 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5539 is non-NULL, this type is being created by the implicit typename
5540 extension, and BASE_TYPE is a type named `t' in some base class of
5541 `T' which depends on template parameters.
5543 Returns the new TYPENAME_TYPE. */
5546 build_typename_type (context
, name
, fullname
, base_type
)
5554 struct hash_entry
* e
;
5556 static struct hash_table ht
;
5560 static struct hash_table
*h
= &ht
;
5561 if (!hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5563 fatal ("virtual memory exhausted");
5564 ggc_add_tree_hash_table_root (&h
, 1);
5567 /* Build the TYPENAME_TYPE. */
5568 t
= make_aggr_type (TYPENAME_TYPE
);
5569 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5570 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5571 TREE_TYPE (t
) = base_type
;
5573 /* Build the corresponding TYPE_DECL. */
5574 d
= build_decl (TYPE_DECL
, name
, t
);
5575 TYPE_NAME (TREE_TYPE (d
)) = d
;
5576 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5577 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5578 DECL_ARTIFICIAL (d
) = 1;
5580 /* See if we already have this type. */
5581 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5585 /* Insert the type into the table. */
5586 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5591 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5592 unless an error occurs, in which case error_mark_node is returned.
5593 If COMPLAIN zero, don't complain about any errors that occur. */
5596 make_typename_type (context
, name
, complain
)
5604 if (!(TYPE_LANG_SPECIFIC (name
)
5605 && (CLASSTYPE_IS_TEMPLATE (name
)
5606 || CLASSTYPE_USE_TEMPLATE (name
))))
5607 name
= TYPE_IDENTIFIER (name
);
5609 /* Create a TEMPLATE_ID_EXPR for the type. */
5610 name
= build_nt (TEMPLATE_ID_EXPR
,
5611 CLASSTYPE_TI_TEMPLATE (name
),
5612 CLASSTYPE_TI_ARGS (name
));
5614 else if (TREE_CODE (name
) == TYPE_DECL
)
5615 name
= DECL_NAME (name
);
5619 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5621 name
= TREE_OPERAND (name
, 0);
5622 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5623 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5625 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5626 my_friendly_abort (2000);
5628 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5630 /* We can get here from typename_sub0 in the explicit_template_type
5631 expansion. Just fail. */
5633 cp_error ("no class template named `%#T' in `%#T'",
5635 return error_mark_node
;
5638 if (! uses_template_parms (context
)
5639 || currently_open_class (context
))
5641 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5643 tree tmpl
= NULL_TREE
;
5644 if (IS_AGGR_TYPE (context
))
5645 tmpl
= lookup_field (context
, name
, 0, 0);
5646 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5649 cp_error ("no class template named `%#T' in `%#T'",
5651 return error_mark_node
;
5654 return lookup_template_class (tmpl
,
5655 TREE_OPERAND (fullname
, 1),
5657 /*entering_scope=*/0);
5663 if (!IS_AGGR_TYPE (context
))
5666 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5667 return error_mark_node
;
5670 t
= lookup_field (context
, name
, 0, 1);
5672 return TREE_TYPE (t
);
5676 /* If the CONTEXT is not a template type, then either the field is
5677 there now or its never going to be. */
5678 if (!uses_template_parms (context
))
5681 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5682 return error_mark_node
;
5686 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5689 /* Select the right _DECL from multiple choices. */
5692 select_decl (binding
, flags
)
5697 val
= BINDING_VALUE (binding
);
5698 if (LOOKUP_NAMESPACES_ONLY (flags
))
5700 /* We are not interested in types. */
5701 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5706 /* If we could have a type and
5707 we have nothing or we need a type and have none. */
5708 if (BINDING_TYPE (binding
)
5709 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5710 && TREE_CODE (val
) != TYPE_DECL
)))
5711 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5712 /* Don't return non-types if we really prefer types. */
5713 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5714 && (TREE_CODE (val
) != TEMPLATE_DECL
5715 || !DECL_CLASS_TEMPLATE_P (val
)))
5721 /* Unscoped lookup of a global: iterate over current namespaces,
5722 considering using-directives. If SPACESP is non-NULL, store a list
5723 of the namespaces we've considered in it. */
5726 unqualified_namespace_lookup (name
, flags
, spacesp
)
5731 tree b
= make_node (CPLUS_BINDING
);
5732 tree initial
= current_decl_namespace();
5733 tree scope
= initial
;
5735 struct binding_level
*level
;
5736 tree val
= NULL_TREE
;
5739 *spacesp
= NULL_TREE
;
5741 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5744 *spacesp
= tree_cons (scope
, NULL_TREE
, *spacesp
);
5745 val
= binding_for_name (name
, scope
);
5747 /* Initialize binding for this context. */
5748 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5749 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5751 /* Add all _DECLs seen through local using-directives. */
5752 for (level
= current_binding_level
;
5753 !level
->namespace_p
;
5754 level
= level
->level_chain
)
5755 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5756 scope
, flags
, spacesp
))
5757 /* Give up because of error. */
5758 return error_mark_node
;
5760 /* Add all _DECLs seen through global using-directives. */
5761 /* XXX local and global using lists should work equally. */
5765 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5766 scope
, flags
, spacesp
))
5767 /* Give up because of error. */
5768 return error_mark_node
;
5769 if (siter
== scope
) break;
5770 siter
= CP_DECL_CONTEXT (siter
);
5773 val
= select_decl (b
, flags
);
5774 if (scope
== global_namespace
)
5780 /* Combine prefer_type and namespaces_only into flags. */
5783 lookup_flags (prefer_type
, namespaces_only
)
5784 int prefer_type
, namespaces_only
;
5786 if (namespaces_only
)
5787 return LOOKUP_PREFER_NAMESPACES
;
5788 if (prefer_type
> 1)
5789 return LOOKUP_PREFER_TYPES
;
5790 if (prefer_type
> 0)
5791 return LOOKUP_PREFER_BOTH
;
5795 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5796 ignore it or not. Subroutine of lookup_name_real. */
5799 qualify_lookup (val
, flags
)
5803 if (val
== NULL_TREE
)
5805 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5807 if ((flags
& LOOKUP_PREFER_TYPES
)
5808 && (TREE_CODE (val
) == TYPE_DECL
5809 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5810 && DECL_CLASS_TEMPLATE_P (val
))))
5812 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5817 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5821 warn_about_implicit_typename_lookup (typename
, binding
)
5825 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5826 tree name
= DECL_NAME (typename
);
5828 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5829 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5830 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5831 && ! (TREE_CODE (binding
) == TYPE_DECL
5832 && same_type_p (TREE_TYPE (binding
), subtype
)))
5834 cp_warning ("lookup of `%D' finds `%#D'",
5836 cp_warning (" instead of `%D' from dependent base class",
5838 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5839 constructor_name (current_class_type
), name
);
5843 /* Look up NAME in the current binding level and its superiors in the
5844 namespace of variables, functions and typedefs. Return a ..._DECL
5845 node of some kind representing its definition if there is only one
5846 such declaration, or return a TREE_LIST with all the overloaded
5847 definitions if there are many, or return 0 if it is undefined.
5849 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5850 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5851 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5852 Otherwise we prefer non-TYPE_DECLs.
5854 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5855 using IDENTIFIER_CLASS_VALUE. */
5858 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5860 int prefer_type
, nonclass
, namespaces_only
;
5863 tree val
= NULL_TREE
;
5865 tree from_obj
= NULL_TREE
;
5867 int val_is_implicit_typename
= 0;
5869 /* Hack: copy flag set by parser, if set. */
5870 if (only_namespace_names
)
5871 namespaces_only
= 1;
5873 if (prefer_type
== -2)
5875 extern int looking_for_typename
;
5876 tree type
= NULL_TREE
;
5879 prefer_type
= looking_for_typename
;
5881 flags
= lookup_flags (prefer_type
, namespaces_only
);
5882 /* If the next thing is '<', class templates are types. */
5883 if (looking_for_template
)
5884 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5886 /* std:: becomes :: for now. */
5887 if (got_scope
== std_node
)
5888 got_scope
= void_type_node
;
5892 else if (got_object
!= error_mark_node
)
5897 if (type
== error_mark_node
)
5898 return error_mark_node
;
5899 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5900 type
= TREE_TYPE (type
);
5903 type
= complete_type (type
);
5905 if (TREE_CODE (type
) == VOID_TYPE
)
5906 type
= global_namespace
;
5907 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5909 val
= make_node (CPLUS_BINDING
);
5910 flags
|= LOOKUP_COMPLAIN
;
5911 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5913 val
= select_decl (val
, flags
);
5915 else if (! IS_AGGR_TYPE (type
)
5916 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5917 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
5918 || TREE_CODE (type
) == TYPENAME_TYPE
)
5919 /* Someone else will give an error about this if needed. */
5921 else if (type
== current_class_type
)
5922 val
= IDENTIFIER_CLASS_VALUE (name
);
5925 val
= lookup_member (type
, name
, 0, prefer_type
);
5926 type_access_control (type
, val
);
5928 /* Restore the containing TYPENAME_TYPE if we looked
5929 through it before. */
5930 if (got_scope
&& got_scope
!= type
5931 && val
&& TREE_CODE (val
) == TYPE_DECL
5932 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
)
5933 TYPE_CONTEXT (TREE_TYPE (val
)) = got_scope
;
5941 else if (got_object
&& val
)
5946 flags
= lookup_flags (prefer_type
, namespaces_only
);
5947 /* If we're not parsing, we need to complain. */
5948 flags
|= LOOKUP_COMPLAIN
;
5951 /* First, look in non-namespace scopes. */
5953 if (current_class_type
== NULL_TREE
)
5956 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5960 if (!LOCAL_BINDING_P (t
) && nonclass
)
5961 /* We're not looking for class-scoped bindings, so keep going. */
5964 /* If this is the kind of thing we're looking for, we're done. */
5965 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5966 binding
= BINDING_VALUE (t
);
5967 else if ((flags
& LOOKUP_PREFER_TYPES
)
5968 && qualify_lookup (BINDING_TYPE (t
), flags
))
5969 binding
= BINDING_TYPE (t
);
5971 binding
= NULL_TREE
;
5973 /* Handle access control on types from enclosing or base classes. */
5974 if (binding
&& ! yylex
5975 && BINDING_LEVEL (t
) && BINDING_LEVEL (t
)->parm_flag
== 2)
5976 type_access_control (BINDING_LEVEL (t
)->this_class
, binding
);
5979 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5981 if (val_is_implicit_typename
&& !yylex
)
5982 warn_about_implicit_typename_lookup (val
, binding
);
5984 val_is_implicit_typename
5985 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5986 if (!val_is_implicit_typename
)
5991 /* Now lookup in namespace scopes. */
5992 if (!val
|| val_is_implicit_typename
)
5994 t
= unqualified_namespace_lookup (name
, flags
, 0);
5997 if (val_is_implicit_typename
&& !yylex
)
5998 warn_about_implicit_typename_lookup (val
, t
);
6006 /* This should only warn about types used in qualified-ids. */
6007 if (from_obj
&& from_obj
!= val
)
6009 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
6010 && TREE_CODE (val
) == TYPE_DECL
6011 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
6013 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6014 name
, got_object
, TREE_TYPE (from_obj
));
6015 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
6019 /* We don't change val to from_obj if got_object depends on
6020 template parms because that breaks implicit typename for
6021 destructor calls. */
6022 if (! uses_template_parms (got_object
))
6026 /* If we have a single function from a using decl, pull it out. */
6027 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
6028 val
= OVL_FUNCTION (val
);
6037 lookup_name_nonclass (name
)
6040 return lookup_name_real (name
, 0, 1, 0);
6044 lookup_function_nonclass (name
, args
)
6048 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
6052 lookup_name_namespace_only (name
)
6055 /* type-or-namespace, nonclass, namespace_only */
6056 return lookup_name_real (name
, 1, 1, 1);
6060 lookup_name (name
, prefer_type
)
6064 return lookup_name_real (name
, prefer_type
, 0, 0);
6067 /* Similar to `lookup_name' but look only in the innermost non-class
6071 lookup_name_current_level (name
)
6074 struct binding_level
*b
;
6077 b
= current_binding_level
;
6078 while (b
->parm_flag
== 2)
6083 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
6085 /* extern "C" function() */
6086 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
6089 else if (IDENTIFIER_BINDING (name
)
6090 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
6094 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
6095 return IDENTIFIER_VALUE (name
);
6107 /* Like lookup_name_current_level, but for types. */
6110 lookup_type_current_level (name
)
6113 register tree t
= NULL_TREE
;
6115 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
6117 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
6118 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
6120 struct binding_level
*b
= current_binding_level
;
6123 if (purpose_member (name
, b
->type_shadowed
))
6124 return REAL_IDENTIFIER_TYPE_VALUE (name
);
6136 begin_only_namespace_names ()
6138 only_namespace_names
= 1;
6142 end_only_namespace_names ()
6144 only_namespace_names
= 0;
6147 /* Push the declarations of builtin types into the namespace.
6148 RID_INDEX is the index of the builtin type
6149 in the array RID_POINTERS. NAME is the name used when looking
6150 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6153 record_builtin_type (rid_index
, name
, type
)
6158 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
6159 tree tdecl
= NULL_TREE
;
6161 if ((int) rid_index
< (int) RID_MAX
)
6162 rname
= ridpointers
[(int) rid_index
];
6164 tname
= get_identifier (name
);
6166 TYPE_BUILT_IN (type
) = 1;
6170 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
6171 set_identifier_type_value (tname
, NULL_TREE
);
6172 if ((int) rid_index
< (int) RID_MAX
)
6173 /* Built-in types live in the global namespace. */
6174 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
6176 if (rname
!= NULL_TREE
)
6178 if (tname
!= NULL_TREE
)
6180 set_identifier_type_value (rname
, NULL_TREE
);
6181 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
6185 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
6186 set_identifier_type_value (rname
, NULL_TREE
);
6191 /* Record one of the standard Java types.
6192 * Declare it as having the given NAME.
6193 * If SIZE > 0, it is the size of one of the integral types;
6194 * otherwise it is the negative of the size of one of the other types. */
6197 record_builtin_java_type (name
, size
)
6203 type
= make_signed_type (size
);
6204 else if (size
> -32)
6205 { /* "__java_char" or ""__java_boolean". */
6206 type
= make_unsigned_type (-size
);
6207 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6210 { /* "__java_float" or ""__java_double". */
6211 type
= make_node (REAL_TYPE
);
6212 TYPE_PRECISION (type
) = - size
;
6215 record_builtin_type (RID_MAX
, name
, type
);
6216 decl
= TYPE_NAME (type
);
6218 /* Suppress generate debug symbol entries for these types,
6219 since for normal C++ they are just clutter.
6220 However, push_lang_context undoes this if extern "Java" is seen. */
6221 DECL_IGNORED_P (decl
) = 1;
6223 TYPE_FOR_JAVA (type
) = 1;
6227 /* Push a type into the namespace so that the back-ends ignore it. */
6230 record_unknown_type (type
, name
)
6234 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
6235 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6236 DECL_IGNORED_P (decl
) = 1;
6237 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6238 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
6239 TYPE_ALIGN (type
) = 1;
6240 TYPE_USER_ALIGN (type
) = 0;
6241 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
6244 /* An string for which we should create an IDENTIFIER_NODE at
6247 typedef struct predefined_identifier
6249 /* The name of the identifier. */
6251 /* The place where the IDENTIFIER_NODE should be stored. */
6253 /* Non-zero if this is the name of a constructor or destructor. */
6255 } predefined_identifier
;
6257 /* Create all the predefined identifiers. */
6260 initialize_predefined_identifiers ()
6262 struct predefined_identifier
*pid
;
6264 /* A table of identifiers to create at startup. */
6265 static predefined_identifier predefined_identifiers
[] = {
6266 { "C++", &lang_name_cplusplus
, 0 },
6267 { "C", &lang_name_c
, 0 },
6268 { "Java", &lang_name_java
, 0 },
6269 { CTOR_NAME
, &ctor_identifier
, 1 },
6270 { "__base_ctor", &base_ctor_identifier
, 1 },
6271 { "__comp_ctor", &complete_ctor_identifier
, 1 },
6272 { DTOR_NAME
, &dtor_identifier
, 1 },
6273 { "__comp_dtor", &complete_dtor_identifier
, 1 },
6274 { "__base_dtor", &base_dtor_identifier
, 1 },
6275 { "__deleting_dtor", &deleting_dtor_identifier
, 1 },
6276 { VTABLE_DELTA2_NAME
, &delta2_identifier
, 0 },
6277 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
6278 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
6279 { VTABLE_INDEX_NAME
, &index_identifier
, 0 },
6280 { "nelts", &nelts_identifier
, 0 },
6281 { THIS_NAME
, &this_identifier
, 0 },
6282 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
6283 { "__pfn_or_delta2", &pfn_or_delta2_identifier
, 0 },
6284 { "_vptr", &vptr_identifier
, 0 },
6285 { "__cp_push_exception", &cp_push_exception_identifier
, 0 },
6286 { "__vtt_parm", &vtt_parm_identifier
, 0 },
6287 { "std", &std_identifier
, 0 },
6291 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
6293 *pid
->node
= get_identifier (pid
->name
);
6294 if (pid
->ctor_or_dtor_p
)
6295 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
6299 /* Create the predefined scalar types of C,
6300 and some nodes representing standard constants (0, 1, (void *)0).
6301 Initialize the global binding level.
6302 Make definitions for built-in primitive functions. */
6305 init_decl_processing ()
6308 int wchar_type_size
;
6309 tree array_domain_type
;
6311 /* Check to see that the user did not specify an invalid combination
6312 of command-line options. */
6313 if (flag_new_abi
&& !flag_vtable_thunks
)
6314 fatal ("the new ABI requires vtable thunks");
6316 /* Create all the identifiers we need. */
6317 initialize_predefined_identifiers ();
6319 /* Fill in back-end hooks. */
6320 init_lang_status
= &push_cp_function_context
;
6321 free_lang_status
= &pop_cp_function_context
;
6322 mark_lang_status
= &mark_cp_function_context
;
6323 lang_safe_from_p
= &c_safe_from_p
;
6329 /* Create the global variables. */
6330 push_to_top_level ();
6332 /* Enter the global namespace. */
6333 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
6334 push_namespace (get_identifier ("::"));
6335 global_namespace
= current_namespace
;
6336 current_lang_name
= NULL_TREE
;
6338 /* Adjust various flags based on command-line settings. */
6339 if (! flag_permissive
&& ! pedantic
)
6340 flag_pedantic_errors
= 1;
6341 if (!flag_no_inline
)
6342 flag_inline_trees
= 1;
6345 current_lang_name
= lang_name_c
;
6347 current_function_decl
= NULL_TREE
;
6348 current_binding_level
= NULL_BINDING_LEVEL
;
6349 free_binding_level
= NULL_BINDING_LEVEL
;
6351 build_common_tree_nodes (flag_signed_char
);
6353 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
6354 TREE_TYPE (error_mark_list
) = error_mark_node
;
6356 /* Make the binding_level structure for global names. */
6358 global_binding_level
= current_binding_level
;
6359 /* The global level is the namespace level of ::. */
6360 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
6361 declare_namespace_level ();
6363 /* Define `int' and `char' first so that dbx will output them first. */
6364 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6365 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6367 /* `signed' is the same as `int' */
6368 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6369 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6370 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6371 record_builtin_type (RID_MAX
, "long unsigned int",
6372 long_unsigned_type_node
);
6373 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6374 record_builtin_type (RID_MAX
, "long long int",
6375 long_long_integer_type_node
);
6376 record_builtin_type (RID_MAX
, "long long unsigned int",
6377 long_long_unsigned_type_node
);
6378 record_builtin_type (RID_MAX
, "long long unsigned",
6379 long_long_unsigned_type_node
);
6380 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6381 record_builtin_type (RID_MAX
, "short unsigned int",
6382 short_unsigned_type_node
);
6383 record_builtin_type (RID_MAX
, "unsigned short",
6384 short_unsigned_type_node
);
6387 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6389 /* Define both `signed char' and `unsigned char'. */
6390 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6391 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6393 /* `unsigned long' is the standard type for sizeof.
6394 Note that stddef.h uses `unsigned long',
6395 and this must agree, even if long and int are the same size. */
6397 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6399 /* Create the widest literal types. */
6400 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6401 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6402 widest_integer_literal_type_node
));
6404 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6405 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6406 widest_unsigned_literal_type_node
));
6408 /* These are types that type_for_size and type_for_mode use. */
6409 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6410 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6411 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6412 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6413 #if HOST_BITS_PER_WIDE_INT >= 64
6414 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6416 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6417 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6418 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6419 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6420 #if HOST_BITS_PER_WIDE_INT >= 64
6421 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6424 build_common_tree_nodes_2 (flag_short_double
);
6426 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6427 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6428 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6429 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6430 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6431 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6432 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6433 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6435 integer_two_node
= build_int_2 (2, 0);
6436 TREE_TYPE (integer_two_node
) = integer_type_node
;
6437 integer_three_node
= build_int_2 (3, 0);
6438 TREE_TYPE (integer_three_node
) = integer_type_node
;
6440 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6441 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6442 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6443 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6444 TYPE_PRECISION (boolean_type_node
) = 1;
6445 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6446 boolean_false_node
= build_int_2 (0, 0);
6447 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6448 boolean_true_node
= build_int_2 (1, 0);
6449 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6451 signed_size_zero_node
= build_int_2 (0, 0);
6452 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6453 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6454 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6456 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6457 complex_integer_type_node
));
6458 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6459 complex_float_type_node
));
6460 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6461 complex_double_type_node
));
6462 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6463 complex_long_double_type_node
));
6465 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6467 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6468 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6469 TREE_PARMLIST (void_list_node
) = 1;
6471 string_type_node
= build_pointer_type (char_type_node
);
6472 const_string_type_node
6473 = build_pointer_type (build_qualified_type (char_type_node
,
6475 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6477 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6480 /* Make a type to be the domain of a few array types
6481 whose domains don't really matter.
6482 200 is small enough that it always fits in size_t. */
6483 array_domain_type
= build_index_type (build_int_2 (200, 0));
6485 /* Make a type for arrays of characters.
6486 With luck nothing will ever really depend on the length of this
6488 char_array_type_node
6489 = build_array_type (char_type_node
, array_domain_type
);
6491 /* Likewise for arrays of ints. */
6493 = build_array_type (integer_type_node
, array_domain_type
);
6496 delta_type_node
= ptrdiff_type_node
;
6497 else if (flag_huge_objects
)
6498 delta_type_node
= long_integer_type_node
;
6500 delta_type_node
= short_integer_type_node
;
6503 vtable_index_type
= ptrdiff_type_node
;
6505 vtable_index_type
= delta_type_node
;
6507 default_function_type
6508 = build_function_type (integer_type_node
, NULL_TREE
);
6510 ptr_type_node
= build_pointer_type (void_type_node
);
6512 = build_pointer_type (build_qualified_type (void_type_node
,
6514 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
6515 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6516 lang_type_promotes_to
= convert_type_from_ellipsis
;
6519 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6521 /* C++ extensions */
6523 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6524 record_unknown_type (unknown_type_node
, "unknown type");
6526 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6527 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6529 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6531 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6533 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6534 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6536 /* This is special for C++ so functions can be overloaded. */
6537 wchar_type_node
= get_identifier (flag_short_wchar
6538 ? "short unsigned int"
6540 wchar_type_node
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node
));
6541 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6542 if (TREE_UNSIGNED (wchar_type_node
))
6543 wchar_type_node
= make_signed_type (wchar_type_size
);
6545 wchar_type_node
= make_unsigned_type (wchar_type_size
);
6546 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6548 /* Artificial declaration of wchar_t -- can be bashed */
6549 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6551 pushdecl (wchar_decl_node
);
6553 /* This is for wide string constants. */
6554 wchar_array_type_node
6555 = build_array_type (wchar_type_node
, array_domain_type
);
6558 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (INTMAX_TYPE
)));
6560 TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (UINTMAX_TYPE
)));
6562 if (flag_vtable_thunks
)
6564 /* Make sure we get a unique function type, so we can give
6565 its pointer type a name. (This wins for gdb.) */
6566 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6567 TREE_TYPE (vfunc_type
) = integer_type_node
;
6568 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6569 layout_type (vfunc_type
);
6571 vtable_entry_type
= build_pointer_type (vfunc_type
);
6575 vtable_entry_type
= make_aggr_type (RECORD_TYPE
);
6576 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
6578 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
6580 fields
[2] = build_decl (FIELD_DECL
, pfn_identifier
,
6582 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6585 /* Make this part of an invisible union. */
6586 fields
[3] = copy_node (fields
[2]);
6587 TREE_TYPE (fields
[3]) = delta_type_node
;
6588 DECL_NAME (fields
[3]) = delta2_identifier
;
6589 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6590 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6591 DECL_SIZE_UNIT (fields
[3]) = TYPE_SIZE_UNIT (delta_type_node
);
6592 TREE_UNSIGNED (fields
[3]) = 0;
6593 TREE_CHAIN (fields
[2]) = fields
[3];
6594 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6597 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6600 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6601 layout_type (vtbl_type_node
);
6602 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6603 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6604 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6605 layout_type (vtbl_ptr_type_node
);
6606 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6608 std_node
= build_decl (NAMESPACE_DECL
,
6610 ? get_identifier ("fake std") : std_identifier
,
6612 pushdecl (std_node
);
6616 push_namespace (get_identifier ("__cxxabiv1"));
6617 abi_node
= current_namespace
;
6621 global_type_node
= make_node (LANG_TYPE
);
6622 record_unknown_type (global_type_node
, "global type");
6625 current_lang_name
= lang_name_cplusplus
;
6628 tree bad_alloc_type_node
, newtype
, deltype
;
6630 push_namespace (get_identifier ("std"));
6631 bad_alloc_type_node
= xref_tag
6632 (class_type_node
, get_identifier ("bad_alloc"), 1);
6635 newtype
= build_exception_variant
6636 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6637 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6638 push_cp_library_fn (NEW_EXPR
, newtype
);
6639 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
6640 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
6641 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
6645 = build_library_fn_ptr ("__pure_virtual", void_ftype
);
6647 /* Perform other language dependent initializations. */
6648 init_class_processing ();
6649 init_init_processing ();
6650 init_search_processing ();
6651 init_rtti_processing ();
6653 if (flag_exceptions
)
6654 init_exception_processing ();
6657 flag_inline_functions
= 0;
6660 if (! supports_one_only ())
6663 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6664 function_id_node
= get_identifier ("__FUNCTION__");
6665 pretty_function_id_node
= get_identifier ("__PRETTY_FUNCTION__");
6666 func_id_node
= get_identifier ("__func__");
6668 make_fname_decl
= cp_make_fname_decl
;
6669 declare_function_name ();
6671 /* Prepare to check format strings against argument lists. */
6672 init_function_format_info ();
6674 /* Show we use EH for cleanups. */
6675 using_eh_for_cleanups ();
6677 valid_lang_attribute
= cp_valid_lang_attribute
;
6679 /* Maintain consistency. Perhaps we should just complain if they
6680 say -fwritable-strings? */
6681 if (flag_writable_strings
)
6682 flag_const_strings
= 0;
6684 /* Add GC roots for all of our global variables. */
6685 ggc_add_tree_root (c_global_trees
, sizeof c_global_trees
/ sizeof(tree
));
6686 ggc_add_tree_root (cp_global_trees
, sizeof cp_global_trees
/ sizeof(tree
));
6687 ggc_add_tree_root (&integer_three_node
, 1);
6688 ggc_add_tree_root (&integer_two_node
, 1);
6689 ggc_add_tree_root (&signed_size_zero_node
, 1);
6690 ggc_add_tree_root (&size_one_node
, 1);
6691 ggc_add_tree_root (&size_zero_node
, 1);
6692 ggc_add_root (&global_binding_level
, 1, sizeof global_binding_level
,
6693 mark_binding_level
);
6694 ggc_add_root (&scope_chain
, 1, sizeof scope_chain
, &mark_saved_scope
);
6695 ggc_add_tree_root (&static_ctors
, 1);
6696 ggc_add_tree_root (&static_dtors
, 1);
6697 ggc_add_tree_root (&lastiddecl
, 1);
6699 ggc_add_tree_root (&last_function_parm_tags
, 1);
6700 ggc_add_tree_root (¤t_function_return_value
, 1);
6701 ggc_add_tree_root (¤t_function_parm_tags
, 1);
6702 ggc_add_tree_root (&last_function_parms
, 1);
6703 ggc_add_tree_root (&error_mark_list
, 1);
6705 ggc_add_tree_root (&global_namespace
, 1);
6706 ggc_add_tree_root (&global_type_node
, 1);
6707 ggc_add_tree_root (&anonymous_namespace_name
, 1);
6709 ggc_add_tree_root (&got_object
, 1);
6710 ggc_add_tree_root (&got_scope
, 1);
6712 ggc_add_tree_root (¤t_lang_name
, 1);
6713 ggc_add_tree_root (&static_aggregates
, 1);
6716 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6717 decl, NAME is the initialization string and TYPE_DEP indicates whether
6718 NAME depended on the type of the function. We make use of that to detect
6719 __PRETTY_FUNCTION__ inside a template fn. Because we build a tree for
6720 the function before emitting any of it, we don't need to treat the
6721 VAR_DECL specially. We can decide whether to emit it later, if it was
6725 cp_make_fname_decl (id
, name
, type_dep
)
6730 tree decl
, type
, init
;
6731 size_t length
= strlen (name
);
6732 tree domain
= NULL_TREE
;
6734 if (!processing_template_decl
)
6737 domain
= build_index_type (build_int_2 (length
, 0));
6739 type
= build_cplus_array_type
6740 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
6743 decl
= build_decl (VAR_DECL
, id
, type
);
6744 TREE_STATIC (decl
) = 1;
6745 TREE_READONLY (decl
) = 1;
6746 DECL_SOURCE_LINE (decl
) = 0;
6747 DECL_ARTIFICIAL (decl
) = 1;
6748 DECL_IN_SYSTEM_HEADER (decl
) = 1;
6750 if (processing_template_decl
)
6751 decl
= push_template_decl (decl
);
6754 init
= build (FUNCTION_NAME
, type
);
6755 DECL_PRETTY_FUNCTION_P (decl
) = 1;
6759 init
= build_string (length
+ 1, name
);
6760 TREE_TYPE (init
) = type
;
6762 DECL_INITIAL (decl
) = init
;
6763 cp_finish_decl (decl
, init
, NULL_TREE
, LOOKUP_ONLYCONVERTING
);
6765 /* We will have to make sure we only emit this, if it is actually used. */
6769 /* Entry point for the benefit of c_common_nodes_and_builtins.
6771 Make a definition for a builtin function named NAME and whose data type
6772 is TYPE. TYPE should be a function type with argument types.
6774 CLASS and CODE tell later passes how to compile calls to this function.
6775 See tree.h for possible values.
6777 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6778 the name to be called if we can't opencode the function. */
6781 builtin_function (name
, type
, code
, class, libname
)
6785 enum built_in_class
class;
6786 const char *libname
;
6788 tree decl
= build_library_fn_1 (get_identifier (name
), ERROR_MARK
, type
);
6789 DECL_BUILT_IN_CLASS (decl
) = class;
6790 DECL_FUNCTION_CODE (decl
) = code
;
6792 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6794 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6795 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6796 function in the namespace. */
6799 DECL_ASSEMBLER_NAME (decl
) = get_identifier (libname
);
6800 make_function_rtl (decl
);
6802 /* Warn if a function in the namespace for users
6803 is used without an occasion to consider it declared. */
6804 if (name
[0] != '_' || name
[1] != '_')
6805 DECL_ANTICIPATED (decl
) = 1;
6810 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6811 function. Not called directly. */
6814 build_library_fn_1 (name
, operator_code
, type
)
6816 enum tree_code operator_code
;
6819 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
6820 DECL_EXTERNAL (fn
) = 1;
6821 TREE_PUBLIC (fn
) = 1;
6822 DECL_ARTIFICIAL (fn
) = 1;
6823 TREE_NOTHROW (fn
) = 1;
6824 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
6828 /* Returns the _DECL for a library function with C linkage.
6829 We assume that such functions never throw; if this is incorrect,
6830 callers should unset TREE_NOTHROW. */
6833 build_library_fn (name
, type
)
6837 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
6838 make_function_rtl (fn
);
6842 /* Returns the _DECL for a library function with C++ linkage. */
6845 build_cp_library_fn (name
, operator_code
, type
)
6847 enum tree_code operator_code
;
6850 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
6851 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
6852 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
6853 set_mangled_name_for_decl (fn
);
6854 make_function_rtl (fn
);
6858 /* Like build_library_fn, but takes a C string instead of an
6862 build_library_fn_ptr (name
, type
)
6866 return build_library_fn (get_identifier (name
), type
);
6869 /* Like build_cp_library_fn, but takes a C string instead of an
6873 build_cp_library_fn_ptr (name
, type
)
6877 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
6880 /* Like build_library_fn, but also pushes the function so that we will
6881 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6884 push_library_fn (name
, type
)
6887 tree fn
= build_library_fn (name
, type
);
6888 pushdecl_top_level (fn
);
6892 /* Like build_cp_library_fn, but also pushes the function so that it
6893 will be found by normal lookup. */
6896 push_cp_library_fn (operator_code
, type
)
6897 enum tree_code operator_code
;
6900 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
6907 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6911 push_void_library_fn (name
, parmtypes
)
6912 tree name
, parmtypes
;
6914 tree type
= build_function_type (void_type_node
, parmtypes
);
6915 return push_library_fn (name
, type
);
6918 /* Like push_library_fn, but also note that this function throws
6919 and does not return. Used for __throw_foo and the like. */
6922 push_throw_library_fn (name
, type
)
6925 tree fn
= push_library_fn (name
, type
);
6926 TREE_THIS_VOLATILE (fn
) = 1;
6927 TREE_NOTHROW (fn
) = 0;
6931 /* When we call finish_struct for an anonymous union, we create
6932 default copy constructors and such. But, an anonymous union
6933 shouldn't have such things; this function undoes the damage to the
6934 anonymous union type T.
6936 (The reason that we create the synthesized methods is that we don't
6937 distinguish `union { int i; }' from `typedef union { int i; } U'.
6938 The first is an anonymous union; the second is just an ordinary
6942 fixup_anonymous_aggr (t
)
6947 /* Wipe out memory of synthesized methods */
6948 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6949 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6950 TYPE_HAS_INIT_REF (t
) = 0;
6951 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6952 TYPE_HAS_ASSIGN_REF (t
) = 0;
6953 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6955 /* Splice the implicitly generated functions out of the TYPE_METHODS
6957 q
= &TYPE_METHODS (t
);
6960 if (DECL_ARTIFICIAL (*q
))
6961 *q
= TREE_CHAIN (*q
);
6963 q
= &TREE_CHAIN (*q
);
6966 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6967 if (TYPE_METHODS (t
))
6968 error ("an anonymous union cannot have function members");
6971 /* Make sure that a declaration with no declarator is well-formed, i.e.
6972 just defines a tagged type or anonymous union.
6974 Returns the type defined, if any. */
6977 check_tag_decl (declspecs
)
6982 tree ob_modifier
= NULL_TREE
;
6984 register tree t
= NULL_TREE
;
6986 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6988 register tree value
= TREE_VALUE (link
);
6991 || (TREE_CODE (value
) == IDENTIFIER_NODE
6992 && IDENTIFIER_GLOBAL_VALUE (value
)
6993 && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value
))))
6997 if ((TREE_CODE (value
) != TYPENAME_TYPE
&& IS_AGGR_TYPE (value
))
6998 || TREE_CODE (value
) == ENUMERAL_TYPE
)
7000 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
7004 else if (value
== ridpointers
[(int) RID_FRIEND
])
7006 if (current_class_type
== NULL_TREE
7007 || current_scope () != current_class_type
)
7008 ob_modifier
= value
;
7012 else if (value
== ridpointers
[(int) RID_STATIC
]
7013 || value
== ridpointers
[(int) RID_EXTERN
]
7014 || value
== ridpointers
[(int) RID_AUTO
]
7015 || value
== ridpointers
[(int) RID_REGISTER
]
7016 || value
== ridpointers
[(int) RID_INLINE
]
7017 || value
== ridpointers
[(int) RID_VIRTUAL
]
7018 || value
== ridpointers
[(int) RID_CONST
]
7019 || value
== ridpointers
[(int) RID_VOLATILE
]
7020 || value
== ridpointers
[(int) RID_EXPLICIT
])
7021 ob_modifier
= value
;
7025 error ("multiple types in one declaration");
7027 if (t
== NULL_TREE
&& ! saw_friend
)
7028 pedwarn ("declaration does not declare anything");
7030 /* Check for an anonymous union. We're careful
7031 accessing TYPE_IDENTIFIER because some built-in types, like
7032 pointer-to-member types, do not have TYPE_NAME. */
7033 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
7035 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
7037 /* Anonymous unions are objects, so they can have specifiers. */;
7038 SET_ANON_AGGR_TYPE_P (t
);
7040 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
7041 pedwarn ("ISO C++ prohibits anonymous structs");
7044 else if (ob_modifier
)
7046 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
7047 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
7048 cp_error ("`%D' can only be specified for functions", ob_modifier
);
7049 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
7050 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
7051 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
7052 cp_error ("`%D' can only be specified for constructors",
7055 cp_error ("`%D' can only be specified for objects and functions",
7062 /* Called when a declaration is seen that contains no names to declare.
7063 If its type is a reference to a structure, union or enum inherited
7064 from a containing scope, shadow that tag name for the current scope
7065 with a forward reference.
7066 If its type defines a new named structure or union
7067 or defines an enum, it is valid but we need not do anything here.
7068 Otherwise, it is an error.
7070 C++: may have to grok the declspecs to learn about static,
7071 complain for anonymous unions. */
7074 shadow_tag (declspecs
)
7077 tree t
= check_tag_decl (declspecs
);
7080 maybe_process_partial_specialization (t
);
7082 /* This is where the variables in an anonymous union are
7083 declared. An anonymous union declaration looks like:
7085 because there is no declarator after the union, the parser
7086 sends that declaration here. */
7087 if (t
&& ANON_AGGR_TYPE_P (t
))
7089 fixup_anonymous_aggr (t
);
7091 if (TYPE_FIELDS (t
))
7093 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
7095 finish_anon_union (decl
);
7100 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
7103 groktypename (typename
)
7106 if (TREE_CODE (typename
) != TREE_LIST
)
7108 return grokdeclarator (TREE_VALUE (typename
),
7109 TREE_PURPOSE (typename
),
7110 TYPENAME
, 0, NULL_TREE
);
7113 /* Decode a declarator in an ordinary declaration or data definition.
7114 This is called as soon as the type information and variable name
7115 have been parsed, before parsing the initializer if any.
7116 Here we create the ..._DECL node, fill in its type,
7117 and put it on the list of decls for the current context.
7118 The ..._DECL node is returned as the value.
7120 Exception: for arrays where the length is not specified,
7121 the type is left null, to be filled in by `cp_finish_decl'.
7123 Function definitions do not come here; they go to start_function
7124 instead. However, external and forward declarations of functions
7125 do go through here. Structure field declarations are done by
7126 grokfield and not through here. */
7129 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
7130 tree declarator
, declspecs
;
7132 tree attributes
, prefix_attributes
;
7135 register tree type
, tem
;
7137 extern int have_extern_spec
;
7138 extern int used_extern_spec
;
7142 /* See code below that used this. */
7143 int init_written
= initialized
;
7146 /* This should only be done once on the top most decl. */
7147 if (have_extern_spec
&& !used_extern_spec
)
7149 declspecs
= tree_cons (NULL_TREE
, get_identifier ("extern"),
7151 used_extern_spec
= 1;
7154 if (attributes
|| prefix_attributes
)
7155 attrlist
= build_tree_list (attributes
, prefix_attributes
);
7157 attrlist
= NULL_TREE
;
7159 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
7162 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
7165 type
= TREE_TYPE (decl
);
7167 if (type
== error_mark_node
)
7170 context
= DECL_CONTEXT (decl
);
7172 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
7173 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
7175 /* When parsing the initializer, lookup should use the object's
7177 push_decl_namespace (context
);
7180 /* We are only interested in class contexts, later. */
7181 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
7182 context
= NULL_TREE
;
7185 /* Is it valid for this decl to have an initializer at all?
7186 If not, set INITIALIZED to zero, which will indirectly
7187 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7188 switch (TREE_CODE (decl
))
7191 /* typedef foo = bar means give foo the same type as bar.
7192 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7193 Any other case of an initialization in a TYPE_DECL is an error. */
7194 if (pedantic
|| list_length (declspecs
) > 1)
7196 cp_error ("typedef `%D' is initialized", decl
);
7202 cp_error ("function `%#D' is initialized like a variable", decl
);
7212 if (! toplevel_bindings_p ()
7213 && DECL_EXTERNAL (decl
))
7214 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7216 DECL_EXTERNAL (decl
) = 0;
7217 if (toplevel_bindings_p ())
7218 TREE_STATIC (decl
) = 1;
7220 /* Tell `pushdecl' this is an initialized decl
7221 even though we don't yet have the initializer expression.
7222 Also tell `cp_finish_decl' it may store the real initializer. */
7223 DECL_INITIAL (decl
) = error_mark_node
;
7226 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7227 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7230 /* Set attributes here so if duplicate decl, will have proper attributes. */
7231 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7233 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
7235 push_nested_class (context
, 2);
7237 if (TREE_CODE (decl
) == VAR_DECL
)
7239 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
7240 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
7241 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
7244 if (DECL_CONTEXT (field
) != context
)
7246 cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7247 DECL_CONTEXT (field
), DECL_NAME (decl
),
7248 context
, DECL_NAME (decl
));
7249 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
7251 /* Static data member are tricky; an in-class initialization
7252 still doesn't provide a definition, so the in-class
7253 declaration will have DECL_EXTERNAL set, but will have an
7254 initialization. Thus, duplicate_decls won't warn
7255 about this situation, and so we check here. */
7256 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
7257 cp_error ("duplicate initialization of %D", decl
);
7258 if (duplicate_decls (decl
, field
))
7264 tree field
= check_classfn (context
, decl
);
7265 if (field
&& duplicate_decls (decl
, field
))
7269 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7270 DECL_IN_AGGR_P (decl
) = 0;
7271 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7272 || CLASSTYPE_TEMPLATE_INSTANTIATION (context
))
7274 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7275 /* [temp.expl.spec] An explicit specialization of a static data
7276 member of a template is a definition if the declaration
7277 includes an initializer; otherwise, it is a declaration.
7279 We check for processing_specialization so this only applies
7280 to the new specialization syntax. */
7281 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7282 DECL_EXTERNAL (decl
) = 1;
7285 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7286 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7290 /* Enter this declaration into the symbol table. */
7291 tem
= maybe_push_decl (decl
);
7293 if (processing_template_decl
)
7294 tem
= push_template_decl (tem
);
7296 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7297 /* Tell the back-end to use or not use .common as appropriate. If we say
7298 -fconserve-space, we want this to save .data space, at the expense of
7299 wrong semantics. If we say -fno-conserve-space, we want this to
7300 produce errors about redefs; to do this we force variables into the
7302 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7305 if (! processing_template_decl
)
7315 tree type
= TREE_TYPE (decl
);
7316 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7318 if (type
== error_mark_node
)
7321 /* If this type of object needs a cleanup, but we're not allowed to
7322 add any more objects with cleanups to the current scope, create a
7323 new binding level. */
7324 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7325 && current_binding_level
->more_cleanups_ok
== 0)
7327 keep_next_level (2);
7330 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7334 /* Is it valid for this decl to have an initializer at all?
7335 If not, set INITIALIZED to zero, which will indirectly
7336 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7338 /* Don't allow initializations for incomplete types except for
7339 arrays which might be completed by the initialization. */
7340 if (COMPLETE_TYPE_P (complete_type (type
)))
7341 ; /* A complete type is ok. */
7342 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7344 cp_error ("variable `%#D' has initializer but incomplete type",
7347 type
= TREE_TYPE (decl
) = error_mark_node
;
7349 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
7351 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7352 cp_error ("elements of array `%#D' have incomplete type", decl
);
7353 /* else we already gave an error in start_decl. */
7359 && TREE_CODE (decl
) != TYPE_DECL
7360 && TREE_CODE (decl
) != TEMPLATE_DECL
7361 && type
!= error_mark_node
7362 && IS_AGGR_TYPE (type
)
7363 && ! DECL_EXTERNAL (decl
))
7365 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7366 && !COMPLETE_TYPE_P (complete_type (type
)))
7368 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7370 /* Change the type so that assemble_variable will give
7371 DECL an rtl we can live with: (mem (const_int 0)). */
7372 type
= TREE_TYPE (decl
) = error_mark_node
;
7376 /* If any base type in the hierarchy of TYPE needs a constructor,
7377 then we set initialized to 1. This way any nodes which are
7378 created for the purposes of initializing this aggregate
7379 will live as long as it does. This is necessary for global
7380 aggregates which do not have their initializers processed until
7381 the end of the file. */
7382 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7387 DECL_INITIAL (decl
) = NULL_TREE
;
7390 /* Handle initialization of references.
7391 These three arguments are from `cp_finish_decl', and have the
7392 same meaning here that they do there.
7394 Quotes on semantics can be found in ARM 8.4.3. */
7397 grok_reference_init (decl
, type
, init
)
7398 tree decl
, type
, init
;
7402 if (init
== NULL_TREE
)
7404 if ((DECL_LANG_SPECIFIC (decl
) == 0
7405 || DECL_IN_AGGR_P (decl
) == 0)
7406 && ! DECL_THIS_EXTERN (decl
))
7407 cp_error ("`%D' declared as reference but not initialized", decl
);
7411 if (init
== error_mark_node
)
7414 if (TREE_CODE (init
) == CONSTRUCTOR
)
7416 cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl
);
7420 if (TREE_CODE (init
) == TREE_LIST
)
7421 init
= build_compound_expr (init
);
7423 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7424 init
= convert_from_reference (init
);
7426 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7427 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7429 /* Note: default conversion is only called in very special cases. */
7430 init
= default_conversion (init
);
7433 /* Convert INIT to the reference type TYPE. This may involve the
7434 creation of a temporary, whose lifetime must be the same as that
7435 of the reference. If so, a DECL_STMT for the temporary will be
7436 added just after the DECL_STMT for DECL. That's why we don't set
7437 DECL_INITIAL for local references (instead assigning to them
7438 explicitly); we need to allow the temporary to be initialized
7440 tmp
= convert_to_reference
7441 (type
, init
, CONV_IMPLICIT
,
7442 LOOKUP_ONLYCONVERTING
|LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
,
7445 if (tmp
== error_mark_node
)
7447 else if (tmp
!= NULL_TREE
)
7450 tmp
= save_expr (tmp
);
7451 if (building_stmt_tree ())
7453 /* Initialize the declaration. */
7454 tmp
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, tmp
);
7455 finish_expr_stmt (tmp
);
7458 DECL_INITIAL (decl
) = tmp
;
7462 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7466 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7468 expand_static_init (decl
, DECL_INITIAL (decl
));
7469 DECL_INITIAL (decl
) = NULL_TREE
;
7474 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7475 mucking with forces it does not comprehend (i.e. initialization with a
7476 constructor). If we are at global scope and won't go into COMMON, fill
7477 it in with a dummy CONSTRUCTOR to force the variable into .data;
7478 otherwise we can use error_mark_node. */
7481 obscure_complex_init (decl
, init
)
7484 if (! flag_no_inline
&& TREE_STATIC (decl
))
7486 if (extract_init (decl
, init
))
7490 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7491 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7492 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7496 DECL_INITIAL (decl
) = error_mark_node
;
7501 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7502 array until we finish parsing the initializer. If that's the
7503 situation we're in, update DECL accordingly. */
7506 maybe_deduce_size_from_array_init (decl
, init
)
7510 tree type
= TREE_TYPE (decl
);
7512 if (TREE_CODE (type
) == ARRAY_TYPE
7513 && TYPE_DOMAIN (type
) == NULL_TREE
7514 && TREE_CODE (decl
) != TYPE_DECL
)
7516 /* do_default is really a C-ism to deal with tentative definitions.
7517 But let's leave it here to ease the eventual merge. */
7518 int do_default
= !DECL_EXTERNAL (decl
);
7519 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7520 int failure
= complete_array_type (type
, initializer
, do_default
);
7523 cp_error ("initializer fails to determine size of `%D'", decl
);
7528 cp_error ("array size missing in `%D'", decl
);
7529 /* If a `static' var's size isn't known, make it extern as
7530 well as static, so it does not get allocated. If it's not
7531 `static', then don't mark it extern; finish_incomplete_decl
7532 will give it a default size and it will get allocated. */
7533 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7534 DECL_EXTERNAL (decl
) = 1;
7537 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7538 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7540 cp_error ("zero-size array `%D'", decl
);
7542 layout_decl (decl
, 0);
7546 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7547 any appropriate error messages regarding the layout. */
7550 layout_var_decl (decl
)
7553 tree type
= TREE_TYPE (decl
);
7555 tree ttype
= target_type (type
);
7558 /* If we haven't already layed out this declaration, do so now.
7559 Note that we must not call complete type for an external object
7560 because it's type might involve templates that we are not
7561 supposed to isntantiate yet. (And it's perfectly legal to say
7562 `extern X x' for some incomplete type `X'.) */
7563 if (!DECL_EXTERNAL (decl
))
7564 complete_type (type
);
7565 if (!DECL_SIZE (decl
) && COMPLETE_TYPE_P (type
))
7566 layout_decl (decl
, 0);
7568 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7570 /* An automatic variable with an incomplete type: that is an error.
7571 Don't talk about array types here, since we took care of that
7572 message in grokdeclarator. */
7573 cp_error ("storage size of `%D' isn't known", decl
);
7574 TREE_TYPE (decl
) = error_mark_node
;
7577 /* Keep this code around in case we later want to control debug info
7578 based on whether a type is "used". (jason 1999-11-11) */
7580 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7581 /* Let debugger know it should output info for this type. */
7582 note_debug_info_needed (ttype
);
7584 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7585 note_debug_info_needed (DECL_CONTEXT (decl
));
7588 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7589 && DECL_SIZE (decl
) != NULL_TREE
7590 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7592 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7593 constant_expression_warning (DECL_SIZE (decl
));
7595 cp_error ("storage size of `%D' isn't constant", decl
);
7599 /* If a local static variable is declared in an inline function, or if
7600 we have a weak definition, we must endeavor to create only one
7601 instance of the variable at link-time. */
7604 maybe_commonize_var (decl
)
7607 /* Static data in a function with comdat linkage also has comdat
7609 if (TREE_STATIC (decl
)
7610 /* Don't mess with __FUNCTION__. */
7611 && ! DECL_ARTIFICIAL (decl
)
7612 && current_function_decl
7613 && DECL_CONTEXT (decl
) == current_function_decl
7614 && (DECL_THIS_INLINE (current_function_decl
)
7615 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7616 && TREE_PUBLIC (current_function_decl
))
7618 /* Rather than try to get this right with inlining, we suppress
7619 inlining of such functions. */
7620 current_function_cannot_inline
7621 = "function with static variable cannot be inline";
7623 /* If flag_weak, we don't need to mess with this, as we can just
7624 make the function weak, and let it refer to its unique local
7625 copy. This works because we don't allow the function to be
7629 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7631 TREE_PUBLIC (decl
) = 1;
7632 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7634 else if (DECL_INITIAL (decl
) == NULL_TREE
7635 || DECL_INITIAL (decl
) == error_mark_node
)
7637 TREE_PUBLIC (decl
) = 1;
7638 DECL_COMMON (decl
) = 1;
7640 /* else we lose. We can only do this if we can use common,
7641 which we can't if it has been initialized. */
7643 if (TREE_PUBLIC (decl
))
7644 DECL_ASSEMBLER_NAME (decl
)
7645 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7648 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7649 cp_warning_at (" you can work around this by removing the initializer", decl
);
7653 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7654 /* Set it up again; we might have set DECL_INITIAL since the last
7656 comdat_linkage (decl
);
7659 /* Issue an error message if DECL is an uninitialized const variable. */
7662 check_for_uninitialized_const_var (decl
)
7665 tree type
= TREE_TYPE (decl
);
7667 /* ``Unless explicitly declared extern, a const object does not have
7668 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7670 if (TREE_CODE (decl
) == VAR_DECL
7671 && TREE_CODE (type
) != REFERENCE_TYPE
7672 && CP_TYPE_CONST_P (type
)
7673 && !TYPE_NEEDS_CONSTRUCTING (type
)
7674 && !DECL_INITIAL (decl
))
7675 cp_error ("uninitialized const `%D'", decl
);
7678 /* Verify INIT (the initializer for DECL), and record the
7679 initialization in DECL_INITIAL, if appropriate. Returns a new
7683 check_initializer (decl
, init
)
7689 if (TREE_CODE (decl
) == FIELD_DECL
)
7692 type
= TREE_TYPE (decl
);
7694 /* If `start_decl' didn't like having an initialization, ignore it now. */
7695 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7698 /* Check the initializer. */
7701 /* Things that are going to be initialized need to have complete
7703 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
7705 if (type
== error_mark_node
)
7706 /* We will have already complained. */
7708 else if (COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7710 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7713 else if (TREE_CODE (type
) == ARRAY_TYPE
7714 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
7716 cp_error ("elements of array `%#D' have incomplete type", decl
);
7719 else if (!COMPLETE_TYPE_P (type
))
7721 cp_error ("`%D' has incomplete type", decl
);
7722 TREE_TYPE (decl
) = error_mark_node
;
7727 if (TREE_CODE (decl
) == CONST_DECL
)
7729 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7731 DECL_INITIAL (decl
) = init
;
7733 /* This will keep us from needing to worry about our obstacks. */
7734 my_friendly_assert (init
!= NULL_TREE
, 149);
7737 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
7739 if (TREE_STATIC (decl
))
7740 make_decl_rtl (decl
, NULL_PTR
, toplevel_bindings_p ());
7741 grok_reference_init (decl
, type
, init
);
7746 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7748 if (TREE_CODE (type
) == ARRAY_TYPE
)
7749 init
= digest_init (type
, init
, (tree
*) 0);
7750 else if (TREE_CODE (init
) == CONSTRUCTOR
7751 && TREE_HAS_CONSTRUCTOR (init
))
7753 if (TYPE_NON_AGGREGATE_CLASS (type
))
7755 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7757 init
= error_mark_node
;
7760 goto dont_use_constructor
;
7765 dont_use_constructor
:
7766 if (TREE_CODE (init
) != TREE_VEC
)
7767 init
= store_init_value (decl
, init
);
7771 /* We must hide the initializer so that expand_decl
7772 won't try to do something it does not understand. */
7773 init
= obscure_complex_init (decl
, init
);
7775 else if (DECL_EXTERNAL (decl
))
7777 else if (TYPE_P (type
)
7778 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7780 tree core_type
= strip_array_types (type
);
7782 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7784 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7785 cp_error ("structure `%D' with uninitialized const members", decl
);
7786 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7787 cp_error ("structure `%D' with uninitialized reference members",
7791 check_for_uninitialized_const_var (decl
);
7793 if (COMPLETE_TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
7794 init
= obscure_complex_init (decl
, NULL_TREE
);
7798 check_for_uninitialized_const_var (decl
);
7803 /* If DECL is not a local variable, give it RTL. */
7806 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7809 const char *asmspec
;
7811 int toplev
= toplevel_bindings_p ();
7814 /* Handle non-variables up front. */
7815 if (TREE_CODE (decl
) != VAR_DECL
)
7817 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7821 /* If we see a class member here, it should be a static data
7823 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
7825 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7826 /* An in-class declaration of a static data member should be
7827 external; it is only a declaration, and not a definition. */
7828 if (init
== NULL_TREE
)
7829 my_friendly_assert (DECL_EXTERNAL (decl
), 20000723);
7832 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7834 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7836 /* We don't create any RTL for local variables. */
7837 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7840 /* We defer emission of local statics until the corresponding
7841 DECL_STMT is expanded. */
7842 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
7844 /* We try to defer namespace-scope static constants so that they are
7845 not emitted into the object file unncessarily. */
7846 if (!DECL_VIRTUAL_P (decl
)
7847 && TREE_READONLY (decl
)
7848 && DECL_INITIAL (decl
) != NULL_TREE
7849 && DECL_INITIAL (decl
) != error_mark_node
7850 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
7852 && !TREE_PUBLIC (decl
))
7854 /* Fool with the linkage according to #pragma interface. */
7855 if (!interface_unknown
)
7857 TREE_PUBLIC (decl
) = 1;
7858 DECL_EXTERNAL (decl
) = interface_only
;
7864 /* If we're deferring the variable, just make RTL. Do not actually
7865 emit the variable. */
7867 make_decl_rtl (decl
, asmspec
, toplev
);
7868 /* If we're not deferring, go ahead and assemble the variable. */
7870 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7873 /* The old ARM scoping rules injected variables declared in the
7874 initialization statement of a for-statement into the surrounding
7875 scope. We support this usage, in order to be backward-compatible.
7876 DECL is a just-declared VAR_DECL; if necessary inject its
7877 declaration into the surrounding scope. */
7880 maybe_inject_for_scope_var (decl
)
7883 if (!DECL_NAME (decl
))
7886 if (current_binding_level
->is_for_scope
)
7888 struct binding_level
*outer
7889 = current_binding_level
->level_chain
;
7891 /* Check to see if the same name is already bound at the outer
7892 level, either because it was directly declared, or because a
7893 dead for-decl got preserved. In either case, the code would
7894 not have been valid under the ARM scope rules, so clear
7895 is_for_scope for the current_binding_level.
7897 Otherwise, we need to preserve the temp slot for decl to last
7898 into the outer binding level. */
7901 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7903 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7904 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7906 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7908 BINDING_VALUE (outer_binding
)
7909 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7910 current_binding_level
->is_for_scope
= 0;
7912 else if (DECL_IN_MEMORY_P (decl
))
7913 preserve_temp_slots (DECL_RTL (decl
));
7917 /* Generate code to initialize DECL (a local variable). */
7920 initialize_local_var (decl
, init
, flags
)
7925 tree type
= TREE_TYPE (decl
);
7927 /* If the type is bogus, don't bother initializing the variable. */
7928 if (type
== error_mark_node
)
7931 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
7933 /* If we used it already as memory, it must stay in memory. */
7934 DECL_INITIAL (decl
) = NULL_TREE
;
7935 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7938 /* Local statics are handled differently from ordinary automatic
7940 if (TREE_STATIC (decl
))
7942 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7943 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7944 expand_static_init (decl
, init
);
7948 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7952 /* Compute and store the initial value. */
7953 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7955 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7957 int saved_stmts_are_full_exprs_p
;
7959 my_friendly_assert (building_stmt_tree (), 20000906);
7960 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
7961 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
7962 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
7963 current_stmt_tree ()->stmts_are_full_exprs_p
=
7964 saved_stmts_are_full_exprs_p
;
7967 /* Set this to 0 so we can tell whether an aggregate which was
7968 initialized was ever used. Don't do this if it has a
7969 destructor, so we don't complain about the 'resource
7970 allocation is initialization' idiom. Now set
7971 attribute((unused)) on types so decls of that type will be
7972 marked used. (see TREE_USED, above.) */
7973 if (TYPE_NEEDS_CONSTRUCTING (type
)
7975 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
7976 && DECL_NAME (decl
))
7977 TREE_USED (decl
) = 0;
7978 else if (already_used
)
7979 TREE_USED (decl
) = 1;
7983 /* Generate code to destroy DECL (a local variable). */
7986 destroy_local_var (decl
)
7989 tree type
= TREE_TYPE (decl
);
7992 /* Only variables get cleaned up. */
7993 if (TREE_CODE (decl
) != VAR_DECL
)
7996 /* And only things with destructors need cleaning up. */
7997 if (type
== error_mark_node
7998 || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
8001 if (TREE_CODE (decl
) == VAR_DECL
&&
8002 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
8003 /* We don't clean up things that aren't defined in this
8004 translation unit, or that need a static cleanup. The latter
8005 are handled by finish_file. */
8008 /* Compute the cleanup. */
8009 cleanup
= maybe_build_cleanup (decl
);
8011 /* Record the cleanup required for this declaration. */
8012 if (DECL_SIZE (decl
) && TREE_TYPE (decl
) != error_mark_node
8014 finish_decl_cleanup (decl
, cleanup
);
8017 /* Finish processing of a declaration;
8018 install its line number and initial value.
8019 If the length of an array type is not known before,
8020 it must be determined now, from the initial value, or it is an error.
8022 INIT holds the value of an initializer that should be allowed to escape
8025 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8026 if the (init) syntax was used. */
8029 cp_finish_decl (decl
, init
, asmspec_tree
, flags
)
8035 tree ttype
= NULL_TREE
;
8036 const char *asmspec
= NULL
;
8037 int was_readonly
= 0;
8042 error ("assignment (not initialization) in declaration");
8046 /* If a name was specified, get the string. */
8048 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
8050 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
8052 cp_error ("cannot initialize `%D' to namespace `%D'",
8057 if (current_class_type
8058 && CP_DECL_CONTEXT (decl
) == current_class_type
8059 && TYPE_BEING_DEFINED (current_class_type
)
8060 && (DECL_INITIAL (decl
) || init
))
8061 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
8063 if (TREE_CODE (decl
) == VAR_DECL
8064 && DECL_CONTEXT (decl
)
8065 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
8066 && DECL_CONTEXT (decl
) != current_namespace
8069 /* Leave the namespace of the object. */
8070 pop_decl_namespace ();
8073 type
= TREE_TYPE (decl
);
8075 if (type
== error_mark_node
)
8078 /* Add this declaration to the statement-tree. */
8079 if (building_stmt_tree ()
8080 && at_function_scope_p ()
8081 && TREE_CODE (decl
) != RESULT_DECL
)
8082 add_decl_stmt (decl
);
8084 if (TYPE_HAS_MUTABLE_P (type
))
8085 TREE_READONLY (decl
) = 0;
8087 if (processing_template_decl
)
8089 if (init
&& DECL_INITIAL (decl
))
8090 DECL_INITIAL (decl
) = init
;
8094 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8095 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
8097 /* Take care of TYPE_DECLs up front. */
8098 if (TREE_CODE (decl
) == TYPE_DECL
)
8100 if (init
&& DECL_INITIAL (decl
))
8102 /* typedef foo = bar; store the type of bar as the type of foo. */
8103 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
8104 DECL_INITIAL (decl
) = init
= NULL_TREE
;
8106 if (type
!= error_mark_node
8107 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
8109 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
8110 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
8111 set_identifier_type_value (DECL_NAME (decl
), type
);
8112 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
8114 GNU_xref_decl (current_function_decl
, decl
);
8116 /* If we have installed this as the canonical typedef for this
8117 type, and that type has not been defined yet, delay emitting
8118 the debug information for it, as we will emit it later. */
8119 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
8120 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
8121 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
8123 rest_of_decl_compilation (decl
, NULL_PTR
,
8124 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
8128 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8129 ttype
= target_type (type
);
8131 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
8132 && TYPE_NEEDS_CONSTRUCTING (type
))
8134 /* Currently, GNU C++ puts constants in text space, making them
8135 impossible to initialize. In the future, one would hope for
8136 an operating system which understood the difference between
8137 initialization and the running of a program. */
8139 TREE_READONLY (decl
) = 0;
8142 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
8144 /* This must override the asm specifier which was placed by
8145 grokclassfn. Lay this out fresh. */
8146 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
8147 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
8148 make_decl_rtl (decl
, asmspec
, 0);
8151 /* Deduce size of array from initialization, if not already known. */
8152 maybe_deduce_size_from_array_init (decl
, init
);
8153 init
= check_initializer (decl
, init
);
8155 GNU_xref_decl (current_function_decl
, decl
);
8157 if (TREE_CODE (decl
) == VAR_DECL
)
8158 layout_var_decl (decl
);
8160 /* Output the assembler code and/or RTL code for variables and functions,
8161 unless the type is an undefined structure or union.
8162 If not, it will get done when the type is completed. */
8163 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
8164 || TREE_CODE (decl
) == RESULT_DECL
)
8166 if (TREE_CODE (decl
) == VAR_DECL
)
8167 maybe_commonize_var (decl
);
8169 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
8171 if (TREE_CODE (type
) == FUNCTION_TYPE
8172 || TREE_CODE (type
) == METHOD_TYPE
)
8173 abstract_virtuals_error (decl
,
8174 strip_array_types (TREE_TYPE (type
)));
8176 abstract_virtuals_error (decl
, strip_array_types (type
));
8178 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8180 else if (DECL_EXTERNAL (decl
)
8181 && ! (DECL_LANG_SPECIFIC (decl
)
8182 && DECL_NOT_REALLY_EXTERN (decl
)))
8185 DECL_INITIAL (decl
) = init
;
8187 else if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
8189 /* This is a local declaration. */
8190 if (doing_semantic_analysis_p ())
8191 maybe_inject_for_scope_var (decl
);
8192 /* Initialize the local variable. But, if we're building a
8193 statement-tree, we'll do the initialization when we
8195 if (processing_template_decl
)
8197 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
8198 DECL_INITIAL (decl
) = init
;
8202 /* If we're not building RTL, then we need to do so
8204 my_friendly_assert (building_stmt_tree (), 20000906);
8205 /* Initialize the variable. */
8206 initialize_local_var (decl
, init
, flags
);
8207 /* Clean up the variable. */
8208 destroy_local_var (decl
);
8211 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
8213 /* Cleanups for static variables are handled by `finish_file'. */
8214 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8215 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
8216 expand_static_init (decl
, init
);
8220 /* Undo call to `pushclass' that was done in `start_decl'
8221 due to initialization of qualified member variable.
8222 I.e., Foo::x = 10; */
8224 tree context
= CP_DECL_CONTEXT (decl
);
8227 && (TREE_CODE (decl
) == VAR_DECL
8228 /* We also have a pushclass done that we need to undo here
8229 if we're at top level and declare a method. */
8230 || TREE_CODE (decl
) == FUNCTION_DECL
)
8231 /* If size hasn't been set, we're still defining it,
8232 and therefore inside the class body; don't pop
8233 the binding level.. */
8234 && COMPLETE_TYPE_P (context
)
8235 && context
== current_class_type
)
8236 pop_nested_class ();
8243 TREE_READONLY (decl
) = 1;
8246 /* This is here for a midend callback from c-common.c */
8249 finish_decl (decl
, init
, asmspec_tree
)
8253 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
8256 /* Returns a declaration for a VAR_DECL as if:
8258 extern "C" TYPE NAME;
8260 had been seen. Used to create compiler-generated global
8264 declare_global_var (name
, type
)
8270 push_to_top_level ();
8271 decl
= build_decl (VAR_DECL
, name
, type
);
8272 TREE_PUBLIC (decl
) = 1;
8273 DECL_EXTERNAL (decl
) = 1;
8274 DECL_ARTIFICIAL (decl
) = 1;
8276 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
8277 pop_from_top_level ();
8282 /* Returns a pointer to the `atexit' function. Note that if
8283 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8284 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8298 if (flag_use_cxa_atexit
)
8300 /* The declaration for `__cxa_atexit' is:
8302 int __cxa_atexit (void (*)(void *), void *, void *)
8304 We build up the argument types and then then function type
8307 /* First, build the pointer-to-function type for the first
8309 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8310 fn_type
= build_function_type (void_type_node
, arg_types
);
8311 fn_ptr_type
= build_pointer_type (fn_type
);
8312 /* Then, build the rest of the argument types. */
8313 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8314 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
8315 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
8316 /* And the final __cxa_atexit type. */
8317 fn_type
= build_function_type (integer_type_node
, arg_types
);
8318 fn_ptr_type
= build_pointer_type (fn_type
);
8319 name
= "__cxa_atexit";
8323 /* The declaration for `atexit' is:
8325 int atexit (void (*)());
8327 We build up the argument types and then then function type
8329 fn_type
= build_function_type (void_type_node
, void_list_node
);
8330 fn_ptr_type
= build_pointer_type (fn_type
);
8331 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
8332 /* Build the final atexit type. */
8333 fn_type
= build_function_type (integer_type_node
, arg_types
);
8337 /* Now, build the function declaration. */
8338 push_lang_context (lang_name_c
);
8339 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
8340 mark_used (atexit_fndecl
);
8341 pop_lang_context ();
8342 atexit_node
= default_conversion (atexit_fndecl
);
8347 /* Returns the __dso_handle VAR_DECL. */
8350 get_dso_handle_node ()
8352 if (dso_handle_node
)
8353 return dso_handle_node
;
8355 /* Declare the variable. */
8356 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8359 return dso_handle_node
;
8362 /* Begin a new function with internal linkage whose job will be simply
8363 to destroy some particular variable. */
8368 static int counter
= 0;
8369 int old_interface_unknown
= interface_unknown
;
8375 push_to_top_level ();
8377 /* No need to mangle this. */
8378 push_lang_context (lang_name_c
);
8380 interface_unknown
= 1;
8382 /* Build the parameter-types. */
8383 parmtypes
= void_list_node
;
8384 /* Functions passed to __cxa_atexit take an additional parameter.
8385 We'll just ignore it. After we implement the new calling
8386 convention for destructors, we can eliminate the use of
8387 additional cleanup functions entirely in the -fnew-abi case. */
8388 if (flag_use_cxa_atexit
)
8389 parmtypes
= tree_cons (NULL_TREE
, ptr_type_node
, parmtypes
);
8390 /* Build the function type itself. */
8391 fntype
= build_function_type (void_type_node
, parmtypes
);
8392 /* Build the name of the function. */
8393 sprintf (name
, "__tcf_%d", counter
++);
8394 /* Build the function declaration. */
8395 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8396 /* It's a function with internal linkage, generated by the
8398 TREE_PUBLIC (fndecl
) = 0;
8399 DECL_ARTIFICIAL (fndecl
) = 1;
8400 /* Make the function `inline' so that it is only emitted if it is
8401 actually needed. It is unlikely that it will be inlined, since
8402 it is only called via a function pointer, but we avoid unncessary
8403 emissions this way. */
8404 DECL_INLINE (fndecl
) = 1;
8405 /* Build the parameter. */
8406 if (flag_use_cxa_atexit
)
8410 parmdecl
= build_decl (PARM_DECL
, NULL_TREE
, ptr_type_node
);
8411 DECL_CONTEXT (parmdecl
) = fndecl
;
8412 DECL_ARG_TYPE (parmdecl
) = ptr_type_node
;
8413 TREE_USED (parmdecl
) = 1;
8414 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8418 start_function (/*specs=*/NULL_TREE
, fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8421 interface_unknown
= old_interface_unknown
;
8423 pop_lang_context ();
8425 return current_function_decl
;
8428 /* Finish the cleanup function begun by start_cleanup_fn. */
8435 expand_body (finish_function (0));
8437 pop_from_top_level ();
8440 /* Generate code to handle the destruction of DECL, an object with
8441 static storage duration. */
8444 register_dtor_fn (decl
)
8452 int saved_flag_access_control
;
8454 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8457 /* Call build_cleanup before we enter the anonymous function so that
8458 any access checks will be done relative to the current scope,
8459 rather than the scope of the anonymous function. */
8460 build_cleanup (decl
);
8462 /* Now start the function. */
8463 cleanup
= start_cleanup_fn ();
8465 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8466 to the original function, rather than the anonymous one. That
8467 will make the back-end think that nested functions are in use,
8468 which causes confusion. */
8469 saved_flag_access_control
= flag_access_control
;
8470 flag_access_control
= 0;
8471 fcall
= build_cleanup (decl
);
8472 flag_access_control
= saved_flag_access_control
;
8474 /* Create the body of the anonymous function. */
8475 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
8476 finish_expr_stmt (fcall
);
8477 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
8480 /* Call atexit with the cleanup function. */
8481 mark_addressable (cleanup
);
8482 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8483 if (flag_use_cxa_atexit
)
8485 args
= tree_cons (NULL_TREE
, get_dso_handle_node (), NULL_TREE
);
8486 args
= tree_cons (NULL_TREE
, null_pointer_node
, args
);
8487 args
= tree_cons (NULL_TREE
, cleanup
, args
);
8490 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
8491 finish_expr_stmt (build_function_call (get_atexit_node (), args
));
8495 expand_static_init (decl
, init
)
8499 tree oldstatic
= value_member (decl
, static_aggregates
);
8503 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8504 cp_error ("multiple initializations given for `%D'", decl
);
8506 else if (! toplevel_bindings_p ())
8508 /* Emit code to perform this initialization but once. */
8515 /* Emit code to perform this initialization but once. This code
8518 static int guard = 0;
8520 // Do initialization.
8522 // Register variable for destruction at end of program.
8525 Note that the `temp' variable is only set to 1 *after* the
8526 initialization is complete. This ensures that an exception,
8527 thrown during the construction, will cause the variable to
8528 reinitialized when we pass through this code again, as per:
8532 If the initialization exits by throwing an exception, the
8533 initialization is not complete, so it will be tried again
8534 the next time control enters the declaration.
8536 In theory, this process should be thread-safe, too; multiple
8537 threads should not be able to initialize the variable more
8538 than once. We don't yet attempt to ensure thread-safety. */
8540 /* Create the guard variable. */
8541 guard
= get_guard (decl
);
8543 /* Begin the conditional initialization. */
8544 if_stmt
= begin_if_stmt ();
8545 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
8546 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
8548 /* Do the initialization itself. */
8549 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8550 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8551 assignment
= build_aggr_init (decl
, init
, 0);
8553 /* The initialization we're doing here is just a bitwise
8555 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
8557 assignment
= NULL_TREE
;
8559 /* Once the assignment is complete, set TEMP to 1. Since the
8560 construction of the static object is complete at this point,
8561 we want to make sure TEMP is set to 1 even if a temporary
8562 constructed during the initialization throws an exception
8563 when it is destroyed. So, we combine the initialization and
8564 the assignment to TEMP into a single expression, ensuring
8565 that when we call finish_expr_stmt the cleanups will not be
8566 run until after TEMP is set to 1. */
8567 guard_init
= set_guard (guard
);
8570 assignment
= tree_cons (NULL_TREE
, assignment
,
8571 build_tree_list (NULL_TREE
,
8573 assignment
= build_compound_expr (assignment
);
8576 assignment
= guard_init
;
8577 finish_expr_stmt (assignment
);
8579 /* Use atexit to register a function for destroying this static
8581 register_dtor_fn (decl
);
8583 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
8584 finish_then_clause (if_stmt
);
8588 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8591 /* Finish the declaration of a catch-parameter. */
8594 start_handler_parms (declspecs
, declarator
)
8601 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8603 if (decl
== NULL_TREE
)
8604 error ("invalid catch parameter");
8613 /* Make TYPE a complete type based on INITIAL_VALUE.
8614 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8615 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8618 complete_array_type (type
, initial_value
, do_default
)
8619 tree type
, initial_value
;
8622 register tree maxindex
= NULL_TREE
;
8627 /* An array of character type can be initialized from a
8628 brace-enclosed string constant. */
8629 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
8630 && TREE_CODE (initial_value
) == CONSTRUCTOR
8631 && CONSTRUCTOR_ELTS (initial_value
)
8632 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
)))
8634 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value
)) == NULL_TREE
)
8635 initial_value
= TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
));
8637 /* Note MAXINDEX is really the maximum index, one less than the
8639 if (TREE_CODE (initial_value
) == STRING_CST
)
8642 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8643 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8646 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8648 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8650 maxindex
= ssize_int (-1);
8651 for (; elts
; elts
= TREE_CHAIN (elts
))
8653 if (TREE_PURPOSE (elts
))
8654 maxindex
= TREE_PURPOSE (elts
);
8656 maxindex
= size_binop (PLUS_EXPR
, maxindex
, ssize_int (1));
8658 maxindex
= copy_node (maxindex
);
8662 /* Make an error message unless that happened already. */
8663 if (initial_value
!= error_mark_node
)
8666 initial_value
= NULL_TREE
;
8668 /* Prevent further error messages. */
8669 maxindex
= build_int_2 (0, 0);
8676 maxindex
= build_int_2 (0, 0);
8685 domain
= build_index_type (maxindex
);
8686 TYPE_DOMAIN (type
) = domain
;
8688 if (! TREE_TYPE (maxindex
))
8689 TREE_TYPE (maxindex
) = domain
;
8691 itype
= TREE_TYPE (initial_value
);
8694 if (itype
&& !TYPE_DOMAIN (itype
))
8695 TYPE_DOMAIN (itype
) = domain
;
8696 /* The type of the main variant should never be used for arrays
8697 of different sizes. It should only ever be completed with the
8698 size of the array. */
8699 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8700 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8703 /* Lay out the type now that we can get the real answer. */
8710 /* Return zero if something is declared to be a member of type
8711 CTYPE when in the context of CUR_TYPE. STRING is the error
8712 message to print in that case. Otherwise, quietly return 1. */
8715 member_function_or_else (ctype
, cur_type
, flags
)
8716 tree ctype
, cur_type
;
8717 enum overload_flags flags
;
8719 if (ctype
&& ctype
!= cur_type
)
8721 if (flags
== DTOR_FLAG
)
8722 cp_error ("destructor for alien class `%T' cannot be a member",
8725 cp_error ("constructor for alien class `%T' cannot be a member",
8732 /* Subroutine of `grokdeclarator'. */
8734 /* Generate errors possibly applicable for a given set of specifiers.
8735 This is for ARM $7.1.2. */
8738 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8741 int virtualp
, quals
, friendp
, raises
, inlinep
;
8744 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8746 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8748 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8751 cp_error_at ("`%D' declared as a friend", object
);
8753 cp_error_at ("`%D' declared with an exception specification", object
);
8756 /* CTYPE is class type, or null if non-class.
8757 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8759 DECLARATOR is the function's name.
8760 VIRTUALP is truthvalue of whether the function is virtual or not.
8761 FLAGS are to be passed through to `grokclassfn'.
8762 QUALS are qualifiers indicating whether the function is `const'
8764 RAISES is a list of exceptions that this function can raise.
8765 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8766 not look, and -1 if we should not call `grokclassfn' at all.
8768 Returns `NULL_TREE' if something goes wrong, after issuing
8769 applicable error messages. */
8772 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8773 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8774 template_count
, in_namespace
)
8777 tree orig_declarator
;
8779 enum overload_flags flags
;
8781 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8785 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8786 int has_default_arg
= 0;
8790 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8791 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8797 type
= build_exception_variant (type
, raises
);
8800 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8801 /* Propagate volatile out from type to decl. */
8802 if (TYPE_VOLATILE (type
))
8803 TREE_THIS_VOLATILE (decl
) = 1;
8805 /* If this decl has namespace scope, set that up. */
8807 set_decl_namespace (decl
, in_namespace
, friendp
);
8809 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8811 /* `main' and builtins have implicit 'C' linkage. */
8812 if ((MAIN_NAME_P (declarator
)
8813 || (IDENTIFIER_LENGTH (declarator
) > 10
8814 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8815 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8816 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8817 && current_lang_name
== lang_name_cplusplus
8818 && ctype
== NULL_TREE
8819 /* NULL_TREE means global namespace. */
8820 && DECL_CONTEXT (decl
) == NULL_TREE
)
8821 DECL_LANGUAGE (decl
) = lang_c
;
8823 /* Should probably propagate const out from type to decl I bet (mrs). */
8826 DECL_STATIC_FUNCTION_P (decl
) = 1;
8827 DECL_CONTEXT (decl
) = ctype
;
8831 DECL_CONTEXT (decl
) = ctype
;
8833 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8835 if (processing_template_decl
)
8836 error ("cannot declare `::main' to be a template");
8838 error ("cannot declare `::main' to be inline");
8840 error ("cannot declare `::main' to be static");
8841 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8843 error ("`main' must return `int'");
8848 /* Members of anonymous types and local classes have no linkage; make
8850 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8851 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8856 /* [basic.link]: A name with no linkage (notably, the name of a class
8857 or enumeration declared in a local scope) shall not be used to
8858 declare an entity with linkage.
8860 Only check this for public decls for now. */
8861 t
= no_linkage_check (TREE_TYPE (decl
));
8864 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8866 if (DECL_EXTERN_C_P (decl
))
8867 /* Allow this; it's pretty common in C. */;
8869 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8873 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8878 TREE_PUBLIC (decl
) = publicp
;
8881 DECL_INTERFACE_KNOWN (decl
) = 1;
8882 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8886 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8888 DECL_EXTERNAL (decl
) = 1;
8889 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8891 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8892 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8896 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8897 grok_op_properties (decl
, virtualp
, check
< 0);
8899 if (ctype
&& decl_function_context (decl
))
8900 DECL_NO_STATIC_CHAIN (decl
) = 1;
8902 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8903 if (TREE_PURPOSE (t
)
8904 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8906 has_default_arg
= 1;
8911 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8915 ("defining explicit specialization `%D' in friend declaration",
8919 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8921 /* Something like `template <class T> friend void f<T>()'. */
8922 cp_error ("invalid use of template-id `%D' in declaration of primary template",
8928 /* A friend declaration of the form friend void f<>(). Record
8929 the information in the TEMPLATE_ID_EXPR. */
8930 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8931 DECL_TEMPLATE_INFO (decl
)
8932 = tree_cons (TREE_OPERAND (orig_declarator
, 0),
8933 TREE_OPERAND (orig_declarator
, 1),
8936 if (has_default_arg
)
8938 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8945 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8952 if (has_default_arg
)
8953 add_defarg_fn (decl
);
8955 /* Plain overloading: will not be grok'd by grokclassfn. */
8956 if (! ctype
&& ! processing_template_decl
8957 && !DECL_EXTERN_C_P (decl
)
8958 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8959 set_mangled_name_for_decl (decl
);
8962 /* Make the init_value nonzero so pushdecl knows this is not
8963 tentative. error_mark_node is replaced later with the BLOCK. */
8964 DECL_INITIAL (decl
) = error_mark_node
;
8966 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8967 TREE_NOTHROW (decl
) = 1;
8969 /* Caller will do the rest of this. */
8973 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8974 DECL_CONSTRUCTOR_P (decl
) = 1;
8976 /* Function gets the ugly name, field gets the nice one. This call
8977 may change the type of the function (because of default
8979 if (ctype
!= NULL_TREE
)
8980 grokclassfn (ctype
, decl
, flags
, quals
);
8982 decl
= check_explicit_specialization (orig_declarator
, decl
,
8984 2 * (funcdef_flag
!= 0) +
8985 4 * (friendp
!= 0));
8986 if (decl
== error_mark_node
)
8989 if (ctype
!= NULL_TREE
8990 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8995 old_decl
= check_classfn (ctype
, decl
);
8997 if (old_decl
&& TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8998 /* Because grokfndecl is always supposed to return a
8999 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9000 here. We depend on our callers to figure out that its
9001 really a template that's being returned. */
9002 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
9004 if (old_decl
&& DECL_STATIC_FUNCTION_P (old_decl
)
9005 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
9007 /* Remove the `this' parm added by grokclassfn.
9008 XXX Isn't this done in start_function, too? */
9009 revert_static_member_fn (decl
);
9010 last_function_parms
= TREE_CHAIN (last_function_parms
);
9012 if (old_decl
&& DECL_ARTIFICIAL (old_decl
))
9013 cp_error ("definition of implicitly-declared `%D'", old_decl
);
9017 /* Since we've smashed OLD_DECL to its
9018 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9019 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9020 decl
= DECL_TEMPLATE_RESULT (decl
);
9022 /* Attempt to merge the declarations. This can fail, in
9023 the case of some illegal specialization declarations. */
9024 if (!duplicate_decls (decl
, old_decl
))
9025 cp_error ("no `%#D' member function declared in class `%T'",
9031 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
9034 if (ctype
== NULL_TREE
|| check
)
9039 DECL_VIRTUAL_P (decl
) = 1;
9040 if (DECL_VINDEX (decl
) == NULL_TREE
)
9041 DECL_VINDEX (decl
) = error_mark_node
;
9042 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
9049 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
9052 RID_BIT_TYPE
*specbits_in
;
9058 RID_BIT_TYPE specbits
;
9060 specbits
= *specbits_in
;
9062 if (TREE_CODE (type
) == OFFSET_TYPE
)
9064 /* If you declare a static member so that it
9065 can be initialized, the code will reach here. */
9066 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
9067 type
= TREE_TYPE (type
);
9068 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
9069 DECL_CONTEXT (decl
) = basetype
;
9070 /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9072 if (!uses_template_parms (decl
))
9075 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9077 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
,
9086 context
= in_namespace
;
9087 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
9088 context
= current_namespace
;
9090 context
= NULL_TREE
;
9092 if (processing_template_decl
&& context
)
9093 /* For global variables, declared in a template, we need the
9095 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
9097 decl
= build_decl (VAR_DECL
, declarator
, type
);
9100 set_decl_namespace (decl
, context
, 0);
9102 context
= DECL_CONTEXT (decl
);
9103 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
9106 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9108 DECL_ASSEMBLER_NAME (decl
)
9109 = build_static_name (context
, declarator
);
9114 set_decl_namespace (decl
, in_namespace
, 0);
9116 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
9118 DECL_THIS_EXTERN (decl
) = 1;
9119 DECL_EXTERNAL (decl
) = !initialized
;
9122 /* In class context, static means one per class,
9123 public access, and static storage. */
9124 if (DECL_CLASS_SCOPE_P (decl
))
9126 TREE_PUBLIC (decl
) = 1;
9127 TREE_STATIC (decl
) = 1;
9128 DECL_EXTERNAL (decl
) = 0;
9130 /* At top level, either `static' or no s.c. makes a definition
9131 (perhaps tentative), and absence of `static' makes it public. */
9132 else if (toplevel_bindings_p ())
9134 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
9135 && (DECL_THIS_EXTERN (decl
) || ! constp
));
9136 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9138 /* Not at top level, only `static' makes a static definition. */
9141 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
9142 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9145 if (TREE_PUBLIC (decl
))
9147 /* [basic.link]: A name with no linkage (notably, the name of a class
9148 or enumeration declared in a local scope) shall not be used to
9149 declare an entity with linkage.
9151 Only check this for public decls for now. */
9152 tree t
= no_linkage_check (TREE_TYPE (decl
));
9155 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
9156 /* Ignore for now; `enum { foo } e' is pretty common. */;
9158 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9166 /* Create and return a canonical pointer to member function type, for
9167 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9170 build_ptrmemfunc_type (type
)
9176 tree unqualified_variant
= NULL_TREE
;
9178 /* If a canonical type already exists for this type, use it. We use
9179 this method instead of type_hash_canon, because it only does a
9180 simple equality check on the list of field members. */
9182 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
9185 /* Make sure that we always have the unqualified pointer-to-member
9187 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9189 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9191 t
= make_aggr_type (RECORD_TYPE
);
9192 /* Let the front-end know this is a pointer to member function... */
9193 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9194 /* ... and not really an aggregate. */
9195 SET_IS_AGGR_TYPE (t
, 0);
9199 u
= make_aggr_type (UNION_TYPE
);
9200 SET_IS_AGGR_TYPE (u
, 0);
9201 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9202 fields
[1] = build_decl (FIELD_DECL
, delta2_identifier
,
9204 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9205 TYPE_NAME (u
) = NULL_TREE
;
9207 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
9209 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
9211 fields
[2] = build_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
9212 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
9216 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9217 fields
[1] = build_decl (FIELD_DECL
, delta_identifier
,
9219 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9222 /* Zap out the name so that the back-end will give us the debugging
9223 information for this anonymous RECORD_TYPE. */
9224 TYPE_NAME (t
) = NULL_TREE
;
9226 /* If this is not the unqualified form of this pointer-to-member
9227 type, set the TYPE_MAIN_VARIANT for this type to be the
9228 unqualified type. Since they are actually RECORD_TYPEs that are
9229 not variants of each other, we must do this manually. */
9230 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9232 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
9233 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
9234 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
9235 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
9238 /* Cache this pointer-to-member type so that we can find it again
9240 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
9242 /* Seems to be wanted. */
9243 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
9248 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9249 Check to see that the definition is valid. Issue appropriate error
9250 messages. Return 1 if the definition is particularly bad, or 0
9254 check_static_variable_definition (decl
, type
)
9258 /* Motion 10 at San Diego: If a static const integral data member is
9259 initialized with an integral constant expression, the initializer
9260 may appear either in the declaration (within the class), or in
9261 the definition, but not both. If it appears in the class, the
9262 member is a member constant. The file-scope definition is always
9264 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
9266 cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9268 /* If we just return the declaration, crashes will sometimes
9269 occur. We therefore return void_type_node, as if this was a
9270 friend declaration, to cause callers to completely ignore
9271 this declaration. */
9274 else if (!CP_TYPE_CONST_P (type
))
9275 cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9277 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
9278 cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
9283 /* Given the SIZE (i.e., number of elements) in an array, compute an
9284 appropriate index type for the array. If non-NULL, NAME is the
9285 name of the thing being declared. */
9288 compute_array_index_type (name
, size
)
9294 /* The size might be the result of a cast. */
9295 STRIP_TYPE_NOPS (size
);
9297 /* It might be a const variable or enumeration constant. */
9298 size
= decl_constant_value (size
);
9300 /* If this involves a template parameter, it will be a constant at
9301 instantiation time, but we don't know what the value is yet.
9302 Even if no template parameters are involved, we may an expression
9303 that is not a constant; we don't even simplify `1 + 2' when
9304 processing a template. */
9305 if (processing_template_decl
)
9307 /* Resolve a qualified reference to an enumerator or static
9308 const data member of ours. */
9309 if (TREE_CODE (size
) == SCOPE_REF
9310 && TREE_OPERAND (size
, 0) == current_class_type
)
9312 tree t
= lookup_field (current_class_type
,
9313 TREE_OPERAND (size
, 1), 0, 0);
9318 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
9319 size
, integer_one_node
));
9322 /* The array bound must be an integer type. */
9323 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9324 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
9325 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
9328 cp_error ("size of array `%D' has non-integer type", name
);
9330 cp_error ("size of array has non-integer type");
9331 size
= integer_one_node
;
9334 /* Normally, the array-bound will be a constant. */
9335 if (TREE_CODE (size
) == INTEGER_CST
)
9337 /* Check to see if the array bound overflowed. Make that an
9338 error, no matter how generous we're being. */
9339 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9340 int old_pedantic
= pedantic
;
9341 pedantic
= flag_pedantic_errors
= 1;
9342 constant_expression_warning (size
);
9343 pedantic
= old_pedantic
;
9344 flag_pedantic_errors
= old_flag_pedantic_errors
;
9346 /* An array must have a positive number of elements. */
9347 if (INT_CST_LT (size
, integer_zero_node
))
9350 cp_error ("size of array `%D' is negative", name
);
9352 cp_error ("size of array is negative");
9353 size
= integer_one_node
;
9355 /* Except that an extension we allow zero-sized arrays. We
9356 always allow them in system headers because glibc uses
9358 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
9361 cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name
);
9363 cp_pedwarn ("ISO C++ forbids zero-size array");
9366 else if (TREE_CONSTANT (size
))
9368 /* `(int) &fn' is not a valid array bound. */
9370 cp_error ("size of array `%D' is not an integral constant-expression",
9373 cp_error ("size of array is not an integral constant-expression");
9376 /* Compute the index of the largest element in the array. It is
9377 one less than the number of elements in the array. */
9379 = fold (cp_build_binary_op (MINUS_EXPR
,
9380 cp_convert (ssizetype
, size
),
9381 cp_convert (ssizetype
,
9382 integer_one_node
)));
9384 /* Check for variable-sized arrays. We allow such things as an
9385 extension, even though they are not allowed in ANSI/ISO C++. */
9386 if (!TREE_CONSTANT (itype
))
9391 cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9394 cp_pedwarn ("ISO C++ forbids variable-size array");
9397 /* Create a variable-sized array index type. */
9398 itype
= variable_size (itype
);
9400 /* Make sure that there was no overflow when creating to a signed
9401 index type. (For example, on a 32-bit machine, an array with
9402 size 2^32 - 1 is too big.) */
9403 else if (TREE_OVERFLOW (itype
))
9405 error ("overflow in array dimension");
9406 TREE_OVERFLOW (itype
) = 0;
9409 /* Create and return the appropriate index type. */
9410 return build_index_type (itype
);
9413 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9414 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9418 create_array_type_for_decl (name
, type
, size
)
9423 tree itype
= NULL_TREE
;
9424 const char* error_msg
;
9426 /* If things have already gone awry, bail now. */
9427 if (type
== error_mark_node
|| size
== error_mark_node
)
9428 return error_mark_node
;
9430 /* Assume that everything will go OK. */
9433 /* There are some types which cannot be array elements. */
9434 switch (TREE_CODE (type
))
9437 error_msg
= "array of void";
9441 error_msg
= "array of functions";
9444 case REFERENCE_TYPE
:
9445 error_msg
= "array of references";
9449 error_msg
= "array of data members";
9453 error_msg
= "array of function members";
9460 /* If something went wrong, issue an error-message and return. */
9464 cp_error ("declaration of `%D' as %s", name
, error_msg
);
9466 cp_error ("creating %s", error_msg
);
9468 return error_mark_node
;
9473 The constant expressions that specify the bounds of the arrays
9474 can be omitted only for the first member of the sequence. */
9475 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9477 cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9480 return error_mark_node
;
9483 /* Figure out the index type for the array. */
9485 itype
= compute_array_index_type (name
, size
);
9487 return build_cplus_array_type (type
, itype
);
9490 /* Check that it's OK to declare a function with the indicated TYPE.
9491 SFK indicates the kind of special function (if any) that this
9492 function is. CTYPE is the class of which this function is a
9493 member. OPTYPE is the type given in a conversion operator
9494 declaration. Returns the actual return type of the function; that
9495 may be different than TYPE if an error occurs, or for certain
9496 special functions. */
9499 check_special_function_return_type (sfk
, type
, ctype
, optype
)
9500 special_function_kind sfk
;
9507 case sfk_constructor
:
9509 cp_error ("return type specification for constructor invalid");
9511 /* In the old ABI, we return `this'; in the new ABI we don't
9513 type
= flag_new_abi
? void_type_node
: build_pointer_type (ctype
);
9516 case sfk_destructor
:
9518 cp_error ("return type specification for destructor invalid");
9519 type
= void_type_node
;
9522 case sfk_conversion
:
9523 if (type
&& !same_type_p (type
, optype
))
9524 cp_error ("operator `%T' declared to return `%T'", optype
, type
);
9526 cp_pedwarn ("return type specified for `operator %T'", optype
);
9531 my_friendly_abort (20000408);
9538 /* Given declspecs and a declarator,
9539 determine the name and type of the object declared
9540 and construct a ..._DECL node for it.
9541 (In one case we can return a ..._TYPE node instead.
9542 For invalid input we sometimes return 0.)
9544 DECLSPECS is a chain of tree_list nodes whose value fields
9545 are the storage classes and type specifiers.
9547 DECL_CONTEXT says which syntactic context this declaration is in:
9548 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9549 FUNCDEF for a function definition. Like NORMAL but a few different
9550 error messages in each case. Return value may be zero meaning
9551 this definition is too screwy to try to parse.
9552 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9553 handle member functions (which have FIELD context).
9554 Return value may be zero meaning this definition is too screwy to
9556 PARM for a parameter declaration (either within a function prototype
9557 or before a function body). Make a PARM_DECL, or return void_type_node.
9558 CATCHPARM for a parameter declaration before a catch clause.
9559 TYPENAME if for a typename (in a cast or sizeof).
9560 Don't make a DECL node; just return the ..._TYPE node.
9561 FIELD for a struct or union field; make a FIELD_DECL.
9562 BITFIELD for a field with specified width.
9563 INITIALIZED is 1 if the decl has an initializer.
9565 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9566 normal attributes in TREE_PURPOSE, or NULL_TREE.
9568 In the TYPENAME case, DECLARATOR is really an abstract declarator.
9569 It may also be so in the PARM case, for a prototype where the
9570 argument type is specified but not the name.
9572 This function is where the complicated C meanings of `static'
9573 and `extern' are interpreted.
9575 For C++, if there is any monkey business to do, the function which
9576 calls this one must do it, i.e., prepending instance variables,
9577 renaming overloaded function names, etc.
9579 Note that for this C++, it is an error to define a method within a class
9580 which does not belong to that class.
9582 Except in the case where SCOPE_REFs are implicitly known (such as
9583 methods within a class being redundantly qualified),
9584 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9585 (class_name::decl_name). The caller must also deal with this.
9587 If a constructor or destructor is seen, and the context is FIELD,
9588 then the type gains the attribute TREE_HAS_x. If such a declaration
9589 is erroneous, NULL_TREE is returned.
9591 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9592 function, these are the qualifiers to give to the `this' pointer. We
9593 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9595 May return void_type_node if the declarator turned out to be a friend.
9596 See grokfield for details. */
9599 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
9602 enum decl_context decl_context
;
9606 RID_BIT_TYPE specbits
;
9609 tree type
= NULL_TREE
;
9615 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9616 int explicit_int
= 0;
9617 int explicit_char
= 0;
9618 int defaulted_int
= 0;
9619 tree typedef_decl
= NULL_TREE
;
9621 tree typedef_type
= NULL_TREE
;
9622 int funcdef_flag
= 0;
9623 enum tree_code innermost_code
= ERROR_MARK
;
9626 /* See the code below that used this. */
9627 tree decl_machine_attr
= NULL_TREE
;
9629 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9630 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9631 tree init
= NULL_TREE
;
9633 /* Keep track of what sort of function is being processed
9634 so that we can warn about default return values, or explicit
9635 return values which do not match prescribed defaults. */
9636 special_function_kind sfk
= sfk_none
;
9638 tree dname
= NULL_TREE
;
9639 tree ctype
= current_class_type
;
9640 tree ctor_return_type
= NULL_TREE
;
9641 enum overload_flags flags
= NO_SPECIAL
;
9642 tree quals
= NULL_TREE
;
9643 tree raises
= NULL_TREE
;
9644 int template_count
= 0;
9645 tree in_namespace
= NULL_TREE
;
9649 RIDBIT_RESET_ALL (specbits
);
9650 if (decl_context
== FUNCDEF
)
9651 funcdef_flag
= 1, decl_context
= NORMAL
;
9652 else if (decl_context
== MEMFUNCDEF
)
9653 funcdef_flag
= -1, decl_context
= FIELD
;
9654 else if (decl_context
== BITFIELD
)
9655 bitfield
= 1, decl_context
= FIELD
;
9657 /* Look inside a declarator for the name being declared
9658 and get it as a string, for an error message. */
9660 tree
*next
= &declarator
;
9664 while (next
&& *next
)
9667 switch (TREE_CODE (decl
))
9670 /* For attributes. */
9671 next
= &TREE_VALUE (decl
);
9676 next
= &TREE_OPERAND (decl
, 0);
9679 case BIT_NOT_EXPR
: /* For C++ destructors! */
9681 tree name
= TREE_OPERAND (decl
, 0);
9682 tree rename
= NULL_TREE
;
9684 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9686 sfk
= sfk_destructor
;
9687 if (TREE_CODE (name
) == TYPE_DECL
)
9688 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9689 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9690 if (ctype
== NULL_TREE
)
9692 if (current_class_type
== NULL_TREE
)
9694 error ("destructors must be member functions");
9699 tree t
= constructor_name (current_class_name
);
9706 tree t
= constructor_name (ctype
);
9713 cp_error ("destructor `%T' must match class name `%T'",
9715 TREE_OPERAND (decl
, 0) = rename
;
9721 case ADDR_EXPR
: /* C++ reference declaration */
9726 innermost_code
= TREE_CODE (decl
);
9727 next
= &TREE_OPERAND (decl
, 0);
9731 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9733 /* This is actually a variable declaration using
9734 constructor syntax. We need to call start_decl and
9735 cp_finish_decl so we can get the variable
9738 tree attributes
, prefix_attributes
;
9740 *next
= TREE_OPERAND (decl
, 0);
9741 init
= CALL_DECLARATOR_PARMS (decl
);
9745 attributes
= TREE_PURPOSE (attrlist
);
9746 prefix_attributes
= TREE_VALUE (attrlist
);
9750 attributes
= NULL_TREE
;
9751 prefix_attributes
= NULL_TREE
;
9754 decl
= start_decl (declarator
, declspecs
, 1,
9755 attributes
, prefix_attributes
);
9756 decl_type_access_control (decl
);
9759 /* Look for __unused__ attribute */
9760 if (TREE_USED (TREE_TYPE (decl
)))
9761 TREE_USED (decl
) = 1;
9762 finish_decl (decl
, init
, NULL_TREE
);
9765 cp_error ("invalid declarator");
9768 innermost_code
= TREE_CODE (decl
);
9769 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9770 ctype
= current_class_type
;
9772 && TREE_OPERAND (decl
, 0)
9773 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9774 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9775 == constructor_name_full (ctype
))
9776 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9777 == constructor_name (ctype
)))))
9778 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9779 next
= &TREE_OPERAND (decl
, 0);
9781 if (ctype
!= NULL_TREE
9782 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9783 && decl
== constructor_name (ctype
))
9785 sfk
= sfk_constructor
;
9786 ctor_return_type
= ctype
;
9791 case TEMPLATE_ID_EXPR
:
9793 tree fns
= TREE_OPERAND (decl
, 0);
9795 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9796 fns
= TREE_OPERAND (fns
, 0);
9799 if (TREE_CODE (dname
) == COMPONENT_REF
)
9800 dname
= TREE_OPERAND (dname
, 1);
9801 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9803 my_friendly_assert (is_overloaded_fn (dname
),
9805 dname
= DECL_NAME (get_first_fn (dname
));
9810 case IDENTIFIER_NODE
:
9811 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9816 if (C_IS_RESERVED_WORD (dname
))
9818 cp_error ("declarator-id missing; using reserved word `%D'",
9820 name
= IDENTIFIER_POINTER (dname
);
9822 else if (!IDENTIFIER_TYPENAME_P (dname
))
9823 name
= IDENTIFIER_POINTER (dname
);
9826 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9827 flags
= TYPENAME_FLAG
;
9828 ctor_return_type
= TREE_TYPE (dname
);
9829 sfk
= sfk_conversion
;
9830 if (IDENTIFIER_GLOBAL_VALUE (dname
)
9831 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname
))
9833 name
= IDENTIFIER_POINTER (dname
);
9835 name
= "<invalid operator>";
9842 /* Perform error checking, and decide on a ctype. */
9843 tree cname
= TREE_OPERAND (decl
, 0);
9844 if (cname
== NULL_TREE
)
9846 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9849 in_namespace
= TREE_OPERAND (decl
, 0);
9850 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9852 else if (! is_aggr_type (cname
, 1))
9853 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9854 /* Must test TREE_OPERAND (decl, 1), in case user gives
9855 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9856 else if (TREE_OPERAND (decl
, 1)
9857 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9859 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9860 || TREE_CODE (cname
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9862 cp_error ("`%T::%D' is not a valid declarator", cname
,
9863 TREE_OPERAND (decl
, 1));
9864 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9865 cname
, TREE_OPERAND (decl
, 1));
9866 return void_type_node
;
9868 else if (ctype
== NULL_TREE
)
9870 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9871 TREE_OPERAND (decl
, 0) = ctype
;
9874 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9876 cp_error ("type `%T' is not derived from type `%T'",
9878 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9884 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9885 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9886 == constructor_name_full (ctype
))
9887 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9888 == constructor_name (ctype
))))
9889 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9890 next
= &TREE_OPERAND (decl
, 1);
9894 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9895 && constructor_name (ctype
) == decl
)
9897 sfk
= sfk_constructor
;
9898 ctor_return_type
= ctype
;
9900 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9901 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9902 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9903 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9905 sfk
= sfk_destructor
;
9906 ctor_return_type
= ctype
;
9908 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9909 next
= &TREE_OPERAND (decl
, 0);
9920 /* Parse error puts this typespec where
9921 a declarator should go. */
9922 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9923 if (TREE_TYPE (decl
) == current_class_type
)
9924 cp_error (" perhaps you want `%T' for a constructor",
9925 current_class_name
);
9926 dname
= DECL_NAME (decl
);
9927 name
= IDENTIFIER_POINTER (dname
);
9929 /* Avoid giving two errors for this. */
9930 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9932 declspecs
= tree_cons (NULL_TREE
, integer_type_node
, declspecs
);
9938 cp_compiler_error ("`%D' as declarator", decl
);
9939 return 0; /* We used to do a 155 abort here. */
9944 /* A function definition's declarator must have the form of
9945 a function declarator. */
9947 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9950 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9951 && innermost_code
!= CALL_EXPR
9952 && ! (ctype
&& declspecs
== NULL_TREE
))
9954 cp_error ("declaration of `%D' as non-function", dname
);
9955 return void_type_node
;
9958 /* Anything declared one level down from the top level
9959 must be one of the parameters of a function
9960 (because the body is at least two levels down). */
9962 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9963 by not allowing C++ class definitions to specify their parameters
9964 with xdecls (must be spec.d in the parmlist).
9966 Since we now wait to push a class scope until we are sure that
9967 we are in a legitimate method context, we must set oldcname
9968 explicitly (since current_class_name is not yet alive).
9970 We also want to avoid calling this a PARM if it is in a namespace. */
9972 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9974 struct binding_level
*b
= current_binding_level
;
9975 current_binding_level
= b
->level_chain
;
9976 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9977 decl_context
= PARM
;
9978 current_binding_level
= b
;
9982 name
= decl_context
== PARM
? "parameter" : "type name";
9984 /* Look through the decl specs and record which ones appear.
9985 Some typespecs are defined as built-in typenames.
9986 Others, the ones that are modifiers of other types,
9987 are represented by bits in SPECBITS: set the bits for
9988 the modifiers that appear. Storage class keywords are also in SPECBITS.
9990 If there is a typedef name or a type, store the type in TYPE.
9991 This includes builtin typedefs such as `int'.
9993 Set EXPLICIT_INT if the type is `int' or `char' and did not
9994 come from a user typedef.
9996 Set LONGLONG if `long' is mentioned twice.
9998 For C++, constructors and destructors have their own fast treatment. */
10000 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
10005 /* Certain parse errors slip through. For example,
10006 `int class;' is not caught by the parser. Try
10007 weakly to recover here. */
10008 if (TREE_CODE (spec
) != TREE_LIST
)
10011 id
= TREE_VALUE (spec
);
10013 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
10015 if (id
== ridpointers
[(int) RID_INT
]
10016 || id
== ridpointers
[(int) RID_CHAR
]
10017 || id
== ridpointers
[(int) RID_BOOL
]
10018 || id
== ridpointers
[(int) RID_WCHAR
])
10022 if (id
== ridpointers
[(int) RID_BOOL
])
10023 error ("`bool' is now a keyword");
10025 cp_error ("extraneous `%T' ignored", id
);
10029 if (id
== ridpointers
[(int) RID_INT
])
10031 else if (id
== ridpointers
[(int) RID_CHAR
])
10033 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
10037 /* C++ aggregate types. */
10038 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
10041 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
10043 type
= IDENTIFIER_TYPE_VALUE (id
);
10047 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
10049 if (ridpointers
[i
] == id
)
10051 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
10053 if (pedantic
&& ! in_system_header
&& warn_long_long
)
10054 pedwarn ("ISO C++ does not support `long long'");
10056 error ("`long long long' is too long for GCC");
10060 else if (RIDBIT_SETP (i
, specbits
))
10061 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
10062 RIDBIT_SET (i
, specbits
);
10067 /* C++ aggregate types. */
10068 else if (TREE_CODE (id
) == TYPE_DECL
)
10071 cp_error ("multiple declarations `%T' and `%T'", type
,
10075 type
= TREE_TYPE (id
);
10076 TREE_VALUE (spec
) = type
;
10081 error ("two or more data types in declaration of `%s'", name
);
10082 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
10084 register tree t
= lookup_name (id
, 1);
10085 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
10086 error ("`%s' fails to be a typedef or built in type",
10087 IDENTIFIER_POINTER (id
));
10090 type
= TREE_TYPE (t
);
10092 /* See the code below that used this. */
10093 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
10098 else if (id
!= error_mark_node
)
10099 /* Can't change CLASS nodes into RECORD nodes here! */
10105 typedef_type
= type
;
10107 /* No type at all: default to `int', and set DEFAULTED_INT
10108 because it was not a user-defined typedef. */
10110 if (type
== NULL_TREE
10111 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
10112 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10113 || RIDBIT_SETP (RID_LONG
, specbits
)
10114 || RIDBIT_SETP (RID_SHORT
, specbits
)))
10116 /* These imply 'int'. */
10117 type
= integer_type_node
;
10121 if (sfk
!= sfk_none
)
10122 type
= check_special_function_return_type (sfk
, type
,
10125 else if (type
== NULL_TREE
)
10131 /* We handle `main' specially here, because 'main () { }' is so
10132 common. With no options, it is allowed. With -Wreturn-type,
10133 it is a warning. It is only an error with -pedantic-errors. */
10134 is_main
= (funcdef_flag
10135 && MAIN_NAME_P (dname
)
10136 && ctype
== NULL_TREE
10137 && in_namespace
== NULL_TREE
10138 && current_namespace
== global_namespace
);
10140 if (in_system_header
|| flag_ms_extensions
)
10141 /* Allow it, sigh. */;
10142 else if (pedantic
|| ! is_main
)
10143 cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10145 else if (warn_return_type
)
10146 cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10149 type
= integer_type_node
;
10154 /* Now process the modifiers that were specified
10155 and check for invalid combinations. */
10157 /* Long double is a special combination. */
10159 if (RIDBIT_SETP (RID_LONG
, specbits
)
10160 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
10162 RIDBIT_RESET (RID_LONG
, specbits
);
10163 type
= build_qualified_type (long_double_type_node
,
10164 CP_TYPE_QUALS (type
));
10167 /* Check all other uses of type modifiers. */
10169 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10170 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10171 || RIDBIT_SETP (RID_LONG
, specbits
)
10172 || RIDBIT_SETP (RID_SHORT
, specbits
))
10176 if (TREE_CODE (type
) == REAL_TYPE
)
10177 error ("short, signed or unsigned invalid for `%s'", name
);
10178 else if (TREE_CODE (type
) != INTEGER_TYPE
)
10179 error ("long, short, signed or unsigned invalid for `%s'", name
);
10180 else if (RIDBIT_SETP (RID_LONG
, specbits
)
10181 && RIDBIT_SETP (RID_SHORT
, specbits
))
10182 error ("long and short specified together for `%s'", name
);
10183 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10184 || RIDBIT_SETP (RID_SHORT
, specbits
))
10186 error ("long or short specified with char for `%s'", name
);
10187 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10188 || RIDBIT_SETP (RID_SHORT
, specbits
))
10189 && TREE_CODE (type
) == REAL_TYPE
)
10190 error ("long or short specified with floating type for `%s'", name
);
10191 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10192 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
10193 error ("signed and unsigned given together for `%s'", name
);
10197 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
10199 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10201 if (flag_pedantic_errors
)
10206 /* Discard the type modifiers if they are invalid. */
10209 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
10210 RIDBIT_RESET (RID_SIGNED
, specbits
);
10211 RIDBIT_RESET (RID_LONG
, specbits
);
10212 RIDBIT_RESET (RID_SHORT
, specbits
);
10217 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
10218 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10220 error ("complex invalid for `%s'", name
);
10221 RIDBIT_RESET (RID_COMPLEX
, specbits
);
10224 /* Decide whether an integer type is signed or not.
10225 Optionally treat bitfields as signed by default. */
10226 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10229 It is implementation-defined whether a plain (neither
10230 explicitly signed or unsigned) char, short, int, or long
10231 bit-field is signed or unsigned.
10233 Naturally, we extend this to long long as well. Note that
10234 this does not include wchar_t. */
10235 || (bitfield
&& !flag_signed_bitfields
10236 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
10237 /* A typedef for plain `int' without `signed' can be
10238 controlled just like plain `int', but a typedef for
10239 `signed int' cannot be so controlled. */
10241 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10242 && (TREE_CODE (type
) == INTEGER_TYPE
10243 || TREE_CODE (type
) == CHAR_TYPE
)
10244 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10247 type
= long_long_unsigned_type_node
;
10248 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10249 type
= long_unsigned_type_node
;
10250 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10251 type
= short_unsigned_type_node
;
10252 else if (type
== char_type_node
)
10253 type
= unsigned_char_type_node
;
10254 else if (typedef_decl
)
10255 type
= unsigned_type (type
);
10257 type
= unsigned_type_node
;
10259 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10260 && type
== char_type_node
)
10261 type
= signed_char_type_node
;
10263 type
= long_long_integer_type_node
;
10264 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10265 type
= long_integer_type_node
;
10266 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10267 type
= short_integer_type_node
;
10269 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
10271 /* If we just have "complex", it is equivalent to
10272 "complex double", but if any modifiers at all are specified it is
10273 the complex form of TYPE. E.g, "complex short" is
10274 "complex short int". */
10276 if (defaulted_int
&& ! longlong
10277 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
10278 || RIDBIT_SETP (RID_SHORT
, specbits
)
10279 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10280 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
10281 type
= complex_double_type_node
;
10282 else if (type
== integer_type_node
)
10283 type
= complex_integer_type_node
;
10284 else if (type
== float_type_node
)
10285 type
= complex_float_type_node
;
10286 else if (type
== double_type_node
)
10287 type
= complex_double_type_node
;
10288 else if (type
== long_double_type_node
)
10289 type
= complex_long_double_type_node
;
10291 type
= build_complex_type (type
);
10294 if (sfk
== sfk_conversion
10295 && (RIDBIT_SETP (RID_CONST
, specbits
)
10296 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
10297 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
10298 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10301 /* Set CONSTP if this declaration is `const', whether by
10302 explicit specification or via a typedef.
10303 Likewise for VOLATILEP. */
10305 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
10307 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
10309 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
10310 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10311 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10312 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10313 type
= cp_build_qualified_type (type
, type_quals
);
10315 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
10316 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
10317 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
10318 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
10319 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
10321 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10322 staticp
= 1 + (decl_context
== FIELD
);
10324 if (virtualp
&& staticp
== 2)
10326 cp_error ("member `%D' cannot be declared both virtual and static",
10330 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
10331 RIDBIT_RESET (RID_FRIEND
, specbits
);
10333 /* Warn if two storage classes are given. Default to `auto'. */
10335 if (RIDBIT_ANY_SET (specbits
))
10337 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
10338 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
10339 if (decl_context
== PARM
&& nclasses
> 0)
10340 error ("storage class specifiers invalid in parameter declarations");
10341 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10343 if (decl_context
== PARM
)
10344 error ("typedef declaration invalid in parameter declaration");
10347 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
10348 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
10351 /* Give error if `virtual' is used outside of class declaration. */
10353 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10355 error ("virtual outside class declaration");
10359 /* Static anonymous unions are dealt with here. */
10360 if (staticp
&& decl_context
== TYPENAME
10361 && TREE_CODE (declspecs
) == TREE_LIST
10362 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
10363 decl_context
= FIELD
;
10365 /* Warn about storage classes that are invalid for certain
10366 kinds of declarations (parameters, typenames, etc.). */
10369 error ("multiple storage classes in declaration of `%s'", name
);
10370 else if (decl_context
!= NORMAL
&& nclasses
> 0)
10372 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
10373 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
10374 || RIDBIT_SETP (RID_AUTO
, specbits
)))
10376 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10378 else if (decl_context
== FIELD
10379 /* C++ allows static class elements */
10380 && RIDBIT_SETP (RID_STATIC
, specbits
))
10381 /* C++ also allows inlines and signed and unsigned elements,
10382 but in those cases we don't come in here. */
10386 if (decl_context
== FIELD
)
10388 tree tmp
= NULL_TREE
;
10389 register int op
= 0;
10393 /* Avoid trying to get an operand off an identifier node. */
10394 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10397 tmp
= TREE_OPERAND (declarator
, 0);
10398 op
= IDENTIFIER_OPNAME_P (tmp
);
10399 if (IDENTIFIER_TYPENAME_P (tmp
))
10401 if (IDENTIFIER_GLOBAL_VALUE (tmp
)
10402 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp
))
10404 name
= IDENTIFIER_POINTER (tmp
);
10406 name
= "<invalid operator>";
10409 error ("storage class specified for %s `%s'",
10410 op
? "member operator" : "field",
10415 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10416 error ("storage class specified for parameter `%s'", name
);
10418 error ("storage class specified for typename");
10420 RIDBIT_RESET (RID_REGISTER
, specbits
);
10421 RIDBIT_RESET (RID_AUTO
, specbits
);
10422 RIDBIT_RESET (RID_EXTERN
, specbits
);
10425 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
10427 if (toplevel_bindings_p ())
10429 /* It's common practice (and completely valid) to have a const
10430 be initialized and declared extern. */
10431 if (!(type_quals
& TYPE_QUAL_CONST
))
10432 warning ("`%s' initialized and declared `extern'", name
);
10435 error ("`%s' has both `extern' and initializer", name
);
10437 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
10438 && ! toplevel_bindings_p ())
10439 error ("nested function `%s' declared `extern'", name
);
10440 else if (toplevel_bindings_p ())
10442 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10443 error ("top-level declaration of `%s' specifies `auto'", name
);
10446 if (nclasses
> 0 && friendp
)
10447 error ("storage class specifiers invalid in friend function declarations");
10449 /* Now figure out the structure of the declarator proper.
10450 Descend through it, creating more complex types, until we reach
10451 the declared identifier (or NULL_TREE, in an absolute declarator). */
10453 inner_attrs
= NULL_TREE
;
10456 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
10457 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
10459 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10460 an INDIRECT_REF (for *...),
10461 a CALL_EXPR (for ...(...)),
10462 an identifier (for the name being declared)
10463 or a null pointer (for the place in an absolute declarator
10464 where the name was omitted).
10465 For the last two cases, we have just exited the loop.
10467 For C++ it could also be
10468 a SCOPE_REF (for class :: ...). In this case, we have converted
10469 sensible names to types, and those are the values we use to
10470 qualify the member name.
10471 an ADDR_EXPR (for &...),
10472 a BIT_NOT_EXPR (for destructors)
10474 At this point, TYPE is the type of elements of an array,
10475 or for a function to return, or for a pointer to point to.
10476 After this sequence of ifs, TYPE is the type of the
10477 array or function or pointer, and DECLARATOR has had its
10478 outermost layer removed. */
10480 if (type
== error_mark_node
)
10482 if (TREE_CODE (declarator
) == SCOPE_REF
)
10483 declarator
= TREE_OPERAND (declarator
, 1);
10485 declarator
= TREE_OPERAND (declarator
, 0);
10488 if (quals
!= NULL_TREE
10489 && (declarator
== NULL_TREE
10490 || TREE_CODE (declarator
) != SCOPE_REF
))
10492 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
10493 ctype
= TYPE_METHOD_BASETYPE (type
);
10494 if (ctype
!= NULL_TREE
)
10496 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
10497 grok_method_quals (ctype
, dummy
, quals
);
10498 type
= TREE_TYPE (dummy
);
10499 ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
)));
10504 /* See the comment for the TREE_LIST case, below. */
10507 else if (inner_attrs
)
10509 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10510 inner_attrs
= NULL_TREE
;
10513 switch (TREE_CODE (declarator
))
10517 /* We encode a declarator with embedded attributes using
10518 a TREE_LIST. The attributes apply to the declarator
10519 directly inside them, so we have to skip an iteration
10520 before applying them to the type. If the declarator just
10521 inside is the declarator-id, we apply the attrs to the
10523 inner_attrs
= TREE_PURPOSE (declarator
);
10525 declarator
= TREE_VALUE (declarator
);
10531 register tree size
;
10533 size
= TREE_OPERAND (declarator
, 1);
10535 /* VC++ spells a zero-sized array with []. */
10536 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10537 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10538 size
= integer_zero_node
;
10540 declarator
= TREE_OPERAND (declarator
, 0);
10542 type
= create_array_type_for_decl (dname
, type
, size
);
10544 /* VLAs never work as fields. */
10545 if (decl_context
== FIELD
&& !processing_template_decl
10546 && TREE_CODE (type
) == ARRAY_TYPE
10547 && TYPE_DOMAIN (type
) != NULL_TREE
10548 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
10550 cp_error ("size of member `%D' is not constant", dname
);
10551 /* Proceed with arbitrary constant size, so that offset
10552 computations don't get confused. */
10553 type
= create_array_type_for_decl (dname
, TREE_TYPE (type
),
10565 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
10566 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10568 /* Declaring a function type.
10569 Make sure we have a valid type for the function to return. */
10571 /* We now know that the TYPE_QUALS don't apply to the
10572 decl, but to its return type. */
10573 type_quals
= TYPE_UNQUALIFIED
;
10575 /* Warn about some types functions can't return. */
10577 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10579 error ("`%s' declared as function returning a function", name
);
10580 type
= integer_type_node
;
10582 if (TREE_CODE (type
) == ARRAY_TYPE
)
10584 error ("`%s' declared as function returning an array", name
);
10585 type
= integer_type_node
;
10588 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10589 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10591 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10592 inner_decl
= dname
;
10594 /* Pick up type qualifiers which should be applied to `this'. */
10595 quals
= CALL_DECLARATOR_QUALS (declarator
);
10597 /* Pick up the exception specifications. */
10598 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
10600 /* Say it's a definition only for the CALL_EXPR
10601 closest to the identifier. */
10604 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10605 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10606 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10608 if (ctype
== NULL_TREE
10609 && decl_context
== FIELD
10611 && (friendp
== 0 || dname
== current_class_name
))
10612 ctype
= current_class_type
;
10614 if (ctype
&& sfk
== sfk_conversion
)
10615 TYPE_HAS_CONVERSION (ctype
) = 1;
10616 if (ctype
&& constructor_name (ctype
) == dname
)
10618 /* We are within a class's scope. If our declarator name
10619 is the same as the class name, and we are defining
10620 a function, then it is a constructor/destructor, and
10621 therefore returns a void type. */
10623 if (flags
== DTOR_FLAG
)
10625 /* ISO C++ 12.4/2. A destructor may not be
10626 declared const or volatile. A destructor may
10629 error ("destructor cannot be static member function");
10632 cp_error ("destructors may not be `%s'",
10633 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10636 if (decl_context
== FIELD
)
10638 if (! member_function_or_else (ctype
,
10639 current_class_type
,
10641 return void_type_node
;
10644 else /* It's a constructor. */
10646 if (explicitp
== 1)
10648 /* ISO C++ 12.1. A constructor may not be
10649 declared const or volatile. A constructor may
10650 not be virtual. A constructor may not be
10653 error ("constructor cannot be static member function");
10656 pedwarn ("constructors cannot be declared virtual");
10661 cp_error ("constructors may not be `%s'",
10662 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10666 RID_BIT_TYPE tmp_bits
;
10667 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10668 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10669 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10670 if (RIDBIT_ANY_SET (tmp_bits
))
10671 error ("return value type specifier for constructor ignored");
10673 if (decl_context
== FIELD
)
10675 if (! member_function_or_else (ctype
,
10676 current_class_type
,
10678 return void_type_node
;
10679 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10680 if (sfk
!= sfk_constructor
)
10684 if (decl_context
== FIELD
)
10690 error ("can't initialize friend function `%s'", name
);
10693 /* Cannot be both friend and virtual. */
10694 error ("virtual functions cannot be friends");
10695 RIDBIT_RESET (RID_FRIEND
, specbits
);
10698 if (decl_context
== NORMAL
)
10699 error ("friend declaration not in class definition");
10700 if (current_function_decl
&& funcdef_flag
)
10701 cp_error ("can't define friend function `%s' in a local class definition",
10705 /* Construct the function type and go to the next
10706 inner layer of declarator. */
10708 declarator
= TREE_OPERAND (declarator
, 0);
10710 /* FIXME: This is where default args should be fully
10713 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10715 if (declarator
&& flags
== DTOR_FLAG
)
10717 /* A destructor declared in the body of a class will
10718 be represented as a BIT_NOT_EXPR. But, we just
10719 want the underlying IDENTIFIER. */
10720 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10721 declarator
= TREE_OPERAND (declarator
, 0);
10723 if (arg_types
!= void_list_node
)
10725 cp_error ("destructors may not have parameters");
10726 arg_types
= void_list_node
;
10727 last_function_parms
= NULL_TREE
;
10731 /* ANSI says that `const int foo ();'
10732 does not make the function foo const. */
10733 type
= build_function_type (type
, arg_types
);
10737 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10738 if (TREE_PURPOSE (t
)
10739 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10741 add_defarg_fn (type
);
10750 /* Filter out pointers-to-references and references-to-references.
10751 We can get these if a TYPE_DECL is used. */
10753 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10755 error ("cannot declare %s to references",
10756 TREE_CODE (declarator
) == ADDR_EXPR
10757 ? "references" : "pointers");
10758 declarator
= TREE_OPERAND (declarator
, 0);
10762 if (TREE_CODE (type
) == OFFSET_TYPE
10763 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10764 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10766 cp_error ("cannot declare pointer to `%#T' member",
10768 type
= TREE_TYPE (type
);
10771 /* Merge any constancy or volatility into the target type
10772 for the pointer. */
10774 /* We now know that the TYPE_QUALS don't apply to the decl,
10775 but to the target of the pointer. */
10776 type_quals
= TYPE_UNQUALIFIED
;
10778 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10780 if (TREE_CODE (type
) == VOID_TYPE
)
10781 error ("invalid type: `void &'");
10783 type
= build_reference_type (type
);
10785 else if (TREE_CODE (type
) == METHOD_TYPE
)
10786 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10788 type
= build_pointer_type (type
);
10790 /* Process a list of type modifier keywords (such as
10791 const or volatile) that were given inside the `*' or `&'. */
10793 if (TREE_TYPE (declarator
))
10795 register tree typemodlist
;
10801 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10802 typemodlist
= TREE_CHAIN (typemodlist
))
10804 tree qualifier
= TREE_VALUE (typemodlist
);
10806 if (qualifier
== ridpointers
[(int) RID_CONST
])
10808 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10810 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10815 error ("invalid type modifier within pointer declarator");
10819 pedwarn ("duplicate `const'");
10821 pedwarn ("duplicate `volatile'");
10823 pedwarn ("duplicate `restrict'");
10825 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10826 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10827 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10828 if (TREE_CODE (declarator
) == ADDR_EXPR
10829 && (constp
|| volatilep
))
10832 pedwarn ("discarding `const' applied to a reference");
10834 pedwarn ("discarding `volatile' applied to a reference");
10835 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10837 type
= cp_build_qualified_type (type
, type_quals
);
10839 declarator
= TREE_OPERAND (declarator
, 0);
10845 /* We have converted type names to NULL_TREE if the
10846 name was bogus, or to a _TYPE node, if not.
10848 The variable CTYPE holds the type we will ultimately
10849 resolve to. The code here just needs to build
10850 up appropriate member types. */
10851 tree sname
= TREE_OPERAND (declarator
, 1);
10854 /* Destructors can have their visibilities changed as well. */
10855 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10856 sname
= TREE_OPERAND (sname
, 0);
10858 if (TREE_COMPLEXITY (declarator
) == 0)
10859 /* This needs to be here, in case we are called
10860 multiple times. */ ;
10861 else if (TREE_COMPLEXITY (declarator
) == -1)
10862 /* Namespace member. */
10863 pop_decl_namespace ();
10864 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10865 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10866 else if (! IS_AGGR_TYPE_CODE
10867 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10869 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10871 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10872 that refer to ctype. They couldn't be resolved earlier
10873 because we hadn't pushed into the class yet.
10874 Example: resolve 'B<T>::type' in
10875 'B<typename B<T>::type> B<T>::f () { }'. */
10876 if (current_template_parms
10877 && uses_template_parms (type
)
10878 && uses_template_parms (current_class_type
))
10880 tree args
= current_template_args ();
10881 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10884 /* This pop_nested_class corresponds to the
10885 push_nested_class used to push into class scope for
10886 parsing the argument list of a function decl, in
10888 pop_nested_class ();
10889 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10892 my_friendly_abort (16);
10894 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10896 /* We had a reference to a global decl, or
10897 perhaps we were given a non-aggregate typedef,
10898 in which case we cleared this out, and should just
10899 keep going as though it wasn't there. */
10900 declarator
= sname
;
10903 ctype
= TREE_OPERAND (declarator
, 0);
10906 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10908 /* You're supposed to have one `template <...>'
10909 for every template class, but you don't need one
10910 for a full specialization. For example:
10912 template <class T> struct S{};
10913 template <> struct S<int> { void f(); };
10914 void S<int>::f () {}
10916 is correct; there shouldn't be a `template <>' for
10917 the definition of `S<int>::f'. */
10918 if (CLASSTYPE_TEMPLATE_INFO (t
)
10919 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
10920 || uses_template_parms (CLASSTYPE_TI_ARGS (t
))))
10921 template_count
+= 1;
10923 t
= TYPE_MAIN_DECL (t
);
10924 if (DECL_LANG_SPECIFIC (t
))
10925 t
= DECL_CONTEXT (t
);
10930 if (sname
== NULL_TREE
)
10933 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10935 /* This is the `standard' use of the scoping operator:
10936 basetype :: member . */
10938 if (ctype
== current_class_type
)
10944 Is this ill-formed? */
10947 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10950 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10952 if (current_class_type
== NULL_TREE
10954 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10955 TYPE_ARG_TYPES (type
));
10958 cp_error ("cannot declare member function `%T::%s' within `%T'",
10959 ctype
, name
, current_class_type
);
10960 return void_type_node
;
10963 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10964 || COMPLETE_TYPE_P (complete_type (ctype
)))
10966 /* Have to move this code elsewhere in this function.
10967 this code is used for i.e., typedef int A::M; M *pm;
10969 It is? How? jason 10/2/94 */
10971 if (current_class_type
)
10973 cp_error ("cannot declare member `%T::%s' within `%T'",
10974 ctype
, name
, current_class_type
);
10975 return void_type_node
;
10977 type
= build_offset_type (ctype
, type
);
10979 else if (uses_template_parms (ctype
))
10981 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10983 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10984 TYPE_ARG_TYPES (type
));
10988 cp_error ("structure `%T' not yet defined", ctype
);
10989 return error_mark_node
;
10992 declarator
= sname
;
10994 else if (TREE_CODE (sname
) == SCOPE_REF
)
10995 my_friendly_abort (17);
10999 declarator
= TREE_OPERAND (declarator
, 1);
11000 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
11001 /* In this case, we will deal with it later. */
11005 if (TREE_CODE (type
) == FUNCTION_TYPE
)
11006 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11007 TYPE_ARG_TYPES (type
));
11009 type
= build_offset_type (ctype
, type
);
11016 declarator
= TREE_OPERAND (declarator
, 0);
11021 case ENUMERAL_TYPE
:
11022 declarator
= NULL_TREE
;
11026 declarator
= NULL_TREE
;
11030 my_friendly_abort (158);
11034 /* See the comment for the TREE_LIST case, above. */
11037 if (! ignore_attrs
)
11038 decl_attributes (type
, inner_attrs
, NULL_TREE
);
11040 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
11042 attrlist
= build_tree_list (NULL_TREE
, inner_attrs
);
11045 /* Now TYPE has the actual type. */
11047 if (explicitp
== 1 || (explicitp
&& friendp
))
11049 /* [dcl.fct.spec] The explicit specifier shall only be used in
11050 declarations of constructors within a class definition. */
11051 error ("only declarations of constructors can be `explicit'");
11055 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11057 if (current_class_name
== NULL_TREE
|| decl_context
== PARM
|| friendp
)
11059 error ("non-member `%s' cannot be declared `mutable'", name
);
11060 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11062 else if (decl_context
== TYPENAME
|| RIDBIT_SETP (RID_TYPEDEF
, specbits
))
11064 error ("non-object member `%s' cannot be declared `mutable'", name
);
11065 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11067 else if (TREE_CODE (type
) == FUNCTION_TYPE
11068 || TREE_CODE (type
) == METHOD_TYPE
)
11070 error ("function `%s' cannot be declared `mutable'", name
);
11071 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11075 error ("static `%s' cannot be declared `mutable'", name
);
11076 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11078 else if (type_quals
& TYPE_QUAL_CONST
)
11080 error ("const `%s' cannot be declared `mutable'", name
);
11081 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11085 if (declarator
== NULL_TREE
11086 || TREE_CODE (declarator
) == IDENTIFIER_NODE
11087 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
11088 && (TREE_CODE (type
) == FUNCTION_TYPE
11089 || TREE_CODE (type
) == METHOD_TYPE
)))
11091 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11093 cp_error ("template-id `%D' used as a declarator", declarator
);
11094 declarator
= dname
;
11097 /* Unexpected declarator format. */
11098 my_friendly_abort (990210);
11100 /* If this is declaring a typedef name, return a TYPE_DECL. */
11102 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
11106 /* Note that the grammar rejects storage classes
11107 in typenames, fields or parameters. */
11108 if (current_lang_name
== lang_name_java
)
11109 TYPE_FOR_JAVA (type
) = 1;
11111 if (decl_context
== FIELD
)
11113 if (declarator
== constructor_name (current_class_type
))
11114 cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11116 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
11119 decl
= build_decl (TYPE_DECL
, declarator
, type
);
11121 /* If the user declares "typedef struct {...} foo" then the
11122 struct will have an anonymous name. Fill that name in now.
11123 Nothing can refer to it, so nothing needs know about the name
11125 if (type
!= error_mark_node
11127 && TYPE_NAME (type
)
11128 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11129 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
11130 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
11132 tree oldname
= TYPE_NAME (type
);
11135 /* Replace the anonymous name with the real name everywhere. */
11136 lookup_tag_reverse (type
, declarator
);
11137 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
11138 if (TYPE_NAME (t
) == oldname
)
11139 TYPE_NAME (t
) = decl
;
11141 if (TYPE_LANG_SPECIFIC (type
))
11142 TYPE_WAS_ANONYMOUS (type
) = 1;
11144 /* If this is a typedef within a template class, the nested
11145 type is a (non-primary) template. The name for the
11146 template needs updating as well. */
11147 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
11148 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
11149 = TYPE_IDENTIFIER (type
);
11152 DECL_ASSEMBLER_NAME (decl
) = mangle_type (type
);
11155 /* XXX Temporarily set the scope.
11156 When returning, start_decl expects it as NULL_TREE,
11157 and will then then set it using pushdecl. */
11158 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
11159 if (current_class_type
)
11160 DECL_CONTEXT (decl
) = current_class_type
;
11162 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
11164 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
11165 DECL_ASSEMBLER_NAME (decl
)
11166 = get_identifier (build_overload_name (type
, 1, 1));
11167 DECL_CONTEXT (decl
) = NULL_TREE
;
11170 /* FIXME remangle member functions; member functions of a
11171 type with external linkage have external linkage. */
11174 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11176 cp_error_at ("typedef name may not be class-qualified", decl
);
11181 if (ctype
== NULL_TREE
)
11183 if (TREE_CODE (type
) != METHOD_TYPE
)
11184 cp_error_at ("invalid type qualifier for non-member function type", decl
);
11186 ctype
= TYPE_METHOD_BASETYPE (type
);
11188 if (ctype
!= NULL_TREE
)
11189 grok_method_quals (ctype
, decl
, quals
);
11192 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
11193 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
11194 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
11196 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
11197 inlinep
, friendp
, raises
!= NULL_TREE
);
11200 error ("typedef declaration includes an initializer");
11205 /* Detect the case of an array type of unspecified size
11206 which came, as such, direct from a typedef name.
11207 We must copy the type, so that each identifier gets
11208 a distinct type, so that each identifier's size can be
11209 controlled separately by its own initializer. */
11211 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
11212 && TYPE_DOMAIN (type
) == NULL_TREE
)
11214 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
11217 /* If this is a type name (such as, in a cast or sizeof),
11218 compute the type and return it now. */
11220 if (decl_context
== TYPENAME
)
11222 /* Note that the grammar rejects storage classes
11223 in typenames, fields or parameters. */
11224 if (type_quals
!= TYPE_UNQUALIFIED
)
11225 type_quals
= TYPE_UNQUALIFIED
;
11227 /* Special case: "friend class foo" looks like a TYPENAME context. */
11230 if (type_quals
!= TYPE_UNQUALIFIED
)
11232 cp_error ("type qualifiers specified for friend class declaration");
11233 type_quals
= TYPE_UNQUALIFIED
;
11237 cp_error ("`inline' specified for friend class declaration");
11241 /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11242 But don't allow implicit typenames. */
11243 if (!current_aggr
&& (TREE_CODE (type
) != TYPENAME_TYPE
11244 || IMPLICIT_TYPENAME_P (type
)))
11246 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11247 cp_pedwarn ("template parameters cannot be friends");
11248 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
11250 friend declaration requires class-key, i.e. `friend class %T::%T'",
11251 constructor_name (current_class_type
),
11252 TYPE_IDENTIFIER (type
));
11255 friend declaration requires class-key, i.e. `friend %#T'",
11259 /* Only try to do this stuff if we didn't already give up. */
11260 if (type
!= integer_type_node
)
11262 /* A friendly class? */
11263 if (current_class_type
)
11264 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
11266 cp_error ("trying to make class `%T' a friend of global scope",
11268 type
= void_type_node
;
11273 if (ctype
== NULL_TREE
)
11275 if (TREE_CODE (type
) != METHOD_TYPE
)
11276 cp_error ("invalid qualifiers on non-member function type");
11278 ctype
= TYPE_METHOD_BASETYPE (type
);
11282 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
11283 grok_method_quals (ctype
, dummy
, quals
);
11284 type
= TREE_TYPE (dummy
);
11290 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
11291 && decl_context
!= CATCHPARM
11292 && TREE_CODE (type
) != UNION_TYPE
11295 cp_error ("abstract declarator `%T' used as declaration", type
);
11296 declarator
= make_anon_name ();
11299 /* `void' at top level (not within pointer)
11300 is allowed only in typedefs or type names.
11301 We don't complain about parms either, but that is because
11302 a better error message can be made later. */
11304 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
11307 error ("unnamed variable or field declared void");
11308 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
11310 if (IDENTIFIER_OPNAME_P (declarator
))
11311 my_friendly_abort (356);
11313 error ("variable or field `%s' declared void", name
);
11316 error ("variable or field declared void");
11317 type
= integer_type_node
;
11320 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11321 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11323 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11325 if (ctype
|| in_namespace
)
11326 error ("cannot use `::' in parameter declaration");
11328 /* A parameter declared as an array of T is really a pointer to T.
11329 One declared as a function is really a pointer to a function.
11330 One declared as a member is really a pointer to member. */
11332 if (TREE_CODE (type
) == ARRAY_TYPE
)
11334 /* Transfer const-ness of array into that of type pointed to. */
11335 type
= build_pointer_type (TREE_TYPE (type
));
11336 type_quals
= TYPE_UNQUALIFIED
;
11338 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11339 type
= build_pointer_type (type
);
11340 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11341 type
= build_pointer_type (type
);
11342 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
11344 error ("declaration of `%s' as void", name
);
11350 register tree decl
;
11352 if (decl_context
== PARM
)
11354 decl
= build_decl (PARM_DECL
, declarator
, type
);
11356 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
11357 inlinep
, friendp
, raises
!= NULL_TREE
);
11359 /* Compute the type actually passed in the parmlist,
11360 for the case where there is no prototype.
11361 (For example, shorts and chars are passed as ints.)
11362 When there is a prototype, this is overridden later. */
11364 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
11366 else if (decl_context
== FIELD
)
11368 if (type
== error_mark_node
)
11370 /* Happens when declaring arrays of sizes which
11371 are error_mark_node, for example. */
11374 else if (in_namespace
&& !friendp
)
11376 /* Something like struct S { int N::j; }; */
11377 cp_error ("invalid use of `::'");
11380 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11383 tree function_context
;
11385 /* We catch the others as conflicts with the builtin
11387 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
11389 cp_error ("function `%D' cannot be declared friend",
11396 if (ctype
== NULL_TREE
)
11397 ctype
= current_class_type
;
11399 if (ctype
== NULL_TREE
)
11401 cp_error ("can't make `%D' into a method -- not in a class",
11403 return void_type_node
;
11406 /* ``A union may [ ... ] not [ have ] virtual functions.''
11408 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11410 cp_error ("function `%D' declared virtual inside a union",
11412 return void_type_node
;
11415 if (declarator
== ansi_opname (NEW_EXPR
)
11416 || declarator
== ansi_opname (VEC_NEW_EXPR
)
11417 || declarator
== ansi_opname (DELETE_EXPR
)
11418 || declarator
== ansi_opname (VEC_DELETE_EXPR
))
11422 cp_error ("`%D' cannot be declared virtual, since it is always static",
11427 else if (staticp
< 2)
11428 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11429 TYPE_ARG_TYPES (type
));
11432 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11433 function_context
= (ctype
!= NULL_TREE
) ?
11434 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11435 publicp
= (! friendp
|| ! staticp
)
11436 && function_context
== NULL_TREE
;
11437 decl
= grokfndecl (ctype
, type
,
11438 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
11439 ? declarator
: dname
,
11441 virtualp
, flags
, quals
, raises
,
11442 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11443 funcdef_flag
, template_count
, in_namespace
);
11444 if (decl
== NULL_TREE
)
11447 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11448 /* The decl and setting of decl_machine_attr is also turned off. */
11449 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11452 /* [class.conv.ctor]
11454 A constructor declared without the function-specifier
11455 explicit that can be called with a single parameter
11456 specifies a conversion from the type of its first
11457 parameter to the type of its class. Such a constructor
11458 is called a converting constructor. */
11459 if (explicitp
== 2)
11460 DECL_NONCONVERTING_P (decl
) = 1;
11461 else if (DECL_CONSTRUCTOR_P (decl
))
11463 /* The constructor can be called with exactly one
11464 parameter if there is at least one parameter, and
11465 any subsequent parameters have default arguments.
11466 We don't look at the first parameter, which is
11467 really just the `this' parameter for the new
11470 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11472 /* Skip the `in_chrg' argument too, if present. */
11473 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
11474 arg_types
= TREE_CHAIN (arg_types
);
11476 if (arg_types
== void_list_node
11478 && TREE_CHAIN (arg_types
)
11479 && TREE_CHAIN (arg_types
) != void_list_node
11480 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11481 DECL_NONCONVERTING_P (decl
) = 1;
11484 else if (TREE_CODE (type
) == METHOD_TYPE
)
11486 /* We only get here for friend declarations of
11487 members of other classes. */
11488 /* All method decls are public, so tell grokfndecl to set
11489 TREE_PUBLIC, also. */
11490 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11491 virtualp
, flags
, quals
, raises
,
11492 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11493 template_count
, in_namespace
);
11494 if (decl
== NULL_TREE
)
11497 else if (!staticp
&& ! processing_template_decl
11498 && !COMPLETE_TYPE_P (complete_type (type
))
11499 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11502 cp_error ("field `%D' has incomplete type", declarator
);
11504 cp_error ("name `%T' has incomplete type", type
);
11506 /* If we're instantiating a template, tell them which
11507 instantiation made the field's type be incomplete. */
11508 if (current_class_type
11509 && TYPE_NAME (current_class_type
)
11510 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11511 && declspecs
&& TREE_VALUE (declspecs
)
11512 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11513 cp_error (" in instantiation of template `%T'",
11514 current_class_type
);
11516 type
= error_mark_node
;
11523 error ("`%s' is neither function nor member function; cannot be declared friend",
11524 IDENTIFIER_POINTER (declarator
));
11532 /* Friends are treated specially. */
11533 if (ctype
== current_class_type
)
11534 warning ("member functions are implicitly friends of their class");
11537 tree t
= NULL_TREE
;
11538 if (decl
&& DECL_NAME (decl
))
11540 if (template_class_depth (current_class_type
) == 0)
11543 = check_explicit_specialization
11545 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11546 if (decl
== error_mark_node
)
11547 return error_mark_node
;
11550 t
= do_friend (ctype
, declarator
, decl
,
11551 last_function_parms
, attrlist
, flags
, quals
,
11554 if (t
&& funcdef_flag
)
11557 return void_type_node
;
11561 /* Structure field. It may not be a function, except for C++ */
11563 if (decl
== NULL_TREE
)
11569 /* An attempt is being made to initialize a non-static
11570 member. But, from [class.mem]:
11572 4 A member-declarator can contain a
11573 constant-initializer only if it declares a static
11574 member (_class.static_) of integral or enumeration
11575 type, see _class.static.data_.
11577 This used to be relatively common practice, but
11578 the rest of the compiler does not correctly
11579 handle the initialization unless the member is
11580 static so we make it static below. */
11581 cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11583 cp_pedwarn ("making `%D' static", declarator
);
11587 if (uses_template_parms (type
))
11588 /* We'll check at instantiation time. */
11590 else if (check_static_variable_definition (declarator
,
11592 /* If we just return the declaration, crashes
11593 will sometimes occur. We therefore return
11594 void_type_node, as if this was a friend
11595 declaration, to cause callers to completely
11596 ignore this declaration. */
11597 return void_type_node
;
11600 /* 9.2p13 [class.mem] */
11601 if (declarator
== constructor_name (current_class_type
)
11602 /* The standard does not allow non-static data members
11603 here either, but we agreed at the 10/99 meeting
11604 to change that in TC 1 so that they are allowed in
11605 classes with no user-defined constructors. */
11607 cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11612 /* C++ allows static class members. All other work
11613 for this is done by grokfield. */
11614 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
11615 TREE_STATIC (decl
) = 1;
11616 /* In class context, 'static' means public access. */
11617 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11621 decl
= build_decl (FIELD_DECL
, declarator
, type
);
11622 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11623 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11625 DECL_MUTABLE_P (decl
) = 1;
11626 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11630 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11631 inlinep
, friendp
, raises
!= NULL_TREE
);
11634 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11636 tree original_name
;
11642 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11643 original_name
= dname
;
11645 original_name
= declarator
;
11647 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11648 error ("storage class `auto' invalid for function `%s'", name
);
11649 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11650 error ("storage class `register' invalid for function `%s'", name
);
11652 /* Function declaration not at top level.
11653 Storage classes other than `extern' are not allowed
11654 and `extern' makes no difference. */
11655 if (! toplevel_bindings_p ()
11656 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11657 || RIDBIT_SETP (RID_INLINE
, specbits
))
11660 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11661 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11663 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11666 if (ctype
== NULL_TREE
)
11670 error ("virtual non-class function `%s'", name
);
11674 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11675 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11676 TYPE_ARG_TYPES (type
));
11678 /* Record presence of `static'. */
11679 publicp
= (ctype
!= NULL_TREE
11680 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11681 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11683 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11684 virtualp
, flags
, quals
, raises
,
11686 publicp
, inlinep
, funcdef_flag
,
11687 template_count
, in_namespace
);
11688 if (decl
== NULL_TREE
)
11693 int illegal_static
= 0;
11695 /* Don't allow a static member function in a class, and forbid
11696 declaring main to be static. */
11697 if (TREE_CODE (type
) == METHOD_TYPE
)
11699 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11700 illegal_static
= 1;
11702 else if (current_function_decl
)
11704 /* FIXME need arm citation */
11705 error ("cannot declare static function inside another function");
11706 illegal_static
= 1;
11709 if (illegal_static
)
11712 RIDBIT_RESET (RID_STATIC
, specbits
);
11718 /* It's a variable. */
11720 /* An uninitialized decl with `extern' is a reference. */
11721 decl
= grokvardecl (type
, declarator
, &specbits
,
11723 (type_quals
& TYPE_QUAL_CONST
) != 0,
11725 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11726 inlinep
, friendp
, raises
!= NULL_TREE
);
11730 DECL_CONTEXT (decl
) = ctype
;
11733 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11735 RIDBIT_RESET (RID_STATIC
, specbits
);
11737 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11739 cp_error ("static member `%D' declared `register'", decl
);
11740 RIDBIT_RESET (RID_REGISTER
, specbits
);
11742 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11744 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11746 RIDBIT_RESET (RID_EXTERN
, specbits
);
11751 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE
, specbits
), 19990927);
11753 /* Record `register' declaration for warnings on &
11754 and in case doing stupid register allocation. */
11756 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11757 DECL_REGISTER (decl
) = 1;
11759 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11760 DECL_THIS_EXTERN (decl
) = 1;
11762 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11763 DECL_THIS_STATIC (decl
) = 1;
11765 /* Record constancy and volatility. There's no need to do this
11766 when processing a template; we'll do this for the instantiated
11767 declaration based on the type of DECL. */
11768 if (!processing_template_decl
)
11769 c_apply_type_quals_to_decl (type_quals
, decl
);
11775 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11776 An empty exprlist is a parmlist. An exprlist which
11777 contains only identifiers at the global level
11778 is a parmlist. Otherwise, it is an exprlist. */
11781 parmlist_is_exprlist (exprs
)
11784 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11787 if (toplevel_bindings_p ())
11789 /* At the global level, if these are all identifiers,
11790 then it is a parmlist. */
11793 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11795 exprs
= TREE_CHAIN (exprs
);
11802 /* Subroutine of start_function. Ensure that each of the parameter
11803 types (as listed in PARMS) is complete, as is required for a
11804 function definition. */
11807 require_complete_types_for_parms (parms
)
11810 for (; parms
; parms
= TREE_CHAIN (parms
))
11812 tree type
= TREE_TYPE (parms
);
11814 /* Try to complete the TYPE. */
11815 type
= complete_type (type
);
11817 if (type
== error_mark_node
)
11820 if (!COMPLETE_TYPE_P (type
))
11822 if (DECL_NAME (parms
))
11823 error ("parameter `%s' has incomplete type",
11824 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11826 error ("parameter has incomplete type");
11827 TREE_TYPE (parms
) = error_mark_node
;
11830 layout_decl (parms
, 0);
11834 /* Returns non-zero if T is a local variable. */
11837 local_variable_p (t
)
11840 if ((TREE_CODE (t
) == VAR_DECL
11841 /* A VAR_DECL with a context that is a _TYPE is a static data
11843 && !TYPE_P (CP_DECL_CONTEXT (t
))
11844 /* Any other non-local variable must be at namespace scope. */
11845 && !DECL_NAMESPACE_SCOPE_P (t
))
11846 || (TREE_CODE (t
) == PARM_DECL
))
11852 /* Returns non-zero if T is an automatic local variable or a label.
11853 (These are the declarations that need to be remapped when the code
11854 containing them is duplicated.) */
11857 nonstatic_local_decl_p (t
)
11860 return ((local_variable_p (t
) && !TREE_STATIC (t
))
11861 || TREE_CODE (t
) == LABEL_DECL
11862 || TREE_CODE (t
) == RESULT_DECL
);
11865 /* Like local_variable_p, but suitable for use as a tree-walking
11869 local_variable_p_walkfn (tp
, walk_subtrees
, data
)
11871 int *walk_subtrees ATTRIBUTE_UNUSED
;
11872 void *data ATTRIBUTE_UNUSED
;
11874 return ((local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
11875 ? *tp
: NULL_TREE
);
11878 /* Check that ARG, which is a default-argument expression for a
11879 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11880 something goes wrong. DECL may also be a _TYPE node, rather than a
11881 DECL, if there is no DECL available. */
11884 check_default_argument (decl
, arg
)
11891 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11892 /* We get a DEFAULT_ARG when looking at an in-class declaration
11893 with a default argument. Ignore the argument for now; we'll
11894 deal with it after the class is complete. */
11897 if (processing_template_decl
|| uses_template_parms (arg
))
11898 /* We don't do anything checking until instantiation-time. Note
11899 that there may be uninstantiated arguments even for an
11900 instantiated function, since default arguments are not
11901 instantiated until they are needed. */
11910 decl_type
= TREE_TYPE (decl
);
11912 if (arg
== error_mark_node
11913 || decl
== error_mark_node
11914 || TREE_TYPE (arg
) == error_mark_node
11915 || decl_type
== error_mark_node
)
11916 /* Something already went wrong. There's no need to check
11918 return error_mark_node
;
11920 /* [dcl.fct.default]
11922 A default argument expression is implicitly converted to the
11924 if (!TREE_TYPE (arg
)
11925 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11928 cp_error ("default argument for `%#D' has type `%T'",
11929 decl
, TREE_TYPE (arg
));
11931 cp_error ("default argument for parameter of type `%T' has type `%T'",
11932 decl_type
, TREE_TYPE (arg
));
11934 return error_mark_node
;
11937 /* [dcl.fct.default]
11939 Local variables shall not be used in default argument
11942 The keyword `this' shall not be used in a default argument of a
11943 member function. */
11944 var
= walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
,
11948 cp_error ("default argument `%E' uses local variable `%D'",
11950 return error_mark_node
;
11957 /* Decode the list of parameter types for a function type.
11958 Given the list of things declared inside the parens,
11959 return a list of types.
11961 The list we receive can have three kinds of elements:
11962 an IDENTIFIER_NODE for names given without types,
11963 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11964 or void_type_node, to mark the end of an argument list
11965 when additional arguments are not permitted (... was not used).
11967 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11968 a mere declaration. A nonempty identifier-list gets an error message
11969 when FUNCDEF_FLAG is zero.
11970 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11971 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11973 If all elements of the input list contain types,
11974 we return a list of the types.
11975 If all elements contain no type (except perhaps a void_type_node
11976 at the end), we return a null list.
11977 If some have types and some do not, it is an error, and we
11978 return a null list.
11980 Also set last_function_parms to either
11981 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11982 A list of names is converted to a chain of PARM_DECLs
11983 by store_parm_decls so that ultimately it is always a chain of decls.
11985 Note that in C++, parameters can take default values. These default
11986 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11987 an error to specify default values which are followed by parameters
11988 that have no default values, or an ELLIPSES. For simplicities sake,
11989 only parameters which are specified with their types can take on
11993 grokparms (first_parm
, funcdef_flag
)
11997 tree result
= NULL_TREE
;
11998 tree decls
= NULL_TREE
;
12000 if (first_parm
!= NULL_TREE
12001 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
12003 if (! funcdef_flag
)
12004 pedwarn ("parameter names (without types) in function declaration");
12005 last_function_parms
= first_parm
;
12008 else if (first_parm
!= NULL_TREE
12009 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
12010 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
12011 my_friendly_abort (145);
12014 /* Types were specified. This is a list of declarators
12015 each represented as a TREE_LIST node. */
12016 register tree parm
, chain
;
12017 int any_init
= 0, any_error
= 0;
12019 if (first_parm
!= NULL_TREE
)
12021 tree last_result
= NULL_TREE
;
12022 tree last_decl
= NULL_TREE
;
12024 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
12026 tree type
= NULL_TREE
, list_node
= parm
;
12027 register tree decl
= TREE_VALUE (parm
);
12028 tree init
= TREE_PURPOSE (parm
);
12030 chain
= TREE_CHAIN (parm
);
12031 /* @@ weak defense against parse errors. */
12032 if (TREE_CODE (decl
) != VOID_TYPE
12033 && TREE_CODE (decl
) != TREE_LIST
)
12035 /* Give various messages as the need arises. */
12036 if (TREE_CODE (decl
) == STRING_CST
)
12037 cp_error ("invalid string constant `%E'", decl
);
12038 else if (TREE_CODE (decl
) == INTEGER_CST
)
12039 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12043 if (TREE_CODE (decl
) != VOID_TYPE
)
12045 decl
= grokdeclarator (TREE_VALUE (decl
),
12046 TREE_PURPOSE (decl
),
12047 PARM
, init
!= NULL_TREE
,
12049 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
12052 /* Top-level qualifiers on the parameters are
12053 ignored for function types. */
12054 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
12056 if (TREE_CODE (type
) == VOID_TYPE
)
12057 decl
= void_type_node
;
12058 else if (TREE_CODE (type
) == METHOD_TYPE
)
12060 if (DECL_NAME (decl
))
12061 /* Cannot use the decl here because
12062 we don't have DECL_CONTEXT set up yet. */
12063 cp_error ("parameter `%D' invalidly declared method type",
12066 error ("parameter invalidly declared method type");
12067 type
= build_pointer_type (type
);
12068 TREE_TYPE (decl
) = type
;
12070 else if (TREE_CODE (type
) == OFFSET_TYPE
)
12072 if (DECL_NAME (decl
))
12073 cp_error ("parameter `%D' invalidly declared offset type",
12076 error ("parameter invalidly declared offset type");
12077 type
= build_pointer_type (type
);
12078 TREE_TYPE (decl
) = type
;
12080 else if (abstract_virtuals_error (decl
, type
))
12081 any_error
= 1; /* Seems like a good idea. */
12082 else if (POINTER_TYPE_P (type
))
12085 while (POINTER_TYPE_P (t
)
12086 || (TREE_CODE (t
) == ARRAY_TYPE
12087 && TYPE_DOMAIN (t
) != NULL_TREE
))
12089 if (TREE_CODE (t
) == ARRAY_TYPE
)
12090 cp_error ("parameter type `%T' includes %s to array of unknown bound",
12092 TYPE_PTR_P (type
) ? "pointer" : "reference");
12096 if (TREE_CODE (decl
) == VOID_TYPE
)
12098 if (result
== NULL_TREE
)
12100 result
= void_list_node
;
12101 last_result
= result
;
12105 TREE_CHAIN (last_result
) = void_list_node
;
12106 last_result
= void_list_node
;
12109 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
12110 error ("`void' in parameter list must be entire list");
12114 /* Since there is a prototype, args are passed in their own types. */
12115 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
12116 if (PROMOTE_PROTOTYPES
12117 && (TREE_CODE (type
) == INTEGER_TYPE
12118 || TREE_CODE (type
) == ENUMERAL_TYPE
)
12119 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
12120 DECL_ARG_TYPE (decl
) = integer_type_node
;
12121 if (!any_error
&& init
)
12124 init
= check_default_argument (decl
, init
);
12129 if (decls
== NULL_TREE
)
12136 TREE_CHAIN (last_decl
) = decl
;
12139 list_node
= tree_cons (init
, type
, NULL_TREE
);
12140 if (result
== NULL_TREE
)
12142 result
= list_node
;
12143 last_result
= result
;
12147 TREE_CHAIN (last_result
) = list_node
;
12148 last_result
= list_node
;
12152 TREE_CHAIN (last_result
) = NULL_TREE
;
12153 /* If there are no parameters, and the function does not end
12154 with `...', then last_decl will be NULL_TREE. */
12155 if (last_decl
!= NULL_TREE
)
12156 TREE_CHAIN (last_decl
) = NULL_TREE
;
12160 last_function_parms
= decls
;
12165 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12166 FUNCTION_TYPE with the newly parsed version of its default argument, which
12167 was previously digested as text. See snarf_defarg et al in lex.c. */
12170 replace_defarg (arg
, init
)
12173 if (! processing_template_decl
12174 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
12175 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12176 TREE_TYPE (init
), TREE_VALUE (arg
));
12177 TREE_PURPOSE (arg
) = init
;
12180 /* D is a constructor or overloaded `operator='. Returns non-zero if
12181 D's arguments allow it to be a copy constructor, or copy assignment
12190 if (!DECL_FUNCTION_MEMBER_P (d
))
12193 t
= FUNCTION_ARG_CHAIN (d
);
12194 if (DECL_CONSTRUCTOR_P (d
) && DECL_HAS_IN_CHARGE_PARM_P (d
))
12195 t
= TREE_CHAIN (t
);
12196 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
12197 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
12198 == DECL_CONTEXT (d
))
12199 && (TREE_CHAIN (t
) == NULL_TREE
12200 || TREE_CHAIN (t
) == void_list_node
12201 || TREE_PURPOSE (TREE_CHAIN (t
))))
12206 /* These memoizing functions keep track of special properties which
12207 a class may have. `grok_ctor_properties' notices whether a class
12208 has a constructor of the form X(X&), and also complains
12209 if the class has a constructor of the form X(X).
12210 `grok_op_properties' takes notice of the various forms of
12211 operator= which are defined, as well as what sorts of type conversion
12212 may apply. Both functions take a FUNCTION_DECL as an argument. */
12215 grok_ctor_properties (ctype
, decl
)
12218 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
12219 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
12221 /* When a type has virtual baseclasses, a magical first int argument is
12222 added to any ctor so we can tell if the class has been initialized
12223 yet. This could screw things up in this function, so we deliberately
12224 ignore the leading int if we're in that situation. */
12225 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
12227 my_friendly_assert (parmtypes
12228 && TREE_VALUE (parmtypes
) == integer_type_node
,
12230 parmtypes
= TREE_CHAIN (parmtypes
);
12231 parmtype
= TREE_VALUE (parmtypes
);
12236 A non-template constructor for class X is a copy constructor if
12237 its first parameter is of type X&, const X&, volatile X& or const
12238 volatile X&, and either there are no other parameters or else all
12239 other parameters have default arguments. */
12240 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
12241 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
12242 && (TREE_CHAIN (parmtypes
) == NULL_TREE
12243 || TREE_CHAIN (parmtypes
) == void_list_node
12244 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
12245 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12246 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12248 TYPE_HAS_INIT_REF (ctype
) = 1;
12249 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12250 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
12254 A declaration of a constructor for a class X is ill-formed if its
12255 first parameter is of type (optionally cv-qualified) X and either
12256 there are no other parameters or else all other parameters have
12259 We *don't* complain about member template instantiations that
12260 have this form, though; they can occur as we try to decide what
12261 constructor to use during overload resolution. Since overload
12262 resolution will never prefer such a constructor to the
12263 non-template copy constructor (which is either explicitly or
12264 implicitly defined), there's no need to worry about their
12265 existence. Theoretically, they should never even be
12266 instantiated, but that's hard to forestall. */
12267 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
12268 && (TREE_CHAIN (parmtypes
) == NULL_TREE
12269 || TREE_CHAIN (parmtypes
) == void_list_node
12270 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
12271 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12272 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12274 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12276 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
12279 else if (TREE_CODE (parmtype
) == VOID_TYPE
12280 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
12281 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
12286 /* An operator with this code is unary, but can also be binary. */
12290 enum tree_code code
;
12292 return (code
== INDIRECT_REF
12293 || code
== ADDR_EXPR
12294 || code
== CONVERT_EXPR
12295 || code
== NEGATE_EXPR
12296 || code
== PREINCREMENT_EXPR
12297 || code
== PREDECREMENT_EXPR
);
12300 /* An operator with this name can only be unary. */
12304 enum tree_code code
;
12306 return (code
== TRUTH_NOT_EXPR
12307 || code
== BIT_NOT_EXPR
12308 || code
== COMPONENT_REF
12309 || code
== TYPE_EXPR
);
12312 /* Do a little sanity-checking on how they declared their operator. */
12315 grok_op_properties (decl
, virtualp
, friendp
)
12317 int virtualp
, friendp
;
12319 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12321 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12322 tree name
= DECL_NAME (decl
);
12323 enum tree_code operator_code
;
12326 /* Count the number of arguments. */
12327 for (argtype
= argtypes
, arity
= 0;
12328 argtype
&& argtype
!= void_list_node
;
12329 argtype
= TREE_CHAIN (argtype
))
12332 if (current_class_type
== NULL_TREE
)
12335 if (DECL_CONV_FN_P (decl
))
12336 operator_code
= TYPE_EXPR
;
12340 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P) \
12341 if (ansi_opname (CODE) == name) \
12343 operator_code = CODE; \
12346 else if (ansi_assopname (CODE) == name) \
12348 operator_code = CODE; \
12349 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12353 #include "operators.def"
12354 #undef DEF_OPERATOR
12356 my_friendly_abort (20000527);
12359 my_friendly_assert (operator_code
!= LAST_CPLUS_TREE_CODE
, 20000526);
12360 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12364 switch (operator_code
)
12367 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
12371 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
12374 case COMPONENT_REF
:
12376 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
12380 TYPE_HAS_NEW_OPERATOR (current_class_type
) = 1;
12384 TYPE_GETS_DELETE (current_class_type
) |= 1;
12388 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type
) = 1;
12391 case VEC_DELETE_EXPR
:
12392 TYPE_GETS_DELETE (current_class_type
) |= 2;
12400 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12402 /* When the compiler encounters the definition of A::operator new, it
12403 doesn't look at the class declaration to find out if it's static. */
12405 revert_static_member_fn (decl
);
12407 /* Take care of function decl if we had syntax errors. */
12408 if (argtypes
== NULL_TREE
)
12410 = build_function_type (ptr_type_node
,
12411 hash_tree_chain (integer_type_node
,
12414 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12416 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12419 revert_static_member_fn (decl
);
12421 if (argtypes
== NULL_TREE
)
12423 = build_function_type (void_type_node
,
12424 hash_tree_chain (ptr_type_node
,
12427 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12431 /* An operator function must either be a non-static member function
12432 or have at least one parameter of a class, a reference to a class,
12433 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12434 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12436 if (operator_code
== TYPE_EXPR
12437 || operator_code
== CALL_EXPR
12438 || operator_code
== COMPONENT_REF
12439 || operator_code
== ARRAY_REF
12440 || operator_code
== NOP_EXPR
)
12441 cp_error ("`%D' must be a nonstatic member function", decl
);
12446 if (DECL_STATIC_FUNCTION_P (decl
))
12447 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
12450 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
12452 tree arg
= TREE_VALUE (p
);
12453 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
12454 arg
= TREE_TYPE (arg
);
12456 /* This lets bad template code slip through. */
12457 if (IS_AGGR_TYPE (arg
)
12458 || TREE_CODE (arg
) == ENUMERAL_TYPE
12459 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
12460 || TREE_CODE (arg
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12464 ("`%D' must have an argument of class or enumerated type",
12471 if (operator_code
== CALL_EXPR
)
12472 return; /* No restrictions on args. */
12474 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
12476 tree t
= TREE_TYPE (name
);
12479 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12480 const char *what
= 0;
12483 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12485 if (TREE_CODE (t
) == VOID_TYPE
)
12487 else if (t
== current_class_type
)
12488 what
= "the same type";
12489 /* Don't force t to be complete here. */
12490 else if (IS_AGGR_TYPE (t
)
12491 && COMPLETE_TYPE_P (t
)
12492 && DERIVED_FROM_P (t
, current_class_type
))
12493 what
= "a base class";
12496 warning ("conversion to %s%s will never use a type conversion operator",
12497 ref
? "a reference to " : "", what
);
12501 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
12502 && operator_code
== NOP_EXPR
)
12506 if (arity
!= 2 && methodp
)
12508 cp_error ("`%D' must take exactly one argument", decl
);
12511 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12515 A user-declared copy assignment operator X::operator= is
12516 a non-static non-template member function of class X with
12517 exactly one parameter of type X, X&, const X&, volatile
12518 X& or const volatile X&. */
12519 if (copy_assignment_arg_p (parmtype
, virtualp
)
12520 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12521 && is_member_template (DECL_TI_TEMPLATE (decl
)))
12524 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12525 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12526 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12527 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12530 else if (operator_code
== COND_EXPR
)
12533 cp_error ("ISO C++ prohibits overloading operator ?:");
12535 else if (ambi_op_p (operator_code
))
12538 /* We pick the one-argument operator codes by default, so
12539 we don't have to change anything. */
12541 else if (arity
== 2)
12543 /* If we thought this was a unary operator, we now know
12544 it to be a binary operator. */
12545 switch (operator_code
)
12548 operator_code
= MULT_EXPR
;
12552 operator_code
= BIT_AND_EXPR
;
12556 operator_code
= PLUS_EXPR
;
12560 operator_code
= MINUS_EXPR
;
12563 case PREINCREMENT_EXPR
:
12564 operator_code
= POSTINCREMENT_EXPR
;
12567 case PREDECREMENT_EXPR
:
12568 operator_code
= POSTDECREMENT_EXPR
;
12572 my_friendly_abort (20000527);
12575 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12577 if ((operator_code
== POSTINCREMENT_EXPR
12578 || operator_code
== POSTDECREMENT_EXPR
)
12579 && ! processing_template_decl
12580 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12583 cp_error ("postfix `%D' must take `int' as its argument",
12587 ("postfix `%D' must take `int' as its second argument",
12594 cp_error ("`%D' must take either zero or one argument", decl
);
12596 cp_error ("`%D' must take either one or two arguments", decl
);
12599 /* More Effective C++ rule 6. */
12601 && (operator_code
== POSTINCREMENT_EXPR
12602 || operator_code
== POSTDECREMENT_EXPR
12603 || operator_code
== PREINCREMENT_EXPR
12604 || operator_code
== PREDECREMENT_EXPR
))
12606 tree arg
= TREE_VALUE (argtypes
);
12607 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12608 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12609 arg
= TREE_TYPE (arg
);
12610 arg
= TYPE_MAIN_VARIANT (arg
);
12611 if (operator_code
== PREINCREMENT_EXPR
12612 || operator_code
== PREDECREMENT_EXPR
)
12614 if (TREE_CODE (ret
) != REFERENCE_TYPE
12615 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12617 cp_warning ("prefix `%D' should return `%T'", decl
,
12618 build_reference_type (arg
));
12622 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12623 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12627 else if (unary_op_p (operator_code
))
12632 cp_error ("`%D' must take `void'", decl
);
12634 cp_error ("`%D' must take exactly one argument", decl
);
12637 else /* if (binary_op_p (operator_code)) */
12642 cp_error ("`%D' must take exactly one argument", decl
);
12644 cp_error ("`%D' must take exactly two arguments", decl
);
12647 /* More Effective C++ rule 7. */
12649 && (operator_code
== TRUTH_ANDIF_EXPR
12650 || operator_code
== TRUTH_ORIF_EXPR
12651 || operator_code
== COMPOUND_EXPR
))
12652 cp_warning ("user-defined `%D' always evaluates both arguments",
12656 /* Effective C++ rule 23. */
12659 && (operator_code
== PLUS_EXPR
12660 || operator_code
== MINUS_EXPR
12661 || operator_code
== TRUNC_DIV_EXPR
12662 || operator_code
== MULT_EXPR
)
12663 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12664 cp_warning ("`%D' should return by value", decl
);
12667 for (; argtypes
&& argtypes
!= void_list_node
;
12668 argtypes
= TREE_CHAIN (argtypes
))
12669 if (TREE_PURPOSE (argtypes
))
12671 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12672 if (operator_code
== POSTINCREMENT_EXPR
12673 || operator_code
== POSTDECREMENT_EXPR
)
12676 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12679 cp_error ("`%D' cannot have default arguments", decl
);
12685 static const char *
12687 enum tag_types code
;
12700 my_friendly_abort (981122);
12704 /* Get the struct, enum or union (CODE says which) with tag NAME.
12705 Define the tag as a forward-reference if it is not defined.
12707 C++: If a class derivation is given, process it here, and report
12708 an error if multiple derivation declarations are not identical.
12710 If this is a definition, come in through xref_tag and only look in
12711 the current frame for the name (since C++ allows new names in any
12715 xref_tag (code_type_node
, name
, globalize
)
12716 tree code_type_node
;
12720 enum tag_types tag_code
;
12721 enum tree_code code
;
12722 register tree ref
, t
;
12723 struct binding_level
*b
= current_binding_level
;
12725 tree attributes
= NULL_TREE
;
12726 tree context
= NULL_TREE
;
12728 /* If we are called from the parser, code_type_node will sometimes be a
12729 TREE_LIST. This indicates that the user wrote
12730 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12732 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12734 attributes
= TREE_PURPOSE (code_type_node
);
12735 code_type_node
= TREE_VALUE (code_type_node
);
12738 tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12743 code
= RECORD_TYPE
;
12749 code
= ENUMERAL_TYPE
;
12752 my_friendly_abort (18);
12755 /* If a cross reference is requested, look up the type
12756 already defined for this tag and return it. */
12760 name
= TYPE_IDENTIFIER (t
);
12764 t
= IDENTIFIER_TYPE_VALUE (name
);
12766 /* Warn about 'friend struct Inherited;' doing the wrong thing. */
12767 if (t
&& globalize
&& TREE_CODE (t
) == TYPENAME_TYPE
)
12769 static int explained
;
12771 cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12772 to refer to the inherited type, say `%s %T::%T'%s",
12773 tag_name (tag_code
), name
, tag_name (tag_code
),
12774 constructor_name (current_class_type
), TYPE_IDENTIFIER (t
),
12776 (names from dependent base classes are not visible to unqualified name lookup)"
12782 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12783 && TREE_CODE (t
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
12788 /* If we know we are defining this tag, only look it up in
12789 this scope and don't try to find it as a type. */
12790 ref
= lookup_tag (code
, name
, b
, 1);
12796 /* [dcl.type.elab] If the identifier resolves to a
12797 typedef-name or a template type-parameter, the
12798 elaborated-type-specifier is ill-formed. */
12799 if (t
!= TYPE_MAIN_VARIANT (t
)
12800 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12801 cp_pedwarn ("using typedef-name `%D' after `%s'",
12802 TYPE_NAME (t
), tag_name (tag_code
));
12803 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12804 cp_error ("using template type parameter `%T' after `%s'",
12805 t
, tag_name (tag_code
));
12810 ref
= lookup_tag (code
, name
, b
, 0);
12814 /* Try finding it as a type declaration. If that wins,
12816 ref
= lookup_name (name
, 1);
12818 if (ref
!= NULL_TREE
12819 && processing_template_decl
12820 && DECL_CLASS_TEMPLATE_P (ref
)
12821 && template_class_depth (current_class_type
) == 0)
12822 /* Since GLOBALIZE is true, we're declaring a global
12823 template, so we want this type. */
12824 ref
= DECL_TEMPLATE_RESULT (ref
);
12826 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12827 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12828 ref
= TREE_TYPE (ref
);
12833 if (ref
&& current_class_type
12834 && template_class_depth (current_class_type
)
12835 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12837 /* Since GLOBALIZE is non-zero, we are not looking at a
12838 definition of this tag. Since, in addition, we are currently
12839 processing a (member) template declaration of a template
12840 class, we must be very careful; consider:
12847 { template <class V>
12848 friend struct S1; };
12850 Here, the S2::S1 declaration should not be confused with the
12851 outer declaration. In particular, the inner version should
12852 have a template parameter of level 2, not level 1. This
12853 would be particularly important if the member declaration
12856 template <class V = U> friend struct S1;
12858 say, when we should tsubst into `U' when instantiating
12859 S2. On the other hand, when presented with:
12869 we must find the inner binding eventually. We
12870 accomplish this by making sure that the new type we
12871 create to represent this declaration has the right
12873 context
= TYPE_CONTEXT (ref
);
12880 /* If no such tag is yet defined, create a forward-reference node
12881 and record it as the "definition".
12882 When a real declaration of this type is found,
12883 the forward-reference will be altered into a real type. */
12884 if (code
== ENUMERAL_TYPE
)
12886 cp_error ("use of enum `%#D' without previous declaration", name
);
12888 ref
= make_node (ENUMERAL_TYPE
);
12890 /* Give the type a default layout like unsigned int
12891 to avoid crashing if it does not get defined. */
12892 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12893 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12894 TYPE_USER_ALIGN (ref
) = 0;
12895 TREE_UNSIGNED (ref
) = 1;
12896 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12897 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12898 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12900 /* Enable us to recognize when a type is created in class context.
12901 To do nested classes correctly, this should probably be cleared
12902 out when we leave this classes scope. Currently this in only
12903 done in `start_enum'. */
12905 pushtag (name
, ref
, globalize
);
12909 struct binding_level
*old_b
= class_binding_level
;
12911 ref
= make_aggr_type (code
);
12912 TYPE_CONTEXT (ref
) = context
;
12914 #ifdef NONNESTED_CLASSES
12915 /* Class types don't nest the way enums do. */
12916 class_binding_level
= (struct binding_level
*)0;
12918 pushtag (name
, ref
, globalize
);
12919 class_binding_level
= old_b
;
12924 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12925 redeclare_class_template (ref
, current_template_parms
);
12928 /* Until the type is defined, tentatively accept whatever
12929 structure tag the user hands us. */
12930 if (!COMPLETE_TYPE_P (ref
)
12931 && ref
!= current_class_type
12932 /* Have to check this, in case we have contradictory tag info. */
12933 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12935 if (tag_code
== class_type
)
12936 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12937 else if (tag_code
== record_type
)
12938 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12941 TREE_TYPE (ref
) = attributes
;
12947 xref_tag_from_type (old
, id
, globalize
)
12951 tree code_type_node
;
12953 if (TREE_CODE (old
) == RECORD_TYPE
)
12954 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12955 ? class_type_node
: record_type_node
);
12957 code_type_node
= union_type_node
;
12959 if (id
== NULL_TREE
)
12960 id
= TYPE_IDENTIFIER (old
);
12962 return xref_tag (code_type_node
, id
, globalize
);
12965 /* REF is a type (named NAME), for which we have just seen some
12966 baseclasses. BINFO is a list of those baseclasses; the
12967 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12968 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12969 struct, or union. */
12972 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12973 tree code_type_node
;
12977 /* In the declaration `A : X, Y, ... Z' we mark all the types
12978 (A, X, Y, ..., Z) so we can check for duplicates. */
12983 enum tag_types tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12985 if (tag_code
== union_type
)
12987 cp_error ("derived union `%T' invalid", ref
);
12991 len
= list_length (binfo
);
12993 /* First, make sure that any templates in base-classes are
12994 instantiated. This ensures that if we call ourselves recursively
12995 we do not get confused about which classes are marked and which
12997 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12998 complete_type (TREE_VALUE (base
));
13000 SET_CLASSTYPE_MARKED (ref
);
13001 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
13003 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
13005 /* The base of a derived struct is public by default. */
13007 = (TREE_PURPOSE (binfo
) == access_public_node
13008 || TREE_PURPOSE (binfo
) == access_public_virtual_node
13009 || (tag_code
!= class_type
13010 && (TREE_PURPOSE (binfo
) == access_default_node
13011 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
13013 = (TREE_PURPOSE (binfo
) == access_protected_node
13014 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
13016 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
13017 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
13018 || TREE_PURPOSE (binfo
) == access_public_virtual_node
13019 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
13020 tree basetype
= TREE_VALUE (binfo
);
13023 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
13024 basetype
= TREE_TYPE (basetype
);
13026 || (TREE_CODE (basetype
) != RECORD_TYPE
13027 && TREE_CODE (basetype
) != TYPENAME_TYPE
13028 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
13029 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
))
13031 cp_error ("base type `%T' fails to be a struct or class type",
13032 TREE_VALUE (binfo
));
13036 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
13038 /* This code replaces similar code in layout_basetypes.
13039 We put the complete_type first for implicit `typename'. */
13040 if (!COMPLETE_TYPE_P (basetype
)
13041 && ! (current_template_parms
&& uses_template_parms (basetype
)))
13043 cp_error ("base class `%T' has incomplete type", basetype
);
13048 if (CLASSTYPE_MARKED (basetype
))
13050 if (basetype
== ref
)
13051 cp_error ("recursive type `%T' undefined", basetype
);
13053 cp_error ("duplicate base type `%T' invalid", basetype
);
13057 if (TYPE_FOR_JAVA (basetype
)
13058 && (current_lang_stack
13059 == &VARRAY_TREE (current_lang_base
, 0)))
13060 TYPE_FOR_JAVA (ref
) = 1;
13062 /* Note that the BINFO records which describe individual
13063 inheritances are *not* shared in the lattice! They
13064 cannot be shared because a given baseclass may be
13065 inherited with different `accessibility' by different
13066 derived classes. (Each BINFO record describing an
13067 individual inheritance contains flags which say what
13068 the `accessibility' of that particular inheritance is.) */
13071 = make_binfo (size_zero_node
, basetype
,
13072 CLASS_TYPE_P (basetype
)
13073 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
13074 CLASS_TYPE_P (basetype
)
13075 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
13077 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
13078 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
13079 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
13080 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
13081 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
13083 /* We need to unshare the binfos now so that lookups during class
13084 definition work. */
13085 unshare_base_binfos (base_binfo
);
13087 SET_CLASSTYPE_MARKED (basetype
);
13089 /* We are free to modify these bits because they are meaningless
13090 at top level, and BASETYPE is a top-level type. */
13091 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
13093 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
13094 /* Converting to a virtual base class requires looking
13095 up the offset of the virtual base. */
13096 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
13099 if (CLASS_TYPE_P (basetype
))
13101 TYPE_HAS_NEW_OPERATOR (ref
)
13102 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13103 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13104 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13105 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13106 /* If the base-class uses multiple inheritance, so do we. */
13107 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
13108 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
13109 /* Likewise, if converting to a base of the base may require
13110 code, then we may need to generate code to convert to a
13112 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
)
13113 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
);
13120 TREE_VEC_LENGTH (binfos
) = i
;
13122 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
13126 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
13127 /* If there is more than one non-empty they cannot be at the same
13129 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
13132 /* Unmark all the types. */
13134 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
13135 CLEAR_CLASSTYPE_MARKED (ref
);
13137 /* Now that we know all the base-classes, set up the list of virtual
13139 get_vbase_types (ref
);
13143 /* Begin compiling the definition of an enumeration type.
13144 NAME is its name (or null if anonymous).
13145 Returns the type object, as yet incomplete.
13146 Also records info about it so that build_enumerator
13147 may be used to declare the individual values as they are read. */
13153 register tree enumtype
= NULL_TREE
;
13154 struct binding_level
*b
= current_binding_level
;
13156 /* If this is the real definition for a previous forward reference,
13157 fill in the contents in the same object that used to be the
13158 forward reference. */
13160 if (name
!= NULL_TREE
)
13161 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
13163 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13165 cp_error ("multiple definition of `%#T'", enumtype
);
13166 cp_error_at ("previous definition here", enumtype
);
13167 /* Clear out TYPE_VALUES, and start again. */
13168 TYPE_VALUES (enumtype
) = NULL_TREE
;
13172 enumtype
= make_node (ENUMERAL_TYPE
);
13173 pushtag (name
, enumtype
, 0);
13176 if (current_class_type
)
13177 TREE_ADDRESSABLE (b
->tags
) = 1;
13179 GNU_xref_decl (current_function_decl
, enumtype
);
13183 /* After processing and defining all the values of an enumeration type,
13184 install their decls in the enumeration type and finish it off.
13185 ENUMTYPE is the type object and VALUES a list of name-value pairs.
13186 Returns ENUMTYPE. */
13189 finish_enum (enumtype
)
13192 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
13193 /* Calculate the maximum value of any enumerator in this type. */
13195 tree values
= TYPE_VALUES (enumtype
);
13200 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
13205 /* The TREE_VALUE is a CONST_DECL for this enumeration
13207 decl
= TREE_VALUE (pair
);
13211 Following the closing brace of an enum-specifier, each
13212 enumerator has the type of its enumeration. Prior to the
13213 closing brace, the type of each enumerator is the type of
13214 its initializing value. */
13215 TREE_TYPE (decl
) = enumtype
;
13217 /* The DECL_INITIAL will be NULL if we are processing a
13218 template declaration and this enumeration constant had no
13219 explicit initializer. */
13220 value
= DECL_INITIAL (decl
);
13221 if (value
&& !processing_template_decl
)
13223 /* Set the TREE_TYPE for the VALUE as well. That's so
13224 that when we call decl_constant_value we get an
13225 entity of the right type (but with the constant
13226 value). Since we shouldn't ever call
13227 decl_constant_value on a template type, there's no
13228 reason to do that when processing_template_decl.
13229 And, if the expression is something like a
13230 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13231 wreak havoc on the intended type of the expression.
13233 Of course, there's also no point in trying to compute
13234 minimum or maximum values if we're in a template. */
13235 TREE_TYPE (value
) = enumtype
;
13238 minnode
= maxnode
= value
;
13239 else if (tree_int_cst_lt (maxnode
, value
))
13241 else if (tree_int_cst_lt (value
, minnode
))
13245 if (processing_template_decl
)
13246 /* If this is just a template, leave the CONST_DECL
13247 alone. That way tsubst_copy will find CONST_DECLs for
13248 CONST_DECLs, and not INTEGER_CSTs. */
13251 /* In the list we're building up, we want the enumeration
13252 values, not the CONST_DECLs. */
13253 TREE_VALUE (pair
) = value
;
13257 maxnode
= minnode
= integer_zero_node
;
13259 TYPE_VALUES (enumtype
) = nreverse (values
);
13261 if (processing_template_decl
)
13263 tree scope
= current_scope ();
13264 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
13265 add_stmt (build_min (TAG_DEFN
, enumtype
));
13269 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
13270 int lowprec
= min_precision (minnode
, unsignedp
);
13271 int highprec
= min_precision (maxnode
, unsignedp
);
13272 int precision
= MAX (lowprec
, highprec
);
13275 TYPE_SIZE (enumtype
) = NULL_TREE
;
13277 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
13279 TYPE_PRECISION (enumtype
) = precision
;
13281 fixup_unsigned_type (enumtype
);
13283 fixup_signed_type (enumtype
);
13285 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
13286 /* Use the width of the narrowest normal C type which is wide
13288 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
13291 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
13293 TYPE_SIZE (enumtype
) = 0;
13294 layout_type (enumtype
);
13296 /* Fix up all variant types of this enum type. */
13297 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
13298 tem
= TYPE_NEXT_VARIANT (tem
))
13300 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
13301 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
13302 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
13303 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
13304 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
13305 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
13306 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
13307 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
13308 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
13309 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
13312 /* Finish debugging output for this type. */
13313 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13319 /* Build and install a CONST_DECL for an enumeration constant of the
13320 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13321 Assignment of sequential values by default is handled here. */
13324 build_enumerator (name
, value
, enumtype
)
13334 /* Remove no-op casts from the value. */
13336 STRIP_TYPE_NOPS (value
);
13338 if (! processing_template_decl
)
13340 /* Validate and default VALUE. */
13341 if (value
!= NULL_TREE
)
13343 value
= decl_constant_value (value
);
13345 if (TREE_CODE (value
) == INTEGER_CST
)
13347 value
= default_conversion (value
);
13348 constant_expression_warning (value
);
13352 cp_error ("enumerator value for `%D' not integer constant", name
);
13357 /* Default based on previous value. */
13358 if (value
== NULL_TREE
&& ! processing_template_decl
)
13362 if (TYPE_VALUES (enumtype
))
13364 /* The next value is the previous value ... */
13365 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13366 /* ... plus one. */
13367 value
= cp_build_binary_op (PLUS_EXPR
,
13371 if (tree_int_cst_lt (value
, prev_value
))
13372 cp_error ("overflow in enumeration values at `%D'", name
);
13375 value
= integer_zero_node
;
13378 /* Remove no-op casts from the value. */
13380 STRIP_TYPE_NOPS (value
);
13382 /* To fix MAX_VAL enum consts. (bkoz) */
13383 TREE_TYPE (value
) = integer_type_node
;
13387 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13388 Even in other cases, we will later (in finish_enum) be setting
13389 the type of VALUE. But, we don't need to make a copy if this
13390 VALUE is one of the enumeration constants for this same
13391 enumeration type. */
13392 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13393 if (TREE_VALUE (values
) == value
)
13395 /* If we didn't break out of the loop, then we do need a copy. */
13396 if (!values
&& value
)
13397 value
= copy_node (value
);
13399 /* C++ associates enums with global, function, or class declarations. */
13400 context
= current_scope ();
13402 /* Build the actual enumeration constant. Note that the enumeration
13403 constants have the type of their initializers until the
13404 enumeration is complete:
13408 Following the closing brace of an enum-specifier, each enumer-
13409 ator has the type of its enumeration. Prior to the closing
13410 brace, the type of each enumerator is the type of its
13411 initializing value.
13413 In finish_enum we will reset the type. Of course, if we're
13414 processing a template, there may be no value. */
13415 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13417 if (context
&& context
== current_class_type
)
13418 /* This enum declaration is local to the class. We need the full
13419 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13420 decl
= build_lang_decl (CONST_DECL
, name
, type
);
13422 /* It's a global enum, or it's local to a function. (Note local to
13423 a function could mean local to a class method. */
13424 decl
= build_decl (CONST_DECL
, name
, type
);
13426 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
13427 DECL_INITIAL (decl
) = value
;
13428 TREE_READONLY (decl
) = 1;
13430 if (context
&& context
== current_class_type
)
13431 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13432 on the TYPE_FIELDS list for `S'. (That's so that you can say
13433 things like `S::i' later.) */
13434 finish_member_declaration (decl
);
13438 GNU_xref_decl (current_function_decl
, decl
);
13441 /* Add this enumeration constant to the list for this type. */
13442 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13446 /* We're defining DECL. Make sure that it's type is OK. */
13449 check_function_type (decl
, current_function_parms
)
13451 tree current_function_parms
;
13453 tree fntype
= TREE_TYPE (decl
);
13454 tree return_type
= complete_type (TREE_TYPE (fntype
));
13456 /* In a function definition, arg types must be complete. */
13457 require_complete_types_for_parms (current_function_parms
);
13459 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13461 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
13463 /* Make it return void instead, but don't change the
13464 type of the DECL_RESULT, in case we have a named return value. */
13465 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13467 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
13469 = build_cplus_method_type (ctype
,
13471 FUNCTION_ARG_CHAIN (decl
));
13475 = build_function_type (void_type_node
,
13476 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
13478 = build_exception_variant (fntype
,
13479 TYPE_RAISES_EXCEPTIONS (fntype
));
13482 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13485 /* Create the FUNCTION_DECL for a function definition.
13486 DECLSPECS and DECLARATOR are the parts of the declaration;
13487 they describe the function's name and the type it returns,
13488 but twisted together in a fashion that parallels the syntax of C.
13490 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13491 DECLARATOR is really the DECL for the function we are about to
13492 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13493 indicating that the function is an inline defined in-class.
13495 This function creates a binding context for the function body
13496 as well as setting up the FUNCTION_DECL in current_function_decl.
13498 Returns 1 on success. If the DECLARATOR is not suitable for a function
13499 (it defines a datum instead), we return 0, which tells
13500 yyparse to report a parse error.
13502 For C++, we must first check whether that datum makes any sense.
13503 For example, "class A local_a(1,2);" means that variable local_a
13504 is an aggregate of type A, which should have a constructor
13505 applied to it with the argument list [1, 2]. */
13508 start_function (declspecs
, declarator
, attrs
, flags
)
13509 tree declspecs
, declarator
, attrs
;
13513 tree ctype
= NULL_TREE
;
13516 extern int have_extern_spec
;
13517 extern int used_extern_spec
;
13518 int doing_friend
= 0;
13519 struct binding_level
*bl
;
13520 tree current_function_parms
;
13522 /* Sanity check. */
13523 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
13524 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
13526 /* This should only be done once on the top most decl. */
13527 if (have_extern_spec
&& !used_extern_spec
)
13529 declspecs
= tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
13530 used_extern_spec
= 1;
13533 if (flags
& SF_PRE_PARSED
)
13535 decl1
= declarator
;
13537 fntype
= TREE_TYPE (decl1
);
13538 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13539 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13541 /* ISO C++ 11.4/5. A friend function defined in a class is in
13542 the (lexical) scope of the class in which it is defined. */
13543 if (!ctype
&& DECL_FRIEND_P (decl1
))
13545 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13547 /* CTYPE could be null here if we're dealing with a template;
13548 for example, `inline friend float foo()' inside a template
13549 will have no CTYPE set. */
13550 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13556 last_function_parms
= DECL_ARGUMENTS (decl1
);
13557 last_function_parm_tags
= NULL_TREE
;
13561 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
13562 /* If the declarator is not suitable for a function definition,
13563 cause a syntax error. */
13564 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13566 fntype
= TREE_TYPE (decl1
);
13568 restype
= TREE_TYPE (fntype
);
13569 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13571 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13572 shadow_tag (build_tree_list (NULL_TREE
, restype
));
13573 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13574 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13575 fntype
= build_function_type (integer_type_node
,
13576 TYPE_ARG_TYPES (fntype
));
13578 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13580 TYPE_ARG_TYPES (fntype
));
13581 TREE_TYPE (decl1
) = fntype
;
13584 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13585 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13586 else if (DECL_MAIN_P (decl1
))
13588 /* If this doesn't return integer_type, complain. */
13589 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13591 if (pedantic
|| warn_return_type
)
13592 pedwarn ("return type for `main' changed to `int'");
13593 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13598 /* Sometimes we don't notice that a function is a static member, and
13599 build a METHOD_TYPE for it. Fix that up now. */
13600 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13601 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
13603 revert_static_member_fn (decl1
);
13604 last_function_parms
= TREE_CHAIN (last_function_parms
);
13608 /* Warn if function was previously implicitly declared
13609 (but not if we warned then). */
13610 if (! warn_implicit
13611 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13612 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13614 /* Set up current_class_type, and enter the scope of the class, if
13617 push_nested_class (ctype
, 1);
13618 else if (DECL_STATIC_FUNCTION_P (decl1
))
13619 push_nested_class (DECL_CONTEXT (decl1
), 2);
13621 /* Now that we have entered the scope of the class, we must restore
13622 the bindings for any template parameters surrounding DECL1, if it
13623 is an inline member template. (Order is important; consider the
13624 case where a template parameter has the same name as a field of
13625 the class.) It is not until after this point that
13626 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13627 if (flags
& SF_INCLASS_INLINE
)
13628 maybe_begin_member_template_processing (decl1
);
13630 /* Effective C++ rule 15. */
13632 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13633 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13634 cp_warning ("`operator=' should return a reference to `*this'");
13636 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13637 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13638 if (!DECL_INITIAL (decl1
))
13639 DECL_INITIAL (decl1
) = error_mark_node
;
13641 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13642 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13645 /* This function exists in static storage.
13646 (This does not mean `static' in the C sense!) */
13647 TREE_STATIC (decl1
) = 1;
13649 /* We must call push_template_decl after current_class_type is set
13650 up. (If we are processing inline definitions after exiting a
13651 class scope, current_class_type will be NULL_TREE until set above
13652 by push_nested_class.) */
13653 if (processing_template_decl
)
13654 decl1
= push_template_decl (decl1
);
13656 /* We are now in the scope of the function being defined. */
13657 current_function_decl
= decl1
;
13659 /* Save the parm names or decls from this function's declarator
13660 where store_parm_decls will find them. */
13661 current_function_parms
= last_function_parms
;
13662 current_function_parm_tags
= last_function_parm_tags
;
13664 /* Make sure the parameter and return types are reasonable. When
13665 you declare a function, these types can be incomplete, but they
13666 must be complete when you define the function. */
13667 if (! processing_template_decl
)
13668 check_function_type (decl1
, current_function_parms
);
13670 /* Build the return declaration for the function. */
13671 restype
= TREE_TYPE (fntype
);
13672 if (!processing_template_decl
)
13674 if (!DECL_RESULT (decl1
))
13676 DECL_RESULT (decl1
)
13677 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13678 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype
),
13679 DECL_RESULT (decl1
));
13683 /* Just use `void'. Nobody will ever look at this anyhow. */
13684 DECL_RESULT (decl1
) = build_decl (RESULT_DECL
, 0, void_type_node
);
13686 /* Initialize RTL machinery. We cannot do this until
13687 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13688 even when processing a template; this is how we get
13689 CFUN set up, and our per-function variables initialized. */
13690 bl
= current_binding_level
;
13691 init_function_start (decl1
, input_filename
, lineno
);
13692 current_binding_level
= bl
;
13694 /* Even though we're inside a function body, we still don't want to
13695 call expand_expr to calculate the size of a variable-sized array.
13696 We haven't necessarily assigned RTL to all variables yet, so it's
13697 not safe to try to expand expressions involving them. */
13698 immediate_size_expand
= 0;
13699 cfun
->x_dont_save_pending_sizes_p
= 1;
13701 /* Start the statement-tree, start the tree now. */
13702 begin_stmt_tree (&DECL_SAVED_TREE (decl1
));
13704 /* Let the user know we're compiling this function. */
13705 announce_function (decl1
);
13707 /* Record the decl so that the function name is defined.
13708 If we already have a decl for this name, and it is a FUNCTION_DECL,
13709 use the old decl. */
13710 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13712 /* A specialization is not used to guide overload resolution. */
13713 if (!DECL_TEMPLATE_SPECIALIZATION (decl1
)
13714 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13715 decl1
= pushdecl (decl1
);
13718 /* We need to set the DECL_CONTEXT. */
13719 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13720 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13721 /* And make sure we have enough default args. */
13722 check_default_args (decl1
);
13724 fntype
= TREE_TYPE (decl1
);
13727 /* Reset these in case the call to pushdecl changed them. */
13728 current_function_decl
= decl1
;
13729 cfun
->decl
= decl1
;
13731 /* If we are (erroneously) defining a function that we have already
13732 defined before, wipe out what we knew before. */
13733 if (!DECL_PENDING_INLINE_P (decl1
)
13734 && DECL_SAVED_FUNCTION_DATA (decl1
))
13736 free (DECL_SAVED_FUNCTION_DATA (decl1
));
13737 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13740 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13742 /* We know that this was set up by `grokclassfn'. We do not
13743 wait until `store_parm_decls', since evil parse errors may
13744 never get us to that point. Here we keep the consistency
13745 between `current_class_type' and `current_class_ptr'. */
13746 tree t
= DECL_ARGUMENTS (decl1
);
13748 my_friendly_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
,
13750 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
13753 cp_function_chain
->x_current_class_ref
13754 = build_indirect_ref (t
, NULL_PTR
);
13755 cp_function_chain
->x_current_class_ptr
= t
;
13757 /* Constructors and destructors need to know whether they're "in
13758 charge" of initializing virtual base classes. */
13759 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13760 current_in_charge_parm
= TREE_CHAIN (t
);
13763 if (DECL_INTERFACE_KNOWN (decl1
))
13765 tree ctx
= decl_function_context (decl1
);
13767 if (DECL_NOT_REALLY_EXTERN (decl1
))
13768 DECL_EXTERNAL (decl1
) = 0;
13770 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13771 && TREE_PUBLIC (ctx
))
13772 /* This is a function in a local class in an extern inline
13774 comdat_linkage (decl1
);
13776 /* If this function belongs to an interface, it is public.
13777 If it belongs to someone else's interface, it is also external.
13778 This only affects inlines and template instantiations. */
13779 else if (interface_unknown
== 0
13780 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13781 || flag_alt_external_templates
))
13783 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13784 || processing_template_decl
)
13786 DECL_EXTERNAL (decl1
)
13788 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13789 && !DECL_VINDEX (decl1
)));
13791 /* For WIN32 we also want to put these in linkonce sections. */
13792 maybe_make_one_only (decl1
);
13795 DECL_EXTERNAL (decl1
) = 0;
13796 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13797 DECL_INTERFACE_KNOWN (decl1
) = 1;
13799 else if (interface_unknown
&& interface_only
13800 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13801 || flag_alt_external_templates
))
13803 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13804 interface, we will have interface_only set but not
13805 interface_known. In that case, we don't want to use the normal
13806 heuristics because someone will supply a #pragma implementation
13807 elsewhere, and deducing it here would produce a conflict. */
13808 comdat_linkage (decl1
);
13809 DECL_EXTERNAL (decl1
) = 0;
13810 DECL_INTERFACE_KNOWN (decl1
) = 1;
13811 DECL_DEFER_OUTPUT (decl1
) = 1;
13815 /* This is a definition, not a reference.
13816 So clear DECL_EXTERNAL. */
13817 DECL_EXTERNAL (decl1
) = 0;
13819 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13820 && ! DECL_INTERFACE_KNOWN (decl1
)
13821 /* Don't try to defer nested functions for now. */
13822 && ! decl_function_context (decl1
))
13823 DECL_DEFER_OUTPUT (decl1
) = 1;
13825 DECL_INTERFACE_KNOWN (decl1
) = 1;
13829 current_binding_level
->parm_flag
= 1;
13832 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13834 /* We need to do this even if we aren't expanding yet so that
13835 assemble_external works. */
13836 make_function_rtl (decl1
);
13838 /* Promote the value to int before returning it. */
13839 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13840 restype
= type_promotes_to (restype
);
13842 /* If this fcn was already referenced via a block-scope `extern' decl
13843 (or an implicit decl), propagate certain information about the usage. */
13844 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13845 TREE_ADDRESSABLE (decl1
) = 1;
13847 if (DECL_RESULT (decl1
) == NULL_TREE
)
13849 DECL_RESULT (decl1
)
13850 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13851 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13852 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13857 if (DECL_DESTRUCTOR_P (decl1
))
13859 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13860 DECL_CONTEXT (dtor_label
) = current_function_decl
;
13862 /* Under the old ABI we return `this' from constructors, so we make
13863 ordinary `return' statements in constructors jump to CTOR_LABEL;
13864 from there we return `this'. Under the new ABI, we don't bother
13865 with any of this. By not setting CTOR_LABEL the remainder of the
13866 machinery is automatically disabled. */
13867 else if (!flag_new_abi
&& DECL_CONSTRUCTOR_P (decl1
))
13869 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13870 DECL_CONTEXT (ctor_label
) = current_function_decl
;
13873 store_parm_decls (current_function_parms
);
13878 /* Store the parameter declarations into the current function declaration.
13879 This is called after parsing the parameter declarations, before
13880 digesting the body of the function.
13882 Also install to binding contour return value identifier, if any. */
13885 store_parm_decls (current_function_parms
)
13886 tree current_function_parms
;
13888 register tree fndecl
= current_function_decl
;
13889 register tree parm
;
13890 int parms_have_cleanups
= 0;
13891 tree cleanups
= NULL_TREE
;
13893 /* This is a list of types declared among parms in a prototype. */
13894 tree parmtags
= current_function_parm_tags
;
13896 /* This is a chain of any other decls that came in among the parm
13897 declarations. If a parm is declared with enum {foo, bar} x;
13898 then CONST_DECLs for foo and bar are put here. */
13899 tree nonparms
= NULL_TREE
;
13901 if (current_function_parms
)
13903 /* This case is when the function was defined with an ANSI prototype.
13904 The parms already have decls, so we need not do anything here
13905 except record them as in effect
13906 and complain if any redundant old-style parm decls were written. */
13908 tree specparms
= current_function_parms
;
13911 /* Must clear this because it might contain TYPE_DECLs declared
13913 storedecls (NULL_TREE
);
13915 /* If we're doing semantic analysis, then we'll call pushdecl
13916 for each of these. We must do them in reverse order so that
13917 they end in the correct forward order. */
13918 specparms
= nreverse (specparms
);
13920 for (parm
= specparms
; parm
; parm
= next
)
13922 next
= TREE_CHAIN (parm
);
13923 if (TREE_CODE (parm
) == PARM_DECL
)
13927 if (DECL_NAME (parm
) == NULL_TREE
13928 || TREE_CODE (parm
) != VOID_TYPE
)
13931 cp_error ("parameter `%D' declared void", parm
);
13933 cleanup
= (processing_template_decl
13935 : maybe_build_cleanup (parm
));
13938 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13942 /* If we find an enum constant or a type tag,
13943 put it aside for the moment. */
13944 TREE_CHAIN (parm
) = NULL_TREE
;
13945 nonparms
= chainon (nonparms
, parm
);
13949 /* Get the decls in their original chain order and record in the
13950 function. This is all and only the PARM_DECLs that were
13951 pushed into scope by the loop above. */
13952 DECL_ARGUMENTS (fndecl
) = getdecls ();
13953 storetags (chainon (parmtags
, gettags ()));
13956 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13958 /* Now store the final chain of decls for the arguments
13959 as the decl-chain of the current lexical scope.
13960 Put the enumerators in as well, at the front so that
13961 DECL_ARGUMENTS is not modified. */
13962 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13964 /* Now that we have initialized the parms, we can start their
13965 cleanups. We cannot do this before, since expand_decl_cleanup
13966 should not be called before the parm can be used. */
13969 finish_decl_cleanup (TREE_PURPOSE (cleanups
),
13970 TREE_VALUE (cleanups
));
13971 cleanups
= TREE_CHAIN (cleanups
);
13974 /* Create a binding contour which can be used to catch
13975 cleanup-generated temporaries. */
13976 if (parms_have_cleanups
)
13979 /* Do the starting of the exception specifications, if we have any. */
13980 if (flag_exceptions
&& !processing_template_decl
13981 && flag_enforce_eh_specs
13982 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13983 current_eh_spec_try_block
= expand_start_eh_spec ();
13987 /* We have finished doing semantic analysis on DECL, but have not yet
13988 generated RTL for its body. Save away our current state, so that
13989 when we want to generate RTL later we know what to do. */
13992 save_function_data (decl
)
13995 struct cp_language_function
*f
;
13997 /* Save the language-specific per-function data so that we can
13998 get it back when we really expand this function. */
13999 my_friendly_assert (!DECL_PENDING_INLINE_P (decl
),
14003 f
= ((struct cp_language_function
*)
14004 xmalloc (sizeof (struct cp_language_function
)));
14005 bcopy ((char *) cp_function_chain
, (char *) f
,
14006 sizeof (struct cp_language_function
));
14007 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
14009 /* Clear out the bits we don't need. */
14010 f
->base
.x_stmt_tree
.x_last_stmt
= NULL_TREE
;
14011 f
->base
.x_stmt_tree
.x_last_expr_type
= NULL_TREE
;
14012 f
->x_named_label_uses
= NULL
;
14013 f
->bindings
= NULL
;
14015 /* When we get back here again, we will be expanding. */
14016 f
->x_expanding_p
= 1;
14018 /* If we've already decided that we cannot inline this function, we
14019 must remember that fact when we actually go to expand the
14021 f
->cannot_inline
= current_function_cannot_inline
;
14024 /* At the end of every constructor we generate to code to return
14025 `this'. Do that now. */
14028 finish_constructor_body ()
14030 /* Any return from a constructor will end up here. */
14032 add_stmt (build_stmt (LABEL_STMT
, ctor_label
));
14034 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14035 generate the return, rather than a goto to CTOR_LABEL. */
14036 ctor_label
= NULL_TREE
;
14037 /* In check_return_expr we translate an empty return from a
14038 constructor to a return of `this'. */
14039 finish_return_stmt (NULL_TREE
);
14040 /* Mark the end of the constructor. */
14041 add_stmt (build_stmt (CTOR_STMT
));
14044 /* At the end of every destructor we generate code to restore virtual
14045 function tables to the values desired by base classes and to call
14046 to base class destructors. Do that now. */
14049 finish_destructor_body ()
14051 tree compound_stmt
;
14056 /* Create a block to contain all the extra code. */
14057 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
14059 /* Any return from a destructor will end up here. */
14060 add_stmt (build_stmt (LABEL_STMT
, dtor_label
));
14062 /* Generate the code to call destructor on base class. If this
14063 destructor belongs to a class with virtual functions, then set
14064 the virtual function table pointer to represent the type of our
14067 /* This side-effect makes call to `build_delete' generate the code
14068 we have to have at the end of this destructor. `build_delete'
14069 will set the flag again. */
14070 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
14072 exprstmt
= build_delete (current_class_type
,
14074 sfk_base_destructor
,
14075 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
14078 if (exprstmt
!= error_mark_node
14079 && (TREE_CODE (exprstmt
) != NOP_EXPR
14080 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
14081 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
14083 if (exprstmt
!= void_zero_node
)
14084 /* Don't call `expand_expr_stmt' if we're not going to do
14085 anything, since -Wall will give a diagnostic. */
14086 finish_expr_stmt (exprstmt
);
14088 /* Run destructors for all virtual baseclasses. */
14089 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
14094 if_stmt
= begin_if_stmt ();
14095 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
14096 current_in_charge_parm
,
14100 vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
14101 /* The CLASSTYPE_VBASECLASSES list is in initialization
14102 order, so we have to march through it in reverse order. */
14103 for (vbases
= nreverse (copy_list (vbases
));
14105 vbases
= TREE_CHAIN (vbases
))
14107 tree vbase
= TREE_VALUE (vbases
);
14109 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase
)))
14111 tree vb
= get_vbase
14112 (BINFO_TYPE (vbase
),
14113 TYPE_BINFO (current_class_type
));
14115 (build_scoped_method_call
14116 (current_class_ref
, vb
, base_dtor_identifier
,
14121 finish_then_clause (if_stmt
);
14126 virtual_size
= c_sizeof (current_class_type
);
14128 /* At the end, call delete if that's what's requested. */
14130 /* FDIS sez: At the point of definition of a virtual destructor
14131 (including an implicit definition), non-placement operator delete
14132 shall be looked up in the scope of the destructor's class and if
14133 found shall be accessible and unambiguous.
14135 This is somewhat unclear, but I take it to mean that if the class
14136 only defines placement deletes we don't do anything here. So we
14137 pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14138 they ever try to delete one of these. */
14139 exprstmt
= build_op_delete_call
14140 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
14141 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
14143 if_stmt
= begin_if_stmt ();
14144 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
14145 current_in_charge_parm
,
14148 finish_expr_stmt (exprstmt
);
14149 finish_then_clause (if_stmt
);
14152 /* Close the block we started above. */
14153 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
14156 /* Finish up a function declaration and compile that function
14157 all the way to assembler language output. The free the storage
14158 for the function definition.
14160 FLAGS is a bitwise or of the following values:
14162 An extra call to poplevel (and expand_end_bindings) must be
14163 made to take care of the binding contour for the base
14164 initializers. This is only relevant for constructors.
14166 We just finished processing the body of an in-class inline
14167 function definition. (This processing will have taken place
14168 after the class definition is complete.) */
14171 finish_function (flags
)
14174 register tree fndecl
= current_function_decl
;
14175 tree fntype
, ctype
= NULL_TREE
;
14176 int call_poplevel
= (flags
& 1) != 0;
14177 int inclass_inline
= (flags
& 2) != 0;
14180 /* When we get some parse errors, we can end up without a
14181 current_function_decl, so cope. */
14182 if (fndecl
== NULL_TREE
)
14183 return error_mark_node
;
14185 nested
= function_depth
> 1;
14186 fntype
= TREE_TYPE (fndecl
);
14188 /* TREE_READONLY (fndecl) = 1;
14189 This caused &foo to be of type ptr-to-const-function
14190 which then got a warning when stored in a ptr-to-function variable. */
14192 my_friendly_assert (building_stmt_tree (), 20000911);
14194 /* For a cloned function, we've already got all the code we need;
14195 there's no need to add any extra bits. */
14196 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14198 if (DECL_CONSTRUCTOR_P (fndecl
))
14200 finish_constructor_body ();
14204 else if (DECL_DESTRUCTOR_P (fndecl
) && !processing_template_decl
)
14205 finish_destructor_body ();
14206 else if (DECL_MAIN_P (fndecl
))
14208 /* Make it so that `main' always returns 0 by default. */
14210 finish_return_stmt (integer_one_node
);
14212 finish_return_stmt (integer_zero_node
);
14216 /* Finish dealing with exception specifiers. */
14217 if (flag_exceptions
&& !processing_template_decl
14218 && flag_enforce_eh_specs
14219 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
14220 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14221 (TREE_TYPE (current_function_decl
)),
14222 current_eh_spec_try_block
);
14225 /* If we're saving up tree structure, tie off the function now. */
14226 finish_stmt_tree (&DECL_SAVED_TREE (fndecl
));
14228 /* This must come after expand_function_end because cleanups might
14229 have declarations (from inline functions) that need to go into
14230 this function's blocks. */
14231 if (current_binding_level
->parm_flag
!= 1)
14232 my_friendly_abort (122);
14233 poplevel (1, 0, 1);
14235 /* Remember that we were in class scope. */
14236 if (current_class_name
)
14237 ctype
= current_class_type
;
14239 /* Must mark the RESULT_DECL as being in this function. */
14240 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14242 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14243 to the FUNCTION_DECL node itself. */
14244 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14246 /* Save away current state, if appropriate. */
14247 if (!processing_template_decl
)
14248 save_function_data (fndecl
);
14250 /* If this function calls `setjmp' it cannot be inlined. When
14251 `longjmp' is called it is not guaranteed to restore the value of
14252 local variables that have been modified since the call to
14253 `setjmp'. So, if were to inline this function into some caller
14254 `c', then when we `longjmp', we might not restore all variables
14255 in `c'. (It might seem, at first blush, that there's no way for
14256 this function to modify local variables in `c', but their
14257 addresses may have been stored somewhere accessible to this
14259 if (!processing_template_decl
&& calls_setjmp_p (fndecl
))
14260 DECL_UNINLINABLE (fndecl
) = 1;
14262 /* Clear out memory we no longer need. */
14263 free_after_parsing (cfun
);
14264 /* Since we never call rest_of_compilation, we never clear
14265 CFUN. Do so explicitly. */
14266 free_after_compilation (cfun
);
14269 /* If this is a in-class inline definition, we may have to pop the
14270 bindings for the template parameters that we added in
14271 maybe_begin_member_template_processing when start_function was
14273 if (inclass_inline
)
14274 maybe_end_member_template_processing ();
14276 /* Leave the scope of the class. */
14278 pop_nested_class ();
14284 /* Let the error reporting routines know that we're outside a
14285 function. For a nested function, this value is used in
14286 pop_cp_function_context and then reset via pop_function_context. */
14287 current_function_decl
= NULL_TREE
;
14292 /* Create the FUNCTION_DECL for a function definition.
14293 DECLSPECS and DECLARATOR are the parts of the declaration;
14294 they describe the return type and the name of the function,
14295 but twisted together in a fashion that parallels the syntax of C.
14297 This function creates a binding context for the function body
14298 as well as setting up the FUNCTION_DECL in current_function_decl.
14300 Returns a FUNCTION_DECL on success.
14302 If the DECLARATOR is not suitable for a function (it defines a datum
14303 instead), we return 0, which tells yyparse to report a parse error.
14305 May return void_type_node indicating that this method is actually
14306 a friend. See grokfield for more details.
14308 Came here with a `.pushlevel' .
14310 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14311 CHANGES TO CODE IN `grokfield'. */
14314 start_method (declspecs
, declarator
, attrlist
)
14315 tree declarator
, declspecs
, attrlist
;
14317 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14320 /* Something too ugly to handle. */
14321 if (fndecl
== NULL_TREE
)
14324 /* Pass friends other than inline friend functions back. */
14325 if (fndecl
== void_type_node
)
14328 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14329 /* Not a function, tell parser to report parse error. */
14332 if (DECL_IN_AGGR_P (fndecl
))
14334 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14336 if (DECL_CONTEXT (fndecl
)
14337 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14338 cp_error ("`%D' is already defined in class `%T'", fndecl
,
14339 DECL_CONTEXT (fndecl
));
14341 return void_type_node
;
14344 check_template_shadow (fndecl
);
14346 DECL_THIS_INLINE (fndecl
) = 1;
14348 if (flag_default_inline
)
14349 DECL_INLINE (fndecl
) = 1;
14351 /* We process method specializations in finish_struct_1. */
14352 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14353 fndecl
= push_template_decl (fndecl
);
14355 if (! DECL_FRIEND_P (fndecl
))
14357 if (TREE_CHAIN (fndecl
))
14359 fndecl
= copy_node (fndecl
);
14360 TREE_CHAIN (fndecl
) = NULL_TREE
;
14363 if (DECL_CONSTRUCTOR_P (fndecl
))
14365 if (! grok_ctor_properties (current_class_type
, fndecl
))
14366 return void_type_node
;
14368 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14369 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14372 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
14374 /* Make a place for the parms */
14376 current_binding_level
->parm_flag
= 1;
14378 DECL_IN_AGGR_P (fndecl
) = 1;
14382 /* Go through the motions of finishing a function definition.
14383 We don't compile this method until after the whole class has
14386 FINISH_METHOD must return something that looks as though it
14387 came from GROKFIELD (since we are defining a method, after all).
14389 This is called after parsing the body of the function definition.
14390 STMTS is the chain of statements that makes up the function body.
14392 DECL is the ..._DECL that `start_method' provided. */
14395 finish_method (decl
)
14398 register tree fndecl
= decl
;
14401 register tree link
;
14403 if (decl
== void_type_node
)
14406 old_initial
= DECL_INITIAL (fndecl
);
14408 /* Undo the level for the parms (from start_method).
14409 This is like poplevel, but it causes nothing to be
14410 saved. Saving information here confuses symbol-table
14411 output routines. Besides, this information will
14412 be correctly output when this method is actually
14415 /* Clear out the meanings of the local variables of this level;
14416 also record in each decl which block it belongs to. */
14418 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14420 if (DECL_NAME (link
) != NULL_TREE
)
14421 pop_binding (DECL_NAME (link
), link
);
14422 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14423 DECL_CONTEXT (link
) = NULL_TREE
;
14426 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14427 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14428 current_binding_level
->parm_flag
,
14429 current_binding_level
->keep
);
14431 poplevel (0, 0, 0);
14433 DECL_INITIAL (fndecl
) = old_initial
;
14435 /* We used to check if the context of FNDECL was different from
14436 current_class_type as another way to get inside here. This didn't work
14437 for String.cc in libg++. */
14438 if (DECL_FRIEND_P (fndecl
))
14440 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14441 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14442 decl
= void_type_node
;
14448 /* Called when a new struct TYPE is defined.
14449 If this structure or union completes the type of any previous
14450 variable declaration, lay it out and output its rtl. */
14453 hack_incomplete_structures (type
)
14457 struct binding_level
*level
;
14459 if (!type
) /* Don't do this for class templates. */
14462 if (namespace_bindings_p ())
14465 list
= &namespace_scope_incomplete
;
14469 level
= innermost_nonclass_level ();
14470 list
= &level
->incomplete
;
14477 tree decl
= TREE_VALUE (*list
);
14478 if ((decl
&& TREE_TYPE (decl
) == type
)
14479 || (TREE_TYPE (decl
)
14480 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14481 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14483 int toplevel
= toplevel_bindings_p ();
14484 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14485 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14486 layout_type (TREE_TYPE (decl
));
14487 layout_decl (decl
, 0);
14488 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14492 expand_decl (decl
);
14493 cleanup
= maybe_build_cleanup (decl
);
14494 expand_decl_init (decl
);
14495 if (! expand_decl_cleanup (decl
, cleanup
))
14496 cp_error ("parser lost in parsing declaration of `%D'",
14499 *list
= TREE_CHAIN (*list
);
14502 list
= &TREE_CHAIN (*list
);
14505 /* Keep looking through artificial binding levels generated
14506 for local variables. */
14507 if (level
&& level
->keep
== 2)
14509 level
= level
->level_chain
;
14510 list
= &level
->incomplete
;
14517 /* If DECL is of a type which needs a cleanup, build that cleanup
14521 maybe_build_cleanup (decl
)
14524 tree type
= TREE_TYPE (decl
);
14526 if (type
!= error_mark_node
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14528 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14531 if (TREE_CODE (type
) == ARRAY_TYPE
)
14535 mark_addressable (decl
);
14536 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14539 /* Optimize for space over speed here. */
14540 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14541 || flag_expensive_optimizations
)
14542 flags
|= LOOKUP_NONVIRTUAL
;
14544 rval
= build_delete (TREE_TYPE (rval
), rval
,
14545 sfk_complete_destructor
, flags
, 0);
14547 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14548 && ! TYPE_HAS_DESTRUCTOR (type
))
14549 rval
= build_compound_expr (tree_cons (NULL_TREE
, rval
,
14550 build_tree_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14557 /* When a stmt has been parsed, this function is called. */
14562 /* Always assume this statement was not an expression statement. If
14563 it actually was an expression statement, its our callers
14564 responsibility to fix this up. */
14565 last_expr_type
= NULL_TREE
;
14568 /* DECL was originally constructed as a non-static member function,
14569 but turned out to be static. Update it accordingly. */
14572 revert_static_member_fn (decl
)
14576 tree function
= TREE_TYPE (decl
);
14577 tree args
= TYPE_ARG_TYPES (function
);
14579 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14580 != TYPE_UNQUALIFIED
)
14581 cp_error ("static member function `%#D' declared with type qualifiers",
14584 args
= TREE_CHAIN (args
);
14585 tmp
= build_function_type (TREE_TYPE (function
), args
);
14586 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14587 tmp
= build_exception_variant (tmp
,
14588 TYPE_RAISES_EXCEPTIONS (function
));
14589 TREE_TYPE (decl
) = tmp
;
14590 if (DECL_ARGUMENTS (decl
))
14591 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
14592 DECL_STATIC_FUNCTION_P (decl
) = 1;
14595 /* Initialize the variables used during compilation of a C++
14599 push_cp_function_context (f
)
14600 struct function
*f
;
14602 struct cp_language_function
*p
14603 = ((struct cp_language_function
*)
14604 xcalloc (1, sizeof (struct cp_language_function
)));
14605 f
->language
= (struct language_function
*) p
;
14607 /* It takes an explicit call to expand_body to generate RTL for a
14611 /* Whenever we start a new function, we destroy temporaries in the
14613 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14616 /* Free the language-specific parts of F, now that we've finished
14617 compiling the function. */
14620 pop_cp_function_context (f
)
14621 struct function
*f
;
14624 free (f
->language
);
14628 /* Mark P for GC. */
14631 mark_lang_function (p
)
14632 struct cp_language_function
*p
;
14637 mark_c_language_function (&p
->base
);
14639 ggc_mark_tree (p
->x_ctor_label
);
14640 ggc_mark_tree (p
->x_dtor_label
);
14641 ggc_mark_tree (p
->x_current_class_ptr
);
14642 ggc_mark_tree (p
->x_current_class_ref
);
14643 ggc_mark_tree (p
->x_eh_spec_try_block
);
14645 mark_named_label_lists (&p
->x_named_labels
, &p
->x_named_label_uses
);
14646 mark_binding_level (&p
->bindings
);
14649 /* Mark the language-specific data in F for GC. */
14652 mark_cp_function_context (f
)
14653 struct function
*f
;
14655 mark_lang_function ((struct cp_language_function
*) f
->language
);
14662 enum tree_code code
= TREE_CODE (t
);
14663 if (code
== IDENTIFIER_NODE
)
14665 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
14666 struct lang_id2
*li2
= li
->x
;
14667 ggc_mark_tree (li
->namespace_bindings
);
14668 ggc_mark_tree (li
->bindings
);
14669 ggc_mark_tree (li
->class_value
);
14670 ggc_mark_tree (li
->class_template_info
);
14674 ggc_mark_tree (li2
->label_value
);
14675 ggc_mark_tree (li2
->implicit_decl
);
14676 ggc_mark_tree (li2
->error_locus
);
14679 else if (code
== CPLUS_BINDING
)
14681 if (BINDING_HAS_LEVEL_P (t
))
14682 mark_binding_level (&BINDING_LEVEL (t
));
14684 ggc_mark_tree (BINDING_SCOPE (t
));
14685 ggc_mark_tree (BINDING_VALUE (t
));
14687 else if (code
== OVERLOAD
)
14688 ggc_mark_tree (OVL_FUNCTION (t
));
14689 else if (code
== TEMPLATE_PARM_INDEX
)
14690 ggc_mark_tree (TEMPLATE_PARM_DECL (t
));
14691 else if (TREE_CODE_CLASS (code
) == 'd')
14693 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
14698 c_mark_lang_decl (&ld
->decl_flags
.base
);
14699 if (!DECL_GLOBAL_CTOR_P (t
)
14700 && !DECL_GLOBAL_DTOR_P (t
)
14701 && !DECL_THUNK_P (t
))
14702 ggc_mark_tree (ld
->decl_flags
.u2
.access
);
14703 else if (DECL_THUNK_P (t
))
14704 ggc_mark_tree (ld
->decl_flags
.u2
.vcall_offset
);
14705 if (TREE_CODE (t
) != NAMESPACE_DECL
)
14706 ggc_mark_tree (ld
->decl_flags
.u
.template_info
);
14708 mark_binding_level (&NAMESPACE_LEVEL (t
));
14709 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
14711 ggc_mark_tree (ld
->befriending_classes
);
14712 ggc_mark_tree (ld
->context
);
14713 ggc_mark_tree (ld
->cloned_function
);
14714 if (!DECL_OVERLOADED_OPERATOR_P (t
))
14715 ggc_mark_tree (ld
->u2
.vtt_parm
);
14716 if (TREE_CODE (t
) == TYPE_DECL
)
14717 ggc_mark_tree (ld
->u
.sorted_fields
);
14718 else if (TREE_CODE (t
) == FUNCTION_DECL
14719 && !DECL_PENDING_INLINE_P (t
))
14720 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t
));
14724 else if (TREE_CODE_CLASS (code
) == 't')
14726 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
14728 if (lt
&& !(TREE_CODE (t
) == POINTER_TYPE
14729 && TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
))
14732 ggc_mark_tree (lt
->primary_base
);
14733 ggc_mark_tree (lt
->vfields
);
14734 ggc_mark_tree (lt
->vbases
);
14735 ggc_mark_tree (lt
->tags
);
14736 ggc_mark_tree (lt
->size
);
14737 ggc_mark_tree (lt
->pure_virtuals
);
14738 ggc_mark_tree (lt
->friend_classes
);
14739 ggc_mark_tree (lt
->rtti
);
14740 ggc_mark_tree (lt
->methods
);
14741 ggc_mark_tree (lt
->template_info
);
14742 ggc_mark_tree (lt
->befriending_classes
);
14745 /* In the case of pointer-to-member function types, the
14746 TYPE_LANG_SPECIFIC is really just a tree. */
14747 ggc_mark_tree ((tree
) lt
);