1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001 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 /* In the new ABI, `bool' has size and alignment `1', on all
56 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
59 static tree grokparms
PARAMS ((tree
));
60 static const char *redeclaration_error_message
PARAMS ((tree
, tree
));
62 static void push_binding_level
PARAMS ((struct binding_level
*, int,
64 static void pop_binding_level
PARAMS ((void));
65 static void suspend_binding_level
PARAMS ((void));
66 static void resume_binding_level
PARAMS ((struct binding_level
*));
67 static struct binding_level
*make_binding_level
PARAMS ((void));
68 static void declare_namespace_level
PARAMS ((void));
69 static int decl_jump_unsafe
PARAMS ((tree
));
70 static void storedecls
PARAMS ((tree
));
71 static void require_complete_types_for_parms
PARAMS ((tree
));
72 static int ambi_op_p
PARAMS ((enum tree_code
));
73 static int unary_op_p
PARAMS ((enum tree_code
));
74 static tree store_bindings
PARAMS ((tree
, tree
));
75 static tree lookup_tag_reverse
PARAMS ((tree
, tree
));
76 static tree obscure_complex_init
PARAMS ((tree
, tree
));
77 static tree lookup_name_real
PARAMS ((tree
, int, int, int));
78 static void warn_extern_redeclared_static
PARAMS ((tree
, tree
));
79 static void grok_reference_init
PARAMS ((tree
, tree
, tree
));
80 static tree grokfndecl
PARAMS ((tree
, tree
, tree
, tree
, int,
81 enum overload_flags
, tree
,
82 tree
, int, int, int, int, int, int, tree
));
83 static tree grokvardecl
PARAMS ((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
84 static tree lookup_tag
PARAMS ((enum tree_code
, tree
,
85 struct binding_level
*, int));
86 static void set_identifier_type_value_with_scope
87 PARAMS ((tree
, tree
, struct binding_level
*));
88 static void record_unknown_type
PARAMS ((tree
, const char *));
89 static tree build_library_fn_1
PARAMS ((tree
, enum tree_code
, tree
));
90 static int member_function_or_else
PARAMS ((tree
, tree
, enum overload_flags
));
91 static void bad_specifiers
PARAMS ((tree
, const char *, int, int, int, int,
93 static tree maybe_process_template_type_declaration
PARAMS ((tree
, int, struct binding_level
*));
94 static void check_for_uninitialized_const_var
PARAMS ((tree
));
95 static unsigned long typename_hash
PARAMS ((hash_table_key
));
96 static boolean typename_compare
PARAMS ((hash_table_key
, hash_table_key
));
97 static void push_binding
PARAMS ((tree
, tree
, struct binding_level
*));
98 static int add_binding
PARAMS ((tree
, tree
));
99 static void pop_binding
PARAMS ((tree
, tree
));
100 static tree local_variable_p_walkfn
PARAMS ((tree
*, int *, void *));
101 static tree find_binding
PARAMS ((tree
, tree
));
102 static tree select_decl
PARAMS ((tree
, int));
103 static int lookup_flags
PARAMS ((int, int));
104 static tree qualify_lookup
PARAMS ((tree
, int));
105 static tree record_builtin_java_type
PARAMS ((const char *, int));
106 static const char *tag_name
PARAMS ((enum tag_types code
));
107 static void find_class_binding_level
PARAMS ((void));
108 static struct binding_level
*innermost_nonclass_level
PARAMS ((void));
109 static void warn_about_implicit_typename_lookup
PARAMS ((tree
, tree
));
110 static int walk_namespaces_r
PARAMS ((tree
, walk_namespaces_fn
, void *));
111 static int walk_globals_r
PARAMS ((tree
, void *));
112 static void add_decl_to_level
PARAMS ((tree
, struct binding_level
*));
113 static tree make_label_decl
PARAMS ((tree
, int));
114 static void use_label
PARAMS ((tree
));
115 static void check_previous_goto_1
PARAMS ((tree
, struct binding_level
*, tree
,
117 static void check_previous_goto
PARAMS ((struct named_label_use_list
*));
118 static void check_switch_goto
PARAMS ((struct binding_level
*));
119 static void check_previous_gotos
PARAMS ((tree
));
120 static void pop_label
PARAMS ((tree
, tree
));
121 static void pop_labels
PARAMS ((tree
));
122 static void maybe_deduce_size_from_array_init
PARAMS ((tree
, tree
));
123 static void layout_var_decl
PARAMS ((tree
));
124 static void maybe_commonize_var
PARAMS ((tree
));
125 static tree check_initializer
PARAMS ((tree
, tree
));
126 static void make_rtl_for_nonlocal_decl
PARAMS ((tree
, tree
, const char *));
127 static void push_cp_function_context
PARAMS ((struct function
*));
128 static void pop_cp_function_context
PARAMS ((struct function
*));
129 static void mark_binding_level
PARAMS ((void *));
130 static void mark_named_label_lists
PARAMS ((void *, void *));
131 static void mark_cp_function_context
PARAMS ((struct function
*));
132 static void mark_saved_scope
PARAMS ((void *));
133 static void mark_lang_function
PARAMS ((struct cp_language_function
*));
134 static void save_function_data
PARAMS ((tree
));
135 static void check_function_type
PARAMS ((tree
, tree
));
136 static void destroy_local_var
PARAMS ((tree
));
137 static void finish_constructor_body
PARAMS ((void));
138 static void finish_destructor_body
PARAMS ((void));
139 static tree create_array_type_for_decl
PARAMS ((tree
, tree
, tree
));
140 static tree get_atexit_node
PARAMS ((void));
141 static tree get_dso_handle_node
PARAMS ((void));
142 static tree start_cleanup_fn
PARAMS ((void));
143 static void end_cleanup_fn
PARAMS ((void));
144 static tree cp_make_fname_decl
PARAMS ((tree
, const char *, int));
145 static void initialize_predefined_identifiers
PARAMS ((void));
146 static tree check_special_function_return_type
147 PARAMS ((special_function_kind
, tree
, tree
));
148 static tree push_cp_library_fn
PARAMS ((enum tree_code
, tree
));
149 static tree build_cp_library_fn
PARAMS ((tree
, enum tree_code
, tree
));
150 static void store_parm_decls
PARAMS ((tree
));
151 static int cp_missing_noreturn_ok_p
PARAMS ((tree
));
153 #if defined (DEBUG_CP_BINDING_LEVELS)
154 static void indent
PARAMS ((void));
157 /* Erroneous argument lists can use this *IFF* they do not modify it. */
158 tree error_mark_list
;
160 /* The following symbols are subsumed in the cp_global_trees array, and
161 listed here individually for documentation purposes.
164 tree wchar_decl_node;
166 tree vtable_entry_type;
167 tree delta_type_node;
170 tree __baselist_desc_type_node;
171 tree __i_desc_type_node, __m_desc_type_node;
172 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
174 tree __t_desc_type_node;
176 tree __tp_desc_type_node;
178 tree ti_desc_type_node;
179 tree bltn_desc_type_node, ptr_desc_type_node;
180 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
181 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
182 tree ptm_desc_type_node;
183 tree base_desc_type_node;
185 Not needed yet? May be needed one day?
186 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
187 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
188 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
191 tree class_type_node, record_type_node, union_type_node, enum_type_node;
192 tree unknown_type_node;
194 Array type `vtable_entry_type[]'
197 tree vtbl_ptr_type_node;
204 A FUNCTION_DECL which can call `abort'. Not necessarily the
205 one that the user will declare, but sufficient to be called
206 by routines that want to abort the program.
210 The FUNCTION_DECL for the default `::operator delete'.
212 tree global_delete_fndecl;
215 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
220 tree cp_global_trees
[CPTI_MAX
];
222 /* Indicates that there is a type value in some namespace, although
223 that is not necessarily in scope at the moment. */
225 static tree global_type_node
;
227 /* If non-zero, this is the number of times we have entered the `std'
228 namespace when we are treating that namespace as an alias for the
230 static int in_fake_std
;
232 /* Expect only namespace names now. */
233 static int only_namespace_names
;
235 /* Used only for jumps to as-yet undefined labels, since jumps to
236 defined labels can have their validity checked immediately. */
238 struct named_label_use_list
240 struct binding_level
*binding_level
;
243 const char *filename_o_goto
;
245 struct named_label_use_list
*next
;
248 #define named_label_uses cp_function_chain->x_named_label_uses
250 /* A list of objects which have constructors or destructors
251 which reside in the global scope. The decl is stored in
252 the TREE_VALUE slot and the initializer is stored
253 in the TREE_PURPOSE slot. */
254 tree static_aggregates
;
258 /* A node for the integer constants 2, and 3. */
260 tree integer_two_node
, integer_three_node
;
262 /* Parsing a function declarator leaves here a chain of structure
263 and enum types declared in the parmlist. */
265 static tree last_function_parm_tags
;
267 /* Similar, for last_function_parm_tags. */
268 tree last_function_parms
;
269 static tree current_function_parm_tags
;
271 /* A list of all LABEL_DECLs in the function that have names. Here so
272 we can clear out their names' definitions at the end of the
273 function, and so we can check the validity of jumps to these labels. */
275 struct named_label_list
277 struct binding_level
*binding_level
;
283 struct named_label_list
*next
;
286 #define named_labels cp_function_chain->x_named_labels
288 /* Set to 0 at beginning of a function definition, and whenever
289 a label (case or named) is defined. Set to value of expression
290 returned from function when that value can be transformed into
291 a named return value. */
293 tree current_function_return_value
;
295 /* Nonzero means use the ISO C94 dialect of C. */
299 /* Nonzero means use the ISO C99 dialect of C. */
303 /* Nonzero means we are a hosted implementation for code shared with C. */
307 /* Nonzero means add default format_arg attributes for functions not
310 int flag_noniso_default_format_attributes
= 1;
312 /* Nonzero if we want to conserve space in the .o files. We do this
313 by putting uninitialized data and runtime initialized data into
314 .common instead of .data at the expense of not flagging multiple
316 extern int flag_conserve_space
;
318 /* C and C++ flags are in decl2.c. */
320 /* Flag used when debugging spew.c */
322 extern int spew_debug
;
324 /* A expression of value 0 with the same precision as a sizetype
326 tree signed_size_zero_node
;
328 /* The name of the anonymous namespace, throughout this translation
330 tree anonymous_namespace_name
;
332 /* The number of function bodies which we are currently processing.
333 (Zero if we are at namespace scope, one inside the body of a
334 function, two inside the body of a function in a local class, etc.) */
337 /* For each binding contour we allocate a binding_level structure
338 which records the names defined in that contour.
341 1) one for each function definition,
342 where internal declarations of the parameters appear.
343 2) one for each compound statement,
344 to record its declarations.
346 The current meaning of a name can be found by searching the levels
347 from the current one out to the global one.
349 Off to the side, may be the class_binding_level. This exists only
350 to catch class-local declarations. It is otherwise nonexistent.
352 Also there may be binding levels that catch cleanups that must be
353 run when exceptions occur. Thus, to see whether a name is bound in
354 the current scope, it is not enough to look in the
355 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
358 /* Note that the information in the `names' component of the global contour
359 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
363 /* A chain of _DECL nodes for all variables, constants, functions,
364 and typedef types. These are in the reverse of the order
365 supplied. There may be OVERLOADs on this list, too, but they
366 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
369 /* A list of structure, union and enum definitions, for looking up
371 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
372 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
373 or ENUMERAL_TYPE node.
375 C++: the TREE_VALUE nodes can be simple types for
376 component_bindings. */
379 /* A list of USING_DECL nodes. */
382 /* A list of used namespaces. PURPOSE is the namespace,
383 VALUE the common ancestor with this binding_level's namespace. */
384 tree using_directives
;
386 /* If this binding level is the binding level for a class, then
387 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
388 is the name of an entity bound in the class. The TREE_TYPE is
389 the DECL bound by this name in the class. */
392 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
393 is used for all binding levels. In addition the TREE_VALUE is the
394 IDENTIFIER_TYPE_VALUE before we entered the class. */
397 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
398 label in this scope. The TREE_PURPOSE is the previous value of
399 the IDENTIFIER_LABEL VALUE. */
400 tree shadowed_labels
;
402 /* For each level (except not the global one),
403 a chain of BLOCK nodes for all the levels
404 that were entered and exited one level down. */
407 /* The _TYPE node for this level, if parm_flag == 2. */
410 /* The binding level which this one is contained in (inherits from). */
411 struct binding_level
*level_chain
;
413 /* List of decls in `names' that have incomplete
414 structure or union types. */
417 /* List of VAR_DECLS saved from a previous for statement.
418 These would be dead in ISO-conforming code, but might
419 be referenced in ARM-era code. These are stored in a
420 TREE_LIST; the TREE_VALUE is the actual declaration. */
421 tree dead_vars_from_for
;
423 /* 1 for the level that holds the parameters of a function.
424 2 for the level that holds a class declaration. */
425 unsigned parm_flag
: 2;
427 /* 1 means make a BLOCK for this level regardless of all else.
428 2 for temporary binding contours created by the compiler. */
431 /* Nonzero if this level "doesn't exist" for tags. */
432 unsigned tag_transparent
: 1;
434 /* Nonzero if this level can safely have additional
435 cleanup-needing variables added to it. */
436 unsigned more_cleanups_ok
: 1;
437 unsigned have_cleanups
: 1;
439 /* Nonzero if this scope is for storing the decls for template
440 parameters and generic decls; these decls will be discarded and
441 replaced with a TEMPLATE_DECL. */
442 unsigned template_parms_p
: 1;
444 /* Nonzero if this scope corresponds to the `<>' in a
445 `template <>' clause. Whenever this flag is set,
446 TEMPLATE_PARMS_P will be set as well. */
447 unsigned template_spec_p
: 1;
449 /* This is set for a namespace binding level. */
450 unsigned namespace_p
: 1;
452 /* True if this level is that of a for-statement where we need to
453 worry about ambiguous (ARM or ISO) scope rules. */
454 unsigned is_for_scope
: 1;
456 /* True if this level corresponds to an EH region, as for a try block.
457 Currently this information is only available while building the
459 unsigned eh_region
: 1;
461 /* Four bits left for this word. */
463 #if defined(DEBUG_CP_BINDING_LEVELS)
464 /* Binding depth at which this level began. */
465 unsigned binding_depth
;
466 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
469 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
471 /* The binding level currently in effect. */
473 #define current_binding_level \
475 ? cp_function_chain->bindings \
476 : scope_chain->bindings)
478 /* The binding level of the current class, if any. */
480 #define class_binding_level scope_chain->class_bindings
482 /* A chain of binding_level structures awaiting reuse. */
484 static struct binding_level
*free_binding_level
;
486 /* The outermost binding level, for names of file scope.
487 This is created when the compiler is started and exists
488 through the entire run. */
490 static struct binding_level
*global_binding_level
;
492 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
494 static int keep_next_level_flag
;
496 #if defined(DEBUG_CP_BINDING_LEVELS)
497 static int binding_depth
= 0;
498 static int is_class_level
= 0;
505 for (i
= 0; i
< binding_depth
*2; i
++)
508 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
510 static tree pushdecl_with_scope
PARAMS ((tree
, struct binding_level
*));
513 push_binding_level (newlevel
, tag_transparent
, keep
)
514 struct binding_level
*newlevel
;
515 int tag_transparent
, keep
;
517 /* Add this level to the front of the chain (stack) of levels that
519 memset ((char*) newlevel
, 0, sizeof (struct binding_level
));
520 newlevel
->level_chain
= current_binding_level
;
521 current_binding_level
= newlevel
;
522 newlevel
->tag_transparent
= tag_transparent
;
523 newlevel
->more_cleanups_ok
= 1;
525 newlevel
->keep
= keep
;
526 #if defined(DEBUG_CP_BINDING_LEVELS)
527 newlevel
->binding_depth
= binding_depth
;
529 fprintf (stderr
, "push %s level 0x%08x line %d\n",
530 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
533 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
536 /* Find the innermost enclosing class scope, and reset
537 CLASS_BINDING_LEVEL appropriately. */
540 find_class_binding_level ()
542 struct binding_level
*level
= current_binding_level
;
544 while (level
&& level
->parm_flag
!= 2)
545 level
= level
->level_chain
;
546 if (level
&& level
->parm_flag
== 2)
547 class_binding_level
= level
;
549 class_binding_level
= 0;
555 if (global_binding_level
)
557 /* Cannot pop a level, if there are none left to pop. */
558 if (current_binding_level
== global_binding_level
)
559 my_friendly_abort (123);
561 /* Pop the current level, and free the structure for reuse. */
562 #if defined(DEBUG_CP_BINDING_LEVELS)
565 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
566 (is_class_level
) ? "class" : "block",
567 current_binding_level
, lineno
);
568 if (is_class_level
!= (current_binding_level
== class_binding_level
))
571 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
574 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
576 register struct binding_level
*level
= current_binding_level
;
577 current_binding_level
= current_binding_level
->level_chain
;
578 level
->level_chain
= free_binding_level
;
579 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
580 if (level
->binding_depth
!= binding_depth
)
582 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
583 free_binding_level
= level
;
584 find_class_binding_level ();
589 suspend_binding_level ()
591 if (class_binding_level
)
592 current_binding_level
= class_binding_level
;
594 if (global_binding_level
)
596 /* Cannot suspend a level, if there are none left to suspend. */
597 if (current_binding_level
== global_binding_level
)
598 my_friendly_abort (123);
600 /* Suspend the current level. */
601 #if defined(DEBUG_CP_BINDING_LEVELS)
604 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
605 (is_class_level
) ? "class" : "block",
606 current_binding_level
, lineno
);
607 if (is_class_level
!= (current_binding_level
== class_binding_level
))
610 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
613 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
614 current_binding_level
= current_binding_level
->level_chain
;
615 find_class_binding_level ();
619 resume_binding_level (b
)
620 struct binding_level
*b
;
622 /* Resuming binding levels is meant only for namespaces,
623 and those cannot nest into classes. */
624 my_friendly_assert(!class_binding_level
, 386);
625 /* Also, resuming a non-directly nested namespace is a no-no. */
626 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
627 current_binding_level
= b
;
628 #if defined(DEBUG_CP_BINDING_LEVELS)
629 b
->binding_depth
= binding_depth
;
631 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
632 (is_class_level
) ? "class" : "block", b
, lineno
);
635 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
638 /* Create a new `struct binding_level'. */
641 struct binding_level
*
642 make_binding_level ()
645 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
648 /* Nonzero if we are currently in the global binding level. */
653 return current_binding_level
== global_binding_level
;
656 /* Return the innermost binding level that is not for a class scope. */
658 static struct binding_level
*
659 innermost_nonclass_level ()
661 struct binding_level
*b
;
663 b
= current_binding_level
;
664 while (b
->parm_flag
== 2)
670 /* Nonzero if we are currently in a toplevel binding level. This
671 means either the global binding level or a namespace in a toplevel
672 binding level. Since there are no non-toplevel namespace levels,
673 this really means any namespace or template parameter level. We
674 also include a class whose context is toplevel. */
677 toplevel_bindings_p ()
679 struct binding_level
*b
= innermost_nonclass_level ();
681 return b
->namespace_p
|| b
->template_parms_p
;
684 /* Nonzero if this is a namespace scope, or if we are defining a class
685 which is itself at namespace scope, or whose enclosing class is
686 such a class, etc. */
689 namespace_bindings_p ()
691 struct binding_level
*b
= innermost_nonclass_level ();
693 return b
->namespace_p
;
696 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
697 unconditionally. Otherwise, use the normal logic to decide whether
698 or not to create a BLOCK. */
701 keep_next_level (keep
)
704 keep_next_level_flag
= keep
;
707 /* Nonzero if the current level needs to have a BLOCK made. */
712 return (current_binding_level
->blocks
!= NULL_TREE
713 || current_binding_level
->keep
714 || current_binding_level
->names
!= NULL_TREE
715 || (current_binding_level
->tags
!= NULL_TREE
716 && !current_binding_level
->tag_transparent
));
720 declare_namespace_level ()
722 current_binding_level
->namespace_p
= 1;
725 /* Returns non-zero if this scope was created to store template
729 template_parm_scope_p ()
731 return current_binding_level
->template_parms_p
;
734 /* Returns the kind of template specialization we are currently
735 processing, given that it's declaration contained N_CLASS_SCOPES
736 explicit scope qualifications. */
739 current_tmpl_spec_kind (n_class_scopes
)
742 int n_template_parm_scopes
= 0;
743 int seen_specialization_p
= 0;
744 int innermost_specialization_p
= 0;
745 struct binding_level
*b
;
747 /* Scan through the template parameter scopes. */
748 for (b
= current_binding_level
; b
->template_parms_p
; b
= b
->level_chain
)
750 /* If we see a specialization scope inside a parameter scope,
751 then something is wrong. That corresponds to a declaration
754 template <class T> template <> ...
756 which is always illegal since [temp.expl.spec] forbids the
757 specialization of a class member template if the enclosing
758 class templates are not explicitly specialized as well. */
759 if (b
->template_spec_p
)
761 if (n_template_parm_scopes
== 0)
762 innermost_specialization_p
= 1;
764 seen_specialization_p
= 1;
766 else if (seen_specialization_p
== 1)
767 return tsk_invalid_member_spec
;
769 ++n_template_parm_scopes
;
772 /* Handle explicit instantiations. */
773 if (processing_explicit_instantiation
)
775 if (n_template_parm_scopes
!= 0)
776 /* We've seen a template parameter list during an explicit
777 instantiation. For example:
779 template <class T> template void f(int);
781 This is erroneous. */
782 return tsk_invalid_expl_inst
;
784 return tsk_expl_inst
;
787 if (n_template_parm_scopes
< n_class_scopes
)
788 /* We've not seen enough template headers to match all the
789 specialized classes present. For example:
791 template <class T> void R<T>::S<T>::f(int);
793 This is illegal; there needs to be one set of template
794 parameters for each class. */
795 return tsk_insufficient_parms
;
796 else if (n_template_parm_scopes
== n_class_scopes
)
797 /* We're processing a non-template declaration (even though it may
798 be a member of a template class.) For example:
800 template <class T> void S<T>::f(int);
802 The `class T' maches the `S<T>', leaving no template headers
803 corresponding to the `f'. */
805 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
806 /* We've got too many template headers. For example:
808 template <> template <class T> void f (T);
810 There need to be more enclosing classes. */
811 return tsk_excessive_parms
;
813 /* This must be a template. It's of the form:
815 template <class T> template <class U> void S<T>::f(U);
817 This is a specialization if the innermost level was a
818 specialization; otherwise it's just a definition of the
820 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
824 set_class_shadows (shadows
)
827 class_binding_level
->class_shadowed
= shadows
;
830 /* Enter a new binding level.
831 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
832 not for that of tags. */
835 pushlevel (tag_transparent
)
838 struct binding_level
*newlevel
;
840 if (cfun
&& !doing_semantic_analysis_p ())
843 /* Reuse or create a struct for this binding level. */
844 #if defined(DEBUG_CP_BINDING_LEVELS)
846 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
847 if (free_binding_level
)
848 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
850 newlevel
= free_binding_level
;
851 free_binding_level
= free_binding_level
->level_chain
;
854 newlevel
= make_binding_level ();
856 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
857 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
858 keep_next_level_flag
= 0;
861 /* We're defining an object of type TYPE. If it needs a cleanup, but
862 we're not allowed to add any more objects with cleanups to the current
863 scope, create a new binding level. */
866 maybe_push_cleanup_level (type
)
869 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
870 && current_binding_level
->more_cleanups_ok
== 0)
875 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
879 /* Enter a new scope. The KIND indicates what kind of scope is being
890 case sk_template_spec
:
891 current_binding_level
->template_spec_p
= 1;
894 case sk_template_parms
:
895 current_binding_level
->template_parms_p
= 1;
899 my_friendly_abort (20000309);
903 /* Exit the current scope. */
912 note_level_for_for ()
914 current_binding_level
->is_for_scope
= 1;
917 /* Record that the current binding level represents a try block. */
922 current_binding_level
->eh_region
= 1;
925 /* For a binding between a name and an entity at a block scope,
926 this is the `struct binding_level' for the block. */
927 #define BINDING_LEVEL(NODE) \
928 (((struct tree_binding*)NODE)->scope.level)
930 /* A free list of CPLUS_BINDING nodes, connected by their
933 static tree free_bindings
;
935 /* Make DECL the innermost binding for ID. The LEVEL is the binding
936 level at which this declaration is being bound. */
939 push_binding (id
, decl
, level
)
942 struct binding_level
* level
;
948 binding
= free_bindings
;
949 free_bindings
= TREE_CHAIN (binding
);
952 binding
= make_node (CPLUS_BINDING
);
954 /* Now, fill in the binding information. */
955 BINDING_VALUE (binding
) = decl
;
956 BINDING_TYPE (binding
) = NULL_TREE
;
957 BINDING_LEVEL (binding
) = level
;
958 INHERITED_VALUE_BINDING_P (binding
) = 0;
959 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
960 BINDING_HAS_LEVEL_P (binding
) = 1;
962 /* And put it on the front of the list of bindings for ID. */
963 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
964 IDENTIFIER_BINDING (id
) = binding
;
967 /* ID is already bound in the current scope. But, DECL is an
968 additional binding for ID in the same scope. This is the `struct
969 stat' hack whereby a non-typedef class-name or enum-name can be
970 bound at the same level as some other kind of entity. It's the
971 responsibility of the caller to check that inserting this name is
972 legal here. Returns nonzero if the new binding was successful. */
974 add_binding (id
, decl
)
978 tree binding
= IDENTIFIER_BINDING (id
);
981 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
982 /* The new name is the type name. */
983 BINDING_TYPE (binding
) = decl
;
984 else if (!BINDING_VALUE (binding
))
985 /* This situation arises when push_class_level_binding moves an
986 inherited type-binding out of the way to make room for a new
988 BINDING_VALUE (binding
) = decl
;
989 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
990 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
992 /* The old binding was a type name. It was placed in
993 BINDING_VALUE because it was thought, at the point it was
994 declared, to be the only entity with such a name. Move the
995 type name into the type slot; it is now hidden by the new
997 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
998 BINDING_VALUE (binding
) = decl
;
999 INHERITED_VALUE_BINDING_P (binding
) = 0;
1001 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1002 && TREE_CODE (decl
) == TYPE_DECL
1003 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1004 && same_type_p (TREE_TYPE (decl
),
1005 TREE_TYPE (BINDING_VALUE (binding
))))
1006 /* We have two typedef-names, both naming the same type to have
1007 the same name. This is OK because of:
1011 In a given scope, a typedef specifier can be used to redefine
1012 the name of any type declared in that scope to refer to the
1013 type to which it already refers. */
1015 /* There can be two block-scope declarations of the same variable,
1016 so long as they are `extern' declarations. */
1017 else if (TREE_CODE (decl
) == VAR_DECL
1018 && TREE_CODE (BINDING_VALUE (binding
)) == VAR_DECL
1019 && DECL_EXTERNAL (decl
)
1020 && DECL_EXTERNAL (BINDING_VALUE (binding
)))
1022 duplicate_decls (decl
, BINDING_VALUE (binding
));
1027 cp_error ("declaration of `%#D'", decl
);
1028 cp_error_at ("conflicts with previous declaration `%#D'",
1029 BINDING_VALUE (binding
));
1036 /* Add DECL to the list of things declared in B. */
1039 add_decl_to_level (decl
, b
)
1041 struct binding_level
*b
;
1043 /* We build up the list in reverse order, and reverse it later if
1045 TREE_CHAIN (decl
) = b
->names
;
1049 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1050 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1051 doesn't really belong to this binding level, that it got here
1052 through a using-declaration. */
1055 push_local_binding (id
, decl
, flags
)
1060 struct binding_level
*b
;
1062 /* Skip over any local classes. This makes sense if we call
1063 push_local_binding with a friend decl of a local class. */
1064 b
= current_binding_level
;
1065 while (b
->parm_flag
== 2)
1068 if (lookup_name_current_level (id
))
1070 /* Supplement the existing binding. */
1071 if (!add_binding (id
, decl
))
1072 /* It didn't work. Something else must be bound at this
1073 level. Do not add DECL to the list of things to pop
1078 /* Create a new binding. */
1079 push_binding (id
, decl
, b
);
1081 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1082 /* We must put the OVERLOAD into a TREE_LIST since the
1083 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1084 decls that got here through a using-declaration. */
1085 decl
= build_tree_list (NULL_TREE
, decl
);
1087 /* And put DECL on the list of things declared by the current
1089 add_decl_to_level (decl
, b
);
1092 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1093 binding was successful. */
1096 push_class_binding (id
, decl
)
1101 tree binding
= IDENTIFIER_BINDING (id
);
1104 /* Note that we declared this value so that we can issue an error if
1105 this an illegal redeclaration of a name already used for some
1107 note_name_declared_in_class (id
, decl
);
1109 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1110 /* Supplement the existing binding. */
1111 result
= add_binding (id
, decl
);
1113 /* Create a new binding. */
1114 push_binding (id
, decl
, class_binding_level
);
1116 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1117 class-level declaration. Note that we do not use DECL here
1118 because of the possibility of the `struct stat' hack; if DECL is
1119 a class-name or enum-name we might prefer a field-name, or some
1121 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1123 /* If this is a binding from a base class, mark it as such. */
1124 binding
= IDENTIFIER_BINDING (id
);
1125 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1127 /* Any implicit typename must be from a base-class. The
1128 context for an implicit typename declaration is always
1129 the derived class in which the lookup was done, so the checks
1130 based on the context of DECL below will not trigger. */
1131 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1132 INHERITED_VALUE_BINDING_P (binding
) = 1;
1135 if (TREE_CODE (decl
) == OVERLOAD
)
1136 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
1139 my_friendly_assert (DECL_P (decl
), 0);
1140 context
= context_for_name_lookup (decl
);
1143 if (is_properly_derived_from (current_class_type
, context
))
1144 INHERITED_VALUE_BINDING_P (binding
) = 1;
1146 INHERITED_VALUE_BINDING_P (binding
) = 0;
1149 else if (BINDING_VALUE (binding
) == decl
)
1150 /* We only encounter a TREE_LIST when push_class_decls detects an
1151 ambiguity. Such an ambiguity can be overridden by a definition
1153 INHERITED_VALUE_BINDING_P (binding
) = 1;
1158 /* Remove the binding for DECL which should be the innermost binding
1162 pop_binding (id
, decl
)
1168 if (id
== NULL_TREE
)
1169 /* It's easiest to write the loops that call this function without
1170 checking whether or not the entities involved have names. We
1171 get here for such an entity. */
1174 /* Get the innermost binding for ID. */
1175 binding
= IDENTIFIER_BINDING (id
);
1177 /* The name should be bound. */
1178 my_friendly_assert (binding
!= NULL_TREE
, 0);
1180 /* The DECL will be either the ordinary binding or the type
1181 binding for this identifier. Remove that binding. */
1182 if (BINDING_VALUE (binding
) == decl
)
1183 BINDING_VALUE (binding
) = NULL_TREE
;
1184 else if (BINDING_TYPE (binding
) == decl
)
1185 BINDING_TYPE (binding
) = NULL_TREE
;
1187 my_friendly_abort (0);
1189 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1191 /* We're completely done with the innermost binding for this
1192 identifier. Unhook it from the list of bindings. */
1193 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1195 /* Add it to the free list. */
1196 TREE_CHAIN (binding
) = free_bindings
;
1197 free_bindings
= binding
;
1199 /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1201 BINDING_LEVEL (binding
) = NULL
;
1205 /* When a label goes out of scope, check to see if that label was used
1206 in a valid manner, and issue any appropriate warnings or errors. */
1209 pop_label (label
, old_value
)
1213 if (!processing_template_decl
&& doing_semantic_analysis_p ())
1215 if (DECL_INITIAL (label
) == NULL_TREE
)
1217 cp_error_at ("label `%D' used but not defined", label
);
1218 /* Avoid crashing later. */
1219 define_label (input_filename
, 1, DECL_NAME (label
));
1221 else if (warn_unused_label
&& !TREE_USED (label
))
1222 cp_warning_at ("label `%D' defined but not used", label
);
1225 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
1228 /* At the end of a function, all labels declared within the function
1229 go out of scope. BLOCK is the top-level block for the
1236 struct named_label_list
*link
;
1238 /* Clear out the definitions of all label names, since their scopes
1240 for (link
= named_labels
; link
; link
= link
->next
)
1242 pop_label (link
->label_decl
, link
->old_value
);
1243 /* Put the labels into the "variables" of the top-level block,
1244 so debugger can see them. */
1245 TREE_CHAIN (link
->label_decl
) = BLOCK_VARS (block
);
1246 BLOCK_VARS (block
) = link
->label_decl
;
1249 named_labels
= NULL
;
1252 /* Exit a binding level.
1253 Pop the level off, and restore the state of the identifier-decl mappings
1254 that were in effect when this level was entered.
1256 If KEEP == 1, this level had explicit declarations, so
1257 and create a "block" (a BLOCK node) for the level
1258 to record its declarations and subblocks for symbol table output.
1260 If FUNCTIONBODY is nonzero, this level is the body of a function,
1261 so create a block as if KEEP were set and also clear out all
1264 If REVERSE is nonzero, reverse the order of decls before putting
1265 them into the BLOCK. */
1268 poplevel (keep
, reverse
, functionbody
)
1274 /* The chain of decls was accumulated in reverse order.
1275 Put it into forward order, just for cleanliness. */
1277 int tmp
= functionbody
;
1278 int real_functionbody
;
1281 tree block
= NULL_TREE
;
1283 int leaving_for_scope
;
1285 if (cfun
&& !doing_semantic_analysis_p ())
1288 my_friendly_assert (current_binding_level
->parm_flag
!= 2,
1291 real_functionbody
= (current_binding_level
->keep
== 2
1292 ? ((functionbody
= 0), tmp
) : functionbody
);
1293 tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1294 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1296 my_friendly_assert (!current_binding_level
->class_shadowed
,
1299 /* We used to use KEEP == 2 to indicate that the new block should go
1300 at the beginning of the list of blocks at this binding level,
1301 rather than the end. This hack is no longer used. */
1302 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1304 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1305 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1306 current_binding_level
->parm_flag
,
1307 current_binding_level
->keep
);
1309 if (current_binding_level
->keep
== 1)
1312 /* Any uses of undefined labels, and any defined labels, now operate
1313 under constraints of next binding contour. */
1314 if (cfun
&& !functionbody
)
1316 struct binding_level
*level_chain
;
1317 level_chain
= current_binding_level
->level_chain
;
1320 struct named_label_use_list
*uses
;
1321 struct named_label_list
*labels
;
1322 for (labels
= named_labels
; labels
; labels
= labels
->next
)
1323 if (labels
->binding_level
== current_binding_level
)
1326 if (current_binding_level
->eh_region
)
1327 labels
->eh_region
= 1;
1328 for (decl
= labels
->names_in_scope
; decl
;
1329 decl
= TREE_CHAIN (decl
))
1330 if (decl_jump_unsafe (decl
))
1331 labels
->bad_decls
= tree_cons (NULL_TREE
, decl
,
1333 labels
->binding_level
= level_chain
;
1334 labels
->names_in_scope
= level_chain
->names
;
1337 for (uses
= named_label_uses
; uses
; uses
= uses
->next
)
1338 if (uses
->binding_level
== current_binding_level
)
1340 uses
->binding_level
= level_chain
;
1341 uses
->names_in_scope
= level_chain
->names
;
1346 /* Get the decls in the order they were written.
1347 Usually current_binding_level->names is in reverse order.
1348 But parameter decls were previously put in forward order. */
1351 current_binding_level
->names
1352 = decls
= nreverse (current_binding_level
->names
);
1354 decls
= current_binding_level
->names
;
1356 /* Output any nested inline functions within this block
1357 if they weren't already output. */
1358 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1359 if (TREE_CODE (decl
) == FUNCTION_DECL
1360 && ! TREE_ASM_WRITTEN (decl
)
1361 && DECL_INITIAL (decl
) != NULL_TREE
1362 && TREE_ADDRESSABLE (decl
)
1363 && decl_function_context (decl
) == current_function_decl
)
1365 /* If this decl was copied from a file-scope decl
1366 on account of a block-scope extern decl,
1367 propagate TREE_ADDRESSABLE to the file-scope decl. */
1368 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1369 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1372 push_function_context ();
1373 output_inline_function (decl
);
1374 pop_function_context ();
1378 /* When not in function-at-a-time mode, expand_end_bindings will
1379 warn about unused variables. But, in function-at-a-time mode
1380 expand_end_bindings is not passed the list of variables in the
1381 current scope, and therefore no warning is emitted. So, we
1382 explicitly warn here. */
1383 if (!processing_template_decl
)
1384 warn_about_unused_variables (getdecls ());
1386 /* If there were any declarations or structure tags in that level,
1387 or if this level is a function body,
1388 create a BLOCK to record them for the life of this function. */
1390 if (keep
== 1 || functionbody
)
1391 block
= make_node (BLOCK
);
1392 if (block
!= NULL_TREE
)
1394 BLOCK_VARS (block
) = decls
;
1395 BLOCK_SUBBLOCKS (block
) = subblocks
;
1398 /* In each subblock, record that this is its superior. */
1400 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1401 BLOCK_SUPERCONTEXT (link
) = block
;
1403 /* We still support the old for-scope rules, whereby the variables
1404 in a for-init statement were in scope after the for-statement
1405 ended. We only use the new rules in flag_new_for_scope is
1408 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1410 /* Remove declarations for all the DECLs in this level. */
1411 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1413 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
1414 && DECL_NAME (link
))
1417 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1421 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1423 ns_binding
= NULL_TREE
;
1426 && (BINDING_LEVEL (outer_binding
)
1427 == current_binding_level
->level_chain
))
1428 /* We have something like:
1433 and we are leaving the `for' scope. There's no reason to
1434 keep the binding of the inner `i' in this case. */
1435 pop_binding (DECL_NAME (link
), link
);
1436 else if ((outer_binding
1437 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1440 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1441 /* Here, we have something like:
1449 We must pop the for-scope binding so we know what's a
1450 type and what isn't. */
1451 pop_binding (DECL_NAME (link
), link
);
1454 /* Mark this VAR_DECL as dead so that we can tell we left it
1455 there only for backward compatibility. */
1456 DECL_DEAD_FOR_LOCAL (link
) = 1;
1458 /* Keep track of what should of have happenned when we
1459 popped the binding. */
1460 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1461 DECL_SHADOWED_FOR_VAR (link
)
1462 = BINDING_VALUE (outer_binding
);
1464 /* Add it to the list of dead variables in the next
1465 outermost binding to that we can remove these when we
1466 leave that binding. */
1467 current_binding_level
->level_chain
->dead_vars_from_for
1468 = tree_cons (NULL_TREE
, link
,
1469 current_binding_level
->level_chain
->
1470 dead_vars_from_for
);
1472 /* Although we don't pop the CPLUS_BINDING, we do clear
1473 its BINDING_LEVEL since the level is going away now. */
1474 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1480 /* Remove the binding. */
1482 if (TREE_CODE (decl
) == TREE_LIST
)
1483 decl
= TREE_VALUE (decl
);
1485 pop_binding (DECL_NAME (decl
), decl
);
1486 else if (TREE_CODE (decl
) == OVERLOAD
)
1487 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1489 my_friendly_abort (0);
1493 /* Remove declarations for any `for' variables from inner scopes
1494 that we kept around. */
1495 for (link
= current_binding_level
->dead_vars_from_for
;
1496 link
; link
= TREE_CHAIN (link
))
1497 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1499 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1500 for (link
= current_binding_level
->type_shadowed
;
1501 link
; link
= TREE_CHAIN (link
))
1502 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1504 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1505 for (link
= current_binding_level
->shadowed_labels
;
1507 link
= TREE_CHAIN (link
))
1508 pop_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
1510 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1511 list if a `using' declaration put them there. The debugging
1512 back-ends won't understand OVERLOAD, so we remove them here.
1513 Because the BLOCK_VARS are (temporarily) shared with
1514 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1515 popped all the bindings. */
1520 for (d
= &BLOCK_VARS (block
); *d
; )
1522 if (TREE_CODE (*d
) == TREE_LIST
)
1523 *d
= TREE_CHAIN (*d
);
1525 d
= &TREE_CHAIN (*d
);
1529 /* If the level being exited is the top level of a function,
1530 check over all the labels. */
1533 /* Since this is the top level block of a function, the vars are
1534 the function's parameters. Don't leave them in the BLOCK
1535 because they are found in the FUNCTION_DECL instead. */
1536 BLOCK_VARS (block
) = 0;
1540 tmp
= current_binding_level
->keep
;
1542 pop_binding_level ();
1544 DECL_INITIAL (current_function_decl
) = block
;
1546 current_binding_level
->blocks
1547 = chainon (current_binding_level
->blocks
, block
);
1549 /* If we did not make a block for the level just exited,
1550 any blocks made for inner levels
1551 (since they cannot be recorded as subblocks in that level)
1552 must be carried forward so they will later become subblocks
1553 of something else. */
1555 current_binding_level
->blocks
1556 = chainon (current_binding_level
->blocks
, subblocks
);
1558 /* Each and every BLOCK node created here in `poplevel' is important
1559 (e.g. for proper debugging information) so if we created one
1560 earlier, mark it as "used". */
1562 TREE_USED (block
) = 1;
1564 /* Take care of compiler's internal binding structures. */
1570 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1573 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts
)) = block
;
1574 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts
)) = block
;
1577 block
= poplevel (keep
, reverse
, functionbody
);
1583 /* Delete the node BLOCK from the current binding level.
1584 This is used for the block inside a stmt expr ({...})
1585 so that the block can be reinserted where appropriate. */
1588 delete_block (block
)
1592 if (current_binding_level
->blocks
== block
)
1593 current_binding_level
->blocks
= TREE_CHAIN (block
);
1594 for (t
= current_binding_level
->blocks
; t
;)
1596 if (TREE_CHAIN (t
) == block
)
1597 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1601 TREE_CHAIN (block
) = NULL_TREE
;
1602 /* Clear TREE_USED which is always set by poplevel.
1603 The flag is set again if insert_block is called. */
1604 TREE_USED (block
) = 0;
1607 /* Insert BLOCK at the end of the list of subblocks of the
1608 current binding level. This is used when a BIND_EXPR is expanded,
1609 to handle the BLOCK node inside the BIND_EXPR. */
1612 insert_block (block
)
1615 TREE_USED (block
) = 1;
1616 current_binding_level
->blocks
1617 = chainon (current_binding_level
->blocks
, block
);
1620 /* Set the BLOCK node for the innermost scope
1621 (the one we are currently in). */
1625 tree block ATTRIBUTE_UNUSED
;
1627 /* The RTL expansion machinery requires us to provide this callback,
1628 but it is not applicable in function-at-a-time mode. */
1629 my_friendly_assert (cfun
&& !doing_semantic_analysis_p (), 20000911);
1632 /* Do a pushlevel for class declarations. */
1637 register struct binding_level
*newlevel
;
1639 /* Reuse or create a struct for this binding level. */
1640 #if defined(DEBUG_CP_BINDING_LEVELS)
1642 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1643 if (free_binding_level
)
1644 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1646 newlevel
= free_binding_level
;
1647 free_binding_level
= free_binding_level
->level_chain
;
1650 newlevel
= make_binding_level ();
1652 #if defined(DEBUG_CP_BINDING_LEVELS)
1654 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1656 push_binding_level (newlevel
, 0, 0);
1658 class_binding_level
= current_binding_level
;
1659 class_binding_level
->parm_flag
= 2;
1660 class_binding_level
->this_class
= current_class_type
;
1663 /* ...and a poplevel for class declarations. */
1668 register struct binding_level
*level
= class_binding_level
;
1671 my_friendly_assert (level
!= 0, 354);
1673 /* If we're leaving a toplevel class, don't bother to do the setting
1674 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1675 shouldn't even be used when current_class_type isn't set, and second,
1676 if we don't touch it here, we're able to use the cache effect if the
1677 next time we're entering a class scope, it is the same class. */
1678 if (current_class_depth
!= 1)
1680 struct binding_level
* b
;
1682 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1683 for (shadowed
= level
->class_shadowed
;
1685 shadowed
= TREE_CHAIN (shadowed
))
1686 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1688 /* Find the next enclosing class, and recreate
1689 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1690 b
= level
->level_chain
;
1691 while (b
&& b
->parm_flag
!= 2)
1695 for (shadowed
= b
->class_shadowed
;
1697 shadowed
= TREE_CHAIN (shadowed
))
1701 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1702 while (t
&& BINDING_LEVEL (t
) != b
)
1706 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1707 = BINDING_VALUE (t
);
1711 /* Remember to save what IDENTIFIER's were bound in this scope so we
1712 can recover from cache misses. */
1714 previous_class_type
= current_class_type
;
1715 previous_class_values
= class_binding_level
->class_shadowed
;
1717 for (shadowed
= level
->type_shadowed
;
1719 shadowed
= TREE_CHAIN (shadowed
))
1720 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1722 /* Remove the bindings for all of the class-level declarations. */
1723 for (shadowed
= level
->class_shadowed
;
1725 shadowed
= TREE_CHAIN (shadowed
))
1726 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1728 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1729 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1730 class_binding_level
->parm_flag
,
1731 class_binding_level
->keep
);
1733 /* Now, pop out of the binding level which we created up in the
1734 `pushlevel_class' routine. */
1735 #if defined(DEBUG_CP_BINDING_LEVELS)
1737 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1739 pop_binding_level ();
1742 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1743 for any names in enclosing classes. */
1746 clear_identifier_class_values ()
1750 if (!class_binding_level
)
1753 for (t
= class_binding_level
->class_shadowed
;
1756 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1759 /* Returns non-zero if T is a virtual function table. */
1762 vtable_decl_p (t
, data
)
1764 void *data ATTRIBUTE_UNUSED
;
1766 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1769 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1773 vtype_decl_p (t
, data
)
1775 void *data ATTRIBUTE_UNUSED
;
1777 return (TREE_CODE (t
) == TYPE_DECL
1778 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
1779 && TYPE_POLYMORPHIC_P (TREE_TYPE (t
)));
1782 /* Return the declarations that are members of the namespace NS. */
1785 cp_namespace_decls (ns
)
1788 return NAMESPACE_LEVEL (ns
)->names
;
1791 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1792 itself, calling F for each. The DATA is passed to F as well. */
1795 walk_namespaces_r (namespace, f
, data
)
1797 walk_namespaces_fn f
;
1803 result
|= (*f
) (namespace, data
);
1805 for (current
= cp_namespace_decls (namespace);
1807 current
= TREE_CHAIN (current
))
1809 if (TREE_CODE (current
) != NAMESPACE_DECL
1810 || DECL_NAMESPACE_ALIAS (current
))
1812 if (!DECL_LANG_SPECIFIC (current
))
1815 my_friendly_assert (current
== fake_std_node
, 393);
1819 /* We found a namespace. */
1820 result
|= walk_namespaces_r (current
, f
, data
);
1826 /* Walk all the namespaces, calling F for each. The DATA is passed to
1830 walk_namespaces (f
, data
)
1831 walk_namespaces_fn f
;
1834 return walk_namespaces_r (global_namespace
, f
, data
);
1837 struct walk_globals_data
{
1838 walk_globals_pred p
;
1843 /* Walk the global declarations in NAMESPACE. Whenever one is found
1844 for which P returns non-zero, call F with its address. If any call
1845 to F returns a non-zero value, return a non-zero value. */
1848 walk_globals_r (namespace, data
)
1852 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1853 walk_globals_pred p
= wgd
->p
;
1854 walk_globals_fn f
= wgd
->f
;
1855 void *d
= wgd
->data
;
1859 t
= &NAMESPACE_LEVEL (namespace)->names
;
1866 result
|= (*f
) (t
, d
);
1868 /* If F changed *T, then *T still points at the next item to
1871 t
= &TREE_CHAIN (*t
);
1877 /* Walk the global declarations. Whenever one is found for which P
1878 returns non-zero, call F with its address. If any call to F
1879 returns a non-zero value, return a non-zero value. */
1882 walk_globals (p
, f
, data
)
1883 walk_globals_pred p
;
1887 struct walk_globals_data wgd
;
1892 return walk_namespaces (walk_globals_r
, &wgd
);
1895 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1896 DATA is non-NULL, this is the last time we will call
1897 wrapup_global_declarations for this NAMESPACE. */
1900 wrapup_globals_for_namespace (namespace, data
)
1904 tree globals
= cp_namespace_decls (namespace);
1905 int len
= list_length (globals
);
1906 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1910 int last_time
= (data
!= 0);
1912 if (last_time
&& namespace == global_namespace
)
1913 /* Let compile_file handle the global namespace. */
1916 /* Process the decls in reverse order--earliest first.
1917 Put them into VEC from back to front, then take out from front. */
1918 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1919 vec
[len
- i
- 1] = decl
;
1923 check_global_declarations (vec
, len
);
1927 /* Temporarily mark vtables as external. That prevents
1928 wrapup_global_declarations from writing them out; we must process
1929 them ourselves in finish_vtable_vardecl. */
1930 for (i
= 0; i
< len
; ++i
)
1931 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1933 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1934 DECL_EXTERNAL (vec
[i
]) = 1;
1937 /* Write out any globals that need to be output. */
1938 result
= wrapup_global_declarations (vec
, len
);
1940 /* Undo the hack to DECL_EXTERNAL above. */
1941 for (i
= 0; i
< len
; ++i
)
1942 if (vtable_decl_p (vec
[i
], /*data=*/0)
1943 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1945 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1946 DECL_EXTERNAL (vec
[i
]) = 0;
1953 /* Mark ARG (which is really a struct binding_level **) for GC. */
1956 mark_binding_level (arg
)
1959 struct binding_level
*lvl
= *(struct binding_level
**)arg
;
1961 for (; lvl
; lvl
= lvl
->level_chain
)
1963 ggc_mark_tree (lvl
->names
);
1964 ggc_mark_tree (lvl
->tags
);
1965 ggc_mark_tree (lvl
->usings
);
1966 ggc_mark_tree (lvl
->using_directives
);
1967 ggc_mark_tree (lvl
->class_shadowed
);
1968 ggc_mark_tree (lvl
->type_shadowed
);
1969 ggc_mark_tree (lvl
->shadowed_labels
);
1970 ggc_mark_tree (lvl
->blocks
);
1971 ggc_mark_tree (lvl
->this_class
);
1972 ggc_mark_tree (lvl
->incomplete
);
1973 ggc_mark_tree (lvl
->dead_vars_from_for
);
1978 mark_named_label_lists (labs
, uses
)
1982 struct named_label_list
*l
= *(struct named_label_list
**)labs
;
1983 struct named_label_use_list
*u
= *(struct named_label_use_list
**)uses
;
1985 for (; l
; l
= l
->next
)
1988 mark_binding_level (l
->binding_level
);
1989 ggc_mark_tree (l
->old_value
);
1990 ggc_mark_tree (l
->label_decl
);
1991 ggc_mark_tree (l
->bad_decls
);
1994 for (; u
; u
= u
->next
)
1998 /* For debugging. */
1999 static int no_print_functions
= 0;
2000 static int no_print_builtins
= 0;
2003 print_binding_level (lvl
)
2004 struct binding_level
*lvl
;
2008 fprintf (stderr
, " blocks=");
2009 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
2010 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
2011 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
2012 if (lvl
->tag_transparent
)
2013 fprintf (stderr
, " tag-transparent");
2014 if (lvl
->more_cleanups_ok
)
2015 fprintf (stderr
, " more-cleanups-ok");
2016 if (lvl
->have_cleanups
)
2017 fprintf (stderr
, " have-cleanups");
2018 fprintf (stderr
, "\n");
2021 fprintf (stderr
, " names:\t");
2022 /* We can probably fit 3 names to a line? */
2023 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2025 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2027 if (no_print_builtins
2028 && (TREE_CODE (t
) == TYPE_DECL
)
2029 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2032 /* Function decls tend to have longer names. */
2033 if (TREE_CODE (t
) == FUNCTION_DECL
)
2040 fprintf (stderr
, "\n\t");
2043 print_node_brief (stderr
, "", t
, 0);
2044 if (t
== error_mark_node
)
2048 fprintf (stderr
, "\n");
2052 fprintf (stderr
, " tags:\t");
2054 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2056 if (TREE_PURPOSE (t
) == NULL_TREE
)
2058 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2065 fprintf (stderr
, "\n\t");
2068 if (TREE_PURPOSE (t
) == NULL_TREE
)
2070 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2071 fprintf (stderr
, ">");
2073 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2074 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2077 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2078 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2079 fprintf (stderr
, ">");
2083 fprintf (stderr
, "\n");
2085 if (lvl
->class_shadowed
)
2087 fprintf (stderr
, " class-shadowed:");
2088 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2090 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2092 fprintf (stderr
, "\n");
2094 if (lvl
->type_shadowed
)
2096 fprintf (stderr
, " type-shadowed:");
2097 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2099 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2101 fprintf (stderr
, "\n");
2106 print_other_binding_stack (stack
)
2107 struct binding_level
*stack
;
2109 struct binding_level
*level
;
2110 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2112 fprintf (stderr
, "binding level ");
2113 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2114 fprintf (stderr
, "\n");
2115 print_binding_level (level
);
2120 print_binding_stack ()
2122 struct binding_level
*b
;
2123 fprintf (stderr
, "current_binding_level=");
2124 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2125 fprintf (stderr
, "\nclass_binding_level=");
2126 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2127 fprintf (stderr
, "\nglobal_binding_level=");
2128 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2129 fprintf (stderr
, "\n");
2130 if (class_binding_level
)
2132 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2133 if (b
== current_binding_level
)
2136 b
= class_binding_level
;
2138 b
= current_binding_level
;
2141 b
= current_binding_level
;
2142 print_other_binding_stack (b
);
2143 fprintf (stderr
, "global:\n");
2144 print_binding_level (global_binding_level
);
2147 /* Namespace binding access routines: The namespace_bindings field of
2148 the identifier is polymorphic, with three possible values:
2149 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2150 indicating the BINDING_VALUE of global_namespace. */
2152 /* Check whether the a binding for the name to scope is known.
2153 Assumes that the bindings of the name are already a list
2154 of bindings. Returns the binding found, or NULL_TREE. */
2157 find_binding (name
, scope
)
2161 tree iter
, prev
= NULL_TREE
;
2163 scope
= ORIGINAL_NAMESPACE (scope
);
2165 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2166 iter
= TREE_CHAIN (iter
))
2168 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2169 if (BINDING_SCOPE (iter
) == scope
)
2171 /* Move binding found to the front of the list, so
2172 subsequent lookups will find it faster. */
2175 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2176 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2177 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2186 /* Always returns a binding for name in scope. If the
2187 namespace_bindings is not a list, convert it to one first.
2188 If no binding is found, make a new one. */
2191 binding_for_name (name
, scope
)
2195 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2198 scope
= ORIGINAL_NAMESPACE (scope
);
2200 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2202 /* Get rid of optimization for global scope. */
2203 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2204 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2205 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2207 if (b
&& (result
= find_binding (name
, scope
)))
2209 /* Not found, make a new one. */
2210 result
= make_node (CPLUS_BINDING
);
2211 TREE_CHAIN (result
) = b
;
2212 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2213 BINDING_SCOPE (result
) = scope
;
2214 BINDING_TYPE (result
) = NULL_TREE
;
2215 BINDING_VALUE (result
) = NULL_TREE
;
2219 /* Return the binding value for name in scope, considering that
2220 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2223 namespace_binding (name
, scope
)
2227 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2230 if (scope
== NULL_TREE
)
2231 scope
= global_namespace
;
2232 if (TREE_CODE (b
) != CPLUS_BINDING
)
2233 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2234 name
= find_binding (name
,scope
);
2235 if (name
== NULL_TREE
)
2237 return BINDING_VALUE (name
);
2240 /* Set the binding value for name in scope. If modifying the binding
2241 of global_namespace is attempted, try to optimize it. */
2244 set_namespace_binding (name
, scope
, val
)
2251 if (scope
== NULL_TREE
)
2252 scope
= global_namespace
;
2254 if (scope
== global_namespace
)
2256 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2257 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2259 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2263 b
= binding_for_name (name
, scope
);
2264 BINDING_VALUE (b
) = val
;
2267 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2268 select a name that is unique to this compilation unit. */
2271 push_namespace (name
)
2276 int implicit_use
= 0;
2278 if (!global_namespace
)
2280 /* This must be ::. */
2281 my_friendly_assert (name
== get_identifier ("::"), 377);
2286 /* The name of anonymous namespace is unique for the translation
2288 if (!anonymous_namespace_name
)
2289 anonymous_namespace_name
= get_file_function_name ('N');
2290 name
= anonymous_namespace_name
;
2291 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2293 /* Reopening anonymous namespace. */
2297 else if (current_namespace
== global_namespace
2299 && name
== std_identifier
)
2306 /* Check whether this is an extended namespace definition. */
2307 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2308 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2311 if (DECL_NAMESPACE_ALIAS (d
))
2313 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2314 d
, DECL_NAMESPACE_ALIAS (d
));
2315 d
= DECL_NAMESPACE_ALIAS (d
);
2322 /* Make a new namespace, binding the name to it. */
2323 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2324 /* The global namespace is not pushed, and the global binding
2325 level is set elsewhere. */
2328 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2331 declare_namespace_level ();
2332 NAMESPACE_LEVEL (d
) = current_binding_level
;
2336 resume_binding_level (NAMESPACE_LEVEL (d
));
2339 do_using_directive (d
);
2340 /* Enter the name space. */
2341 current_namespace
= d
;
2344 /* Pop from the scope of the current namespace. */
2349 if (current_namespace
== global_namespace
)
2351 my_friendly_assert (in_fake_std
> 0, 980421);
2355 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2356 /* The binding level is not popped, as it might be re-opened later. */
2357 suspend_binding_level ();
2360 /* Push into the scope of the namespace NS, even if it is deeply
2361 nested within another namespace. */
2364 push_nested_namespace (ns
)
2367 if (ns
== global_namespace
)
2368 push_to_top_level ();
2371 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2372 push_namespace (DECL_NAME (ns
));
2376 /* Pop back from the scope of the namespace NS, which was previously
2377 entered with push_nested_namespace. */
2380 pop_nested_namespace (ns
)
2383 while (ns
!= global_namespace
)
2386 ns
= CP_DECL_CONTEXT (ns
);
2389 pop_from_top_level ();
2393 /* Subroutines for reverting temporarily to top-level for instantiation
2394 of templates and such. We actually need to clear out the class- and
2395 local-value slots of all identifiers, so that only the global values
2396 are at all visible. Simply setting current_binding_level to the global
2397 scope isn't enough, because more binding levels may be pushed. */
2398 struct saved_scope
*scope_chain
;
2400 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2403 mark_saved_scope (arg
)
2406 struct saved_scope
*t
= *(struct saved_scope
**)arg
;
2409 mark_binding_level (&t
->class_bindings
);
2410 ggc_mark_tree (t
->old_bindings
);
2411 ggc_mark_tree (t
->old_namespace
);
2412 ggc_mark_tree (t
->class_name
);
2413 ggc_mark_tree (t
->class_type
);
2414 ggc_mark_tree (t
->access_specifier
);
2415 ggc_mark_tree (t
->function_decl
);
2417 ggc_mark_tree_varray (t
->lang_base
);
2418 ggc_mark_tree (t
->lang_name
);
2419 ggc_mark_tree (t
->template_parms
);
2420 ggc_mark_tree (t
->x_previous_class_type
);
2421 ggc_mark_tree (t
->x_previous_class_values
);
2422 ggc_mark_tree (t
->x_saved_tree
);
2423 ggc_mark_tree (t
->incomplete
);
2424 ggc_mark_tree (t
->lookups
);
2426 mark_stmt_tree (&t
->x_stmt_tree
);
2427 mark_binding_level (&t
->bindings
);
2433 store_bindings (names
, old_bindings
)
2434 tree names
, old_bindings
;
2437 tree search_bindings
= old_bindings
;
2439 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2441 tree binding
, t1
, id
;
2443 if (TREE_CODE (t
) == TREE_LIST
)
2444 id
= TREE_PURPOSE (t
);
2449 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2450 we have no IDENTIFIER_BINDING if we have left the class
2451 scope, but cached the class-level declarations. */
2452 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2455 for (t1
= search_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2456 if (TREE_VEC_ELT (t1
, 0) == id
)
2459 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2460 binding
= make_tree_vec (4);
2461 TREE_VEC_ELT (binding
, 0) = id
;
2462 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2463 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2464 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2465 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2466 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2467 TREE_CHAIN (binding
) = old_bindings
;
2468 old_bindings
= binding
;
2472 return old_bindings
;
2476 maybe_push_to_top_level (pseudo
)
2479 struct saved_scope
*s
;
2480 struct binding_level
*b
;
2484 s
= (struct saved_scope
*) xcalloc (1, sizeof (struct saved_scope
));
2486 b
= scope_chain
? current_binding_level
: 0;
2488 /* If we're in the middle of some function, save our state. */
2492 push_function_context_to (NULL_TREE
);
2497 old_bindings
= NULL_TREE
;
2498 if (scope_chain
&& previous_class_type
)
2499 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2501 /* Have to include global_binding_level, because class-level decls
2502 aren't listed anywhere useful. */
2503 for (; b
; b
= b
->level_chain
)
2507 /* Template IDs are inserted into the global level. If they were
2508 inserted into namespace level, finish_file wouldn't find them
2509 when doing pending instantiations. Therefore, don't stop at
2510 namespace level, but continue until :: . */
2511 if (b
== global_binding_level
|| (pseudo
&& b
->template_parms_p
))
2514 old_bindings
= store_bindings (b
->names
, old_bindings
);
2515 /* We also need to check class_shadowed to save class-level type
2516 bindings, since pushclass doesn't fill in b->names. */
2517 if (b
->parm_flag
== 2)
2518 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2520 /* Unwind type-value slots back to top level. */
2521 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2522 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2524 s
->prev
= scope_chain
;
2525 s
->old_bindings
= old_bindings
;
2527 s
->need_pop_function_context
= need_pop
;
2528 s
->function_decl
= current_function_decl
;
2531 current_function_decl
= NULL_TREE
;
2532 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
2533 current_lang_stack
= &VARRAY_TREE (current_lang_base
, 0);
2534 current_lang_name
= lang_name_cplusplus
;
2535 current_namespace
= global_namespace
;
2539 push_to_top_level ()
2541 maybe_push_to_top_level (0);
2545 pop_from_top_level ()
2547 struct saved_scope
*s
= scope_chain
;
2550 /* Clear out class-level bindings cache. */
2551 if (previous_class_type
)
2552 invalidate_class_lookup_cache ();
2554 VARRAY_FREE (current_lang_base
);
2556 scope_chain
= s
->prev
;
2557 for (t
= s
->old_bindings
; t
; t
= TREE_CHAIN (t
))
2559 tree id
= TREE_VEC_ELT (t
, 0);
2561 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2562 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2563 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2566 /* If we were in the middle of compiling a function, restore our
2568 if (s
->need_pop_function_context
)
2569 pop_function_context_from (NULL_TREE
);
2570 current_function_decl
= s
->function_decl
;
2575 /* Push a definition of struct, union or enum tag "name".
2576 into binding_level "b". "type" should be the type node,
2577 We assume that the tag "name" is not already defined.
2579 Note that the definition may really be just a forward reference.
2580 In that case, the TYPE_SIZE will be a NULL_TREE.
2582 C++ gratuitously puts all these tags in the name space. */
2584 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2585 record the shadowed value for this binding contour. TYPE is
2586 the type that ID maps to. */
2589 set_identifier_type_value_with_scope (id
, type
, b
)
2592 struct binding_level
*b
;
2594 if (!b
->namespace_p
)
2596 /* Shadow the marker, not the real thing, so that the marker
2597 gets restored later. */
2598 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2600 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2604 tree binding
= binding_for_name (id
, current_namespace
);
2605 BINDING_TYPE (binding
) = type
;
2606 /* Store marker instead of real type. */
2607 type
= global_type_node
;
2609 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2612 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2615 set_identifier_type_value (id
, type
)
2619 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2622 /* Return the type associated with id. */
2625 identifier_type_value (id
)
2628 /* There is no type with that name, anywhere. */
2629 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2631 /* This is not the type marker, but the real thing. */
2632 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2633 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2634 /* Have to search for it. It must be on the global level, now.
2635 Ask lookup_name not to return non-types. */
2636 id
= lookup_name_real (id
, 2, 1, 0);
2638 return TREE_TYPE (id
);
2642 /* Pop off extraneous binding levels left over due to syntax errors.
2644 We don't pop past namespaces, as they might be valid. */
2649 #ifdef DEBUG_CP_BINDING_LEVELS
2650 fprintf (stderr
, "XXX entering pop_everything ()\n");
2652 while (!toplevel_bindings_p ())
2654 if (current_binding_level
->parm_flag
== 2)
2655 pop_nested_class ();
2659 #ifdef DEBUG_CP_BINDING_LEVELS
2660 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2664 /* The type TYPE is being declared. If it is a class template, or a
2665 specialization of a class template, do any processing required and
2666 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2667 being declared a friend. B is the binding level at which this TYPE
2670 Returns the TYPE_DECL for TYPE, which may have been altered by this
2674 maybe_process_template_type_declaration (type
, globalize
, b
)
2677 struct binding_level
* b
;
2679 tree decl
= TYPE_NAME (type
);
2681 if (processing_template_parmlist
)
2682 /* You can't declare a new template type in a template parameter
2683 list. But, you can declare a non-template type:
2685 template <class A*> struct S;
2687 is a forward-declaration of `A'. */
2691 maybe_check_template_type (type
);
2693 my_friendly_assert (IS_AGGR_TYPE (type
)
2694 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2697 if (processing_template_decl
)
2699 /* This may change after the call to
2700 push_template_decl_real, but we want the original value. */
2701 tree name
= DECL_NAME (decl
);
2703 decl
= push_template_decl_real (decl
, globalize
);
2704 /* If the current binding level is the binding level for the
2705 template parameters (see the comment in
2706 begin_template_parm_list) and the enclosing level is a class
2707 scope, and we're not looking at a friend, push the
2708 declaration of the member class into the class scope. In the
2709 friend case, push_template_decl will already have put the
2710 friend into global scope, if appropriate. */
2711 if (TREE_CODE (type
) != ENUMERAL_TYPE
2712 && !globalize
&& b
->template_parms_p
2713 && b
->level_chain
->parm_flag
== 2)
2715 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2716 /* Put this tag on the list of tags for the class, since
2717 that won't happen below because B is not the class
2718 binding level, but is instead the pseudo-global level. */
2719 b
->level_chain
->tags
=
2720 tree_cons (name
, type
, b
->level_chain
->tags
);
2721 if (!COMPLETE_TYPE_P (current_class_type
))
2722 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2730 /* In C++, you don't have to write `struct S' to refer to `S'; you
2731 can just use `S'. We accomplish this by creating a TYPE_DECL as
2732 if the user had written `typedef struct S S'. Create and return
2733 the TYPE_DECL for TYPE. */
2736 create_implicit_typedef (name
, type
)
2742 decl
= build_decl (TYPE_DECL
, name
, type
);
2743 DECL_ARTIFICIAL (decl
) = 1;
2744 /* There are other implicit type declarations, like the one *within*
2745 a class that allows you to write `S::S'. We must distinguish
2747 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2748 TYPE_NAME (type
) = decl
;
2753 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2754 Normally put it into the inner-most non-tag-transparent scope,
2755 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2756 The latter is needed for implicit declarations. */
2759 pushtag (name
, type
, globalize
)
2763 register struct binding_level
*b
;
2765 b
= current_binding_level
;
2766 while (b
->tag_transparent
2767 || (globalize
&& b
->parm_flag
== 2))
2770 b
->tags
= tree_cons (name
, type
, b
->tags
);
2774 /* Do C++ gratuitous typedefing. */
2775 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2777 register tree d
= NULL_TREE
;
2779 tree context
= TYPE_CONTEXT (type
);
2783 tree cs
= current_scope ();
2787 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
2788 /* When declaring a friend class of a local class, we want
2789 to inject the newly named class into the scope
2790 containing the local class, not the namespace scope. */
2791 context
= decl_function_context (get_type_decl (cs
));
2794 context
= current_namespace
;
2796 if ((b
->template_parms_p
&& b
->level_chain
->parm_flag
== 2)
2797 || b
->parm_flag
== 2)
2800 if (current_lang_name
== lang_name_java
)
2801 TYPE_FOR_JAVA (type
) = 1;
2803 d
= create_implicit_typedef (name
, type
);
2804 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2806 set_identifier_type_value_with_scope (name
, type
, b
);
2808 d
= maybe_process_template_type_declaration (type
,
2811 if (b
->parm_flag
== 2)
2813 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2814 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2815 class. But if it's a member template class, we
2816 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2818 finish_member_declaration (d
);
2820 pushdecl_class_level (d
);
2823 d
= pushdecl_with_scope (d
, b
);
2825 if (ANON_AGGRNAME_P (name
))
2826 DECL_IGNORED_P (d
) = 1;
2828 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2829 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2831 /* If this is a local class, keep track of it. We need this
2832 information for name-mangling, and so that it is possible to find
2833 all function definitions in a translation unit in a convenient
2834 way. (It's otherwise tricky to find a member function definition
2835 it's only pointed to from within a local class.) */
2836 if (TYPE_CONTEXT (type
)
2837 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
2838 && !processing_template_decl
)
2839 VARRAY_PUSH_TREE (local_classes
, type
);
2841 if (!uses_template_parms (type
))
2842 DECL_ASSEMBLER_NAME (d
) = mangle_type (type
);
2844 if (b
->parm_flag
== 2)
2846 if (!COMPLETE_TYPE_P (current_class_type
))
2847 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2851 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2852 /* Use the canonical TYPE_DECL for this node. */
2853 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2856 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2857 will be the tagged type we just added to the current
2858 binding level. This fake NULL-named TYPE_DECL node helps
2859 dwarfout.c to know when it needs to output a
2860 representation of a tagged type, and it also gives us a
2861 convenient place to record the "scope start" address for
2864 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2865 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2869 /* Counter used to create anonymous type names. */
2871 static int anon_cnt
= 0;
2873 /* Return an IDENTIFIER which can be used as a name for
2874 anonymous structs and unions. */
2881 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2882 return get_identifier (buf
);
2885 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2886 This keeps dbxout from getting confused. */
2891 register struct binding_level
*b
;
2893 static int last_cnt
= 0;
2895 /* Fast out if no new anon names were declared. */
2896 if (last_cnt
== anon_cnt
)
2899 b
= current_binding_level
;
2900 while (b
->tag_transparent
)
2905 /* A NULL purpose means we have already processed all tags
2906 from here to the end of the list. */
2907 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2909 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2910 TREE_PURPOSE (tags
) = NULL_TREE
;
2911 tags
= TREE_CHAIN (tags
);
2913 last_cnt
= anon_cnt
;
2916 /* Subroutine of duplicate_decls: return truthvalue of whether
2917 or not types of these decls match.
2919 For C++, we must compare the parameter list so that `int' can match
2920 `int&' in a parameter position, but `int&' is not confused with
2924 decls_match (newdecl
, olddecl
)
2925 tree newdecl
, olddecl
;
2929 if (newdecl
== olddecl
)
2932 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2933 /* If the two DECLs are not even the same kind of thing, we're not
2934 interested in their types. */
2937 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2939 tree f1
= TREE_TYPE (newdecl
);
2940 tree f2
= TREE_TYPE (olddecl
);
2941 tree p1
= TYPE_ARG_TYPES (f1
);
2942 tree p2
= TYPE_ARG_TYPES (f2
);
2944 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
2945 && ! (DECL_EXTERN_C_P (newdecl
)
2946 && DECL_EXTERN_C_P (olddecl
)))
2949 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2952 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2954 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
2955 && (DECL_BUILT_IN (olddecl
)
2956 #ifndef NO_IMPLICIT_EXTERN_C
2957 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
2958 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
2962 types_match
= self_promoting_args_p (p1
);
2963 if (p1
== void_list_node
)
2964 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2966 #ifndef NO_IMPLICIT_EXTERN_C
2967 else if (p1
== NULL_TREE
2968 && (DECL_EXTERN_C_P (olddecl
)
2969 && DECL_IN_SYSTEM_HEADER (olddecl
)
2970 && !DECL_CLASS_SCOPE_P (olddecl
))
2971 && (DECL_EXTERN_C_P (newdecl
)
2972 && DECL_IN_SYSTEM_HEADER (newdecl
)
2973 && !DECL_CLASS_SCOPE_P (newdecl
)))
2975 types_match
= self_promoting_args_p (p2
);
2976 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2980 types_match
= compparms (p1
, p2
);
2985 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2987 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
2988 DECL_TEMPLATE_PARMS (olddecl
)))
2991 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
2992 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
2995 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2998 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
2999 DECL_TEMPLATE_RESULT (newdecl
));
3003 if (TREE_TYPE (newdecl
) == error_mark_node
)
3004 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3005 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3006 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3007 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3010 types_match
= comptypes (TREE_TYPE (newdecl
),
3011 TREE_TYPE (olddecl
),
3012 COMPARE_REDECLARATION
);
3018 /* If NEWDECL is `static' and an `extern' was seen previously,
3019 warn about it. OLDDECL is the previous declaration.
3021 Note that this does not apply to the C++ case of declaring
3022 a variable `extern const' and then later `const'.
3024 Don't complain about built-in functions, since they are beyond
3025 the user's control. */
3028 warn_extern_redeclared_static (newdecl
, olddecl
)
3029 tree newdecl
, olddecl
;
3031 static const char *explicit_extern_static_warning
3032 = "`%D' was declared `extern' and later `static'";
3033 static const char *implicit_extern_static_warning
3034 = "`%D' was declared implicitly `extern' and later `static'";
3038 if (TREE_CODE (newdecl
) == TYPE_DECL
3039 || TREE_CODE (newdecl
) == TEMPLATE_DECL
3040 || TREE_CODE (newdecl
) == CONST_DECL
)
3043 /* Don't get confused by static member functions; that's a different
3045 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3046 && DECL_STATIC_FUNCTION_P (newdecl
))
3049 /* If the old declaration was `static', or the new one isn't, then
3050 then everything is OK. */
3051 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
3054 /* It's OK to declare a builtin function as `static'. */
3055 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3056 && DECL_ARTIFICIAL (olddecl
))
3059 name
= DECL_ASSEMBLER_NAME (newdecl
);
3060 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3061 ? implicit_extern_static_warning
3062 : explicit_extern_static_warning
, newdecl
);
3063 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3066 /* Handle when a new declaration NEWDECL has the same name as an old
3067 one OLDDECL in the same binding contour. Prints an error message
3070 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3071 Otherwise, return 0. */
3074 duplicate_decls (newdecl
, olddecl
)
3075 tree newdecl
, olddecl
;
3077 unsigned olddecl_uid
= DECL_UID (olddecl
);
3078 int olddecl_friend
= 0, types_match
= 0;
3079 int new_defines_function
= 0;
3081 if (newdecl
== olddecl
)
3084 types_match
= decls_match (newdecl
, olddecl
);
3086 /* If either the type of the new decl or the type of the old decl is an
3087 error_mark_node, then that implies that we have already issued an
3088 error (earlier) for some bogus type specification, and in that case,
3089 it is rather pointless to harass the user with yet more error message
3090 about the same declaration, so just pretend the types match here. */
3091 if (TREE_TYPE (newdecl
) == error_mark_node
3092 || TREE_TYPE (olddecl
) == error_mark_node
)
3095 /* Check for redeclaration and other discrepancies. */
3096 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3097 && DECL_ARTIFICIAL (olddecl
))
3099 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3101 /* If you declare a built-in or predefined function name as static,
3102 the old definition is overridden, but optionally warn this was a
3103 bad choice of name. */
3104 if (! TREE_PUBLIC (newdecl
))
3107 cp_warning ("shadowing %s function `%#D'",
3108 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3110 /* Discard the old built-in function. */
3113 /* If the built-in is not ansi, then programs can override
3114 it even globally without an error. */
3115 else if (! DECL_BUILT_IN (olddecl
))
3116 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3120 cp_error ("declaration of `%#D'", newdecl
);
3121 cp_error ("conflicts with built-in declaration `%#D'",
3126 else if (!types_match
)
3128 if ((DECL_EXTERN_C_P (newdecl
)
3129 && DECL_EXTERN_C_P (olddecl
))
3130 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3131 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3133 /* A near match; override the builtin. */
3135 if (TREE_PUBLIC (newdecl
))
3137 cp_warning ("new declaration `%#D'", newdecl
);
3138 cp_warning ("ambiguates built-in declaration `%#D'",
3141 else if (warn_shadow
)
3142 cp_warning ("shadowing %s function `%#D'",
3143 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3147 /* Discard the old built-in function. */
3151 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
3153 /* If a builtin function is redeclared as `static', merge
3154 the declarations, but make the original one static. */
3155 DECL_THIS_STATIC (olddecl
) = 1;
3156 TREE_PUBLIC (olddecl
) = 0;
3158 /* Make the old declaration consistent with the new one so
3159 that all remnants of the builtin-ness of this function
3160 will be banished. */
3161 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3162 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3163 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3164 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl
),
3168 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3170 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3171 && TREE_CODE (newdecl
) != TYPE_DECL
3172 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3173 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3174 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3175 && TREE_CODE (olddecl
) != TYPE_DECL
3176 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3177 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3180 /* We do nothing special here, because C++ does such nasty
3181 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3182 get shadowed, and know that if we need to find a TYPE_DECL
3183 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3184 slot of the identifier. */
3188 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3189 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3190 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3191 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3194 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3195 if (TREE_CODE (olddecl
) == TREE_LIST
)
3196 olddecl
= TREE_VALUE (olddecl
);
3197 cp_error_at ("previous declaration of `%#D'", olddecl
);
3199 /* New decl is completely inconsistent with the old one =>
3200 tell caller to replace the old one. */
3204 else if (!types_match
)
3206 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
3207 /* These are certainly not duplicate declarations; they're
3208 from different scopes. */
3211 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3213 /* The name of a class template may not be declared to refer to
3214 any other template, class, function, object, namespace, value,
3215 or type in the same scope. */
3216 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3217 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3219 cp_error ("declaration of template `%#D'", newdecl
);
3220 cp_error_at ("conflicts with previous declaration `%#D'",
3223 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3224 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3225 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3226 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3227 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3228 DECL_TEMPLATE_PARMS (olddecl
)))
3230 cp_error ("new declaration `%#D'", newdecl
);
3231 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3235 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3237 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
3239 cp_error ("declaration of C function `%#D' conflicts with",
3241 cp_error_at ("previous declaration `%#D' here", olddecl
);
3243 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3244 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3246 cp_error ("new declaration `%#D'", newdecl
);
3247 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3253 /* Already complained about this, so don't do so again. */
3254 else if (current_class_type
== NULL_TREE
3255 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3257 cp_error ("conflicting types for `%#D'", newdecl
);
3258 cp_error_at ("previous declaration as `%#D'", olddecl
);
3261 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3262 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3263 && (!DECL_TEMPLATE_INFO (newdecl
)
3264 || (DECL_TI_TEMPLATE (newdecl
)
3265 != DECL_TI_TEMPLATE (olddecl
))))
3266 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3267 && (!DECL_TEMPLATE_INFO (olddecl
)
3268 || (DECL_TI_TEMPLATE (olddecl
)
3269 != DECL_TI_TEMPLATE (newdecl
))))))
3270 /* It's OK to have a template specialization and a non-template
3271 with the same type, or to have specializations of two
3272 different templates with the same type. Note that if one is a
3273 specialization, and the other is an instantiation of the same
3274 template, that we do not exit at this point. That situation
3275 can occur if we instantiate a template class, and then
3276 specialize one of its methods. This situation is legal, but
3277 the declarations must be merged in the usual way. */
3279 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3280 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3281 && !DECL_USE_TEMPLATE (newdecl
))
3282 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3283 && !DECL_USE_TEMPLATE (olddecl
))))
3284 /* One of the declarations is a template instantiation, and the
3285 other is not a template at all. That's OK. */
3287 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3288 && DECL_NAMESPACE_ALIAS (newdecl
)
3289 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3290 /* Redeclaration of namespace alias, ignore it. */
3294 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3297 cp_error (errmsg
, newdecl
);
3298 if (DECL_NAME (olddecl
) != NULL_TREE
)
3299 cp_error_at ((DECL_INITIAL (olddecl
)
3300 && namespace_bindings_p ())
3301 ? "`%#D' previously defined here"
3302 : "`%#D' previously declared here", olddecl
);
3304 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3305 && DECL_INITIAL (olddecl
) != NULL_TREE
3306 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3307 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3309 /* Prototype decl follows defn w/o prototype. */
3310 cp_warning_at ("prototype for `%#D'", newdecl
);
3311 cp_warning_at ("follows non-prototype definition here", olddecl
);
3313 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3314 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3316 /* extern "C" int foo ();
3317 int foo () { bar (); }
3319 if (current_lang_stack
3320 == &VARRAY_TREE (current_lang_base
, 0))
3321 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3324 cp_error_at ("previous declaration of `%#D' with %L linkage",
3325 olddecl
, DECL_LANGUAGE (olddecl
));
3326 cp_error ("conflicts with new declaration with %L linkage",
3327 DECL_LANGUAGE (newdecl
));
3331 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3333 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3335 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3336 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3339 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3340 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3342 for (; t1
&& t1
!= void_list_node
;
3343 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3344 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3346 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3351 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3353 cp_pedwarn_at ("after previous specification in `%#D'",
3359 cp_error ("default argument given for parameter %d of `%#D'",
3361 cp_error_at ("after previous specification in `%#D'",
3366 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3367 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3369 cp_warning ("`%#D' was used before it was declared inline",
3371 cp_warning_at ("previous non-inline declaration here",
3377 /* If new decl is `static' and an `extern' was seen previously,
3379 warn_extern_redeclared_static (newdecl
, olddecl
);
3381 /* We have committed to returning 1 at this point. */
3382 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3384 /* Now that functions must hold information normally held
3385 by field decls, there is extra work to do so that
3386 declaration information does not get destroyed during
3388 if (DECL_VINDEX (olddecl
))
3389 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3390 if (DECL_VIRTUAL_CONTEXT (olddecl
))
3391 DECL_VIRTUAL_CONTEXT (newdecl
) = DECL_VIRTUAL_CONTEXT (olddecl
);
3392 if (DECL_CONTEXT (olddecl
))
3393 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3394 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
3395 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3396 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3397 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3398 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
3399 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3400 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3401 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
3402 DECL_LANG_SPECIFIC (newdecl
)->u2
= DECL_LANG_SPECIFIC (olddecl
)->u2
;
3403 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3405 /* Optionally warn about more than one declaration for the same
3406 name, but don't warn about a function declaration followed by a
3408 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3409 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3410 /* Don't warn about extern decl followed by definition. */
3411 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3412 /* Don't warn about friends, let add_friend take care of it. */
3413 && ! DECL_FRIEND_P (newdecl
))
3415 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3416 cp_warning_at ("previous declaration of `%D'", olddecl
);
3420 /* Deal with C++: must preserve virtual function table size. */
3421 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3423 register tree newtype
= TREE_TYPE (newdecl
);
3424 register tree oldtype
= TREE_TYPE (olddecl
);
3426 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3427 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3429 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3430 CLASSTYPE_FRIEND_CLASSES (newtype
)
3431 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3434 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
3437 /* Copy all the DECL_... slots specified in the new decl
3438 except for any that we copy here from the old type. */
3439 DECL_MACHINE_ATTRIBUTES (newdecl
)
3440 = merge_machine_decl_attributes (olddecl
, newdecl
);
3442 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3444 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3445 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3446 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3447 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3454 /* Automatically handles default parameters. */
3455 tree oldtype
= TREE_TYPE (olddecl
);
3458 /* Merge the data types specified in the two decls. */
3459 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3461 /* If common_type produces a non-typedef type, just use the old type. */
3462 if (TREE_CODE (newdecl
) == TYPE_DECL
3463 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
3466 if (TREE_CODE (newdecl
) == VAR_DECL
)
3467 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3468 /* Do this after calling `common_type' so that default
3469 parameters don't confuse us. */
3470 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3471 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3472 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3474 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3475 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3476 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3477 TYPE_RAISES_EXCEPTIONS (oldtype
));
3479 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3480 && DECL_SOURCE_LINE (olddecl
) != 0
3482 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3483 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3485 cp_error ("declaration of `%F' throws different exceptions",
3487 cp_error_at ("than previous declaration `%F'", olddecl
);
3490 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3492 /* Lay the type out, unless already done. */
3493 if (! same_type_p (newtype
, oldtype
)
3494 && TREE_TYPE (newdecl
) != error_mark_node
3495 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3496 layout_type (TREE_TYPE (newdecl
));
3498 if ((TREE_CODE (newdecl
) == VAR_DECL
3499 || TREE_CODE (newdecl
) == PARM_DECL
3500 || TREE_CODE (newdecl
) == RESULT_DECL
3501 || TREE_CODE (newdecl
) == FIELD_DECL
3502 || TREE_CODE (newdecl
) == TYPE_DECL
)
3503 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3504 layout_decl (newdecl
, 0);
3506 /* Merge the type qualifiers. */
3507 if (TREE_READONLY (newdecl
))
3508 TREE_READONLY (olddecl
) = 1;
3509 if (TREE_THIS_VOLATILE (newdecl
))
3510 TREE_THIS_VOLATILE (olddecl
) = 1;
3512 /* Merge the initialization information. */
3513 if (DECL_INITIAL (newdecl
) == NULL_TREE
3514 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3516 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3517 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3518 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3519 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3520 && DECL_LANG_SPECIFIC (newdecl
)
3521 && DECL_LANG_SPECIFIC (olddecl
))
3522 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3525 /* Merge the section attribute.
3526 We want to issue an error if the sections conflict but that must be
3527 done later in decl_attributes since we are called before attributes
3529 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3530 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3532 /* Keep the old rtl since we can safely use it. */
3533 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3535 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3537 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
3538 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
3539 DECL_NO_CHECK_MEMORY_USAGE (newdecl
)
3540 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl
);
3541 DECL_NO_LIMIT_STACK (newdecl
)
3542 |= DECL_NO_LIMIT_STACK (olddecl
);
3545 /* If cannot merge, then use the new type and qualifiers,
3546 and don't preserve the old rtl. */
3549 /* Clean out any memory we had of the old declaration. */
3550 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3552 TREE_VALUE (oldstatic
) = error_mark_node
;
3554 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3555 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3556 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3557 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3560 /* Merge the storage class information. */
3561 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3562 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3563 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
3564 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3565 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3566 if (! DECL_EXTERNAL (olddecl
))
3567 DECL_EXTERNAL (newdecl
) = 0;
3569 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3571 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3572 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3573 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3574 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3575 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3576 /* Don't really know how much of the language-specific
3577 values we should copy from old to new. */
3578 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3579 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3580 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3581 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3582 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
3583 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
3584 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3586 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3587 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3588 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3589 DECL_BEFRIENDING_CLASSES (newdecl
)
3590 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3591 DECL_BEFRIENDING_CLASSES (olddecl
));
3594 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3596 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3597 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3599 /* If newdecl is not a specialization, then it is not a
3600 template-related function at all. And that means that we
3601 shoud have exited above, returning 0. */
3602 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3605 if (TREE_USED (olddecl
))
3606 /* From [temp.expl.spec]:
3608 If a template, a member template or the member of a class
3609 template is explicitly specialized then that
3610 specialization shall be declared before the first use of
3611 that specialization that would cause an implicit
3612 instantiation to take place, in every translation unit in
3613 which such a use occurs. */
3614 cp_error ("explicit specialization of %D after first use",
3617 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3619 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3621 /* If either decl says `inline', this fn is inline, unless its
3622 definition was passed already. */
3623 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3624 DECL_INLINE (olddecl
) = 1;
3625 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3629 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3630 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3631 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3633 if (! types_match
|| new_defines_function
)
3635 /* These need to be copied so that the names are available.
3636 Note that if the types do match, we'll preserve inline
3637 info and other bits, but if not, we won't. */
3638 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3639 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3641 if (new_defines_function
)
3642 /* If defining a function declared with other language
3643 linkage, use the previously declared language linkage. */
3644 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3645 else if (types_match
)
3647 /* If redeclaring a builtin function, and not a definition,
3648 it stays built in. */
3649 if (DECL_BUILT_IN (olddecl
))
3651 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
3652 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3653 /* If we're keeping the built-in definition, keep the rtl,
3654 regardless of declaration matches. */
3655 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3658 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3660 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3661 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3662 /* Previously saved insns go together with
3663 the function's previous definition. */
3664 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3665 /* Don't clear out the arguments if we're redefining a function. */
3666 if (DECL_ARGUMENTS (olddecl
))
3667 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3671 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3673 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3676 /* Now preserve various other info from the definition. */
3677 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3678 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3679 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3680 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3682 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3686 function_size
= sizeof (struct tree_decl
);
3688 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3689 (char *) olddecl
+ sizeof (struct tree_common
),
3690 function_size
- sizeof (struct tree_common
));
3692 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3694 /* If newdecl is a template instantiation, it is possible that
3695 the following sequence of events has occurred:
3697 o A friend function was declared in a class template. The
3698 class template was instantiated.
3700 o The instantiation of the friend declaration was
3701 recorded on the instantiation list, and is newdecl.
3703 o Later, however, instantiate_class_template called pushdecl
3704 on the newdecl to perform name injection. But, pushdecl in
3705 turn called duplicate_decls when it discovered that another
3706 declaration of a global function with the same name already
3709 o Here, in duplicate_decls, we decided to clobber newdecl.
3711 If we're going to do that, we'd better make sure that
3712 olddecl, and not newdecl, is on the list of
3713 instantiations so that if we try to do the instantiation
3714 again we won't get the clobbered declaration. */
3716 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3717 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3719 for (; decls
; decls
= TREE_CHAIN (decls
))
3720 if (TREE_VALUE (decls
) == newdecl
)
3721 TREE_VALUE (decls
) = olddecl
;
3726 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3727 (char *) olddecl
+ sizeof (struct tree_common
),
3728 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3729 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3732 DECL_UID (olddecl
) = olddecl_uid
;
3734 DECL_FRIEND_P (olddecl
) = 1;
3736 /* NEWDECL contains the merged attribute lists.
3737 Update OLDDECL to be the same. */
3738 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3743 /* Record a decl-node X as belonging to the current lexical scope.
3744 Check for errors (such as an incompatible declaration for the same
3745 name already seen in the same scope).
3747 Returns either X or an old decl for the same name.
3748 If an old decl is returned, it may have been smashed
3749 to agree with what X says. */
3757 int need_new_binding
;
3759 /* We shouldn't be calling pushdecl when we're generating RTL for a
3760 function that we already did semantic analysis on previously. */
3761 my_friendly_assert (!cfun
|| doing_semantic_analysis_p (),
3764 need_new_binding
= 1;
3766 if (DECL_TEMPLATE_PARM_P (x
))
3767 /* Template parameters have no context; they are not X::T even
3768 when declared within a class or namespace. */
3772 if (current_function_decl
&& x
!= current_function_decl
3773 /* A local declaration for a function doesn't constitute
3775 && !(TREE_CODE (x
) == FUNCTION_DECL
&& !DECL_INITIAL (x
))
3776 /* A local declaration for an `extern' variable is in the
3777 scope of the current namespace, not the current
3779 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
3780 && !DECL_CONTEXT (x
))
3781 DECL_CONTEXT (x
) = current_function_decl
;
3783 /* If this is the declaration for a namespace-scope function,
3784 but the declaration itself is in a local scope, mark the
3786 if (TREE_CODE (x
) == FUNCTION_DECL
3787 && DECL_NAMESPACE_SCOPE_P (x
)
3788 && current_function_decl
3789 && x
!= current_function_decl
)
3790 DECL_LOCAL_FUNCTION_P (x
) = 1;
3793 name
= DECL_NAME (x
);
3796 int different_binding_level
= 0;
3798 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3799 name
= TREE_OPERAND (name
, 0);
3801 /* In case this decl was explicitly namespace-qualified, look it
3802 up in its namespace context. */
3803 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
)
3804 && namespace_bindings_p ())
3805 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3807 t
= lookup_name_current_level (name
);
3809 /* [basic.link] If there is a visible declaration of an entity
3810 with linkage having the same name and type, ignoring entities
3811 declared outside the innermost enclosing namespace scope, the
3812 block scope declaration declares that same entity and
3813 receives the linkage of the previous declaration. */
3814 if (! t
&& current_function_decl
&& x
!= current_function_decl
3815 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
3816 && DECL_EXTERNAL (x
))
3818 /* Look in block scope. */
3819 t
= IDENTIFIER_VALUE (name
);
3820 /* Or in the innermost namespace. */
3822 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3823 /* Does it have linkage? Note that if this isn't a DECL, it's an
3824 OVERLOAD, which is OK. */
3825 if (t
&& DECL_P (t
) && ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
3828 different_binding_level
= 1;
3831 /* If we are declaring a function, and the result of name-lookup
3832 was an OVERLOAD, look for an overloaded instance that is
3833 actually the same as the function we are declaring. (If
3834 there is one, we have to merge our declaration with the
3835 previous declaration.) */
3836 if (t
&& TREE_CODE (t
) == OVERLOAD
)
3840 if (TREE_CODE (x
) == FUNCTION_DECL
)
3841 for (match
= t
; match
; match
= OVL_NEXT (match
))
3843 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t
))
3844 == DECL_ASSEMBLER_NAME (x
))
3848 /* Just choose one. */
3852 t
= OVL_CURRENT (match
);
3857 if (t
== error_mark_node
)
3859 /* error_mark_node is 0 for a while during initialization! */
3861 cp_error_at ("`%#D' used prior to declaration", x
);
3863 else if (t
!= NULL_TREE
)
3865 if (different_binding_level
)
3867 if (decls_match (x
, t
))
3868 /* The standard only says that the local extern
3869 inherits linkage from the previous decl; in
3870 particular, default args are not shared. It would
3871 be nice to propagate inlining info, though. FIXME. */
3872 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
3874 else if (TREE_CODE (t
) == PARM_DECL
)
3876 if (DECL_CONTEXT (t
) == NULL_TREE
)
3877 /* This is probaby caused by too many errors, but calling
3878 abort will say that if errors have occurred. */
3881 /* Check for duplicate params. */
3882 if (duplicate_decls (x
, t
))
3885 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
3886 || DECL_FUNCTION_TEMPLATE_P (x
))
3887 && is_overloaded_fn (t
))
3888 /* Don't do anything just yet. */;
3889 else if (t
== wchar_decl_node
)
3891 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3892 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3894 /* Throw away the redeclaration. */
3897 else if (TREE_CODE (t
) != TREE_CODE (x
))
3899 if (duplicate_decls (x
, t
))
3902 else if (duplicate_decls (x
, t
))
3904 if (TREE_CODE (t
) == TYPE_DECL
)
3905 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3906 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3907 check_default_args (t
);
3911 else if (DECL_MAIN_P (x
))
3913 /* A redeclaration of main, but not a duplicate of the
3918 This function shall not be overloaded. */
3919 cp_error_at ("invalid redeclaration of `%D'", t
);
3920 cp_error ("as `%D'", x
);
3921 /* We don't try to push this declaration since that
3927 check_template_shadow (x
);
3929 /* If this is a function conjured up by the backend, massage it
3930 so it looks friendly. */
3931 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
3933 retrofit_lang_decl (x
);
3934 DECL_LANGUAGE (x
) = lang_c
;
3937 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
3939 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3942 if (!namespace_bindings_p ())
3943 /* We do not need to create a binding for this name;
3944 push_overloaded_decl will have already done so if
3946 need_new_binding
= 0;
3948 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3950 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
3952 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
3956 /* If declaring a type as a typedef, copy the type (unless we're
3957 at line 0), and install this TYPE_DECL as the new type's typedef
3958 name. See the extensive comment in ../c-decl.c (pushdecl). */
3959 if (TREE_CODE (x
) == TYPE_DECL
)
3961 tree type
= TREE_TYPE (x
);
3962 if (DECL_SOURCE_LINE (x
) == 0)
3964 if (TYPE_NAME (type
) == 0)
3965 TYPE_NAME (type
) = x
;
3967 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3968 /* We don't want to copy the type when all we're
3969 doing is making a TYPE_DECL for the purposes of
3971 && (!TYPE_NAME (type
)
3972 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3974 DECL_ORIGINAL_TYPE (x
) = type
;
3975 type
= build_type_copy (type
);
3976 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3977 TYPE_NAME (type
) = x
;
3978 TREE_TYPE (x
) = type
;
3981 if (type
!= error_mark_node
3983 && TYPE_IDENTIFIER (type
))
3984 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
3985 current_binding_level
);
3989 /* Multiple external decls of the same identifier ought to match.
3991 We get warnings about inline functions where they are defined.
3992 We get warnings about other functions from push_overloaded_decl.
3994 Avoid duplicate warnings where they are used. */
3995 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
3999 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
4000 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
4001 decl
= OVL_FUNCTION (decl
);
4003 if (decl
&& decl
!= error_mark_node
4004 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
4005 /* If different sort of thing, we already gave an error. */
4006 && TREE_CODE (decl
) == TREE_CODE (x
)
4007 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4009 cp_pedwarn ("type mismatch with previous external decl", x
);
4010 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4014 /* This name is new in its binding level.
4015 Install the new declaration and return it. */
4016 if (namespace_bindings_p ())
4018 /* Install a global value. */
4020 /* If the first global decl has external linkage,
4021 warn if we later see static one. */
4022 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4023 TREE_PUBLIC (name
) = 1;
4025 /* Bind the mangled name for the entity. In the future, we
4026 should not need to do this; mangled names are an
4027 implementation detail of which the front-end should not
4028 need to be aware. */
4029 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4031 /* For an ordinary function, we create a binding from
4032 the mangled name (i.e., NAME) to the DECL. But, for
4033 an `extern "C"' function, the mangled name and the
4034 ordinary name are the same so we need not do this. */
4035 && !DECL_EXTERN_C_FUNCTION_P (x
))
4039 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
4040 || TREE_CODE (x
) == NAMESPACE_DECL
)
4041 mangled_name
= name
;
4043 mangled_name
= DECL_ASSEMBLER_NAME (x
);
4045 if (TREE_CODE (x
) == FUNCTION_DECL
)
4047 ((IDENTIFIER_GLOBAL_VALUE (mangled_name
) == NULL_TREE
)
4048 || (IDENTIFIER_GLOBAL_VALUE (mangled_name
) == x
), 378);
4049 SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name
, x
);
4052 /* Don't forget if the function was used via an implicit decl. */
4053 if (IDENTIFIER_IMPLICIT_DECL (name
)
4054 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4057 /* Don't forget if its address was taken in that way. */
4058 if (IDENTIFIER_IMPLICIT_DECL (name
)
4059 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4060 TREE_ADDRESSABLE (x
) = 1;
4062 /* Warn about mismatches against previous implicit decl. */
4063 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4064 /* If this real decl matches the implicit, don't complain. */
4065 && ! (TREE_CODE (x
) == FUNCTION_DECL
4066 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4068 ("`%D' was previously implicitly declared to return `int'", x
);
4070 /* If new decl is `static' and an `extern' was seen previously,
4072 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4073 warn_extern_redeclared_static (x
, t
);
4077 /* Here to install a non-global value. */
4078 tree oldlocal
= IDENTIFIER_VALUE (name
);
4079 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4081 if (need_new_binding
)
4083 push_local_binding (name
, x
, 0);
4084 /* Because push_local_binding will hook X on to the
4085 current_binding_level's name list, we don't want to
4086 do that again below. */
4087 need_new_binding
= 0;
4090 /* If this is a TYPE_DECL, push it into the type value slot. */
4091 if (TREE_CODE (x
) == TYPE_DECL
)
4092 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4093 current_binding_level
);
4095 /* Clear out any TYPE_DECL shadowed by a namespace so that
4096 we won't think this is a type. The C struct hack doesn't
4097 go through namespaces. */
4098 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4099 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4100 current_binding_level
);
4107 && TREE_CODE (oldlocal
) == VAR_DECL
4108 && DECL_DEAD_FOR_LOCAL (oldlocal
))
4109 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
4111 if (oldlocal
== NULL_TREE
)
4112 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
4115 /* If this is an extern function declaration, see if we
4116 have a global definition or declaration for the function. */
4117 if (oldlocal
== NULL_TREE
4118 && DECL_EXTERNAL (x
)
4119 && oldglobal
!= NULL_TREE
4120 && TREE_CODE (x
) == FUNCTION_DECL
4121 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4123 /* We have one. Their types must agree. */
4124 if (decls_match (x
, oldglobal
))
4128 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4129 cp_warning_at ("global declaration `%#D'", oldglobal
);
4132 /* If we have a local external declaration,
4133 and no file-scope declaration has yet been seen,
4134 then if we later have a file-scope decl it must not be static. */
4135 if (oldlocal
== NULL_TREE
4136 && oldglobal
== NULL_TREE
4137 && DECL_EXTERNAL (x
)
4139 TREE_PUBLIC (name
) = 1;
4141 /* Warn if shadowing an argument at the top level of the body. */
4142 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4143 /* Inline decls shadow nothing. */
4144 && !DECL_FROM_INLINE (x
)
4145 && TREE_CODE (oldlocal
) == PARM_DECL
4146 /* Don't complain if it's from an enclosing function. */
4147 && DECL_CONTEXT (oldlocal
) == current_function_decl
4148 && TREE_CODE (x
) != PARM_DECL
)
4150 /* Go to where the parms should be and see if we
4152 struct binding_level
*b
= current_binding_level
->level_chain
;
4158 if (b
->parm_flag
== 1)
4159 cp_error ("declaration of `%#D' shadows a parameter", name
);
4162 /* Maybe warn if shadowing something else. */
4163 if (warn_shadow
&& !DECL_EXTERNAL (x
)
4164 /* Inline decls shadow nothing. */
4165 && !DECL_FROM_INLINE (x
)
4166 /* No shadow warnings for internally generated vars. */
4167 && ! DECL_ARTIFICIAL (x
)
4168 /* No shadow warnings for vars made for inlining. */
4169 && ! DECL_FROM_INLINE (x
))
4171 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4172 warning ("declaration of `%s' shadows a parameter",
4173 IDENTIFIER_POINTER (name
));
4174 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4175 && current_class_ptr
4176 && !TREE_STATIC (name
))
4177 warning ("declaration of `%s' shadows a member of `this'",
4178 IDENTIFIER_POINTER (name
));
4179 else if (oldlocal
!= NULL_TREE
)
4180 warning ("declaration of `%s' shadows previous local",
4181 IDENTIFIER_POINTER (name
));
4182 else if (oldglobal
!= NULL_TREE
)
4183 /* XXX shadow warnings in outer-more namespaces */
4184 warning ("declaration of `%s' shadows global declaration",
4185 IDENTIFIER_POINTER (name
));
4189 if (TREE_CODE (x
) == FUNCTION_DECL
)
4190 check_default_args (x
);
4192 /* Keep count of variables in this level with incomplete type. */
4193 if (TREE_CODE (x
) == VAR_DECL
4194 && TREE_TYPE (x
) != error_mark_node
4195 && ((!COMPLETE_TYPE_P (TREE_TYPE (x
))
4196 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4197 /* RTTI TD entries are created while defining the type_info. */
4198 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4199 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4201 if (namespace_bindings_p ())
4202 namespace_scope_incomplete
4203 = tree_cons (NULL_TREE
, x
, namespace_scope_incomplete
);
4205 current_binding_level
->incomplete
4206 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4210 if (need_new_binding
)
4211 add_decl_to_level (x
,
4212 DECL_NAMESPACE_SCOPE_P (x
)
4213 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
4214 : current_binding_level
);
4219 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4220 caller to set DECL_CONTEXT properly. */
4223 pushdecl_with_scope (x
, level
)
4225 struct binding_level
*level
;
4227 register struct binding_level
*b
;
4228 tree function_decl
= current_function_decl
;
4230 current_function_decl
= NULL_TREE
;
4231 if (level
->parm_flag
== 2)
4233 b
= class_binding_level
;
4234 class_binding_level
= level
;
4235 pushdecl_class_level (x
);
4236 class_binding_level
= b
;
4240 b
= current_binding_level
;
4241 current_binding_level
= level
;
4243 current_binding_level
= b
;
4245 current_function_decl
= function_decl
;
4249 /* Like pushdecl, only it places X in the current namespace,
4253 pushdecl_namespace_level (x
)
4256 register struct binding_level
*b
= current_binding_level
;
4259 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4261 /* Now, the type_shadowed stack may screw us. Munge it so it does
4263 if (TREE_CODE (x
) == TYPE_DECL
)
4265 tree name
= DECL_NAME (x
);
4267 tree
*ptr
= (tree
*)0;
4268 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4270 tree shadowed
= b
->type_shadowed
;
4271 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4272 if (TREE_PURPOSE (shadowed
) == name
)
4274 ptr
= &TREE_VALUE (shadowed
);
4275 /* Can't break out of the loop here because sometimes
4276 a binding level will have duplicate bindings for
4277 PT names. It's gross, but I haven't time to fix it. */
4280 newval
= TREE_TYPE (x
);
4281 if (ptr
== (tree
*)0)
4283 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4284 up here if this is changed to an assertion. --KR */
4285 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4295 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4299 pushdecl_top_level (x
)
4302 push_to_top_level ();
4303 x
= pushdecl_namespace_level (x
);
4304 pop_from_top_level ();
4308 /* Make the declaration of X appear in CLASS scope. */
4311 pushdecl_class_level (x
)
4314 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4315 scope looks for the pre-mangled name. */
4318 if (TREE_CODE (x
) == OVERLOAD
)
4319 x
= OVL_CURRENT (x
);
4320 name
= DECL_NAME (x
);
4324 push_class_level_binding (name
, x
);
4325 if (TREE_CODE (x
) == TYPE_DECL
)
4326 set_identifier_type_value (name
, TREE_TYPE (x
));
4328 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4332 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4335 pushdecl_class_level (f
);
4339 /* Enter DECL into the symbol table, if that's appropriate. Returns
4340 DECL, or a modified version thereof. */
4343 maybe_push_decl (decl
)
4346 tree type
= TREE_TYPE (decl
);
4348 /* Add this decl to the current binding level, but not if it comes
4349 from another scope, e.g. a static member variable. TEM may equal
4350 DECL or it may be a previous decl of the same name. */
4351 if (decl
== error_mark_node
4352 || (TREE_CODE (decl
) != PARM_DECL
4353 && DECL_CONTEXT (decl
) != NULL_TREE
4354 /* Definitions of namespace members outside their namespace are
4356 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4357 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4358 || TREE_CODE (type
) == UNKNOWN_TYPE
4359 /* The declaration of a template specialization does not affect
4360 the functions available for overload resolution, so we do not
4362 || (TREE_CODE (decl
) == FUNCTION_DECL
4363 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4366 return pushdecl (decl
);
4369 /* Make the declaration(s) of X appear in CLASS scope
4370 under the name NAME. */
4373 push_class_level_binding (name
, x
)
4378 /* The class_binding_level will be NULL if x is a template
4379 parameter name in a member template. */
4380 if (!class_binding_level
)
4383 /* Make sure that this new member does not have the same name
4384 as a template parameter. */
4385 if (TYPE_BEING_DEFINED (current_class_type
))
4386 check_template_shadow (x
);
4388 /* If this declaration shadows a declaration from an enclosing
4389 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4390 we leave this class. Record the shadowed declaration here. */
4391 binding
= IDENTIFIER_BINDING (name
);
4393 && ((TREE_CODE (x
) == OVERLOAD
4394 && BINDING_VALUE (binding
)
4395 && is_overloaded_fn (BINDING_VALUE (binding
)))
4396 || INHERITED_VALUE_BINDING_P (binding
)))
4401 /* If the old binding was from a base class, and was for a tag
4402 name, slide it over to make room for the new binding. The
4403 old binding is still visible if explicitly qualified with a
4405 if (INHERITED_VALUE_BINDING_P (binding
)
4406 && BINDING_VALUE (binding
)
4407 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4408 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4409 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4411 old_decl
= BINDING_TYPE (binding
);
4412 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4413 BINDING_VALUE (binding
) = NULL_TREE
;
4414 INHERITED_VALUE_BINDING_P (binding
) = 0;
4417 old_decl
= BINDING_VALUE (binding
);
4419 /* Find the previous binding of name on the class-shadowed
4420 list, and update it. */
4421 for (shadow
= class_binding_level
->class_shadowed
;
4423 shadow
= TREE_CHAIN (shadow
))
4424 if (TREE_PURPOSE (shadow
) == name
4425 && TREE_TYPE (shadow
) == old_decl
)
4427 BINDING_VALUE (binding
) = x
;
4428 INHERITED_VALUE_BINDING_P (binding
) = 0;
4429 TREE_TYPE (shadow
) = x
;
4430 IDENTIFIER_CLASS_VALUE (name
) = x
;
4435 /* If we didn't replace an existing binding, put the binding on the
4436 stack of bindings for the identifier, and update the shadowed list. */
4437 if (push_class_binding (name
, x
))
4439 class_binding_level
->class_shadowed
4440 = tree_cons (name
, NULL
,
4441 class_binding_level
->class_shadowed
);
4442 /* Record the value we are binding NAME to so that we can know
4443 what to pop later. */
4444 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4448 /* Insert another USING_DECL into the current binding level, returning
4449 this declaration. If this is a redeclaration, do nothing, and
4450 return NULL_TREE if this not in namespace scope (in namespace
4451 scope, a using decl might extend any previous bindings). */
4454 push_using_decl (scope
, name
)
4460 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4461 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4462 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4463 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4466 return namespace_bindings_p () ? decl
: NULL_TREE
;
4467 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4468 DECL_INITIAL (decl
) = scope
;
4469 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4470 current_binding_level
->usings
= decl
;
4474 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4475 changed (i.e. there was already a directive), or the fresh
4476 TREE_LIST otherwise. */
4479 push_using_directive (used
)
4482 tree ud
= current_binding_level
->using_directives
;
4483 tree iter
, ancestor
;
4485 /* Check if we already have this. */
4486 if (purpose_member (used
, ud
) != NULL_TREE
)
4489 /* Recursively add all namespaces used. */
4490 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4491 push_using_directive (TREE_PURPOSE (iter
));
4493 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4494 ud
= current_binding_level
->using_directives
;
4495 ud
= tree_cons (used
, ancestor
, ud
);
4496 current_binding_level
->using_directives
= ud
;
4500 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4501 other definitions already in place. We get around this by making
4502 the value of the identifier point to a list of all the things that
4503 want to be referenced by that name. It is then up to the users of
4504 that name to decide what to do with that list.
4506 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4507 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4509 FLAGS is a bitwise-or of the following values:
4510 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4512 PUSH_USING: DECL is being pushed as the result of a using
4515 The value returned may be a previous declaration if we guessed wrong
4516 about what language DECL should belong to (C or C++). Otherwise,
4517 it's always DECL (and never something that's not a _DECL). */
4520 push_overloaded_decl (decl
, flags
)
4524 tree name
= DECL_NAME (decl
);
4527 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4530 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4532 old
= lookup_name_current_level (name
);
4536 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4538 tree t
= TREE_TYPE (old
);
4539 if (IS_AGGR_TYPE (t
) && warn_shadow
4540 && (! DECL_IN_SYSTEM_HEADER (decl
)
4541 || ! DECL_IN_SYSTEM_HEADER (old
)))
4542 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4545 else if (is_overloaded_fn (old
))
4549 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4551 tree fn
= OVL_CURRENT (tmp
);
4553 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4554 && !(flags
& PUSH_USING
)
4555 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4556 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4557 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4560 if (duplicate_decls (decl
, fn
))
4564 else if (old
== error_mark_node
)
4565 /* Ignore the undefined symbol marker. */
4569 cp_error_at ("previous non-function declaration `%#D'", old
);
4570 cp_error ("conflicts with function declaration `%#D'", decl
);
4575 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4577 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4578 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4580 new_binding
= ovl_cons (decl
, old
);
4581 if (flags
& PUSH_USING
)
4582 OVL_USED (new_binding
) = 1;
4585 /* NAME is not ambiguous. */
4589 set_namespace_binding (name
, current_namespace
, new_binding
);
4592 /* We only create an OVERLOAD if there was a previous binding at
4593 this level, or if decl is a template. In the former case, we
4594 need to remove the old binding and replace it with the new
4595 binding. We must also run through the NAMES on the binding
4596 level where the name was bound to update the chain. */
4598 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4602 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4604 d
= &TREE_CHAIN (*d
))
4606 || (TREE_CODE (*d
) == TREE_LIST
4607 && TREE_VALUE (*d
) == old
))
4609 if (TREE_CODE (*d
) == TREE_LIST
)
4610 /* Just replace the old binding with the new. */
4611 TREE_VALUE (*d
) = new_binding
;
4613 /* Build a TREE_LIST to wrap the OVERLOAD. */
4614 *d
= tree_cons (NULL_TREE
, new_binding
,
4617 /* And update the CPLUS_BINDING node. */
4618 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4623 /* We should always find a previous binding in this case. */
4624 my_friendly_abort (0);
4627 /* Install the new binding. */
4628 push_local_binding (name
, new_binding
, flags
);
4634 /* Generate an implicit declaration for identifier FUNCTIONID
4635 as a function of type int (). Print a warning if appropriate. */
4638 implicitly_declare (functionid
)
4643 /* We used to reuse an old implicit decl here,
4644 but this loses with inline functions because it can clobber
4645 the saved decl chains. */
4646 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4648 DECL_EXTERNAL (decl
) = 1;
4649 TREE_PUBLIC (decl
) = 1;
4651 /* ISO standard says implicit declarations are in the innermost block.
4652 So we record the decl in the standard fashion. */
4654 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4657 /* Only one warning per identifier. */
4658 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4660 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4663 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4668 /* Return zero if the declaration NEWDECL is valid
4669 when the declaration OLDDECL (assumed to be for the same name)
4670 has already been seen.
4671 Otherwise return an error message format string with a %s
4672 where the identifier should go. */
4675 redeclaration_error_message (newdecl
, olddecl
)
4676 tree newdecl
, olddecl
;
4678 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4680 /* Because C++ can put things into name space for free,
4681 constructs like "typedef struct foo { ... } foo"
4682 would look like an erroneous redeclaration. */
4683 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4686 return "redefinition of `%#D'";
4688 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4690 /* If this is a pure function, its olddecl will actually be
4691 the original initialization to `0' (which we force to call
4692 abort()). Don't complain about redefinition in this case. */
4693 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
))
4696 /* If both functions come from different namespaces, this is not
4697 a redeclaration - this is a conflict with a used function. */
4698 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4699 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4700 return "`%D' conflicts with used function";
4702 /* We'll complain about linkage mismatches in
4703 warn_extern_redeclared_static. */
4705 /* Defining the same name twice is no good. */
4706 if (DECL_INITIAL (olddecl
) != NULL_TREE
4707 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4709 if (DECL_NAME (olddecl
) == NULL_TREE
)
4710 return "`%#D' not declared in class";
4712 return "redefinition of `%#D'";
4716 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4718 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4719 && (DECL_TEMPLATE_RESULT (newdecl
)
4720 != DECL_TEMPLATE_RESULT (olddecl
))
4721 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4722 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4723 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4724 && COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
4725 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
))))
4726 return "redefinition of `%#D'";
4729 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
4731 /* Objects declared at top level: */
4732 /* If at least one is a reference, it's ok. */
4733 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4735 /* Reject two definitions. */
4736 return "redefinition of `%#D'";
4740 /* Objects declared with block scope: */
4741 /* Reject two definitions, and reject a definition
4742 together with an external reference. */
4743 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4744 return "redeclaration of `%#D'";
4749 /* Create a new label, named ID. */
4752 make_label_decl (id
, local_p
)
4758 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4760 /* Make sure every label has an rtx. */
4763 DECL_CONTEXT (decl
) = current_function_decl
;
4764 DECL_MODE (decl
) = VOIDmode
;
4765 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4767 /* Say where one reference is to the label, for the sake of the
4768 error if it is not defined. */
4769 DECL_SOURCE_LINE (decl
) = lineno
;
4770 DECL_SOURCE_FILE (decl
) = input_filename
;
4772 /* Record the fact that this identifier is bound to this label. */
4773 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4778 /* Record this label on the list of used labels so that we can check
4779 at the end of the function to see whether or not the label was
4780 actually defined, and so we can check when the label is defined whether
4781 this use is valid. */
4787 if (named_label_uses
== NULL
4788 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4789 || named_label_uses
->label_decl
!= decl
)
4791 struct named_label_use_list
*new_ent
;
4792 new_ent
= ((struct named_label_use_list
*)
4793 ggc_alloc (sizeof (struct named_label_use_list
)));
4794 new_ent
->label_decl
= decl
;
4795 new_ent
->names_in_scope
= current_binding_level
->names
;
4796 new_ent
->binding_level
= current_binding_level
;
4797 new_ent
->lineno_o_goto
= lineno
;
4798 new_ent
->filename_o_goto
= input_filename
;
4799 new_ent
->next
= named_label_uses
;
4800 named_label_uses
= new_ent
;
4804 /* Look for a label named ID in the current function. If one cannot
4805 be found, create one. (We keep track of used, but undefined,
4806 labels, and complain about them at the end of a function.) */
4813 struct named_label_list
*ent
;
4815 /* You can't use labels at global scope. */
4816 if (current_function_decl
== NULL_TREE
)
4818 error ("label `%s' referenced outside of any function",
4819 IDENTIFIER_POINTER (id
));
4823 /* See if we've already got this label. */
4824 decl
= IDENTIFIER_LABEL_VALUE (id
);
4825 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4828 /* Record this label on the list of labels used in this function.
4829 We do this before calling make_label_decl so that we get the
4830 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4831 ent
= ((struct named_label_list
*)
4832 ggc_alloc_cleared (sizeof (struct named_label_list
)));
4833 ent
->old_value
= IDENTIFIER_LABEL_VALUE (id
);
4834 ent
->next
= named_labels
;
4837 /* We need a new label. */
4838 decl
= make_label_decl (id
, /*local_p=*/0);
4840 /* Now fill in the information we didn't have before. */
4841 ent
->label_decl
= decl
;
4846 /* Declare a local label named ID. */
4849 declare_local_label (id
)
4854 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4855 this scope we can restore the old value of
4856 IDENTIFIER_TYPE_VALUE. */
4857 current_binding_level
->shadowed_labels
4858 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4859 current_binding_level
->shadowed_labels
);
4860 /* Look for the label. */
4861 decl
= make_label_decl (id
, /*local_p=*/1);
4862 /* Now fill in the information we didn't have before. */
4863 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4868 /* Returns nonzero if it is ill-formed to jump past the declaration of
4869 DECL. Returns 2 if it's also a real problem. */
4872 decl_jump_unsafe (decl
)
4875 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
4878 if (DECL_INITIAL (decl
) == NULL_TREE
4879 && pod_type_p (TREE_TYPE (decl
)))
4882 /* This is really only important if we're crossing an initialization.
4883 The POD stuff is just pedantry; why should it matter if the class
4884 contains a field of pointer to member type? */
4885 if (DECL_INITIAL (decl
)
4886 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
4891 /* Check that a single previously seen jump to a newly defined label
4892 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4893 the jump context; NAMES are the names in scope in LEVEL at the jump
4894 context; FILE and LINE are the source position of the jump or 0. */
4897 check_previous_goto_1 (decl
, level
, names
, file
, line
)
4899 struct binding_level
*level
;
4906 struct binding_level
*b
= current_binding_level
;
4907 for (; b
; b
= b
->level_chain
)
4909 tree new_decls
= b
->names
;
4910 tree old_decls
= (b
== level
? names
: NULL_TREE
);
4911 for (; new_decls
!= old_decls
;
4912 new_decls
= TREE_CHAIN (new_decls
))
4914 int problem
= decl_jump_unsafe (new_decls
);
4921 cp_pedwarn ("jump to label `%D'", decl
);
4923 pedwarn ("jump to case label");
4926 pedwarn_with_file_and_line (file
, line
, " from here");
4930 if (problem
> 1 && DECL_ARTIFICIAL (new_decls
))
4931 /* Can't skip init of __exception_info. */
4932 cp_error_at (" enters catch block", new_decls
);
4933 else if (problem
> 1)
4934 cp_error_at (" crosses initialization of `%#D'",
4937 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4943 if (b
->eh_region
&& ! saw_eh
)
4948 cp_pedwarn ("jump to label `%D'", decl
);
4950 pedwarn ("jump to case label");
4953 pedwarn_with_file_and_line (file
, line
, " from here");
4956 error (" enters try block");
4963 check_previous_goto (use
)
4964 struct named_label_use_list
*use
;
4966 check_previous_goto_1 (use
->label_decl
, use
->binding_level
,
4967 use
->names_in_scope
, use
->filename_o_goto
,
4968 use
->lineno_o_goto
);
4972 check_switch_goto (level
)
4973 struct binding_level
*level
;
4975 check_previous_goto_1 (NULL_TREE
, level
, level
->names
, NULL
, 0);
4978 /* Check that any previously seen jumps to a newly defined label DECL
4979 are OK. Called by define_label. */
4982 check_previous_gotos (decl
)
4985 struct named_label_use_list
**usep
;
4987 if (! TREE_USED (decl
))
4990 for (usep
= &named_label_uses
; *usep
; )
4992 struct named_label_use_list
*use
= *usep
;
4993 if (use
->label_decl
== decl
)
4995 check_previous_goto (use
);
4999 usep
= &(use
->next
);
5003 /* Check that a new jump to a label DECL is OK. Called by
5004 finish_goto_stmt. */
5012 struct named_label_list
*lab
;
5014 /* We can't know where a computed goto is jumping. So we assume
5016 if (! DECL_P (decl
))
5019 /* If the label hasn't been defined yet, defer checking. */
5020 if (! DECL_INITIAL (decl
))
5026 for (lab
= named_labels
; lab
; lab
= lab
->next
)
5027 if (decl
== lab
->label_decl
)
5030 /* If the label is not on named_labels it's a gcc local label, so
5031 it must be in an outer scope, so jumping to it is always OK. */
5035 if ((lab
->eh_region
|| lab
->bad_decls
) && !identified
)
5037 cp_pedwarn_at ("jump to label `%D'", decl
);
5038 pedwarn (" from here");
5042 for (bad
= lab
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
5044 tree b
= TREE_VALUE (bad
);
5045 int u
= decl_jump_unsafe (b
);
5047 if (u
> 1 && DECL_ARTIFICIAL (b
))
5048 /* Can't skip init of __exception_info. */
5049 cp_error_at (" enters catch block", b
);
5051 cp_error_at (" skips initialization of `%#D'", b
);
5053 cp_pedwarn_at (" enters scope of non-POD `%#D'", b
);
5057 error (" enters try block");
5060 /* Define a label, specifying the location in the source file.
5061 Return the LABEL_DECL node for the label, if the definition is valid.
5062 Otherwise return 0. */
5065 define_label (filename
, line
, name
)
5066 const char *filename
;
5070 tree decl
= lookup_label (name
);
5071 struct named_label_list
*ent
;
5072 register struct binding_level
*p
;
5074 for (ent
= named_labels
; ent
; ent
= ent
->next
)
5075 if (ent
->label_decl
== decl
)
5078 /* After labels, make any new cleanups in the function go into their
5079 own new (temporary) binding contour. */
5080 for (p
= current_binding_level
; !(p
->parm_flag
); p
= p
->level_chain
)
5081 p
->more_cleanups_ok
= 0;
5083 if (name
== get_identifier ("wchar_t"))
5084 cp_pedwarn ("label named wchar_t");
5086 if (DECL_INITIAL (decl
) != NULL_TREE
)
5088 cp_error ("duplicate label `%D'", decl
);
5093 /* Mark label as having been defined. */
5094 DECL_INITIAL (decl
) = error_mark_node
;
5095 /* Say where in the source. */
5096 DECL_SOURCE_FILE (decl
) = filename
;
5097 DECL_SOURCE_LINE (decl
) = line
;
5100 ent
->names_in_scope
= current_binding_level
->names
;
5101 ent
->binding_level
= current_binding_level
;
5103 check_previous_gotos (decl
);
5104 current_function_return_value
= NULL_TREE
;
5111 struct binding_level
*level
;
5112 struct cp_switch
*next
;
5113 /* The SWITCH_STMT being built. */
5115 /* A splay-tree mapping the low element of a case range to the high
5116 element, or NULL_TREE if there is no high element. Used to
5117 determine whether or not a new case label duplicates an old case
5118 label. We need a tree, rather than simply a hash table, because
5119 of the GNU case range extension. */
5123 /* A stack of the currently active switch statements. The innermost
5124 switch statement is on the top of the stack. There is no need to
5125 mark the stack for garbage collection because it is only active
5126 during the processing of the body of a function, and we never
5127 collect at that point. */
5129 static struct cp_switch
*switch_stack
;
5131 /* Called right after a switch-statement condition is parsed.
5132 SWITCH_STMT is the switch statement being parsed. */
5135 push_switch (switch_stmt
)
5139 = (struct cp_switch
*) xmalloc (sizeof (struct cp_switch
));
5140 p
->level
= current_binding_level
;
5141 p
->next
= switch_stack
;
5142 p
->switch_stmt
= switch_stmt
;
5143 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
5150 struct cp_switch
*cs
;
5153 splay_tree_delete (cs
->cases
);
5154 switch_stack
= switch_stack
->next
;
5158 /* Note that we've seen a definition of a case label, and complain if this
5159 is a bad place for one. */
5162 finish_case_label (low_value
, high_value
)
5167 register struct binding_level
*p
;
5172 error ("case label not within a switch statement");
5174 cp_error ("case label `%E' not within a switch statement",
5177 error ("`default' label not within a switch statement");
5181 if (processing_template_decl
)
5185 /* For templates, just add the case label; we'll do semantic
5186 analysis at instantiation-time. */
5187 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5188 return add_stmt (build_case_label (low_value
, high_value
, label
));
5191 /* Find the condition on which this switch statement depends. */
5192 cond
= SWITCH_COND (switch_stack
->switch_stmt
);
5193 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
5194 cond
= TREE_VALUE (cond
);
5196 r
= c_add_case_label (switch_stack
->cases
, cond
, low_value
, high_value
);
5197 if (r
== error_mark_node
)
5200 check_switch_goto (switch_stack
->level
);
5202 /* After labels, make any new cleanups in the function go into their
5203 own new (temporary) binding contour. */
5204 for (p
= current_binding_level
; !(p
->parm_flag
); p
= p
->level_chain
)
5205 p
->more_cleanups_ok
= 0;
5206 current_function_return_value
= NULL_TREE
;
5211 /* Return the list of declarations of the current level.
5212 Note that this list is in reverse order unless/until
5213 you nreverse it; and when you do nreverse it, you must
5214 store the result back using `storedecls' or you will lose. */
5219 return current_binding_level
->names
;
5222 /* Return the list of type-tags (for structs, etc) of the current level. */
5227 return current_binding_level
->tags
;
5230 /* Store the list of declarations of the current level.
5231 This is done for the parameter declarations of a function being defined,
5232 after they are modified in the light of any missing parameters. */
5238 current_binding_level
->names
= decls
;
5241 /* Similarly, store the list of tags of the current level. */
5247 current_binding_level
->tags
= tags
;
5250 /* Given NAME, an IDENTIFIER_NODE,
5251 return the structure (or union or enum) definition for that name.
5252 Searches binding levels from BINDING_LEVEL up to the global level.
5253 If THISLEVEL_ONLY is nonzero, searches only the specified context
5254 (but skips any tag-transparent contexts to find one that is
5255 meaningful for tags).
5256 FORM says which kind of type the caller wants;
5257 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5258 If the wrong kind of type is found, and it's not a template, an error is
5262 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5263 enum tree_code form
;
5265 struct binding_level
*binding_level
;
5268 register struct binding_level
*level
;
5269 /* Non-zero if, we should look past a template parameter level, even
5270 if THISLEVEL_ONLY. */
5271 int allow_template_parms_p
= 1;
5273 for (level
= binding_level
; level
; level
= level
->level_chain
)
5276 if (ANON_AGGRNAME_P (name
))
5277 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5279 /* There's no need for error checking here, because
5280 anon names are unique throughout the compilation. */
5281 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5282 return TREE_VALUE (tail
);
5284 else if (level
->namespace_p
)
5285 /* Do namespace lookup. */
5286 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5288 tree old
= binding_for_name (name
, tail
);
5290 /* If we just skipped past a template parameter level,
5291 even though THISLEVEL_ONLY, and we find a template
5292 class declaration, then we use the _TYPE node for the
5293 template. See the example below. */
5294 if (thislevel_only
&& !allow_template_parms_p
5295 && old
&& BINDING_VALUE (old
)
5296 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5297 old
= TREE_TYPE (BINDING_VALUE (old
));
5299 old
= BINDING_TYPE (old
);
5301 /* If it has an original type, it is a typedef, and we
5302 should not return it. */
5303 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5305 if (old
&& TREE_CODE (old
) != form
5306 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5308 cp_error ("`%#D' redeclared as %C", old
, form
);
5313 if (thislevel_only
|| tail
== global_namespace
)
5317 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5319 if (TREE_PURPOSE (tail
) == name
)
5321 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5322 /* Should tighten this up; it'll probably permit
5323 UNION_TYPE and a struct template, for example. */
5325 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5327 /* Definition isn't the kind we were looking for. */
5328 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5332 return TREE_VALUE (tail
);
5335 if (thislevel_only
&& ! level
->tag_transparent
)
5337 if (level
->template_parms_p
&& allow_template_parms_p
)
5339 /* We must deal with cases like this:
5341 template <class T> struct S;
5342 template <class T> struct S {};
5344 When looking up `S', for the second declaration, we
5345 would like to find the first declaration. But, we
5346 are in the pseudo-global level created for the
5347 template parameters, rather than the (surrounding)
5348 namespace level. Thus, we keep going one more level,
5349 even though THISLEVEL_ONLY is non-zero. */
5350 allow_template_parms_p
= 0;
5362 set_current_level_tags_transparency (tags_transparent
)
5363 int tags_transparent
;
5365 current_binding_level
->tag_transparent
= tags_transparent
;
5369 /* Given a type, find the tag that was defined for it and return the tag name.
5370 Otherwise return 0. However, the value can never be 0
5371 in the cases in which this is used.
5373 C++: If NAME is non-zero, this is the new name to install. This is
5374 done when replacing anonymous tags with real tag names. */
5377 lookup_tag_reverse (type
, name
)
5381 register struct binding_level
*level
;
5383 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5386 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5388 if (TREE_VALUE (tail
) == type
)
5391 TREE_PURPOSE (tail
) = name
;
5392 return TREE_PURPOSE (tail
);
5399 /* Look up NAME in the NAMESPACE. */
5402 lookup_namespace_name (namespace, name
)
5403 tree
namespace, name
;
5406 tree template_id
= NULL_TREE
;
5408 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5410 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5411 /* This happens for A::B<int> when B is a namespace. */
5413 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5415 /* This happens for A::B where B is a template, and there are no
5416 template arguments. */
5417 cp_error ("invalid use of `%D'", name
);
5418 return error_mark_node
;
5421 namespace = ORIGINAL_NAMESPACE (namespace);
5423 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5426 name
= TREE_OPERAND (name
, 0);
5427 if (TREE_CODE (name
) == OVERLOAD
)
5428 name
= DECL_NAME (OVL_CURRENT (name
));
5429 else if (DECL_P (name
))
5430 name
= DECL_NAME (name
);
5433 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5435 val
= make_node (CPLUS_BINDING
);
5436 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5437 return error_mark_node
;
5439 if (BINDING_VALUE (val
))
5441 val
= BINDING_VALUE (val
);
5445 if (DECL_CLASS_TEMPLATE_P (val
))
5446 val
= lookup_template_class (val
,
5447 TREE_OPERAND (template_id
, 1),
5448 /*in_decl=*/NULL_TREE
,
5449 /*context=*/NULL_TREE
,
5450 /*entering_scope=*/0,
5452 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5453 || TREE_CODE (val
) == OVERLOAD
)
5454 val
= lookup_template_function (val
,
5455 TREE_OPERAND (template_id
, 1));
5458 cp_error ("`%D::%D' is not a template",
5460 return error_mark_node
;
5464 /* If we have a single function from a using decl, pull it out. */
5465 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5466 val
= OVL_FUNCTION (val
);
5470 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5471 return error_mark_node
;
5474 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5476 static unsigned long
5484 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5485 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5490 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5493 typename_compare (k1
, k2
)
5504 d1
= TYPE_NAME (t1
);
5505 d2
= TYPE_NAME (t2
);
5507 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5508 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5509 && ((TREE_TYPE (t1
) != NULL_TREE
)
5510 == (TREE_TYPE (t2
) != NULL_TREE
))
5511 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5512 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5515 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5516 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5517 is non-NULL, this type is being created by the implicit typename
5518 extension, and BASE_TYPE is a type named `t' in some base class of
5519 `T' which depends on template parameters.
5521 Returns the new TYPENAME_TYPE. */
5524 build_typename_type (context
, name
, fullname
, base_type
)
5532 struct hash_entry
*e
;
5534 static struct hash_table ht
;
5538 static struct hash_table
*h
= &ht
;
5540 hash_table_init (&ht
, &hash_newfunc
, &typename_hash
, &typename_compare
);
5541 ggc_add_tree_hash_table_root (&h
, 1);
5544 /* Build the TYPENAME_TYPE. */
5545 t
= make_aggr_type (TYPENAME_TYPE
);
5546 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5547 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5548 TREE_TYPE (t
) = base_type
;
5550 /* Build the corresponding TYPE_DECL. */
5551 d
= build_decl (TYPE_DECL
, name
, t
);
5552 TYPE_NAME (TREE_TYPE (d
)) = d
;
5553 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5554 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5555 DECL_ARTIFICIAL (d
) = 1;
5557 /* See if we already have this type. */
5558 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5562 /* Insert the type into the table. */
5563 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5568 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5569 unless an error occurs, in which case error_mark_node is returned.
5570 If COMPLAIN zero, don't complain about any errors that occur. */
5573 make_typename_type (context
, name
, complain
)
5581 if (!(TYPE_LANG_SPECIFIC (name
)
5582 && (CLASSTYPE_IS_TEMPLATE (name
)
5583 || CLASSTYPE_USE_TEMPLATE (name
))))
5584 name
= TYPE_IDENTIFIER (name
);
5586 /* Create a TEMPLATE_ID_EXPR for the type. */
5587 name
= build_nt (TEMPLATE_ID_EXPR
,
5588 CLASSTYPE_TI_TEMPLATE (name
),
5589 CLASSTYPE_TI_ARGS (name
));
5591 else if (TREE_CODE (name
) == TYPE_DECL
)
5592 name
= DECL_NAME (name
);
5596 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5598 name
= TREE_OPERAND (name
, 0);
5599 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5600 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5602 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5603 my_friendly_abort (2000);
5605 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5607 /* We can get here from typename_sub0 in the explicit_template_type
5608 expansion. Just fail. */
5610 cp_error ("no class template named `%#T' in `%#T'",
5612 return error_mark_node
;
5615 if (! uses_template_parms (context
)
5616 || currently_open_class (context
))
5618 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5620 tree tmpl
= NULL_TREE
;
5621 if (IS_AGGR_TYPE (context
))
5622 tmpl
= lookup_field (context
, name
, 0, 0);
5623 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5626 cp_error ("no class template named `%#T' in `%#T'",
5628 return error_mark_node
;
5631 return lookup_template_class (tmpl
,
5632 TREE_OPERAND (fullname
, 1),
5634 /*entering_scope=*/0,
5641 if (!IS_AGGR_TYPE (context
))
5644 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5645 return error_mark_node
;
5648 t
= lookup_field (context
, name
, 0, 1);
5650 return TREE_TYPE (t
);
5654 /* If the CONTEXT is not a template type, then either the field is
5655 there now or its never going to be. */
5656 if (!uses_template_parms (context
))
5659 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5660 return error_mark_node
;
5664 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5667 /* Select the right _DECL from multiple choices. */
5670 select_decl (binding
, flags
)
5675 val
= BINDING_VALUE (binding
);
5677 /* When we implicitly declare some builtin entity, we mark it
5678 DECL_ANTICIPATED, so that we know to ignore it until it is
5680 if (val
&& DECL_P (val
)
5681 && DECL_LANG_SPECIFIC (val
)
5682 && DECL_ANTICIPATED (val
))
5685 if (LOOKUP_NAMESPACES_ONLY (flags
))
5687 /* We are not interested in types. */
5688 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5693 /* If we could have a type and
5694 we have nothing or we need a type and have none. */
5695 if (BINDING_TYPE (binding
)
5696 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5697 && TREE_CODE (val
) != TYPE_DECL
)))
5698 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5699 /* Don't return non-types if we really prefer types. */
5700 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5701 && (TREE_CODE (val
) != TEMPLATE_DECL
5702 || !DECL_CLASS_TEMPLATE_P (val
)))
5708 /* Unscoped lookup of a global: iterate over current namespaces,
5709 considering using-directives. If SPACESP is non-NULL, store a list
5710 of the namespaces we've considered in it. */
5713 unqualified_namespace_lookup (name
, flags
, spacesp
)
5718 tree b
= make_node (CPLUS_BINDING
);
5719 tree initial
= current_decl_namespace();
5720 tree scope
= initial
;
5722 struct binding_level
*level
;
5723 tree val
= NULL_TREE
;
5726 *spacesp
= NULL_TREE
;
5728 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5731 *spacesp
= tree_cons (scope
, NULL_TREE
, *spacesp
);
5732 val
= binding_for_name (name
, scope
);
5734 /* Initialize binding for this context. */
5735 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5736 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5738 /* Add all _DECLs seen through local using-directives. */
5739 for (level
= current_binding_level
;
5740 !level
->namespace_p
;
5741 level
= level
->level_chain
)
5742 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5743 scope
, flags
, spacesp
))
5744 /* Give up because of error. */
5745 return error_mark_node
;
5747 /* Add all _DECLs seen through global using-directives. */
5748 /* XXX local and global using lists should work equally. */
5752 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5753 scope
, flags
, spacesp
))
5754 /* Give up because of error. */
5755 return error_mark_node
;
5756 if (siter
== scope
) break;
5757 siter
= CP_DECL_CONTEXT (siter
);
5760 val
= select_decl (b
, flags
);
5761 if (scope
== global_namespace
)
5767 /* Combine prefer_type and namespaces_only into flags. */
5770 lookup_flags (prefer_type
, namespaces_only
)
5771 int prefer_type
, namespaces_only
;
5773 if (namespaces_only
)
5774 return LOOKUP_PREFER_NAMESPACES
;
5775 if (prefer_type
> 1)
5776 return LOOKUP_PREFER_TYPES
;
5777 if (prefer_type
> 0)
5778 return LOOKUP_PREFER_BOTH
;
5782 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5783 ignore it or not. Subroutine of lookup_name_real. */
5786 qualify_lookup (val
, flags
)
5790 if (val
== NULL_TREE
)
5792 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5794 if ((flags
& LOOKUP_PREFER_TYPES
)
5795 && (TREE_CODE (val
) == TYPE_DECL
5796 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5797 && DECL_CLASS_TEMPLATE_P (val
))))
5799 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5804 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5808 warn_about_implicit_typename_lookup (typename
, binding
)
5812 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5813 tree name
= DECL_NAME (typename
);
5815 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5816 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5817 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5818 && ! (TREE_CODE (binding
) == TYPE_DECL
5819 && same_type_p (TREE_TYPE (binding
), subtype
)))
5821 cp_warning ("lookup of `%D' finds `%#D'",
5823 cp_warning (" instead of `%D' from dependent base class",
5825 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5826 constructor_name (current_class_type
), name
);
5830 /* Look up NAME in the current binding level and its superiors in the
5831 namespace of variables, functions and typedefs. Return a ..._DECL
5832 node of some kind representing its definition if there is only one
5833 such declaration, or return a TREE_LIST with all the overloaded
5834 definitions if there are many, or return 0 if it is undefined.
5836 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5837 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5838 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5839 Otherwise we prefer non-TYPE_DECLs.
5841 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5842 using IDENTIFIER_CLASS_VALUE. */
5845 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5847 int prefer_type
, nonclass
, namespaces_only
;
5850 tree val
= NULL_TREE
;
5852 tree from_obj
= NULL_TREE
;
5854 int val_is_implicit_typename
= 0;
5856 /* Hack: copy flag set by parser, if set. */
5857 if (only_namespace_names
)
5858 namespaces_only
= 1;
5860 if (prefer_type
== -2)
5862 extern int looking_for_typename
;
5863 tree type
= NULL_TREE
;
5866 prefer_type
= looking_for_typename
;
5868 flags
= lookup_flags (prefer_type
, namespaces_only
);
5869 /* If the next thing is '<', class templates are types. */
5870 if (looking_for_template
)
5871 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5873 /* std:: becomes :: for now. */
5874 if (got_scope
&& got_scope
== fake_std_node
)
5875 got_scope
= void_type_node
;
5879 else if (got_object
!= error_mark_node
)
5884 if (type
== error_mark_node
)
5885 return error_mark_node
;
5886 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5887 type
= TREE_TYPE (type
);
5890 type
= complete_type (type
);
5892 if (TREE_CODE (type
) == VOID_TYPE
)
5893 type
= global_namespace
;
5894 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5896 val
= make_node (CPLUS_BINDING
);
5897 flags
|= LOOKUP_COMPLAIN
;
5898 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5900 val
= select_decl (val
, flags
);
5902 else if (! IS_AGGR_TYPE (type
)
5903 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5904 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
5905 || TREE_CODE (type
) == TYPENAME_TYPE
)
5906 /* Someone else will give an error about this if needed. */
5908 else if (type
== current_class_type
)
5909 val
= IDENTIFIER_CLASS_VALUE (name
);
5912 val
= lookup_member (type
, name
, 0, prefer_type
);
5913 type_access_control (type
, val
);
5915 /* Restore the containing TYPENAME_TYPE if we looked
5916 through it before. */
5917 if (got_scope
&& got_scope
!= type
5918 && val
&& TREE_CODE (val
) == TYPE_DECL
5919 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
)
5920 TYPE_CONTEXT (TREE_TYPE (val
)) = got_scope
;
5928 else if (got_object
&& val
)
5936 flags
= lookup_flags (prefer_type
, namespaces_only
);
5937 /* If we're not parsing, we need to complain. */
5938 flags
|= LOOKUP_COMPLAIN
;
5941 /* First, look in non-namespace scopes. */
5943 if (current_class_type
== NULL_TREE
)
5946 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5950 if (!LOCAL_BINDING_P (t
) && nonclass
)
5951 /* We're not looking for class-scoped bindings, so keep going. */
5954 /* If this is the kind of thing we're looking for, we're done. */
5955 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5956 binding
= BINDING_VALUE (t
);
5957 else if ((flags
& LOOKUP_PREFER_TYPES
)
5958 && qualify_lookup (BINDING_TYPE (t
), flags
))
5959 binding
= BINDING_TYPE (t
);
5961 binding
= NULL_TREE
;
5963 /* Handle access control on types from enclosing or base classes. */
5964 if (binding
&& ! yylex
5965 && BINDING_LEVEL (t
) && BINDING_LEVEL (t
)->parm_flag
== 2)
5966 type_access_control (BINDING_LEVEL (t
)->this_class
, binding
);
5969 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5971 if (val_is_implicit_typename
&& !yylex
)
5972 warn_about_implicit_typename_lookup (val
, binding
);
5974 val_is_implicit_typename
5975 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5976 if (!val_is_implicit_typename
)
5981 /* Now lookup in namespace scopes. */
5982 if (!val
|| val_is_implicit_typename
)
5984 t
= unqualified_namespace_lookup (name
, flags
, 0);
5987 if (val_is_implicit_typename
&& !yylex
)
5988 warn_about_implicit_typename_lookup (val
, t
);
5996 /* This should only warn about types used in qualified-ids. */
5997 if (from_obj
&& from_obj
!= val
)
5999 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
6000 && TREE_CODE (val
) == TYPE_DECL
6001 && ! same_type_p (TREE_TYPE (from_obj
), TREE_TYPE (val
)))
6003 lookup of `%D' in the scope of `%#T' (`%#D') \
6004 does not match lookup in the current scope (`%#D')",
6005 name
, got_object
, from_obj
, val
);
6007 /* We don't change val to from_obj if got_object depends on
6008 template parms because that breaks implicit typename for
6009 destructor calls. */
6010 if (! uses_template_parms (got_object
))
6014 /* If we have a single function from a using decl, pull it out. */
6015 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
6016 val
= OVL_FUNCTION (val
);
6025 lookup_name_nonclass (name
)
6028 return lookup_name_real (name
, 0, 1, 0);
6032 lookup_function_nonclass (name
, args
)
6036 return lookup_arg_dependent (name
, lookup_name_nonclass (name
), args
);
6040 lookup_name_namespace_only (name
)
6043 /* type-or-namespace, nonclass, namespace_only */
6044 return lookup_name_real (name
, 1, 1, 1);
6048 lookup_name (name
, prefer_type
)
6052 return lookup_name_real (name
, prefer_type
, 0, 0);
6055 /* Similar to `lookup_name' but look only in the innermost non-class
6059 lookup_name_current_level (name
)
6062 struct binding_level
*b
;
6065 b
= current_binding_level
;
6066 while (b
->parm_flag
== 2)
6071 t
= IDENTIFIER_NAMESPACE_VALUE (name
);
6073 /* extern "C" function() */
6074 if (t
!= NULL_TREE
&& TREE_CODE (t
) == TREE_LIST
)
6077 else if (IDENTIFIER_BINDING (name
)
6078 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name
)))
6082 if (BINDING_LEVEL (IDENTIFIER_BINDING (name
)) == b
)
6083 return IDENTIFIER_VALUE (name
);
6095 /* Like lookup_name_current_level, but for types. */
6098 lookup_type_current_level (name
)
6101 register tree t
= NULL_TREE
;
6103 my_friendly_assert (! current_binding_level
->namespace_p
, 980716);
6105 if (REAL_IDENTIFIER_TYPE_VALUE (name
) != NULL_TREE
6106 && REAL_IDENTIFIER_TYPE_VALUE (name
) != global_type_node
)
6108 struct binding_level
*b
= current_binding_level
;
6111 if (purpose_member (name
, b
->type_shadowed
))
6112 return REAL_IDENTIFIER_TYPE_VALUE (name
);
6124 begin_only_namespace_names ()
6126 only_namespace_names
= 1;
6130 end_only_namespace_names ()
6132 only_namespace_names
= 0;
6135 /* Push the declarations of builtin types into the namespace.
6136 RID_INDEX is the index of the builtin type
6137 in the array RID_POINTERS. NAME is the name used when looking
6138 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6141 record_builtin_type (rid_index
, name
, type
)
6146 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
6147 tree tdecl
= NULL_TREE
;
6149 if ((int) rid_index
< (int) RID_MAX
)
6150 rname
= ridpointers
[(int) rid_index
];
6152 tname
= get_identifier (name
);
6154 TYPE_BUILT_IN (type
) = 1;
6158 tdecl
= pushdecl (build_decl (TYPE_DECL
, tname
, type
));
6159 set_identifier_type_value (tname
, NULL_TREE
);
6160 if ((int) rid_index
< (int) RID_MAX
)
6161 /* Built-in types live in the global namespace. */
6162 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
6164 if (rname
!= NULL_TREE
)
6166 if (tname
!= NULL_TREE
)
6168 set_identifier_type_value (rname
, NULL_TREE
);
6169 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
6173 tdecl
= pushdecl (build_decl (TYPE_DECL
, rname
, type
));
6174 set_identifier_type_value (rname
, NULL_TREE
);
6179 /* Record one of the standard Java types.
6180 * Declare it as having the given NAME.
6181 * If SIZE > 0, it is the size of one of the integral types;
6182 * otherwise it is the negative of the size of one of the other types. */
6185 record_builtin_java_type (name
, size
)
6191 type
= make_signed_type (size
);
6192 else if (size
> -32)
6193 { /* "__java_char" or ""__java_boolean". */
6194 type
= make_unsigned_type (-size
);
6195 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6198 { /* "__java_float" or ""__java_double". */
6199 type
= make_node (REAL_TYPE
);
6200 TYPE_PRECISION (type
) = - size
;
6203 record_builtin_type (RID_MAX
, name
, type
);
6204 decl
= TYPE_NAME (type
);
6206 /* Suppress generate debug symbol entries for these types,
6207 since for normal C++ they are just clutter.
6208 However, push_lang_context undoes this if extern "Java" is seen. */
6209 DECL_IGNORED_P (decl
) = 1;
6211 TYPE_FOR_JAVA (type
) = 1;
6215 /* Push a type into the namespace so that the back-ends ignore it. */
6218 record_unknown_type (type
, name
)
6222 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
6223 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6224 DECL_IGNORED_P (decl
) = 1;
6225 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6226 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
6227 TYPE_ALIGN (type
) = 1;
6228 TYPE_USER_ALIGN (type
) = 0;
6229 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
6232 /* An string for which we should create an IDENTIFIER_NODE at
6235 typedef struct predefined_identifier
6237 /* The name of the identifier. */
6239 /* The place where the IDENTIFIER_NODE should be stored. */
6241 /* Non-zero if this is the name of a constructor or destructor. */
6243 } predefined_identifier
;
6245 /* Create all the predefined identifiers. */
6248 initialize_predefined_identifiers ()
6250 struct predefined_identifier
*pid
;
6252 /* A table of identifiers to create at startup. */
6253 static predefined_identifier predefined_identifiers
[] = {
6254 { "C++", &lang_name_cplusplus
, 0 },
6255 { "C", &lang_name_c
, 0 },
6256 { "Java", &lang_name_java
, 0 },
6257 { CTOR_NAME
, &ctor_identifier
, 1 },
6258 { "__base_ctor", &base_ctor_identifier
, 1 },
6259 { "__comp_ctor", &complete_ctor_identifier
, 1 },
6260 { DTOR_NAME
, &dtor_identifier
, 1 },
6261 { "__comp_dtor", &complete_dtor_identifier
, 1 },
6262 { "__base_dtor", &base_dtor_identifier
, 1 },
6263 { "__deleting_dtor", &deleting_dtor_identifier
, 1 },
6264 { VTABLE_DELTA2_NAME
, &delta2_identifier
, 0 },
6265 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
6266 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
6267 { VTABLE_INDEX_NAME
, &index_identifier
, 0 },
6268 { "nelts", &nelts_identifier
, 0 },
6269 { THIS_NAME
, &this_identifier
, 0 },
6270 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
6271 { "__pfn_or_delta2", &pfn_or_delta2_identifier
, 0 },
6272 { "_vptr", &vptr_identifier
, 0 },
6273 { "__cp_push_exception", &cp_push_exception_identifier
, 0 },
6274 { "__vtt_parm", &vtt_parm_identifier
, 0 },
6275 { "std", &std_identifier
, 0 },
6279 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
6281 *pid
->node
= get_identifier (pid
->name
);
6282 if (pid
->ctor_or_dtor_p
)
6283 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
6287 /* Create the predefined scalar types of C,
6288 and some nodes representing standard constants (0, 1, (void *)0).
6289 Initialize the global binding level.
6290 Make definitions for built-in primitive functions. */
6293 init_decl_processing ()
6297 /* Check to see that the user did not specify an invalid combination
6298 of command-line options. */
6299 if (!flag_vtable_thunks
)
6300 error ("the ABI requires vtable thunks");
6302 /* Create all the identifiers we need. */
6303 initialize_predefined_identifiers ();
6305 /* Fill in back-end hooks. */
6306 init_lang_status
= &push_cp_function_context
;
6307 free_lang_status
= &pop_cp_function_context
;
6308 mark_lang_status
= &mark_cp_function_context
;
6309 lang_safe_from_p
= &c_safe_from_p
;
6310 lang_dump_tree
= &cp_dump_tree
;
6311 lang_missing_noreturn_ok_p
= &cp_missing_noreturn_ok_p
;
6317 /* Create the global variables. */
6318 push_to_top_level ();
6320 /* Enter the global namespace. */
6321 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
6322 push_namespace (get_identifier ("::"));
6323 global_namespace
= current_namespace
;
6324 current_lang_name
= NULL_TREE
;
6326 /* Adjust various flags based on command-line settings. */
6327 if (! flag_permissive
&& ! pedantic
)
6328 flag_pedantic_errors
= 1;
6329 if (!flag_no_inline
)
6330 flag_inline_trees
= 1;
6333 current_lang_name
= lang_name_c
;
6335 current_function_decl
= NULL_TREE
;
6336 current_binding_level
= NULL_BINDING_LEVEL
;
6337 free_binding_level
= NULL_BINDING_LEVEL
;
6339 build_common_tree_nodes (flag_signed_char
);
6341 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
6342 TREE_TYPE (error_mark_list
) = error_mark_node
;
6344 /* Make the binding_level structure for global names. */
6346 global_binding_level
= current_binding_level
;
6347 /* The global level is the namespace level of ::. */
6348 NAMESPACE_LEVEL (global_namespace
) = global_binding_level
;
6349 declare_namespace_level ();
6351 /* Create the `std' namespace. */
6354 push_namespace (std_identifier
);
6355 std_node
= current_namespace
;
6357 fake_std_node
= error_mark_node
;
6361 fake_std_node
= build_decl (NAMESPACE_DECL
,
6364 pushdecl (fake_std_node
);
6367 c_common_nodes_and_builtins ();
6369 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6370 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6371 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6372 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6373 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6374 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6375 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6376 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6378 integer_two_node
= build_int_2 (2, 0);
6379 TREE_TYPE (integer_two_node
) = integer_type_node
;
6380 integer_three_node
= build_int_2 (3, 0);
6381 TREE_TYPE (integer_three_node
) = integer_type_node
;
6383 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6384 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6385 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6386 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6387 TYPE_PRECISION (boolean_type_node
) = 1;
6388 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6389 boolean_false_node
= build_int_2 (0, 0);
6390 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6391 boolean_true_node
= build_int_2 (1, 0);
6392 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6394 signed_size_zero_node
= build_int_2 (0, 0);
6395 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6397 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6400 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6403 delta_type_node
= ptrdiff_type_node
;
6404 vtable_index_type
= ptrdiff_type_node
;
6406 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
6407 lang_type_promotes_to
= convert_type_from_ellipsis
;
6410 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6412 /* C++ extensions */
6414 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6415 record_unknown_type (unknown_type_node
, "unknown type");
6417 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6418 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6420 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6422 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6424 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6425 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6427 if (flag_vtable_thunks
)
6429 /* Make sure we get a unique function type, so we can give
6430 its pointer type a name. (This wins for gdb.) */
6431 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6432 TREE_TYPE (vfunc_type
) = integer_type_node
;
6433 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6434 layout_type (vfunc_type
);
6436 vtable_entry_type
= build_pointer_type (vfunc_type
);
6440 vtable_entry_type
= make_aggr_type (RECORD_TYPE
);
6441 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
6443 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
6445 fields
[2] = build_decl (FIELD_DECL
, pfn_identifier
,
6447 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6450 /* Make this part of an invisible union. */
6451 fields
[3] = copy_node (fields
[2]);
6452 TREE_TYPE (fields
[3]) = delta_type_node
;
6453 DECL_NAME (fields
[3]) = delta2_identifier
;
6454 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6455 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6456 DECL_SIZE_UNIT (fields
[3]) = TYPE_SIZE_UNIT (delta_type_node
);
6457 TREE_UNSIGNED (fields
[3]) = 0;
6458 TREE_CHAIN (fields
[2]) = fields
[3];
6459 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6462 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6465 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6466 layout_type (vtbl_type_node
);
6467 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6468 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6469 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6470 layout_type (vtbl_ptr_type_node
);
6471 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6473 push_namespace (get_identifier ("__cxxabiv1"));
6474 abi_node
= current_namespace
;
6477 global_type_node
= make_node (LANG_TYPE
);
6478 record_unknown_type (global_type_node
, "global type");
6481 current_lang_name
= lang_name_cplusplus
;
6484 tree bad_alloc_type_node
, newtype
, deltype
;
6486 push_namespace (std_identifier
);
6487 bad_alloc_type_node
= xref_tag
6488 (class_type_node
, get_identifier ("bad_alloc"), 1);
6491 newtype
= build_exception_variant
6492 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6493 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6494 push_cp_library_fn (NEW_EXPR
, newtype
);
6495 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
6496 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
6497 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
6501 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
6503 /* Perform other language dependent initializations. */
6504 init_class_processing ();
6505 init_init_processing ();
6506 init_search_processing ();
6507 init_rtti_processing ();
6509 if (flag_exceptions
)
6510 init_exception_processing ();
6513 flag_inline_functions
= 0;
6516 if (! supports_one_only ())
6519 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6520 function_id_node
= get_identifier ("__FUNCTION__");
6521 pretty_function_id_node
= get_identifier ("__PRETTY_FUNCTION__");
6522 func_id_node
= get_identifier ("__func__");
6524 make_fname_decl
= cp_make_fname_decl
;
6525 declare_function_name ();
6527 /* Prepare to check format strings against argument lists. */
6528 init_function_format_info ();
6530 /* Show we use EH for cleanups. */
6531 using_eh_for_cleanups ();
6533 valid_lang_attribute
= cp_valid_lang_attribute
;
6535 /* Maintain consistency. Perhaps we should just complain if they
6536 say -fwritable-strings? */
6537 if (flag_writable_strings
)
6538 flag_const_strings
= 0;
6540 /* Add GC roots for all of our global variables. */
6541 ggc_add_tree_root (c_global_trees
, sizeof c_global_trees
/ sizeof(tree
));
6542 ggc_add_tree_root (cp_global_trees
, sizeof cp_global_trees
/ sizeof(tree
));
6543 ggc_add_tree_root (&integer_three_node
, 1);
6544 ggc_add_tree_root (&integer_two_node
, 1);
6545 ggc_add_tree_root (&signed_size_zero_node
, 1);
6546 ggc_add_tree_root (&size_one_node
, 1);
6547 ggc_add_tree_root (&size_zero_node
, 1);
6548 ggc_add_root (&global_binding_level
, 1, sizeof global_binding_level
,
6549 mark_binding_level
);
6550 ggc_add_root (&scope_chain
, 1, sizeof scope_chain
, &mark_saved_scope
);
6551 ggc_add_tree_root (&static_ctors
, 1);
6552 ggc_add_tree_root (&static_dtors
, 1);
6553 ggc_add_tree_root (&lastiddecl
, 1);
6555 ggc_add_tree_root (&last_function_parm_tags
, 1);
6556 ggc_add_tree_root (¤t_function_return_value
, 1);
6557 ggc_add_tree_root (¤t_function_parm_tags
, 1);
6558 ggc_add_tree_root (&last_function_parms
, 1);
6559 ggc_add_tree_root (&error_mark_list
, 1);
6561 ggc_add_tree_root (&global_namespace
, 1);
6562 ggc_add_tree_root (&global_type_node
, 1);
6563 ggc_add_tree_root (&anonymous_namespace_name
, 1);
6565 ggc_add_tree_root (&got_object
, 1);
6566 ggc_add_tree_root (&got_scope
, 1);
6568 ggc_add_tree_root (¤t_lang_name
, 1);
6569 ggc_add_tree_root (&static_aggregates
, 1);
6570 ggc_add_tree_root (&free_bindings
, 1);
6573 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6574 decl, NAME is the initialization string and TYPE_DEP indicates whether
6575 NAME depended on the type of the function. We make use of that to detect
6576 __PRETTY_FUNCTION__ inside a template fn. Because we build a tree for
6577 the function before emitting any of it, we don't need to treat the
6578 VAR_DECL specially. We can decide whether to emit it later, if it was
6582 cp_make_fname_decl (id
, name
, type_dep
)
6587 tree decl
, type
, init
;
6588 size_t length
= strlen (name
);
6589 tree domain
= NULL_TREE
;
6591 if (!processing_template_decl
)
6594 domain
= build_index_type (size_int (length
));
6596 type
= build_cplus_array_type
6597 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
6600 decl
= build_decl (VAR_DECL
, id
, type
);
6601 TREE_STATIC (decl
) = 1;
6602 TREE_READONLY (decl
) = 1;
6603 DECL_SOURCE_LINE (decl
) = 0;
6604 DECL_ARTIFICIAL (decl
) = 1;
6605 DECL_IN_SYSTEM_HEADER (decl
) = 1;
6607 if (processing_template_decl
)
6608 decl
= push_template_decl (decl
);
6611 init
= build (FUNCTION_NAME
, type
);
6612 DECL_PRETTY_FUNCTION_P (decl
) = 1;
6616 init
= build_string (length
+ 1, name
);
6617 TREE_TYPE (init
) = type
;
6619 DECL_INITIAL (decl
) = init
;
6620 cp_finish_decl (decl
, init
, NULL_TREE
, LOOKUP_ONLYCONVERTING
);
6622 /* We will have to make sure we only emit this, if it is actually used. */
6626 /* Entry point for the benefit of c_common_nodes_and_builtins.
6628 Make a definition for a builtin function named NAME and whose data type
6629 is TYPE. TYPE should be a function type with argument types.
6631 CLASS and CODE tell later passes how to compile calls to this function.
6632 See tree.h for possible values.
6634 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6635 the name to be called if we can't opencode the function. */
6638 builtin_function (name
, type
, code
, class, libname
)
6642 enum built_in_class
class;
6643 const char *libname
;
6645 tree decl
= build_library_fn_1 (get_identifier (name
), ERROR_MARK
, type
);
6646 DECL_BUILT_IN_CLASS (decl
) = class;
6647 DECL_FUNCTION_CODE (decl
) = code
;
6649 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6651 /* All builtins that don't begin with an `_' should go in the `std'
6653 if (flag_honor_std
&& name
[0] != '_')
6655 push_namespace (std_identifier
);
6656 DECL_CONTEXT (decl
) = std_node
;
6659 if (flag_honor_std
&& name
[0] != '_')
6662 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6663 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6664 function in the namespace. */
6666 DECL_ASSEMBLER_NAME (decl
) = get_identifier (libname
);
6667 make_decl_rtl (decl
, NULL
);
6669 /* Warn if a function in the namespace for users
6670 is used without an occasion to consider it declared. */
6671 if (name
[0] != '_' || name
[1] != '_')
6672 DECL_ANTICIPATED (decl
) = 1;
6677 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6678 function. Not called directly. */
6681 build_library_fn_1 (name
, operator_code
, type
)
6683 enum tree_code operator_code
;
6686 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
6687 DECL_EXTERNAL (fn
) = 1;
6688 TREE_PUBLIC (fn
) = 1;
6689 DECL_ARTIFICIAL (fn
) = 1;
6690 TREE_NOTHROW (fn
) = 1;
6691 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
6695 /* Returns the _DECL for a library function with C linkage.
6696 We assume that such functions never throw; if this is incorrect,
6697 callers should unset TREE_NOTHROW. */
6700 build_library_fn (name
, type
)
6704 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
6705 make_decl_rtl (fn
, NULL
);
6709 /* Returns the _DECL for a library function with C++ linkage. */
6712 build_cp_library_fn (name
, operator_code
, type
)
6714 enum tree_code operator_code
;
6717 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
6718 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
6719 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
6720 set_mangled_name_for_decl (fn
);
6721 make_decl_rtl (fn
, NULL
);
6725 /* Like build_library_fn, but takes a C string instead of an
6729 build_library_fn_ptr (name
, type
)
6733 return build_library_fn (get_identifier (name
), type
);
6736 /* Like build_cp_library_fn, but takes a C string instead of an
6740 build_cp_library_fn_ptr (name
, type
)
6744 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
6747 /* Like build_library_fn, but also pushes the function so that we will
6748 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6751 push_library_fn (name
, type
)
6754 tree fn
= build_library_fn (name
, type
);
6755 pushdecl_top_level (fn
);
6759 /* Like build_cp_library_fn, but also pushes the function so that it
6760 will be found by normal lookup. */
6763 push_cp_library_fn (operator_code
, type
)
6764 enum tree_code operator_code
;
6767 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
6774 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6778 push_void_library_fn (name
, parmtypes
)
6779 tree name
, parmtypes
;
6781 tree type
= build_function_type (void_type_node
, parmtypes
);
6782 return push_library_fn (name
, type
);
6785 /* Like push_library_fn, but also note that this function throws
6786 and does not return. Used for __throw_foo and the like. */
6789 push_throw_library_fn (name
, type
)
6792 tree fn
= push_library_fn (name
, type
);
6793 TREE_THIS_VOLATILE (fn
) = 1;
6794 TREE_NOTHROW (fn
) = 0;
6798 /* When we call finish_struct for an anonymous union, we create
6799 default copy constructors and such. But, an anonymous union
6800 shouldn't have such things; this function undoes the damage to the
6801 anonymous union type T.
6803 (The reason that we create the synthesized methods is that we don't
6804 distinguish `union { int i; }' from `typedef union { int i; } U'.
6805 The first is an anonymous union; the second is just an ordinary
6809 fixup_anonymous_aggr (t
)
6814 /* Wipe out memory of synthesized methods */
6815 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6816 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6817 TYPE_HAS_INIT_REF (t
) = 0;
6818 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6819 TYPE_HAS_ASSIGN_REF (t
) = 0;
6820 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6822 /* Splice the implicitly generated functions out of the TYPE_METHODS
6824 q
= &TYPE_METHODS (t
);
6827 if (DECL_ARTIFICIAL (*q
))
6828 *q
= TREE_CHAIN (*q
);
6830 q
= &TREE_CHAIN (*q
);
6833 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6834 if (TYPE_METHODS (t
))
6835 cp_error_at ("an anonymous union cannot have function members", t
);
6838 /* Make sure that a declaration with no declarator is well-formed, i.e.
6839 just defines a tagged type or anonymous union.
6841 Returns the type defined, if any. */
6844 check_tag_decl (declspecs
)
6849 int saw_typedef
= 0;
6850 tree ob_modifier
= NULL_TREE
;
6852 register tree t
= NULL_TREE
;
6854 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6856 register tree value
= TREE_VALUE (link
);
6859 || TREE_CODE (value
) == TYPE_DECL
6860 || (TREE_CODE (value
) == IDENTIFIER_NODE
6861 && IDENTIFIER_GLOBAL_VALUE (value
)
6862 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value
)) == TYPE_DECL
))
6866 if (found_type
== 2 && TREE_CODE (value
) == IDENTIFIER_NODE
)
6868 if (! in_system_header
)
6869 cp_pedwarn ("redeclaration of C++ built-in type `%T'", value
);
6874 && ((TREE_CODE (value
) != TYPENAME_TYPE
&& IS_AGGR_TYPE (value
))
6875 || TREE_CODE (value
) == ENUMERAL_TYPE
))
6877 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6881 else if (value
== ridpointers
[(int) RID_TYPEDEF
])
6883 else if (value
== ridpointers
[(int) RID_FRIEND
])
6885 if (current_class_type
== NULL_TREE
6886 || current_scope () != current_class_type
)
6887 ob_modifier
= value
;
6891 else if (value
== ridpointers
[(int) RID_STATIC
]
6892 || value
== ridpointers
[(int) RID_EXTERN
]
6893 || value
== ridpointers
[(int) RID_AUTO
]
6894 || value
== ridpointers
[(int) RID_REGISTER
]
6895 || value
== ridpointers
[(int) RID_INLINE
]
6896 || value
== ridpointers
[(int) RID_VIRTUAL
]
6897 || value
== ridpointers
[(int) RID_CONST
]
6898 || value
== ridpointers
[(int) RID_VOLATILE
]
6899 || value
== ridpointers
[(int) RID_EXPLICIT
])
6900 ob_modifier
= value
;
6904 error ("multiple types in one declaration");
6906 if (t
== NULL_TREE
&& ! saw_friend
)
6907 pedwarn ("declaration does not declare anything");
6909 /* Check for an anonymous union. We're careful
6910 accessing TYPE_IDENTIFIER because some built-in types, like
6911 pointer-to-member types, do not have TYPE_NAME. */
6912 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
6914 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
6916 /* 7/3 In a simple-declaration, the optional init-declarator-list
6917 can be omitted only when declaring a class (clause 9) or
6918 enumeration (7.2), that is, when the decl-specifier-seq contains
6919 either a class-specifier, an elaborated-type-specifier with
6920 a class-key (9.1), or an enum-specifier. In these cases and
6921 whenever a class-specifier or enum-specifier is present in the
6922 decl-specifier-seq, the identifiers in these specifiers are among
6923 the names being declared by the declaration (as class-name,
6924 enum-names, or enumerators, depending on the syntax). In such
6925 cases, and except for the declaration of an unnamed bit-field (9.6),
6926 the decl-specifier-seq shall introduce one or more names into the
6927 program, or shall redeclare a name introduced by a previous
6928 declaration. [Example:
6929 enum { }; // ill-formed
6930 typedef class { }; // ill-formed
6934 error ("Missing type-name in typedef-declaration.");
6937 /* Anonymous unions are objects, so they can have specifiers. */;
6938 SET_ANON_AGGR_TYPE_P (t
);
6940 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
6941 pedwarn ("ISO C++ prohibits anonymous structs");
6944 else if (ob_modifier
)
6946 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
6947 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
6948 cp_error ("`%D' can only be specified for functions", ob_modifier
);
6949 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
6950 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
6951 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
6952 cp_error ("`%D' can only be specified for constructors",
6955 cp_error ("`%D' can only be specified for objects and functions",
6962 /* Called when a declaration is seen that contains no names to declare.
6963 If its type is a reference to a structure, union or enum inherited
6964 from a containing scope, shadow that tag name for the current scope
6965 with a forward reference.
6966 If its type defines a new named structure or union
6967 or defines an enum, it is valid but we need not do anything here.
6968 Otherwise, it is an error.
6970 C++: may have to grok the declspecs to learn about static,
6971 complain for anonymous unions. */
6974 shadow_tag (declspecs
)
6977 tree t
= check_tag_decl (declspecs
);
6980 maybe_process_partial_specialization (t
);
6982 /* This is where the variables in an anonymous union are
6983 declared. An anonymous union declaration looks like:
6985 because there is no declarator after the union, the parser
6986 sends that declaration here. */
6987 if (t
&& ANON_AGGR_TYPE_P (t
))
6989 fixup_anonymous_aggr (t
);
6991 if (TYPE_FIELDS (t
))
6993 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
6995 finish_anon_union (decl
);
7000 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
7003 groktypename (typename
)
7006 if (TREE_CODE (typename
) != TREE_LIST
)
7008 return grokdeclarator (TREE_VALUE (typename
),
7009 TREE_PURPOSE (typename
),
7010 TYPENAME
, 0, NULL_TREE
);
7013 /* Decode a declarator in an ordinary declaration or data definition.
7014 This is called as soon as the type information and variable name
7015 have been parsed, before parsing the initializer if any.
7016 Here we create the ..._DECL node, fill in its type,
7017 and put it on the list of decls for the current context.
7018 The ..._DECL node is returned as the value.
7020 Exception: for arrays where the length is not specified,
7021 the type is left null, to be filled in by `cp_finish_decl'.
7023 Function definitions do not come here; they go to start_function
7024 instead. However, external and forward declarations of functions
7025 do go through here. Structure field declarations are done by
7026 grokfield and not through here. */
7029 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
7030 tree declarator
, declspecs
;
7032 tree attributes
, prefix_attributes
;
7035 register tree type
, tem
;
7037 extern int have_extern_spec
;
7038 extern int used_extern_spec
;
7042 /* See code below that used this. */
7043 int init_written
= initialized
;
7046 /* This should only be done once on the top most decl. */
7047 if (have_extern_spec
&& !used_extern_spec
)
7049 declspecs
= tree_cons (NULL_TREE
, get_identifier ("extern"),
7051 used_extern_spec
= 1;
7054 if (attributes
|| prefix_attributes
)
7055 attrlist
= build_tree_list (attributes
, prefix_attributes
);
7057 attrlist
= NULL_TREE
;
7059 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
7062 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
7065 type
= TREE_TYPE (decl
);
7067 if (type
== error_mark_node
)
7070 context
= DECL_CONTEXT (decl
);
7072 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
7073 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
7075 /* When parsing the initializer, lookup should use the object's
7077 push_decl_namespace (context
);
7080 /* We are only interested in class contexts, later. */
7081 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
7082 context
= NULL_TREE
;
7085 /* Is it valid for this decl to have an initializer at all?
7086 If not, set INITIALIZED to zero, which will indirectly
7087 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7088 switch (TREE_CODE (decl
))
7091 /* typedef foo = bar means give foo the same type as bar.
7092 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7093 Any other case of an initialization in a TYPE_DECL is an error. */
7094 if (pedantic
|| list_length (declspecs
) > 1)
7096 cp_error ("typedef `%D' is initialized", decl
);
7102 cp_error ("function `%#D' is initialized like a variable", decl
);
7112 if (! toplevel_bindings_p ()
7113 && DECL_EXTERNAL (decl
))
7114 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7116 DECL_EXTERNAL (decl
) = 0;
7117 if (toplevel_bindings_p ())
7118 TREE_STATIC (decl
) = 1;
7120 /* Tell `pushdecl' this is an initialized decl
7121 even though we don't yet have the initializer expression.
7122 Also tell `cp_finish_decl' it may store the real initializer. */
7123 DECL_INITIAL (decl
) = error_mark_node
;
7126 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7127 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7130 /* Set attributes here so if duplicate decl, will have proper attributes. */
7131 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7133 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
7135 push_nested_class (context
, 2);
7137 if (TREE_CODE (decl
) == VAR_DECL
)
7139 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
7140 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
7141 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
7144 if (DECL_CONTEXT (field
) != context
)
7146 cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7147 DECL_CONTEXT (field
), DECL_NAME (decl
),
7148 context
, DECL_NAME (decl
));
7149 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
7151 /* Static data member are tricky; an in-class initialization
7152 still doesn't provide a definition, so the in-class
7153 declaration will have DECL_EXTERNAL set, but will have an
7154 initialization. Thus, duplicate_decls won't warn
7155 about this situation, and so we check here. */
7156 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
7157 cp_error ("duplicate initialization of %D", decl
);
7158 if (duplicate_decls (decl
, field
))
7164 tree field
= check_classfn (context
, decl
);
7165 if (field
&& duplicate_decls (decl
, field
))
7169 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7170 DECL_IN_AGGR_P (decl
) = 0;
7171 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7172 || CLASSTYPE_TEMPLATE_INSTANTIATION (context
))
7174 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7175 /* [temp.expl.spec] An explicit specialization of a static data
7176 member of a template is a definition if the declaration
7177 includes an initializer; otherwise, it is a declaration.
7179 We check for processing_specialization so this only applies
7180 to the new specialization syntax. */
7181 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7182 DECL_EXTERNAL (decl
) = 1;
7185 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7186 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7190 /* Enter this declaration into the symbol table. */
7191 tem
= maybe_push_decl (decl
);
7193 if (processing_template_decl
)
7194 tem
= push_template_decl (tem
);
7196 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7197 /* Tell the back-end to use or not use .common as appropriate. If we say
7198 -fconserve-space, we want this to save .data space, at the expense of
7199 wrong semantics. If we say -fno-conserve-space, we want this to
7200 produce errors about redefs; to do this we force variables into the
7202 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7205 if (! processing_template_decl
)
7215 tree type
= TREE_TYPE (decl
);
7216 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7218 if (type
== error_mark_node
)
7221 maybe_push_cleanup_level (type
);
7224 /* Is it valid for this decl to have an initializer at all?
7225 If not, set INITIALIZED to zero, which will indirectly
7226 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7228 /* Don't allow initializations for incomplete types except for
7229 arrays which might be completed by the initialization. */
7230 if (COMPLETE_TYPE_P (complete_type (type
)))
7231 ; /* A complete type is ok. */
7232 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7234 cp_error ("variable `%#D' has initializer but incomplete type",
7237 type
= TREE_TYPE (decl
) = error_mark_node
;
7239 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
7241 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7242 cp_error ("elements of array `%#D' have incomplete type", decl
);
7243 /* else we already gave an error in start_decl. */
7249 && TREE_CODE (decl
) != TYPE_DECL
7250 && TREE_CODE (decl
) != TEMPLATE_DECL
7251 && type
!= error_mark_node
7252 && IS_AGGR_TYPE (type
)
7253 && ! DECL_EXTERNAL (decl
))
7255 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7256 && !COMPLETE_TYPE_P (complete_type (type
)))
7258 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7260 /* Change the type so that assemble_variable will give
7261 DECL an rtl we can live with: (mem (const_int 0)). */
7262 type
= TREE_TYPE (decl
) = error_mark_node
;
7266 /* If any base type in the hierarchy of TYPE needs a constructor,
7267 then we set initialized to 1. This way any nodes which are
7268 created for the purposes of initializing this aggregate
7269 will live as long as it does. This is necessary for global
7270 aggregates which do not have their initializers processed until
7271 the end of the file. */
7272 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7277 DECL_INITIAL (decl
) = NULL_TREE
;
7280 /* Handle initialization of references.
7281 These three arguments are from `cp_finish_decl', and have the
7282 same meaning here that they do there.
7284 Quotes on semantics can be found in ARM 8.4.3. */
7287 grok_reference_init (decl
, type
, init
)
7288 tree decl
, type
, init
;
7292 if (init
== NULL_TREE
)
7294 if ((DECL_LANG_SPECIFIC (decl
) == 0
7295 || DECL_IN_AGGR_P (decl
) == 0)
7296 && ! DECL_THIS_EXTERN (decl
))
7297 cp_error ("`%D' declared as reference but not initialized", decl
);
7301 if (init
== error_mark_node
)
7304 if (TREE_CODE (init
) == CONSTRUCTOR
)
7306 cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl
);
7310 if (TREE_CODE (init
) == TREE_LIST
)
7311 init
= build_compound_expr (init
);
7313 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7314 init
= convert_from_reference (init
);
7316 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7317 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7319 /* Note: default conversion is only called in very special cases. */
7320 init
= default_conversion (init
);
7323 /* Convert INIT to the reference type TYPE. This may involve the
7324 creation of a temporary, whose lifetime must be the same as that
7325 of the reference. If so, a DECL_STMT for the temporary will be
7326 added just after the DECL_STMT for DECL. That's why we don't set
7327 DECL_INITIAL for local references (instead assigning to them
7328 explicitly); we need to allow the temporary to be initialized
7330 tmp
= convert_to_reference
7331 (type
, init
, CONV_IMPLICIT
,
7332 LOOKUP_ONLYCONVERTING
|LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
,
7335 if (tmp
== error_mark_node
)
7337 else if (tmp
!= NULL_TREE
)
7340 tmp
= save_expr (tmp
);
7341 if (building_stmt_tree ())
7343 /* Initialize the declaration. */
7344 tmp
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, tmp
);
7345 finish_expr_stmt (tmp
);
7348 DECL_INITIAL (decl
) = tmp
;
7352 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7356 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7358 expand_static_init (decl
, DECL_INITIAL (decl
));
7359 DECL_INITIAL (decl
) = NULL_TREE
;
7364 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7365 mucking with forces it does not comprehend (i.e. initialization with a
7366 constructor). If we are at global scope and won't go into COMMON, fill
7367 it in with a dummy CONSTRUCTOR to force the variable into .data;
7368 otherwise we can use error_mark_node. */
7371 obscure_complex_init (decl
, init
)
7374 if (! flag_no_inline
&& TREE_STATIC (decl
))
7376 if (extract_init (decl
, init
))
7380 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7381 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7382 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7386 DECL_INITIAL (decl
) = error_mark_node
;
7391 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7392 array until we finish parsing the initializer. If that's the
7393 situation we're in, update DECL accordingly. */
7396 maybe_deduce_size_from_array_init (decl
, init
)
7400 tree type
= TREE_TYPE (decl
);
7402 if (TREE_CODE (type
) == ARRAY_TYPE
7403 && TYPE_DOMAIN (type
) == NULL_TREE
7404 && TREE_CODE (decl
) != TYPE_DECL
)
7406 /* do_default is really a C-ism to deal with tentative definitions.
7407 But let's leave it here to ease the eventual merge. */
7408 int do_default
= !DECL_EXTERNAL (decl
);
7409 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7410 int failure
= complete_array_type (type
, initializer
, do_default
);
7413 cp_error ("initializer fails to determine size of `%D'", decl
);
7418 cp_error ("array size missing in `%D'", decl
);
7419 /* If a `static' var's size isn't known, make it extern as
7420 well as static, so it does not get allocated. If it's not
7421 `static', then don't mark it extern; finish_incomplete_decl
7422 will give it a default size and it will get allocated. */
7423 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7424 DECL_EXTERNAL (decl
) = 1;
7427 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7428 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7430 cp_error ("zero-size array `%D'", decl
);
7432 layout_decl (decl
, 0);
7436 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7437 any appropriate error messages regarding the layout. */
7440 layout_var_decl (decl
)
7443 tree type
= TREE_TYPE (decl
);
7445 tree ttype
= target_type (type
);
7448 /* If we haven't already layed out this declaration, do so now.
7449 Note that we must not call complete type for an external object
7450 because it's type might involve templates that we are not
7451 supposed to isntantiate yet. (And it's perfectly legal to say
7452 `extern X x' for some incomplete type `X'.) */
7453 if (!DECL_EXTERNAL (decl
))
7454 complete_type (type
);
7455 if (!DECL_SIZE (decl
) && COMPLETE_TYPE_P (type
))
7456 layout_decl (decl
, 0);
7458 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7460 /* An automatic variable with an incomplete type: that is an error.
7461 Don't talk about array types here, since we took care of that
7462 message in grokdeclarator. */
7463 cp_error ("storage size of `%D' isn't known", decl
);
7464 TREE_TYPE (decl
) = error_mark_node
;
7467 /* Keep this code around in case we later want to control debug info
7468 based on whether a type is "used". (jason 1999-11-11) */
7470 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7471 /* Let debugger know it should output info for this type. */
7472 note_debug_info_needed (ttype
);
7474 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7475 note_debug_info_needed (DECL_CONTEXT (decl
));
7478 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7479 && DECL_SIZE (decl
) != NULL_TREE
7480 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7482 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7483 constant_expression_warning (DECL_SIZE (decl
));
7485 cp_error ("storage size of `%D' isn't constant", decl
);
7489 /* If a local static variable is declared in an inline function, or if
7490 we have a weak definition, we must endeavor to create only one
7491 instance of the variable at link-time. */
7494 maybe_commonize_var (decl
)
7497 /* Static data in a function with comdat linkage also has comdat
7499 if (TREE_STATIC (decl
)
7500 /* Don't mess with __FUNCTION__. */
7501 && ! DECL_ARTIFICIAL (decl
)
7502 && current_function_decl
7503 && DECL_CONTEXT (decl
) == current_function_decl
7504 && (DECL_THIS_INLINE (current_function_decl
)
7505 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7506 && TREE_PUBLIC (current_function_decl
))
7508 /* Rather than try to get this right with inlining, we suppress
7509 inlining of such functions. */
7510 current_function_cannot_inline
7511 = "function with static variable cannot be inline";
7512 DECL_UNINLINABLE (current_function_decl
) = 1;
7514 /* If flag_weak, we don't need to mess with this, as we can just
7515 make the function weak, and let it refer to its unique local
7516 copy. This works because we don't allow the function to be
7520 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7522 TREE_PUBLIC (decl
) = 1;
7523 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7525 else if (DECL_INITIAL (decl
) == NULL_TREE
7526 || DECL_INITIAL (decl
) == error_mark_node
)
7528 TREE_PUBLIC (decl
) = 1;
7529 DECL_COMMON (decl
) = 1;
7531 /* else we lose. We can only do this if we can use common,
7532 which we can't if it has been initialized. */
7534 if (TREE_PUBLIC (decl
))
7535 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
7538 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7539 cp_warning_at (" you can work around this by removing the initializer", decl
);
7543 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7544 /* Set it up again; we might have set DECL_INITIAL since the last
7546 comdat_linkage (decl
);
7549 /* Issue an error message if DECL is an uninitialized const variable. */
7552 check_for_uninitialized_const_var (decl
)
7555 tree type
= TREE_TYPE (decl
);
7557 /* ``Unless explicitly declared extern, a const object does not have
7558 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7560 if (TREE_CODE (decl
) == VAR_DECL
7561 && TREE_CODE (type
) != REFERENCE_TYPE
7562 && CP_TYPE_CONST_P (type
)
7563 && !TYPE_NEEDS_CONSTRUCTING (type
)
7564 && !DECL_INITIAL (decl
))
7565 cp_error ("uninitialized const `%D'", decl
);
7568 /* Verify INIT (the initializer for DECL), and record the
7569 initialization in DECL_INITIAL, if appropriate. Returns a new
7573 check_initializer (decl
, init
)
7579 if (TREE_CODE (decl
) == FIELD_DECL
)
7582 type
= TREE_TYPE (decl
);
7584 /* If `start_decl' didn't like having an initialization, ignore it now. */
7585 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7588 /* Check the initializer. */
7591 /* Things that are going to be initialized need to have complete
7593 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
7595 if (type
== error_mark_node
)
7596 /* We will have already complained. */
7598 else if (COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7600 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7603 else if (TREE_CODE (type
) == ARRAY_TYPE
7604 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
7606 cp_error ("elements of array `%#D' have incomplete type", decl
);
7609 else if (!COMPLETE_TYPE_P (type
))
7611 cp_error ("`%D' has incomplete type", decl
);
7612 TREE_TYPE (decl
) = error_mark_node
;
7617 if (TREE_CODE (decl
) == CONST_DECL
)
7619 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7621 DECL_INITIAL (decl
) = init
;
7623 my_friendly_assert (init
!= NULL_TREE
, 149);
7626 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
7628 if (TREE_STATIC (decl
))
7629 make_decl_rtl (decl
, NULL_PTR
);
7630 grok_reference_init (decl
, type
, init
);
7635 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7637 if (TREE_CODE (type
) == ARRAY_TYPE
)
7638 init
= digest_init (type
, init
, (tree
*) 0);
7639 else if (TREE_CODE (init
) == CONSTRUCTOR
7640 && TREE_HAS_CONSTRUCTOR (init
))
7642 if (TYPE_NON_AGGREGATE_CLASS (type
))
7644 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7646 init
= error_mark_node
;
7649 goto dont_use_constructor
;
7654 dont_use_constructor
:
7655 if (TREE_CODE (init
) != TREE_VEC
)
7656 init
= store_init_value (decl
, init
);
7660 /* We must hide the initializer so that expand_decl
7661 won't try to do something it does not understand. */
7662 init
= obscure_complex_init (decl
, init
);
7664 else if (DECL_EXTERNAL (decl
))
7666 else if (TYPE_P (type
)
7667 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7669 tree core_type
= strip_array_types (type
);
7671 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7673 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7674 cp_error ("structure `%D' with uninitialized const members", decl
);
7675 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7676 cp_error ("structure `%D' with uninitialized reference members",
7680 check_for_uninitialized_const_var (decl
);
7682 if (COMPLETE_TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
7683 init
= obscure_complex_init (decl
, NULL_TREE
);
7687 check_for_uninitialized_const_var (decl
);
7692 /* If DECL is not a local variable, give it RTL. */
7695 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7698 const char *asmspec
;
7700 int toplev
= toplevel_bindings_p ();
7703 /* Handle non-variables up front. */
7704 if (TREE_CODE (decl
) != VAR_DECL
)
7706 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7710 /* If we see a class member here, it should be a static data
7712 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
7714 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7715 /* An in-class declaration of a static data member should be
7716 external; it is only a declaration, and not a definition. */
7717 if (init
== NULL_TREE
)
7718 my_friendly_assert (DECL_EXTERNAL (decl
), 20000723);
7721 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7723 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7725 /* We don't create any RTL for local variables. */
7726 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7729 /* We defer emission of local statics until the corresponding
7730 DECL_STMT is expanded. */
7731 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
7733 /* We try to defer namespace-scope static constants so that they are
7734 not emitted into the object file unncessarily. */
7735 if (!DECL_VIRTUAL_P (decl
)
7736 && TREE_READONLY (decl
)
7737 && DECL_INITIAL (decl
) != NULL_TREE
7738 && DECL_INITIAL (decl
) != error_mark_node
7739 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
7741 && !TREE_PUBLIC (decl
))
7743 /* Fool with the linkage according to #pragma interface. */
7744 if (!interface_unknown
)
7746 TREE_PUBLIC (decl
) = 1;
7747 DECL_EXTERNAL (decl
) = interface_only
;
7753 /* If we're deferring the variable, just make RTL. Do not actually
7754 emit the variable. */
7756 make_decl_rtl (decl
, asmspec
);
7757 /* If we're not deferring, go ahead and assemble the variable. */
7759 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7762 /* The old ARM scoping rules injected variables declared in the
7763 initialization statement of a for-statement into the surrounding
7764 scope. We support this usage, in order to be backward-compatible.
7765 DECL is a just-declared VAR_DECL; if necessary inject its
7766 declaration into the surrounding scope. */
7769 maybe_inject_for_scope_var (decl
)
7772 if (!DECL_NAME (decl
))
7775 if (current_binding_level
->is_for_scope
)
7777 struct binding_level
*outer
7778 = current_binding_level
->level_chain
;
7780 /* Check to see if the same name is already bound at the outer
7781 level, either because it was directly declared, or because a
7782 dead for-decl got preserved. In either case, the code would
7783 not have been valid under the ARM scope rules, so clear
7784 is_for_scope for the current_binding_level.
7786 Otherwise, we need to preserve the temp slot for decl to last
7787 into the outer binding level. */
7790 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7792 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7793 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7795 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7797 BINDING_VALUE (outer_binding
)
7798 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7799 current_binding_level
->is_for_scope
= 0;
7801 else if (DECL_IN_MEMORY_P (decl
))
7802 preserve_temp_slots (DECL_RTL (decl
));
7806 /* Generate code to initialize DECL (a local variable). */
7809 initialize_local_var (decl
, init
, flags
)
7814 tree type
= TREE_TYPE (decl
);
7816 /* If the type is bogus, don't bother initializing the variable. */
7817 if (type
== error_mark_node
)
7820 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
7822 /* If we used it already as memory, it must stay in memory. */
7823 DECL_INITIAL (decl
) = NULL_TREE
;
7824 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7827 /* Local statics are handled differently from ordinary automatic
7829 if (TREE_STATIC (decl
))
7831 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7832 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7833 expand_static_init (decl
, init
);
7837 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7841 /* Compute and store the initial value. */
7842 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7844 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7846 int saved_stmts_are_full_exprs_p
;
7848 my_friendly_assert (building_stmt_tree (), 20000906);
7849 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
7850 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
7851 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
7852 current_stmt_tree ()->stmts_are_full_exprs_p
=
7853 saved_stmts_are_full_exprs_p
;
7856 /* Set this to 0 so we can tell whether an aggregate which was
7857 initialized was ever used. Don't do this if it has a
7858 destructor, so we don't complain about the 'resource
7859 allocation is initialization' idiom. Now set
7860 attribute((unused)) on types so decls of that type will be
7861 marked used. (see TREE_USED, above.) */
7862 if (TYPE_NEEDS_CONSTRUCTING (type
)
7864 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
7865 && DECL_NAME (decl
))
7866 TREE_USED (decl
) = 0;
7867 else if (already_used
)
7868 TREE_USED (decl
) = 1;
7872 /* Generate code to destroy DECL (a local variable). */
7875 destroy_local_var (decl
)
7878 tree type
= TREE_TYPE (decl
);
7881 /* Only variables get cleaned up. */
7882 if (TREE_CODE (decl
) != VAR_DECL
)
7885 /* And only things with destructors need cleaning up. */
7886 if (type
== error_mark_node
7887 || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7890 if (TREE_CODE (decl
) == VAR_DECL
&&
7891 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
7892 /* We don't clean up things that aren't defined in this
7893 translation unit, or that need a static cleanup. The latter
7894 are handled by finish_file. */
7897 /* Compute the cleanup. */
7898 cleanup
= maybe_build_cleanup (decl
);
7900 /* Record the cleanup required for this declaration. */
7901 if (DECL_SIZE (decl
) && TREE_TYPE (decl
) != error_mark_node
7903 finish_decl_cleanup (decl
, cleanup
);
7906 /* Finish processing of a declaration;
7907 install its line number and initial value.
7908 If the length of an array type is not known before,
7909 it must be determined now, from the initial value, or it is an error.
7911 INIT holds the value of an initializer that should be allowed to escape
7914 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7915 if the (init) syntax was used. */
7918 cp_finish_decl (decl
, init
, asmspec_tree
, flags
)
7924 tree ttype
= NULL_TREE
;
7925 const char *asmspec
= NULL
;
7926 int was_readonly
= 0;
7931 error ("assignment (not initialization) in declaration");
7935 /* If a name was specified, get the string. */
7937 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
7939 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
7941 cp_error ("cannot initialize `%D' to namespace `%D'",
7946 if (current_class_type
7947 && CP_DECL_CONTEXT (decl
) == current_class_type
7948 && TYPE_BEING_DEFINED (current_class_type
)
7949 && (DECL_INITIAL (decl
) || init
))
7950 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
7952 if (TREE_CODE (decl
) == VAR_DECL
7953 && DECL_CONTEXT (decl
)
7954 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
7955 && DECL_CONTEXT (decl
) != current_namespace
7958 /* Leave the namespace of the object. */
7959 pop_decl_namespace ();
7962 type
= TREE_TYPE (decl
);
7964 if (type
== error_mark_node
)
7967 /* Add this declaration to the statement-tree. */
7968 if (building_stmt_tree ()
7969 && at_function_scope_p ()
7970 && TREE_CODE (decl
) != RESULT_DECL
)
7971 add_decl_stmt (decl
);
7973 if (TYPE_HAS_MUTABLE_P (type
))
7974 TREE_READONLY (decl
) = 0;
7976 if (processing_template_decl
)
7978 if (init
&& DECL_INITIAL (decl
))
7979 DECL_INITIAL (decl
) = init
;
7983 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7984 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
7986 /* Take care of TYPE_DECLs up front. */
7987 if (TREE_CODE (decl
) == TYPE_DECL
)
7989 if (init
&& DECL_INITIAL (decl
))
7991 /* typedef foo = bar; store the type of bar as the type of foo. */
7992 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
7993 DECL_INITIAL (decl
) = init
= NULL_TREE
;
7995 if (type
!= error_mark_node
7996 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
7998 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
7999 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
8000 set_identifier_type_value (DECL_NAME (decl
), type
);
8001 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
8003 GNU_xref_decl (current_function_decl
, decl
);
8005 /* If we have installed this as the canonical typedef for this
8006 type, and that type has not been defined yet, delay emitting
8007 the debug information for it, as we will emit it later. */
8008 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
8009 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
8010 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
8012 rest_of_decl_compilation (decl
, NULL_PTR
,
8013 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
8017 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8018 ttype
= target_type (type
);
8020 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
8021 && TYPE_NEEDS_CONSTRUCTING (type
))
8023 /* Currently, GNU C++ puts constants in text space, making them
8024 impossible to initialize. In the future, one would hope for
8025 an operating system which understood the difference between
8026 initialization and the running of a program. */
8028 TREE_READONLY (decl
) = 0;
8031 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
8033 /* This must override the asm specifier which was placed by
8034 grokclassfn. Lay this out fresh. */
8035 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
8036 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
8037 make_decl_rtl (decl
, asmspec
);
8040 /* Deduce size of array from initialization, if not already known. */
8041 maybe_deduce_size_from_array_init (decl
, init
);
8042 init
= check_initializer (decl
, init
);
8044 GNU_xref_decl (current_function_decl
, decl
);
8046 if (TREE_CODE (decl
) == VAR_DECL
)
8047 layout_var_decl (decl
);
8049 /* Output the assembler code and/or RTL code for variables and functions,
8050 unless the type is an undefined structure or union.
8051 If not, it will get done when the type is completed. */
8052 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
8053 || TREE_CODE (decl
) == RESULT_DECL
)
8055 if (TREE_CODE (decl
) == VAR_DECL
)
8056 maybe_commonize_var (decl
);
8058 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
8060 if (TREE_CODE (type
) == FUNCTION_TYPE
8061 || TREE_CODE (type
) == METHOD_TYPE
)
8062 abstract_virtuals_error (decl
,
8063 strip_array_types (TREE_TYPE (type
)));
8065 abstract_virtuals_error (decl
, strip_array_types (type
));
8067 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8069 else if (DECL_EXTERNAL (decl
)
8070 && ! (DECL_LANG_SPECIFIC (decl
)
8071 && DECL_NOT_REALLY_EXTERN (decl
)))
8074 DECL_INITIAL (decl
) = init
;
8076 else if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
8078 /* This is a local declaration. */
8079 if (doing_semantic_analysis_p ())
8080 maybe_inject_for_scope_var (decl
);
8081 /* Initialize the local variable. But, if we're building a
8082 statement-tree, we'll do the initialization when we
8084 if (processing_template_decl
)
8086 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
8087 DECL_INITIAL (decl
) = init
;
8091 /* If we're not building RTL, then we need to do so
8093 my_friendly_assert (building_stmt_tree (), 20000906);
8094 /* Initialize the variable. */
8095 initialize_local_var (decl
, init
, flags
);
8096 /* Clean up the variable. */
8097 destroy_local_var (decl
);
8100 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
8102 /* Cleanups for static variables are handled by `finish_file'. */
8103 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8104 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
8105 expand_static_init (decl
, init
);
8109 /* Undo call to `pushclass' that was done in `start_decl'
8110 due to initialization of qualified member variable.
8111 I.e., Foo::x = 10; */
8113 tree context
= CP_DECL_CONTEXT (decl
);
8116 && (TREE_CODE (decl
) == VAR_DECL
8117 /* We also have a pushclass done that we need to undo here
8118 if we're at top level and declare a method. */
8119 || TREE_CODE (decl
) == FUNCTION_DECL
)
8120 /* If size hasn't been set, we're still defining it,
8121 and therefore inside the class body; don't pop
8122 the binding level.. */
8123 && COMPLETE_TYPE_P (context
)
8124 && context
== current_class_type
)
8125 pop_nested_class ();
8132 TREE_READONLY (decl
) = 1;
8135 /* This is here for a midend callback from c-common.c */
8138 finish_decl (decl
, init
, asmspec_tree
)
8142 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
8145 /* Returns a declaration for a VAR_DECL as if:
8147 extern "C" TYPE NAME;
8149 had been seen. Used to create compiler-generated global
8153 declare_global_var (name
, type
)
8159 push_to_top_level ();
8160 decl
= build_decl (VAR_DECL
, name
, type
);
8161 TREE_PUBLIC (decl
) = 1;
8162 DECL_EXTERNAL (decl
) = 1;
8163 DECL_ARTIFICIAL (decl
) = 1;
8165 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
8166 pop_from_top_level ();
8171 /* Returns a pointer to the `atexit' function. Note that if
8172 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8173 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8187 if (flag_use_cxa_atexit
)
8189 /* The declaration for `__cxa_atexit' is:
8191 int __cxa_atexit (void (*)(void *), void *, void *)
8193 We build up the argument types and then then function type
8196 /* First, build the pointer-to-function type for the first
8198 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8199 fn_type
= build_function_type (void_type_node
, arg_types
);
8200 fn_ptr_type
= build_pointer_type (fn_type
);
8201 /* Then, build the rest of the argument types. */
8202 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8203 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
8204 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
8205 /* And the final __cxa_atexit type. */
8206 fn_type
= build_function_type (integer_type_node
, arg_types
);
8207 fn_ptr_type
= build_pointer_type (fn_type
);
8208 name
= "__cxa_atexit";
8212 /* The declaration for `atexit' is:
8214 int atexit (void (*)());
8216 We build up the argument types and then then function type
8218 fn_type
= build_function_type (void_type_node
, void_list_node
);
8219 fn_ptr_type
= build_pointer_type (fn_type
);
8220 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
8221 /* Build the final atexit type. */
8222 fn_type
= build_function_type (integer_type_node
, arg_types
);
8226 /* Now, build the function declaration. */
8227 push_lang_context (lang_name_c
);
8228 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
8229 mark_used (atexit_fndecl
);
8230 pop_lang_context ();
8231 atexit_node
= default_conversion (atexit_fndecl
);
8236 /* Returns the __dso_handle VAR_DECL. */
8239 get_dso_handle_node ()
8241 if (dso_handle_node
)
8242 return dso_handle_node
;
8244 /* Declare the variable. */
8245 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8248 return dso_handle_node
;
8251 /* Begin a new function with internal linkage whose job will be simply
8252 to destroy some particular variable. */
8257 static int counter
= 0;
8258 int old_interface_unknown
= interface_unknown
;
8264 push_to_top_level ();
8266 /* No need to mangle this. */
8267 push_lang_context (lang_name_c
);
8269 interface_unknown
= 1;
8271 /* Build the parameter-types. */
8272 parmtypes
= void_list_node
;
8273 /* Functions passed to __cxa_atexit take an additional parameter.
8274 We'll just ignore it. After we implement the new calling
8275 convention for destructors, we can eliminate the use of
8276 additional cleanup functions entirely in the -fnew-abi case. */
8277 if (flag_use_cxa_atexit
)
8278 parmtypes
= tree_cons (NULL_TREE
, ptr_type_node
, parmtypes
);
8279 /* Build the function type itself. */
8280 fntype
= build_function_type (void_type_node
, parmtypes
);
8281 /* Build the name of the function. */
8282 sprintf (name
, "__tcf_%d", counter
++);
8283 /* Build the function declaration. */
8284 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8285 /* It's a function with internal linkage, generated by the
8287 TREE_PUBLIC (fndecl
) = 0;
8288 DECL_ARTIFICIAL (fndecl
) = 1;
8289 /* Make the function `inline' so that it is only emitted if it is
8290 actually needed. It is unlikely that it will be inlined, since
8291 it is only called via a function pointer, but we avoid unncessary
8292 emissions this way. */
8293 DECL_INLINE (fndecl
) = 1;
8294 /* Build the parameter. */
8295 if (flag_use_cxa_atexit
)
8299 parmdecl
= build_decl (PARM_DECL
, NULL_TREE
, ptr_type_node
);
8300 DECL_CONTEXT (parmdecl
) = fndecl
;
8301 DECL_ARG_TYPE (parmdecl
) = ptr_type_node
;
8302 TREE_USED (parmdecl
) = 1;
8303 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8307 start_function (/*specs=*/NULL_TREE
, fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8310 interface_unknown
= old_interface_unknown
;
8312 pop_lang_context ();
8314 return current_function_decl
;
8317 /* Finish the cleanup function begun by start_cleanup_fn. */
8324 expand_body (finish_function (0));
8326 pop_from_top_level ();
8329 /* Generate code to handle the destruction of DECL, an object with
8330 static storage duration. */
8333 register_dtor_fn (decl
)
8341 int saved_flag_access_control
;
8343 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8346 /* Call build_cleanup before we enter the anonymous function so that
8347 any access checks will be done relative to the current scope,
8348 rather than the scope of the anonymous function. */
8349 build_cleanup (decl
);
8351 /* Now start the function. */
8352 cleanup
= start_cleanup_fn ();
8354 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8355 to the original function, rather than the anonymous one. That
8356 will make the back-end think that nested functions are in use,
8357 which causes confusion. */
8358 saved_flag_access_control
= flag_access_control
;
8359 flag_access_control
= 0;
8360 fcall
= build_cleanup (decl
);
8361 flag_access_control
= saved_flag_access_control
;
8363 /* Create the body of the anonymous function. */
8364 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
8365 finish_expr_stmt (fcall
);
8366 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
8369 /* Call atexit with the cleanup function. */
8370 mark_addressable (cleanup
);
8371 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8372 if (flag_use_cxa_atexit
)
8374 args
= tree_cons (NULL_TREE
, get_dso_handle_node (), NULL_TREE
);
8375 args
= tree_cons (NULL_TREE
, null_pointer_node
, args
);
8376 args
= tree_cons (NULL_TREE
, cleanup
, args
);
8379 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
8380 finish_expr_stmt (build_function_call (get_atexit_node (), args
));
8384 expand_static_init (decl
, init
)
8388 tree oldstatic
= value_member (decl
, static_aggregates
);
8392 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8393 cp_error ("multiple initializations given for `%D'", decl
);
8395 else if (! toplevel_bindings_p ())
8397 /* Emit code to perform this initialization but once. */
8404 /* Emit code to perform this initialization but once. This code
8407 static int guard = 0;
8409 // Do initialization.
8411 // Register variable for destruction at end of program.
8414 Note that the `temp' variable is only set to 1 *after* the
8415 initialization is complete. This ensures that an exception,
8416 thrown during the construction, will cause the variable to
8417 reinitialized when we pass through this code again, as per:
8421 If the initialization exits by throwing an exception, the
8422 initialization is not complete, so it will be tried again
8423 the next time control enters the declaration.
8425 In theory, this process should be thread-safe, too; multiple
8426 threads should not be able to initialize the variable more
8427 than once. We don't yet attempt to ensure thread-safety. */
8429 /* Create the guard variable. */
8430 guard
= get_guard (decl
);
8432 /* Begin the conditional initialization. */
8433 if_stmt
= begin_if_stmt ();
8434 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
8435 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
8437 /* Do the initialization itself. */
8438 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8439 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8440 assignment
= build_aggr_init (decl
, init
, 0);
8442 /* The initialization we're doing here is just a bitwise
8444 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
8446 assignment
= NULL_TREE
;
8448 /* Once the assignment is complete, set TEMP to 1. Since the
8449 construction of the static object is complete at this point,
8450 we want to make sure TEMP is set to 1 even if a temporary
8451 constructed during the initialization throws an exception
8452 when it is destroyed. So, we combine the initialization and
8453 the assignment to TEMP into a single expression, ensuring
8454 that when we call finish_expr_stmt the cleanups will not be
8455 run until after TEMP is set to 1. */
8456 guard_init
= set_guard (guard
);
8459 assignment
= tree_cons (NULL_TREE
, assignment
,
8460 build_tree_list (NULL_TREE
,
8462 assignment
= build_compound_expr (assignment
);
8465 assignment
= guard_init
;
8466 finish_expr_stmt (assignment
);
8468 /* Use atexit to register a function for destroying this static
8470 register_dtor_fn (decl
);
8472 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
8473 finish_then_clause (if_stmt
);
8477 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8480 /* Finish the declaration of a catch-parameter. */
8483 start_handler_parms (declspecs
, declarator
)
8490 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8492 if (decl
== NULL_TREE
)
8493 error ("invalid catch parameter");
8502 /* Make TYPE a complete type based on INITIAL_VALUE.
8503 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8504 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8507 complete_array_type (type
, initial_value
, do_default
)
8508 tree type
, initial_value
;
8511 register tree maxindex
= NULL_TREE
;
8516 /* An array of character type can be initialized from a
8517 brace-enclosed string constant. */
8518 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
8519 && TREE_CODE (initial_value
) == CONSTRUCTOR
8520 && CONSTRUCTOR_ELTS (initial_value
)
8521 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
)))
8523 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value
)) == NULL_TREE
)
8524 initial_value
= TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
));
8526 /* Note MAXINDEX is really the maximum index, one less than the
8528 if (TREE_CODE (initial_value
) == STRING_CST
)
8531 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8532 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8535 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8537 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8539 maxindex
= ssize_int (-1);
8540 for (; elts
; elts
= TREE_CHAIN (elts
))
8542 if (TREE_PURPOSE (elts
))
8543 maxindex
= TREE_PURPOSE (elts
);
8545 maxindex
= size_binop (PLUS_EXPR
, maxindex
, ssize_int (1));
8547 maxindex
= copy_node (maxindex
);
8551 /* Make an error message unless that happened already. */
8552 if (initial_value
!= error_mark_node
)
8555 initial_value
= NULL_TREE
;
8557 /* Prevent further error messages. */
8558 maxindex
= build_int_2 (0, 0);
8565 maxindex
= build_int_2 (0, 0);
8574 domain
= build_index_type (maxindex
);
8575 TYPE_DOMAIN (type
) = domain
;
8577 if (! TREE_TYPE (maxindex
))
8578 TREE_TYPE (maxindex
) = domain
;
8580 itype
= TREE_TYPE (initial_value
);
8583 if (itype
&& !TYPE_DOMAIN (itype
))
8584 TYPE_DOMAIN (itype
) = domain
;
8585 /* The type of the main variant should never be used for arrays
8586 of different sizes. It should only ever be completed with the
8587 size of the array. */
8588 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8589 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8592 /* Lay out the type now that we can get the real answer. */
8599 /* Return zero if something is declared to be a member of type
8600 CTYPE when in the context of CUR_TYPE. STRING is the error
8601 message to print in that case. Otherwise, quietly return 1. */
8604 member_function_or_else (ctype
, cur_type
, flags
)
8605 tree ctype
, cur_type
;
8606 enum overload_flags flags
;
8608 if (ctype
&& ctype
!= cur_type
)
8610 if (flags
== DTOR_FLAG
)
8611 cp_error ("destructor for alien class `%T' cannot be a member",
8614 cp_error ("constructor for alien class `%T' cannot be a member",
8621 /* Subroutine of `grokdeclarator'. */
8623 /* Generate errors possibly applicable for a given set of specifiers.
8624 This is for ARM $7.1.2. */
8627 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8630 int virtualp
, quals
, friendp
, raises
, inlinep
;
8633 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8635 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8637 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8640 cp_error_at ("`%D' declared as a friend", object
);
8641 if (raises
&& !TYPE_PTRFN_P (TREE_TYPE (object
))
8642 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))
8643 cp_error_at ("`%D' declared with an exception specification", object
);
8646 /* CTYPE is class type, or null if non-class.
8647 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8649 DECLARATOR is the function's name.
8650 VIRTUALP is truthvalue of whether the function is virtual or not.
8651 FLAGS are to be passed through to `grokclassfn'.
8652 QUALS are qualifiers indicating whether the function is `const'
8654 RAISES is a list of exceptions that this function can raise.
8655 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8656 not look, and -1 if we should not call `grokclassfn' at all.
8658 Returns `NULL_TREE' if something goes wrong, after issuing
8659 applicable error messages. */
8662 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8663 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8664 template_count
, in_namespace
)
8667 tree orig_declarator
;
8669 enum overload_flags flags
;
8671 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8675 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8676 int has_default_arg
= 0;
8680 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8681 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8687 type
= build_exception_variant (type
, raises
);
8690 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8691 /* Propagate volatile out from type to decl. */
8692 if (TYPE_VOLATILE (type
))
8693 TREE_THIS_VOLATILE (decl
) = 1;
8695 /* If this decl has namespace scope, set that up. */
8697 set_decl_namespace (decl
, in_namespace
, friendp
);
8699 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8701 /* `main' and builtins have implicit 'C' linkage. */
8702 if ((MAIN_NAME_P (declarator
)
8703 || (IDENTIFIER_LENGTH (declarator
) > 10
8704 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8705 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8706 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8707 && current_lang_name
== lang_name_cplusplus
8708 && ctype
== NULL_TREE
8709 /* NULL_TREE means global namespace. */
8710 && DECL_CONTEXT (decl
) == NULL_TREE
)
8711 DECL_LANGUAGE (decl
) = lang_c
;
8713 /* Should probably propagate const out from type to decl I bet (mrs). */
8716 DECL_STATIC_FUNCTION_P (decl
) = 1;
8717 DECL_CONTEXT (decl
) = ctype
;
8721 DECL_CONTEXT (decl
) = ctype
;
8723 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8725 if (processing_template_decl
)
8726 error ("cannot declare `::main' to be a template");
8728 error ("cannot declare `::main' to be inline");
8730 error ("cannot declare `::main' to be static");
8731 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8733 error ("`main' must return `int'");
8738 /* Members of anonymous types and local classes have no linkage; make
8740 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8741 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8746 /* [basic.link]: A name with no linkage (notably, the name of a class
8747 or enumeration declared in a local scope) shall not be used to
8748 declare an entity with linkage.
8750 Only check this for public decls for now. */
8751 t
= no_linkage_check (TREE_TYPE (decl
));
8754 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8756 if (DECL_EXTERN_C_P (decl
))
8757 /* Allow this; it's pretty common in C. */;
8759 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8763 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8768 TREE_PUBLIC (decl
) = publicp
;
8771 DECL_INTERFACE_KNOWN (decl
) = 1;
8772 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8776 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8778 DECL_EXTERNAL (decl
) = 1;
8779 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8781 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8782 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8786 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8787 grok_op_properties (decl
, virtualp
, check
< 0);
8789 if (ctype
&& decl_function_context (decl
))
8790 DECL_NO_STATIC_CHAIN (decl
) = 1;
8792 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8793 if (TREE_PURPOSE (t
)
8794 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8796 has_default_arg
= 1;
8801 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8805 ("defining explicit specialization `%D' in friend declaration",
8809 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8810 tree args
= TREE_OPERAND (orig_declarator
, 1);
8812 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8814 /* Something like `template <class T> friend void f<T>()'. */
8815 cp_error ("invalid use of template-id `%D' in declaration of primary template",
8821 /* A friend declaration of the form friend void f<>(). Record
8822 the information in the TEMPLATE_ID_EXPR. */
8823 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8825 if (TREE_CODE (fns
) == COMPONENT_REF
)
8827 /* Due to bison parser ickiness, we will have already looked
8828 up an operator_name or PFUNCNAME within the current class
8829 (see template_id in parse.y). If the current class contains
8830 such a name, we'll get a COMPONENT_REF here. Undo that. */
8832 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
8833 == current_class_type
, 20001120);
8834 fns
= TREE_OPERAND (fns
, 1);
8836 my_friendly_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
8837 || TREE_CODE (fns
) == LOOKUP_EXPR
8838 || TREE_CODE (fns
) == OVERLOAD
, 20001120);
8839 DECL_TEMPLATE_INFO (decl
) = tree_cons (fns
, args
, NULL_TREE
);
8841 if (has_default_arg
)
8843 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8850 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8857 if (has_default_arg
)
8858 add_defarg_fn (decl
);
8860 /* Plain overloading: will not be grok'd by grokclassfn. */
8861 if (! ctype
&& ! processing_template_decl
8862 && (! DECL_EXTERN_C_P (decl
) || DECL_OVERLOADED_OPERATOR_P (decl
))
8863 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8864 set_mangled_name_for_decl (decl
);
8867 /* Make the init_value nonzero so pushdecl knows this is not
8868 tentative. error_mark_node is replaced later with the BLOCK. */
8869 DECL_INITIAL (decl
) = error_mark_node
;
8871 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8872 TREE_NOTHROW (decl
) = 1;
8874 /* Caller will do the rest of this. */
8878 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8879 DECL_CONSTRUCTOR_P (decl
) = 1;
8881 /* Function gets the ugly name, field gets the nice one. This call
8882 may change the type of the function (because of default
8884 if (ctype
!= NULL_TREE
)
8885 grokclassfn (ctype
, decl
, flags
, quals
);
8887 decl
= check_explicit_specialization (orig_declarator
, decl
,
8889 2 * (funcdef_flag
!= 0) +
8890 4 * (friendp
!= 0));
8891 if (decl
== error_mark_node
)
8894 if (ctype
!= NULL_TREE
8895 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8900 old_decl
= check_classfn (ctype
, decl
);
8902 if (old_decl
&& TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8903 /* Because grokfndecl is always supposed to return a
8904 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8905 here. We depend on our callers to figure out that its
8906 really a template that's being returned. */
8907 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8909 if (old_decl
&& DECL_STATIC_FUNCTION_P (old_decl
)
8910 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8912 /* Remove the `this' parm added by grokclassfn.
8913 XXX Isn't this done in start_function, too? */
8914 revert_static_member_fn (decl
);
8915 last_function_parms
= TREE_CHAIN (last_function_parms
);
8917 if (old_decl
&& DECL_ARTIFICIAL (old_decl
))
8918 cp_error ("definition of implicitly-declared `%D'", old_decl
);
8922 /* Since we've smashed OLD_DECL to its
8923 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8924 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8925 decl
= DECL_TEMPLATE_RESULT (decl
);
8927 /* Attempt to merge the declarations. This can fail, in
8928 the case of some illegal specialization declarations. */
8929 if (!duplicate_decls (decl
, old_decl
))
8930 cp_error ("no `%#D' member function declared in class `%T'",
8936 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8939 if (ctype
== NULL_TREE
|| check
)
8943 DECL_VIRTUAL_P (decl
) = 1;
8949 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
8952 RID_BIT_TYPE
*specbits_in
;
8958 RID_BIT_TYPE specbits
;
8960 specbits
= *specbits_in
;
8962 if (TREE_CODE (type
) == OFFSET_TYPE
)
8964 /* If you declare a static member so that it
8965 can be initialized, the code will reach here. */
8966 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
8967 type
= TREE_TYPE (type
);
8968 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
8969 DECL_CONTEXT (decl
) = basetype
;
8970 /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
8972 if (!uses_template_parms (decl
))
8973 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
8980 context
= in_namespace
;
8981 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
8982 context
= current_namespace
;
8984 context
= NULL_TREE
;
8986 if (processing_template_decl
&& context
)
8987 /* For global variables, declared in a template, we need the
8989 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
8991 decl
= build_decl (VAR_DECL
, declarator
, type
);
8994 set_decl_namespace (decl
, context
, 0);
8996 context
= DECL_CONTEXT (decl
);
8997 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
8998 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9002 set_decl_namespace (decl
, in_namespace
, 0);
9004 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
9006 DECL_THIS_EXTERN (decl
) = 1;
9007 DECL_EXTERNAL (decl
) = !initialized
;
9010 /* In class context, static means one per class,
9011 public access, and static storage. */
9012 if (DECL_CLASS_SCOPE_P (decl
))
9014 TREE_PUBLIC (decl
) = 1;
9015 TREE_STATIC (decl
) = 1;
9016 DECL_EXTERNAL (decl
) = 0;
9018 /* At top level, either `static' or no s.c. makes a definition
9019 (perhaps tentative), and absence of `static' makes it public. */
9020 else if (toplevel_bindings_p ())
9022 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
9023 && (DECL_THIS_EXTERN (decl
) || ! constp
));
9024 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9026 /* Not at top level, only `static' makes a static definition. */
9029 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
9030 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9033 if (TREE_PUBLIC (decl
))
9035 /* [basic.link]: A name with no linkage (notably, the name of a class
9036 or enumeration declared in a local scope) shall not be used to
9037 declare an entity with linkage.
9039 Only check this for public decls for now. */
9040 tree t
= no_linkage_check (TREE_TYPE (decl
));
9043 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
9044 /* Ignore for now; `enum { foo } e' is pretty common. */;
9046 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9054 /* Create and return a canonical pointer to member function type, for
9055 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9058 build_ptrmemfunc_type (type
)
9063 tree unqualified_variant
= NULL_TREE
;
9065 if (type
== error_mark_node
)
9068 /* If a canonical type already exists for this type, use it. We use
9069 this method instead of type_hash_canon, because it only does a
9070 simple equality check on the list of field members. */
9072 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
9075 /* Make sure that we always have the unqualified pointer-to-member
9077 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9079 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9081 t
= make_aggr_type (RECORD_TYPE
);
9082 /* Let the front-end know this is a pointer to member function... */
9083 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9084 /* ... and not really an aggregate. */
9085 SET_IS_AGGR_TYPE (t
, 0);
9087 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9088 fields
[1] = build_decl (FIELD_DECL
, delta_identifier
,
9090 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9092 /* Zap out the name so that the back-end will give us the debugging
9093 information for this anonymous RECORD_TYPE. */
9094 TYPE_NAME (t
) = NULL_TREE
;
9096 /* If this is not the unqualified form of this pointer-to-member
9097 type, set the TYPE_MAIN_VARIANT for this type to be the
9098 unqualified type. Since they are actually RECORD_TYPEs that are
9099 not variants of each other, we must do this manually. */
9100 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9102 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
9103 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
9104 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
9105 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
9108 /* Cache this pointer-to-member type so that we can find it again
9110 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
9112 /* Seems to be wanted. */
9113 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
9118 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9119 Check to see that the definition is valid. Issue appropriate error
9120 messages. Return 1 if the definition is particularly bad, or 0
9124 check_static_variable_definition (decl
, type
)
9128 /* Motion 10 at San Diego: If a static const integral data member is
9129 initialized with an integral constant expression, the initializer
9130 may appear either in the declaration (within the class), or in
9131 the definition, but not both. If it appears in the class, the
9132 member is a member constant. The file-scope definition is always
9134 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
9136 cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9138 /* If we just return the declaration, crashes will sometimes
9139 occur. We therefore return void_type_node, as if this was a
9140 friend declaration, to cause callers to completely ignore
9141 this declaration. */
9144 else if (!CP_TYPE_CONST_P (type
))
9145 cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9147 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
9148 cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
9153 /* Given the SIZE (i.e., number of elements) in an array, compute an
9154 appropriate index type for the array. If non-NULL, NAME is the
9155 name of the thing being declared. */
9158 compute_array_index_type (name
, size
)
9164 /* The size might be the result of a cast. */
9165 STRIP_TYPE_NOPS (size
);
9167 /* It might be a const variable or enumeration constant. */
9168 size
= decl_constant_value (size
);
9170 /* If this involves a template parameter, it will be a constant at
9171 instantiation time, but we don't know what the value is yet.
9172 Even if no template parameters are involved, we may an expression
9173 that is not a constant; we don't even simplify `1 + 2' when
9174 processing a template. */
9175 if (processing_template_decl
)
9177 /* Resolve a qualified reference to an enumerator or static
9178 const data member of ours. */
9179 if (TREE_CODE (size
) == SCOPE_REF
9180 && TREE_OPERAND (size
, 0) == current_class_type
)
9182 tree t
= lookup_field (current_class_type
,
9183 TREE_OPERAND (size
, 1), 0, 0);
9188 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
9189 size
, integer_one_node
));
9192 /* The array bound must be an integer type. */
9193 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9194 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
9195 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
9198 cp_error ("size of array `%D' has non-integer type", name
);
9200 cp_error ("size of array has non-integer type");
9201 size
= integer_one_node
;
9204 /* Normally, the array-bound will be a constant. */
9205 if (TREE_CODE (size
) == INTEGER_CST
)
9207 /* Check to see if the array bound overflowed. Make that an
9208 error, no matter how generous we're being. */
9209 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9210 int old_pedantic
= pedantic
;
9211 pedantic
= flag_pedantic_errors
= 1;
9212 constant_expression_warning (size
);
9213 pedantic
= old_pedantic
;
9214 flag_pedantic_errors
= old_flag_pedantic_errors
;
9216 /* An array must have a positive number of elements. */
9217 if (INT_CST_LT (size
, integer_zero_node
))
9220 cp_error ("size of array `%D' is negative", name
);
9222 cp_error ("size of array is negative");
9223 size
= integer_one_node
;
9225 /* Except that an extension we allow zero-sized arrays. We
9226 always allow them in system headers because glibc uses
9228 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
9231 cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name
);
9233 cp_pedwarn ("ISO C++ forbids zero-size array");
9236 else if (TREE_CONSTANT (size
))
9238 /* `(int) &fn' is not a valid array bound. */
9240 cp_error ("size of array `%D' is not an integral constant-expression",
9243 cp_error ("size of array is not an integral constant-expression");
9246 /* Compute the index of the largest element in the array. It is
9247 one less than the number of elements in the array. */
9249 = fold (cp_build_binary_op (MINUS_EXPR
,
9250 cp_convert (ssizetype
, size
),
9251 cp_convert (ssizetype
,
9252 integer_one_node
)));
9254 /* Check for variable-sized arrays. We allow such things as an
9255 extension, even though they are not allowed in ANSI/ISO C++. */
9256 if (!TREE_CONSTANT (itype
))
9261 cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9264 cp_pedwarn ("ISO C++ forbids variable-size array");
9267 /* Create a variable-sized array index type. */
9268 itype
= variable_size (itype
);
9270 /* Make sure that there was no overflow when creating to a signed
9271 index type. (For example, on a 32-bit machine, an array with
9272 size 2^32 - 1 is too big.) */
9273 else if (TREE_OVERFLOW (itype
))
9275 error ("overflow in array dimension");
9276 TREE_OVERFLOW (itype
) = 0;
9279 /* Create and return the appropriate index type. */
9280 return build_index_type (itype
);
9283 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9284 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9288 create_array_type_for_decl (name
, type
, size
)
9293 tree itype
= NULL_TREE
;
9294 const char* error_msg
;
9296 /* If things have already gone awry, bail now. */
9297 if (type
== error_mark_node
|| size
== error_mark_node
)
9298 return error_mark_node
;
9300 /* Assume that everything will go OK. */
9303 /* There are some types which cannot be array elements. */
9304 switch (TREE_CODE (type
))
9307 error_msg
= "array of void";
9311 error_msg
= "array of functions";
9314 case REFERENCE_TYPE
:
9315 error_msg
= "array of references";
9319 error_msg
= "array of data members";
9323 error_msg
= "array of function members";
9330 /* If something went wrong, issue an error-message and return. */
9334 cp_error ("declaration of `%D' as %s", name
, error_msg
);
9336 cp_error ("creating %s", error_msg
);
9338 return error_mark_node
;
9343 The constant expressions that specify the bounds of the arrays
9344 can be omitted only for the first member of the sequence. */
9345 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9347 cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9350 return error_mark_node
;
9353 /* Figure out the index type for the array. */
9355 itype
= compute_array_index_type (name
, size
);
9357 return build_cplus_array_type (type
, itype
);
9360 /* Check that it's OK to declare a function with the indicated TYPE.
9361 SFK indicates the kind of special function (if any) that this
9362 function is. OPTYPE is the type given in a conversion operator
9363 declaration. Returns the actual return type of the function; that
9364 may be different than TYPE if an error occurs, or for certain
9365 special functions. */
9368 check_special_function_return_type (sfk
, type
, optype
)
9369 special_function_kind sfk
;
9375 case sfk_constructor
:
9377 cp_error ("return type specification for constructor invalid");
9379 /* In the new ABI constructors do not return a value. */
9380 type
= void_type_node
;
9383 case sfk_destructor
:
9385 cp_error ("return type specification for destructor invalid");
9386 type
= void_type_node
;
9389 case sfk_conversion
:
9390 if (type
&& !same_type_p (type
, optype
))
9391 cp_error ("operator `%T' declared to return `%T'", optype
, type
);
9393 cp_pedwarn ("return type specified for `operator %T'", optype
);
9398 my_friendly_abort (20000408);
9405 /* Given declspecs and a declarator,
9406 determine the name and type of the object declared
9407 and construct a ..._DECL node for it.
9408 (In one case we can return a ..._TYPE node instead.
9409 For invalid input we sometimes return 0.)
9411 DECLSPECS is a chain of tree_list nodes whose value fields
9412 are the storage classes and type specifiers.
9414 DECL_CONTEXT says which syntactic context this declaration is in:
9415 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9416 FUNCDEF for a function definition. Like NORMAL but a few different
9417 error messages in each case. Return value may be zero meaning
9418 this definition is too screwy to try to parse.
9419 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9420 handle member functions (which have FIELD context).
9421 Return value may be zero meaning this definition is too screwy to
9423 PARM for a parameter declaration (either within a function prototype
9424 or before a function body). Make a PARM_DECL, or return void_type_node.
9425 CATCHPARM for a parameter declaration before a catch clause.
9426 TYPENAME if for a typename (in a cast or sizeof).
9427 Don't make a DECL node; just return the ..._TYPE node.
9428 FIELD for a struct or union field; make a FIELD_DECL.
9429 BITFIELD for a field with specified width.
9430 INITIALIZED is 1 if the decl has an initializer.
9432 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9433 normal attributes in TREE_PURPOSE, or NULL_TREE.
9435 In the TYPENAME case, DECLARATOR is really an abstract declarator.
9436 It may also be so in the PARM case, for a prototype where the
9437 argument type is specified but not the name.
9439 This function is where the complicated C meanings of `static'
9440 and `extern' are interpreted.
9442 For C++, if there is any monkey business to do, the function which
9443 calls this one must do it, i.e., prepending instance variables,
9444 renaming overloaded function names, etc.
9446 Note that for this C++, it is an error to define a method within a class
9447 which does not belong to that class.
9449 Except in the case where SCOPE_REFs are implicitly known (such as
9450 methods within a class being redundantly qualified),
9451 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9452 (class_name::decl_name). The caller must also deal with this.
9454 If a constructor or destructor is seen, and the context is FIELD,
9455 then the type gains the attribute TREE_HAS_x. If such a declaration
9456 is erroneous, NULL_TREE is returned.
9458 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9459 function, these are the qualifiers to give to the `this' pointer. We
9460 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9462 May return void_type_node if the declarator turned out to be a friend.
9463 See grokfield for details. */
9466 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
9469 enum decl_context decl_context
;
9473 RID_BIT_TYPE specbits
;
9476 tree type
= NULL_TREE
;
9482 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9483 int explicit_int
= 0;
9484 int explicit_char
= 0;
9485 int defaulted_int
= 0;
9486 tree typedef_decl
= NULL_TREE
;
9488 tree typedef_type
= NULL_TREE
;
9489 int funcdef_flag
= 0;
9490 enum tree_code innermost_code
= ERROR_MARK
;
9493 /* See the code below that used this. */
9494 tree decl_machine_attr
= NULL_TREE
;
9496 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9497 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9498 tree init
= NULL_TREE
;
9500 /* Keep track of what sort of function is being processed
9501 so that we can warn about default return values, or explicit
9502 return values which do not match prescribed defaults. */
9503 special_function_kind sfk
= sfk_none
;
9505 tree dname
= NULL_TREE
;
9506 tree ctype
= current_class_type
;
9507 tree ctor_return_type
= NULL_TREE
;
9508 enum overload_flags flags
= NO_SPECIAL
;
9509 tree quals
= NULL_TREE
;
9510 tree raises
= NULL_TREE
;
9511 int template_count
= 0;
9512 tree in_namespace
= NULL_TREE
;
9516 RIDBIT_RESET_ALL (specbits
);
9517 if (decl_context
== FUNCDEF
)
9518 funcdef_flag
= 1, decl_context
= NORMAL
;
9519 else if (decl_context
== MEMFUNCDEF
)
9520 funcdef_flag
= -1, decl_context
= FIELD
;
9521 else if (decl_context
== BITFIELD
)
9522 bitfield
= 1, decl_context
= FIELD
;
9524 /* Look inside a declarator for the name being declared
9525 and get it as a string, for an error message. */
9527 tree
*next
= &declarator
;
9531 while (next
&& *next
)
9534 switch (TREE_CODE (decl
))
9537 /* For attributes. */
9538 next
= &TREE_VALUE (decl
);
9543 next
= &TREE_OPERAND (decl
, 0);
9546 case BIT_NOT_EXPR
: /* For C++ destructors! */
9548 tree name
= TREE_OPERAND (decl
, 0);
9549 tree rename
= NULL_TREE
;
9551 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9553 sfk
= sfk_destructor
;
9554 if (TREE_CODE (name
) == TYPE_DECL
)
9555 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9556 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9557 if (ctype
== NULL_TREE
)
9559 if (current_class_type
== NULL_TREE
)
9561 error ("destructors must be member functions");
9566 tree t
= constructor_name (current_class_name
);
9573 tree t
= constructor_name (ctype
);
9580 cp_error ("destructor `%T' must match class name `%T'",
9582 TREE_OPERAND (decl
, 0) = rename
;
9588 case ADDR_EXPR
: /* C++ reference declaration */
9593 innermost_code
= TREE_CODE (decl
);
9594 next
= &TREE_OPERAND (decl
, 0);
9598 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9600 /* This is actually a variable declaration using
9601 constructor syntax. We need to call start_decl and
9602 cp_finish_decl so we can get the variable
9605 tree attributes
, prefix_attributes
;
9607 *next
= TREE_OPERAND (decl
, 0);
9608 init
= CALL_DECLARATOR_PARMS (decl
);
9612 attributes
= TREE_PURPOSE (attrlist
);
9613 prefix_attributes
= TREE_VALUE (attrlist
);
9617 attributes
= NULL_TREE
;
9618 prefix_attributes
= NULL_TREE
;
9621 decl
= start_decl (declarator
, declspecs
, 1,
9622 attributes
, prefix_attributes
);
9623 decl_type_access_control (decl
);
9626 /* Look for __unused__ attribute */
9627 if (TREE_USED (TREE_TYPE (decl
)))
9628 TREE_USED (decl
) = 1;
9629 finish_decl (decl
, init
, NULL_TREE
);
9632 cp_error ("invalid declarator");
9635 innermost_code
= TREE_CODE (decl
);
9636 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9637 ctype
= current_class_type
;
9639 && TREE_OPERAND (decl
, 0)
9640 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9641 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9642 == constructor_name_full (ctype
))
9643 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9644 == constructor_name (ctype
)))))
9645 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9646 next
= &TREE_OPERAND (decl
, 0);
9648 if (ctype
!= NULL_TREE
9649 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9650 && decl
== constructor_name (ctype
))
9652 sfk
= sfk_constructor
;
9653 ctor_return_type
= ctype
;
9658 case TEMPLATE_ID_EXPR
:
9660 tree fns
= TREE_OPERAND (decl
, 0);
9662 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9663 fns
= TREE_OPERAND (fns
, 0);
9666 if (TREE_CODE (dname
) == COMPONENT_REF
)
9667 dname
= TREE_OPERAND (dname
, 1);
9668 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9670 my_friendly_assert (is_overloaded_fn (dname
),
9672 dname
= DECL_NAME (get_first_fn (dname
));
9677 case IDENTIFIER_NODE
:
9678 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9683 if (C_IS_RESERVED_WORD (dname
))
9685 cp_error ("declarator-id missing; using reserved word `%D'",
9687 name
= IDENTIFIER_POINTER (dname
);
9689 else if (!IDENTIFIER_TYPENAME_P (dname
))
9690 name
= IDENTIFIER_POINTER (dname
);
9693 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9694 flags
= TYPENAME_FLAG
;
9695 ctor_return_type
= TREE_TYPE (dname
);
9696 sfk
= sfk_conversion
;
9697 if (IDENTIFIER_GLOBAL_VALUE (dname
)
9698 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname
))
9700 name
= IDENTIFIER_POINTER (dname
);
9702 name
= "<invalid operator>";
9709 /* Perform error checking, and decide on a ctype. */
9710 tree cname
= TREE_OPERAND (decl
, 0);
9711 if (cname
== NULL_TREE
)
9713 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9716 in_namespace
= TREE_OPERAND (decl
, 0);
9717 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9719 else if (! is_aggr_type (cname
, 1))
9720 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9721 /* Must test TREE_OPERAND (decl, 1), in case user gives
9722 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9723 else if (TREE_OPERAND (decl
, 1)
9724 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9726 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9727 || TREE_CODE (cname
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9729 cp_error ("`%T::%D' is not a valid declarator", cname
,
9730 TREE_OPERAND (decl
, 1));
9731 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9732 cname
, TREE_OPERAND (decl
, 1));
9733 return void_type_node
;
9735 else if (ctype
== NULL_TREE
)
9737 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9738 TREE_OPERAND (decl
, 0) = ctype
;
9741 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9743 cp_error ("type `%T' is not derived from type `%T'",
9745 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9751 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9752 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9753 == constructor_name_full (ctype
))
9754 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9755 == constructor_name (ctype
))))
9756 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9757 next
= &TREE_OPERAND (decl
, 1);
9761 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9762 && constructor_name (ctype
) == decl
)
9764 sfk
= sfk_constructor
;
9765 ctor_return_type
= ctype
;
9767 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9768 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9769 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9770 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9772 sfk
= sfk_destructor
;
9773 ctor_return_type
= ctype
;
9775 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9776 next
= &TREE_OPERAND (decl
, 0);
9787 /* Parse error puts this typespec where
9788 a declarator should go. */
9789 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9790 if (TREE_TYPE (decl
) == current_class_type
)
9791 cp_error (" perhaps you want `%T' for a constructor",
9792 current_class_name
);
9793 dname
= DECL_NAME (decl
);
9794 name
= IDENTIFIER_POINTER (dname
);
9796 /* Avoid giving two errors for this. */
9797 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9799 declspecs
= tree_cons (NULL_TREE
, integer_type_node
, declspecs
);
9805 cp_compiler_error ("`%D' as declarator", decl
);
9806 return 0; /* We used to do a 155 abort here. */
9811 /* A function definition's declarator must have the form of
9812 a function declarator. */
9814 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9817 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9818 && innermost_code
!= CALL_EXPR
9819 && ! (ctype
&& declspecs
== NULL_TREE
))
9821 cp_error ("declaration of `%D' as non-function", dname
);
9822 return void_type_node
;
9825 /* Anything declared one level down from the top level
9826 must be one of the parameters of a function
9827 (because the body is at least two levels down). */
9829 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9830 by not allowing C++ class definitions to specify their parameters
9831 with xdecls (must be spec.d in the parmlist).
9833 Since we now wait to push a class scope until we are sure that
9834 we are in a legitimate method context, we must set oldcname
9835 explicitly (since current_class_name is not yet alive).
9837 We also want to avoid calling this a PARM if it is in a namespace. */
9839 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9841 struct binding_level
*b
= current_binding_level
;
9842 current_binding_level
= b
->level_chain
;
9843 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9844 decl_context
= PARM
;
9845 current_binding_level
= b
;
9849 name
= decl_context
== PARM
? "parameter" : "type name";
9851 /* Look through the decl specs and record which ones appear.
9852 Some typespecs are defined as built-in typenames.
9853 Others, the ones that are modifiers of other types,
9854 are represented by bits in SPECBITS: set the bits for
9855 the modifiers that appear. Storage class keywords are also in SPECBITS.
9857 If there is a typedef name or a type, store the type in TYPE.
9858 This includes builtin typedefs such as `int'.
9860 Set EXPLICIT_INT if the type is `int' or `char' and did not
9861 come from a user typedef.
9863 Set LONGLONG if `long' is mentioned twice.
9865 For C++, constructors and destructors have their own fast treatment. */
9867 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
9872 /* Certain parse errors slip through. For example,
9873 `int class;' is not caught by the parser. Try
9874 weakly to recover here. */
9875 if (TREE_CODE (spec
) != TREE_LIST
)
9878 id
= TREE_VALUE (spec
);
9880 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9882 if (id
== ridpointers
[(int) RID_INT
]
9883 || id
== ridpointers
[(int) RID_CHAR
]
9884 || id
== ridpointers
[(int) RID_BOOL
]
9885 || id
== ridpointers
[(int) RID_WCHAR
])
9889 if (id
== ridpointers
[(int) RID_BOOL
])
9890 error ("`bool' is now a keyword");
9892 cp_error ("extraneous `%T' ignored", id
);
9896 if (id
== ridpointers
[(int) RID_INT
])
9898 else if (id
== ridpointers
[(int) RID_CHAR
])
9900 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
9904 /* C++ aggregate types. */
9905 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
9908 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
9910 type
= IDENTIFIER_TYPE_VALUE (id
);
9914 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
9916 if (ridpointers
[i
] == id
)
9918 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
9920 if (pedantic
&& ! in_system_header
&& warn_long_long
)
9921 pedwarn ("ISO C++ does not support `long long'");
9923 error ("`long long long' is too long for GCC");
9927 else if (RIDBIT_SETP (i
, specbits
))
9928 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
9929 RIDBIT_SET (i
, specbits
);
9934 /* C++ aggregate types. */
9935 else if (TREE_CODE (id
) == TYPE_DECL
)
9938 cp_error ("multiple declarations `%T' and `%T'", type
,
9942 type
= TREE_TYPE (id
);
9943 TREE_VALUE (spec
) = type
;
9948 error ("two or more data types in declaration of `%s'", name
);
9949 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9951 register tree t
= lookup_name (id
, 1);
9952 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
9953 error ("`%s' fails to be a typedef or built in type",
9954 IDENTIFIER_POINTER (id
));
9957 type
= TREE_TYPE (t
);
9959 /* See the code below that used this. */
9960 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
9965 else if (id
!= error_mark_node
)
9966 /* Can't change CLASS nodes into RECORD nodes here! */
9972 typedef_type
= type
;
9974 /* No type at all: default to `int', and set DEFAULTED_INT
9975 because it was not a user-defined typedef. */
9977 if (type
== NULL_TREE
9978 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
9979 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
9980 || RIDBIT_SETP (RID_LONG
, specbits
)
9981 || RIDBIT_SETP (RID_SHORT
, specbits
)))
9983 /* These imply 'int'. */
9984 type
= integer_type_node
;
9988 if (sfk
!= sfk_none
)
9989 type
= check_special_function_return_type (sfk
, type
,
9991 else if (type
== NULL_TREE
)
9997 /* We handle `main' specially here, because 'main () { }' is so
9998 common. With no options, it is allowed. With -Wreturn-type,
9999 it is a warning. It is only an error with -pedantic-errors. */
10000 is_main
= (funcdef_flag
10001 && MAIN_NAME_P (dname
)
10002 && ctype
== NULL_TREE
10003 && in_namespace
== NULL_TREE
10004 && current_namespace
== global_namespace
);
10006 if (in_system_header
|| flag_ms_extensions
)
10007 /* Allow it, sigh. */;
10008 else if (pedantic
|| ! is_main
)
10009 cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10011 else if (warn_return_type
)
10012 cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10015 type
= integer_type_node
;
10020 /* Now process the modifiers that were specified
10021 and check for invalid combinations. */
10023 /* Long double is a special combination. */
10025 if (RIDBIT_SETP (RID_LONG
, specbits
)
10026 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
10028 RIDBIT_RESET (RID_LONG
, specbits
);
10029 type
= build_qualified_type (long_double_type_node
,
10030 CP_TYPE_QUALS (type
));
10033 /* Check all other uses of type modifiers. */
10035 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10036 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10037 || RIDBIT_SETP (RID_LONG
, specbits
)
10038 || RIDBIT_SETP (RID_SHORT
, specbits
))
10042 if (TREE_CODE (type
) == REAL_TYPE
)
10043 error ("short, signed or unsigned invalid for `%s'", name
);
10044 else if (TREE_CODE (type
) != INTEGER_TYPE
)
10045 error ("long, short, signed or unsigned invalid for `%s'", name
);
10046 else if (RIDBIT_SETP (RID_LONG
, specbits
)
10047 && RIDBIT_SETP (RID_SHORT
, specbits
))
10048 error ("long and short specified together for `%s'", name
);
10049 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10050 || RIDBIT_SETP (RID_SHORT
, specbits
))
10052 error ("long or short specified with char for `%s'", name
);
10053 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10054 || RIDBIT_SETP (RID_SHORT
, specbits
))
10055 && TREE_CODE (type
) == REAL_TYPE
)
10056 error ("long or short specified with floating type for `%s'", name
);
10057 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10058 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
10059 error ("signed and unsigned given together for `%s'", name
);
10063 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
10065 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10067 if (flag_pedantic_errors
)
10072 /* Discard the type modifiers if they are invalid. */
10075 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
10076 RIDBIT_RESET (RID_SIGNED
, specbits
);
10077 RIDBIT_RESET (RID_LONG
, specbits
);
10078 RIDBIT_RESET (RID_SHORT
, specbits
);
10083 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
10084 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10086 error ("complex invalid for `%s'", name
);
10087 RIDBIT_RESET (RID_COMPLEX
, specbits
);
10090 /* Decide whether an integer type is signed or not.
10091 Optionally treat bitfields as signed by default. */
10092 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10095 It is implementation-defined whether a plain (neither
10096 explicitly signed or unsigned) char, short, int, or long
10097 bit-field is signed or unsigned.
10099 Naturally, we extend this to long long as well. Note that
10100 this does not include wchar_t. */
10101 || (bitfield
&& !flag_signed_bitfields
10102 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
10103 /* A typedef for plain `int' without `signed' can be
10104 controlled just like plain `int', but a typedef for
10105 `signed int' cannot be so controlled. */
10107 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10108 && (TREE_CODE (type
) == INTEGER_TYPE
10109 || TREE_CODE (type
) == CHAR_TYPE
)
10110 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10113 type
= long_long_unsigned_type_node
;
10114 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10115 type
= long_unsigned_type_node
;
10116 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10117 type
= short_unsigned_type_node
;
10118 else if (type
== char_type_node
)
10119 type
= unsigned_char_type_node
;
10120 else if (typedef_decl
)
10121 type
= unsigned_type (type
);
10123 type
= unsigned_type_node
;
10125 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10126 && type
== char_type_node
)
10127 type
= signed_char_type_node
;
10129 type
= long_long_integer_type_node
;
10130 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10131 type
= long_integer_type_node
;
10132 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10133 type
= short_integer_type_node
;
10135 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
10137 /* If we just have "complex", it is equivalent to
10138 "complex double", but if any modifiers at all are specified it is
10139 the complex form of TYPE. E.g, "complex short" is
10140 "complex short int". */
10142 if (defaulted_int
&& ! longlong
10143 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
10144 || RIDBIT_SETP (RID_SHORT
, specbits
)
10145 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10146 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
10147 type
= complex_double_type_node
;
10148 else if (type
== integer_type_node
)
10149 type
= complex_integer_type_node
;
10150 else if (type
== float_type_node
)
10151 type
= complex_float_type_node
;
10152 else if (type
== double_type_node
)
10153 type
= complex_double_type_node
;
10154 else if (type
== long_double_type_node
)
10155 type
= complex_long_double_type_node
;
10157 type
= build_complex_type (type
);
10160 if (sfk
== sfk_conversion
10161 && (RIDBIT_SETP (RID_CONST
, specbits
)
10162 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
10163 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
10164 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10167 /* Set CONSTP if this declaration is `const', whether by
10168 explicit specification or via a typedef.
10169 Likewise for VOLATILEP. */
10171 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
10173 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
10175 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
10176 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10177 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10178 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10179 type
= cp_build_qualified_type (type
, type_quals
);
10181 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
10182 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
10183 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
10184 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
10185 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
10187 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10188 staticp
= 1 + (decl_context
== FIELD
);
10190 if (virtualp
&& staticp
== 2)
10192 cp_error ("member `%D' cannot be declared both virtual and static",
10196 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
10197 RIDBIT_RESET (RID_FRIEND
, specbits
);
10199 /* Warn if two storage classes are given. Default to `auto'. */
10201 if (RIDBIT_ANY_SET (specbits
))
10203 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
10204 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
10205 if (decl_context
== PARM
&& nclasses
> 0)
10206 error ("storage class specifiers invalid in parameter declarations");
10207 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10209 if (decl_context
== PARM
)
10210 error ("typedef declaration invalid in parameter declaration");
10213 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
10214 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
10217 /* Give error if `virtual' is used outside of class declaration. */
10219 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10221 error ("virtual outside class declaration");
10225 /* Static anonymous unions are dealt with here. */
10226 if (staticp
&& decl_context
== TYPENAME
10227 && TREE_CODE (declspecs
) == TREE_LIST
10228 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
10229 decl_context
= FIELD
;
10231 /* Warn about storage classes that are invalid for certain
10232 kinds of declarations (parameters, typenames, etc.). */
10235 error ("multiple storage classes in declaration of `%s'", name
);
10236 else if (decl_context
!= NORMAL
&& nclasses
> 0)
10238 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
10239 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
10240 || RIDBIT_SETP (RID_AUTO
, specbits
)))
10242 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10244 else if (decl_context
== FIELD
10245 /* C++ allows static class elements */
10246 && RIDBIT_SETP (RID_STATIC
, specbits
))
10247 /* C++ also allows inlines and signed and unsigned elements,
10248 but in those cases we don't come in here. */
10252 if (decl_context
== FIELD
)
10254 tree tmp
= NULL_TREE
;
10255 register int op
= 0;
10259 /* Avoid trying to get an operand off an identifier node. */
10260 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10263 tmp
= TREE_OPERAND (declarator
, 0);
10264 op
= IDENTIFIER_OPNAME_P (tmp
);
10265 if (IDENTIFIER_TYPENAME_P (tmp
))
10267 if (IDENTIFIER_GLOBAL_VALUE (tmp
)
10268 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp
))
10270 name
= IDENTIFIER_POINTER (tmp
);
10272 name
= "<invalid operator>";
10275 error ("storage class specified for %s `%s'",
10276 op
? "member operator" : "field",
10281 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10282 error ("storage class specified for parameter `%s'", name
);
10284 error ("storage class specified for typename");
10286 RIDBIT_RESET (RID_REGISTER
, specbits
);
10287 RIDBIT_RESET (RID_AUTO
, specbits
);
10288 RIDBIT_RESET (RID_EXTERN
, specbits
);
10291 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
10293 if (toplevel_bindings_p ())
10295 /* It's common practice (and completely valid) to have a const
10296 be initialized and declared extern. */
10297 if (!(type_quals
& TYPE_QUAL_CONST
))
10298 warning ("`%s' initialized and declared `extern'", name
);
10301 error ("`%s' has both `extern' and initializer", name
);
10303 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
10304 && ! toplevel_bindings_p ())
10305 error ("nested function `%s' declared `extern'", name
);
10306 else if (toplevel_bindings_p ())
10308 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10309 error ("top-level declaration of `%s' specifies `auto'", name
);
10312 if (nclasses
> 0 && friendp
)
10313 error ("storage class specifiers invalid in friend function declarations");
10315 /* Now figure out the structure of the declarator proper.
10316 Descend through it, creating more complex types, until we reach
10317 the declared identifier (or NULL_TREE, in an absolute declarator). */
10319 inner_attrs
= NULL_TREE
;
10322 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
10323 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
10325 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10326 an INDIRECT_REF (for *...),
10327 a CALL_EXPR (for ...(...)),
10328 an identifier (for the name being declared)
10329 or a null pointer (for the place in an absolute declarator
10330 where the name was omitted).
10331 For the last two cases, we have just exited the loop.
10333 For C++ it could also be
10334 a SCOPE_REF (for class :: ...). In this case, we have converted
10335 sensible names to types, and those are the values we use to
10336 qualify the member name.
10337 an ADDR_EXPR (for &...),
10338 a BIT_NOT_EXPR (for destructors)
10340 At this point, TYPE is the type of elements of an array,
10341 or for a function to return, or for a pointer to point to.
10342 After this sequence of ifs, TYPE is the type of the
10343 array or function or pointer, and DECLARATOR has had its
10344 outermost layer removed. */
10346 if (type
== error_mark_node
)
10348 if (TREE_CODE (declarator
) == SCOPE_REF
)
10349 declarator
= TREE_OPERAND (declarator
, 1);
10351 declarator
= TREE_OPERAND (declarator
, 0);
10354 if (quals
!= NULL_TREE
10355 && (declarator
== NULL_TREE
10356 || TREE_CODE (declarator
) != SCOPE_REF
))
10358 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
10359 ctype
= TYPE_METHOD_BASETYPE (type
);
10360 if (ctype
!= NULL_TREE
)
10362 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
10363 grok_method_quals (ctype
, dummy
, quals
);
10364 type
= TREE_TYPE (dummy
);
10365 ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
)));
10370 /* See the comment for the TREE_LIST case, below. */
10373 else if (inner_attrs
)
10375 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10376 inner_attrs
= NULL_TREE
;
10379 switch (TREE_CODE (declarator
))
10383 /* We encode a declarator with embedded attributes using
10384 a TREE_LIST. The attributes apply to the declarator
10385 directly inside them, so we have to skip an iteration
10386 before applying them to the type. If the declarator just
10387 inside is the declarator-id, we apply the attrs to the
10389 inner_attrs
= TREE_PURPOSE (declarator
);
10391 declarator
= TREE_VALUE (declarator
);
10397 register tree size
;
10399 size
= TREE_OPERAND (declarator
, 1);
10401 /* VC++ spells a zero-sized array with []. */
10402 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10403 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10404 size
= integer_zero_node
;
10406 declarator
= TREE_OPERAND (declarator
, 0);
10408 type
= create_array_type_for_decl (dname
, type
, size
);
10410 /* VLAs never work as fields. */
10411 if (decl_context
== FIELD
&& !processing_template_decl
10412 && TREE_CODE (type
) == ARRAY_TYPE
10413 && TYPE_DOMAIN (type
) != NULL_TREE
10414 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
10416 cp_error ("size of member `%D' is not constant", dname
);
10417 /* Proceed with arbitrary constant size, so that offset
10418 computations don't get confused. */
10419 type
= create_array_type_for_decl (dname
, TREE_TYPE (type
),
10431 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
10432 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10434 /* Declaring a function type.
10435 Make sure we have a valid type for the function to return. */
10437 /* We now know that the TYPE_QUALS don't apply to the
10438 decl, but to its return type. */
10439 type_quals
= TYPE_UNQUALIFIED
;
10441 /* Warn about some types functions can't return. */
10443 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10445 error ("`%s' declared as function returning a function", name
);
10446 type
= integer_type_node
;
10448 if (TREE_CODE (type
) == ARRAY_TYPE
)
10450 error ("`%s' declared as function returning an array", name
);
10451 type
= integer_type_node
;
10454 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10455 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10457 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10458 inner_decl
= dname
;
10460 /* Pick up type qualifiers which should be applied to `this'. */
10461 quals
= CALL_DECLARATOR_QUALS (declarator
);
10463 /* Pick up the exception specifications. */
10464 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
10466 /* Say it's a definition only for the CALL_EXPR
10467 closest to the identifier. */
10470 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10471 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10472 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10474 if (ctype
== NULL_TREE
10475 && decl_context
== FIELD
10477 && (friendp
== 0 || dname
== current_class_name
))
10478 ctype
= current_class_type
;
10480 if (ctype
&& sfk
== sfk_conversion
)
10481 TYPE_HAS_CONVERSION (ctype
) = 1;
10482 if (ctype
&& constructor_name (ctype
) == dname
)
10484 /* We are within a class's scope. If our declarator name
10485 is the same as the class name, and we are defining
10486 a function, then it is a constructor/destructor, and
10487 therefore returns a void type. */
10489 if (flags
== DTOR_FLAG
)
10491 /* ISO C++ 12.4/2. A destructor may not be
10492 declared const or volatile. A destructor may
10495 error ("destructor cannot be static member function");
10498 cp_error ("destructors may not be `%s'",
10499 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10502 if (decl_context
== FIELD
)
10504 if (! member_function_or_else (ctype
,
10505 current_class_type
,
10507 return void_type_node
;
10510 else /* It's a constructor. */
10512 if (explicitp
== 1)
10514 /* ISO C++ 12.1. A constructor may not be
10515 declared const or volatile. A constructor may
10516 not be virtual. A constructor may not be
10519 error ("constructor cannot be static member function");
10522 pedwarn ("constructors cannot be declared virtual");
10527 cp_error ("constructors may not be `%s'",
10528 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10532 RID_BIT_TYPE tmp_bits
;
10533 memcpy (&tmp_bits
, &specbits
, sizeof (RID_BIT_TYPE
));
10534 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10535 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10536 if (RIDBIT_ANY_SET (tmp_bits
))
10537 error ("return value type specifier for constructor ignored");
10539 if (decl_context
== FIELD
)
10541 if (! member_function_or_else (ctype
,
10542 current_class_type
,
10544 return void_type_node
;
10545 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10546 if (sfk
!= sfk_constructor
)
10550 if (decl_context
== FIELD
)
10556 error ("can't initialize friend function `%s'", name
);
10559 /* Cannot be both friend and virtual. */
10560 error ("virtual functions cannot be friends");
10561 RIDBIT_RESET (RID_FRIEND
, specbits
);
10564 if (decl_context
== NORMAL
)
10565 error ("friend declaration not in class definition");
10566 if (current_function_decl
&& funcdef_flag
)
10567 cp_error ("can't define friend function `%s' in a local class definition",
10571 /* Construct the function type and go to the next
10572 inner layer of declarator. */
10574 declarator
= TREE_OPERAND (declarator
, 0);
10576 /* FIXME: This is where default args should be fully
10579 arg_types
= grokparms (inner_parms
);
10581 if (declarator
&& flags
== DTOR_FLAG
)
10583 /* A destructor declared in the body of a class will
10584 be represented as a BIT_NOT_EXPR. But, we just
10585 want the underlying IDENTIFIER. */
10586 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10587 declarator
= TREE_OPERAND (declarator
, 0);
10589 if (arg_types
!= void_list_node
)
10591 cp_error ("destructors may not have parameters");
10592 arg_types
= void_list_node
;
10593 last_function_parms
= NULL_TREE
;
10597 /* ANSI says that `const int foo ();'
10598 does not make the function foo const. */
10599 type
= build_function_type (type
, arg_types
);
10603 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10604 if (TREE_PURPOSE (t
)
10605 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10607 add_defarg_fn (type
);
10616 /* Filter out pointers-to-references and references-to-references.
10617 We can get these if a TYPE_DECL is used. */
10619 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10621 error ("cannot declare %s to references",
10622 TREE_CODE (declarator
) == ADDR_EXPR
10623 ? "references" : "pointers");
10624 declarator
= TREE_OPERAND (declarator
, 0);
10628 if (TREE_CODE (type
) == OFFSET_TYPE
10629 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10630 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10632 cp_error ("cannot declare pointer to `%#T' member",
10634 type
= TREE_TYPE (type
);
10637 /* Merge any constancy or volatility into the target type
10638 for the pointer. */
10640 /* We now know that the TYPE_QUALS don't apply to the decl,
10641 but to the target of the pointer. */
10642 type_quals
= TYPE_UNQUALIFIED
;
10644 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10646 if (TREE_CODE (type
) == VOID_TYPE
)
10647 error ("invalid type: `void &'");
10649 type
= build_reference_type (type
);
10651 else if (TREE_CODE (type
) == METHOD_TYPE
)
10652 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10654 type
= build_pointer_type (type
);
10656 /* Process a list of type modifier keywords (such as
10657 const or volatile) that were given inside the `*' or `&'. */
10659 if (TREE_TYPE (declarator
))
10661 register tree typemodlist
;
10667 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10668 typemodlist
= TREE_CHAIN (typemodlist
))
10670 tree qualifier
= TREE_VALUE (typemodlist
);
10672 if (qualifier
== ridpointers
[(int) RID_CONST
])
10674 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10676 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10681 error ("invalid type modifier within pointer declarator");
10685 pedwarn ("duplicate `const'");
10687 pedwarn ("duplicate `volatile'");
10689 pedwarn ("duplicate `restrict'");
10691 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10692 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10693 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10694 if (TREE_CODE (declarator
) == ADDR_EXPR
10695 && (constp
|| volatilep
))
10698 pedwarn ("discarding `const' applied to a reference");
10700 pedwarn ("discarding `volatile' applied to a reference");
10701 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10703 type
= cp_build_qualified_type (type
, type_quals
);
10705 declarator
= TREE_OPERAND (declarator
, 0);
10711 /* We have converted type names to NULL_TREE if the
10712 name was bogus, or to a _TYPE node, if not.
10714 The variable CTYPE holds the type we will ultimately
10715 resolve to. The code here just needs to build
10716 up appropriate member types. */
10717 tree sname
= TREE_OPERAND (declarator
, 1);
10720 /* Destructors can have their visibilities changed as well. */
10721 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10722 sname
= TREE_OPERAND (sname
, 0);
10724 if (TREE_COMPLEXITY (declarator
) == 0)
10725 /* This needs to be here, in case we are called
10726 multiple times. */ ;
10727 else if (TREE_COMPLEXITY (declarator
) == -1)
10728 /* Namespace member. */
10729 pop_decl_namespace ();
10730 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10731 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10732 else if (! IS_AGGR_TYPE_CODE
10733 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10735 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10737 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10738 that refer to ctype. They couldn't be resolved earlier
10739 because we hadn't pushed into the class yet.
10740 Example: resolve 'B<T>::type' in
10741 'B<typename B<T>::type> B<T>::f () { }'. */
10742 if (current_template_parms
10743 && uses_template_parms (type
)
10744 && uses_template_parms (current_class_type
))
10746 tree args
= current_template_args ();
10747 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10750 /* This pop_nested_class corresponds to the
10751 push_nested_class used to push into class scope for
10752 parsing the argument list of a function decl, in
10754 pop_nested_class ();
10755 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10758 my_friendly_abort (16);
10760 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10762 /* We had a reference to a global decl, or
10763 perhaps we were given a non-aggregate typedef,
10764 in which case we cleared this out, and should just
10765 keep going as though it wasn't there. */
10766 declarator
= sname
;
10769 ctype
= TREE_OPERAND (declarator
, 0);
10772 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10774 /* You're supposed to have one `template <...>'
10775 for every template class, but you don't need one
10776 for a full specialization. For example:
10778 template <class T> struct S{};
10779 template <> struct S<int> { void f(); };
10780 void S<int>::f () {}
10782 is correct; there shouldn't be a `template <>' for
10783 the definition of `S<int>::f'. */
10784 if (CLASSTYPE_TEMPLATE_INFO (t
)
10785 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
10786 || uses_template_parms (CLASSTYPE_TI_ARGS (t
)))
10787 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))
10788 template_count
+= 1;
10790 t
= TYPE_MAIN_DECL (t
);
10791 t
= DECL_CONTEXT (t
);
10794 if (sname
== NULL_TREE
)
10797 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10799 /* This is the `standard' use of the scoping operator:
10800 basetype :: member . */
10802 if (ctype
== current_class_type
)
10808 Is this ill-formed? */
10811 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10814 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10816 if (current_class_type
== NULL_TREE
|| friendp
)
10817 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10818 TYPE_ARG_TYPES (type
));
10821 cp_error ("cannot declare member function `%T::%s' within `%T'",
10822 ctype
, name
, current_class_type
);
10823 return void_type_node
;
10826 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10827 || COMPLETE_TYPE_P (complete_type (ctype
)))
10829 /* Have to move this code elsewhere in this function.
10830 this code is used for i.e., typedef int A::M; M *pm;
10832 It is? How? jason 10/2/94 */
10834 if (current_class_type
)
10836 cp_error ("cannot declare member `%T::%s' within `%T'",
10837 ctype
, name
, current_class_type
);
10838 return void_type_node
;
10840 type
= build_offset_type (ctype
, type
);
10844 incomplete_type_error (NULL_TREE
, ctype
);
10845 return error_mark_node
;
10848 declarator
= sname
;
10850 else if (TREE_CODE (sname
) == SCOPE_REF
)
10851 my_friendly_abort (17);
10855 declarator
= TREE_OPERAND (declarator
, 1);
10856 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10857 /* In this case, we will deal with it later. */
10861 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10862 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10863 TYPE_ARG_TYPES (type
));
10865 type
= build_offset_type (ctype
, type
);
10872 declarator
= TREE_OPERAND (declarator
, 0);
10877 case ENUMERAL_TYPE
:
10878 declarator
= NULL_TREE
;
10882 declarator
= NULL_TREE
;
10886 my_friendly_abort (158);
10890 /* See the comment for the TREE_LIST case, above. */
10893 if (! ignore_attrs
)
10894 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10896 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
10898 attrlist
= build_tree_list (NULL_TREE
, inner_attrs
);
10901 /* Now TYPE has the actual type. */
10903 if (explicitp
== 1 || (explicitp
&& friendp
))
10905 /* [dcl.fct.spec] The explicit specifier shall only be used in
10906 declarations of constructors within a class definition. */
10907 error ("only declarations of constructors can be `explicit'");
10911 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
10913 if (current_class_name
== NULL_TREE
|| decl_context
== PARM
|| friendp
)
10915 error ("non-member `%s' cannot be declared `mutable'", name
);
10916 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10918 else if (decl_context
== TYPENAME
|| RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10920 error ("non-object member `%s' cannot be declared `mutable'", name
);
10921 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10923 else if (TREE_CODE (type
) == FUNCTION_TYPE
10924 || TREE_CODE (type
) == METHOD_TYPE
)
10926 error ("function `%s' cannot be declared `mutable'", name
);
10927 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10931 error ("static `%s' cannot be declared `mutable'", name
);
10932 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10934 else if (type_quals
& TYPE_QUAL_CONST
)
10936 error ("const `%s' cannot be declared `mutable'", name
);
10937 RIDBIT_RESET (RID_MUTABLE
, specbits
);
10941 if (declarator
== NULL_TREE
10942 || TREE_CODE (declarator
) == IDENTIFIER_NODE
10943 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
10944 && (TREE_CODE (type
) == FUNCTION_TYPE
10945 || TREE_CODE (type
) == METHOD_TYPE
)))
10947 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
10949 cp_error ("template-id `%D' used as a declarator", declarator
);
10950 declarator
= dname
;
10953 /* Unexpected declarator format. */
10954 my_friendly_abort (990210);
10956 /* If this is declaring a typedef name, return a TYPE_DECL. */
10958 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
10962 /* Note that the grammar rejects storage classes
10963 in typenames, fields or parameters. */
10964 if (current_lang_name
== lang_name_java
)
10965 TYPE_FOR_JAVA (type
) = 1;
10967 if (decl_context
== FIELD
)
10969 if (declarator
== constructor_name (current_class_type
))
10970 cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10972 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
10975 decl
= build_decl (TYPE_DECL
, declarator
, type
);
10977 /* If the user declares "typedef struct {...} foo" then the
10978 struct will have an anonymous name. Fill that name in now.
10979 Nothing can refer to it, so nothing needs know about the name
10981 if (type
!= error_mark_node
10983 && TYPE_NAME (type
)
10984 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10985 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
10986 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
10988 tree oldname
= TYPE_NAME (type
);
10991 /* Replace the anonymous name with the real name everywhere. */
10992 lookup_tag_reverse (type
, declarator
);
10993 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10994 if (TYPE_NAME (t
) == oldname
)
10995 TYPE_NAME (t
) = decl
;
10997 if (TYPE_LANG_SPECIFIC (type
))
10998 TYPE_WAS_ANONYMOUS (type
) = 1;
11000 /* If this is a typedef within a template class, the nested
11001 type is a (non-primary) template. The name for the
11002 template needs updating as well. */
11003 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
11004 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
11005 = TYPE_IDENTIFIER (type
);
11007 DECL_ASSEMBLER_NAME (decl
) = mangle_type (type
);
11009 /* FIXME remangle member functions; member functions of a
11010 type with external linkage have external linkage. */
11013 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11015 cp_error_at ("typedef name may not be class-qualified", decl
);
11020 if (ctype
== NULL_TREE
)
11022 if (TREE_CODE (type
) != METHOD_TYPE
)
11023 cp_error_at ("invalid type qualifier for non-member function type", decl
);
11025 ctype
= TYPE_METHOD_BASETYPE (type
);
11027 if (ctype
!= NULL_TREE
)
11028 grok_method_quals (ctype
, decl
, quals
);
11031 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
11032 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
11033 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
11035 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
11036 inlinep
, friendp
, raises
!= NULL_TREE
);
11039 error ("typedef declaration includes an initializer");
11044 /* Detect the case of an array type of unspecified size
11045 which came, as such, direct from a typedef name.
11046 We must copy the type, so that each identifier gets
11047 a distinct type, so that each identifier's size can be
11048 controlled separately by its own initializer. */
11050 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
11051 && TYPE_DOMAIN (type
) == NULL_TREE
)
11053 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
11056 /* If this is a type name (such as, in a cast or sizeof),
11057 compute the type and return it now. */
11059 if (decl_context
== TYPENAME
)
11061 /* Note that the grammar rejects storage classes
11062 in typenames, fields or parameters. */
11063 if (type_quals
!= TYPE_UNQUALIFIED
)
11064 type_quals
= TYPE_UNQUALIFIED
;
11066 /* Special case: "friend class foo" looks like a TYPENAME context. */
11069 if (type_quals
!= TYPE_UNQUALIFIED
)
11071 cp_error ("type qualifiers specified for friend class declaration");
11072 type_quals
= TYPE_UNQUALIFIED
;
11076 cp_error ("`inline' specified for friend class declaration");
11080 /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11081 But don't allow implicit typenames except with a class-key. */
11082 if (!current_aggr
&& (TREE_CODE (type
) != TYPENAME_TYPE
11083 || IMPLICIT_TYPENAME_P (type
)))
11085 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11086 cp_pedwarn ("template parameters cannot be friends");
11087 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
11089 friend declaration requires class-key, i.e. `friend class %T::%T'",
11090 constructor_name (current_class_type
),
11091 TYPE_IDENTIFIER (type
));
11094 friend declaration requires class-key, i.e. `friend %#T'",
11098 /* Only try to do this stuff if we didn't already give up. */
11099 if (type
!= integer_type_node
)
11101 decl_type_access_control (TYPE_NAME (type
));
11103 /* A friendly class? */
11104 if (current_class_type
)
11105 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
11107 cp_error ("trying to make class `%T' a friend of global scope",
11110 type
= void_type_node
;
11115 if (ctype
== NULL_TREE
)
11117 if (TREE_CODE (type
) != METHOD_TYPE
)
11118 cp_error ("invalid qualifiers on non-member function type");
11120 ctype
= TYPE_METHOD_BASETYPE (type
);
11124 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
11125 grok_method_quals (ctype
, dummy
, quals
);
11126 type
= TREE_TYPE (dummy
);
11132 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
11133 && decl_context
!= CATCHPARM
11134 && TREE_CODE (type
) != UNION_TYPE
11137 cp_error ("abstract declarator `%T' used as declaration", type
);
11138 declarator
= make_anon_name ();
11141 /* `void' at top level (not within pointer)
11142 is allowed only in typedefs or type names.
11143 We don't complain about parms either, but that is because
11144 a better error message can be made later. */
11146 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
11149 error ("unnamed variable or field declared void");
11150 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
11152 if (IDENTIFIER_OPNAME_P (declarator
))
11153 my_friendly_abort (356);
11155 error ("variable or field `%s' declared void", name
);
11158 error ("variable or field declared void");
11159 type
= integer_type_node
;
11162 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11163 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11165 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11167 if (ctype
|| in_namespace
)
11168 error ("cannot use `::' in parameter declaration");
11170 /* A parameter declared as an array of T is really a pointer to T.
11171 One declared as a function is really a pointer to a function.
11172 One declared as a member is really a pointer to member. */
11174 if (TREE_CODE (type
) == ARRAY_TYPE
)
11176 /* Transfer const-ness of array into that of type pointed to. */
11177 type
= build_pointer_type (TREE_TYPE (type
));
11178 type_quals
= TYPE_UNQUALIFIED
;
11180 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11181 type
= build_pointer_type (type
);
11182 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11183 type
= build_pointer_type (type
);
11187 register tree decl
;
11189 if (decl_context
== PARM
)
11191 decl
= build_decl (PARM_DECL
, declarator
, type
);
11193 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
11194 inlinep
, friendp
, raises
!= NULL_TREE
);
11196 /* Compute the type actually passed in the parmlist,
11197 for the case where there is no prototype.
11198 (For example, shorts and chars are passed as ints.)
11199 When there is a prototype, this is overridden later. */
11201 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
11203 else if (decl_context
== FIELD
)
11205 if (type
== error_mark_node
)
11207 /* Happens when declaring arrays of sizes which
11208 are error_mark_node, for example. */
11211 else if (in_namespace
&& !friendp
)
11213 /* Something like struct S { int N::j; }; */
11214 cp_error ("invalid use of `::'");
11217 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11220 tree function_context
;
11222 /* We catch the others as conflicts with the builtin
11224 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
11226 cp_error ("function `%D' cannot be declared friend",
11233 if (ctype
== NULL_TREE
)
11234 ctype
= current_class_type
;
11236 if (ctype
== NULL_TREE
)
11238 cp_error ("can't make `%D' into a method -- not in a class",
11240 return void_type_node
;
11243 /* ``A union may [ ... ] not [ have ] virtual functions.''
11245 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11247 cp_error ("function `%D' declared virtual inside a union",
11249 return void_type_node
;
11252 if (declarator
== ansi_opname (NEW_EXPR
)
11253 || declarator
== ansi_opname (VEC_NEW_EXPR
)
11254 || declarator
== ansi_opname (DELETE_EXPR
)
11255 || declarator
== ansi_opname (VEC_DELETE_EXPR
))
11259 cp_error ("`%D' cannot be declared virtual, since it is always static",
11264 else if (staticp
< 2)
11265 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11266 TYPE_ARG_TYPES (type
));
11269 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11270 function_context
= (ctype
!= NULL_TREE
) ?
11271 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11272 publicp
= (! friendp
|| ! staticp
)
11273 && function_context
== NULL_TREE
;
11274 decl
= grokfndecl (ctype
, type
,
11275 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
11276 ? declarator
: dname
,
11278 virtualp
, flags
, quals
, raises
,
11279 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11280 funcdef_flag
, template_count
, in_namespace
);
11281 if (decl
== NULL_TREE
)
11284 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11285 /* The decl and setting of decl_machine_attr is also turned off. */
11286 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11289 /* [class.conv.ctor]
11291 A constructor declared without the function-specifier
11292 explicit that can be called with a single parameter
11293 specifies a conversion from the type of its first
11294 parameter to the type of its class. Such a constructor
11295 is called a converting constructor. */
11296 if (explicitp
== 2)
11297 DECL_NONCONVERTING_P (decl
) = 1;
11298 else if (DECL_CONSTRUCTOR_P (decl
))
11300 /* The constructor can be called with exactly one
11301 parameter if there is at least one parameter, and
11302 any subsequent parameters have default arguments.
11303 We don't look at the first parameter, which is
11304 really just the `this' parameter for the new
11307 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11309 /* Skip the `in_chrg' argument too, if present. */
11310 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
11311 arg_types
= TREE_CHAIN (arg_types
);
11313 if (arg_types
== void_list_node
11315 && TREE_CHAIN (arg_types
)
11316 && TREE_CHAIN (arg_types
) != void_list_node
11317 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11318 DECL_NONCONVERTING_P (decl
) = 1;
11321 else if (TREE_CODE (type
) == METHOD_TYPE
)
11323 /* We only get here for friend declarations of
11324 members of other classes. */
11325 /* All method decls are public, so tell grokfndecl to set
11326 TREE_PUBLIC, also. */
11327 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11328 virtualp
, flags
, quals
, raises
,
11329 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11330 template_count
, in_namespace
);
11331 if (decl
== NULL_TREE
)
11334 else if (!staticp
&& ! processing_template_decl
11335 && !COMPLETE_TYPE_P (complete_type (type
))
11336 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11339 cp_error ("field `%D' has incomplete type", declarator
);
11341 cp_error ("name `%T' has incomplete type", type
);
11343 /* If we're instantiating a template, tell them which
11344 instantiation made the field's type be incomplete. */
11345 if (current_class_type
11346 && TYPE_NAME (current_class_type
)
11347 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11348 && declspecs
&& TREE_VALUE (declspecs
)
11349 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11350 cp_error (" in instantiation of template `%T'",
11351 current_class_type
);
11353 type
= error_mark_node
;
11360 error ("`%s' is neither function nor member function; cannot be declared friend",
11361 IDENTIFIER_POINTER (declarator
));
11369 /* Friends are treated specially. */
11370 if (ctype
== current_class_type
)
11371 warning ("member functions are implicitly friends of their class");
11374 tree t
= NULL_TREE
;
11375 if (decl
&& DECL_NAME (decl
))
11377 if (template_class_depth (current_class_type
) == 0)
11380 = check_explicit_specialization
11382 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11383 if (decl
== error_mark_node
)
11384 return error_mark_node
;
11387 t
= do_friend (ctype
, declarator
, decl
,
11388 last_function_parms
, attrlist
, flags
, quals
,
11391 if (t
&& funcdef_flag
)
11394 return void_type_node
;
11398 /* Structure field. It may not be a function, except for C++ */
11400 if (decl
== NULL_TREE
)
11406 /* An attempt is being made to initialize a non-static
11407 member. But, from [class.mem]:
11409 4 A member-declarator can contain a
11410 constant-initializer only if it declares a static
11411 member (_class.static_) of integral or enumeration
11412 type, see _class.static.data_.
11414 This used to be relatively common practice, but
11415 the rest of the compiler does not correctly
11416 handle the initialization unless the member is
11417 static so we make it static below. */
11418 cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11420 cp_pedwarn ("making `%D' static", declarator
);
11424 if (uses_template_parms (type
))
11425 /* We'll check at instantiation time. */
11427 else if (check_static_variable_definition (declarator
,
11429 /* If we just return the declaration, crashes
11430 will sometimes occur. We therefore return
11431 void_type_node, as if this was a friend
11432 declaration, to cause callers to completely
11433 ignore this declaration. */
11434 return void_type_node
;
11437 /* 9.2p13 [class.mem] */
11438 if (declarator
== constructor_name (current_class_type
)
11439 /* The standard does not allow non-static data members
11440 here either, but we agreed at the 10/99 meeting
11441 to change that in TC 1 so that they are allowed in
11442 classes with no user-defined constructors. */
11444 cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11449 /* C++ allows static class members. All other work
11450 for this is done by grokfield. */
11451 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
11452 TREE_STATIC (decl
) = 1;
11453 /* In class context, 'static' means public access. */
11454 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11458 decl
= build_decl (FIELD_DECL
, declarator
, type
);
11459 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11460 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11462 DECL_MUTABLE_P (decl
) = 1;
11463 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11467 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11468 inlinep
, friendp
, raises
!= NULL_TREE
);
11471 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11473 tree original_name
;
11479 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11480 original_name
= dname
;
11482 original_name
= declarator
;
11484 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11485 error ("storage class `auto' invalid for function `%s'", name
);
11486 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11487 error ("storage class `register' invalid for function `%s'", name
);
11489 /* Function declaration not at top level.
11490 Storage classes other than `extern' are not allowed
11491 and `extern' makes no difference. */
11492 if (! toplevel_bindings_p ()
11493 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11494 || RIDBIT_SETP (RID_INLINE
, specbits
))
11497 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11498 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11500 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11503 if (ctype
== NULL_TREE
)
11507 error ("virtual non-class function `%s'", name
);
11511 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11512 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11513 TYPE_ARG_TYPES (type
));
11515 /* Record presence of `static'. */
11516 publicp
= (ctype
!= NULL_TREE
11517 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11518 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11520 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11521 virtualp
, flags
, quals
, raises
,
11523 publicp
, inlinep
, funcdef_flag
,
11524 template_count
, in_namespace
);
11525 if (decl
== NULL_TREE
)
11530 int illegal_static
= 0;
11532 /* Don't allow a static member function in a class, and forbid
11533 declaring main to be static. */
11534 if (TREE_CODE (type
) == METHOD_TYPE
)
11536 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11537 illegal_static
= 1;
11539 else if (current_function_decl
)
11541 /* FIXME need arm citation */
11542 error ("cannot declare static function inside another function");
11543 illegal_static
= 1;
11546 if (illegal_static
)
11549 RIDBIT_RESET (RID_STATIC
, specbits
);
11555 /* It's a variable. */
11557 /* An uninitialized decl with `extern' is a reference. */
11558 decl
= grokvardecl (type
, declarator
, &specbits
,
11560 (type_quals
& TYPE_QUAL_CONST
) != 0,
11562 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11563 inlinep
, friendp
, raises
!= NULL_TREE
);
11567 DECL_CONTEXT (decl
) = ctype
;
11570 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11572 RIDBIT_RESET (RID_STATIC
, specbits
);
11574 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11576 cp_error ("static member `%D' declared `register'", decl
);
11577 RIDBIT_RESET (RID_REGISTER
, specbits
);
11579 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11581 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11583 RIDBIT_RESET (RID_EXTERN
, specbits
);
11588 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE
, specbits
), 19990927);
11590 /* Record `register' declaration for warnings on &
11591 and in case doing stupid register allocation. */
11593 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11594 DECL_REGISTER (decl
) = 1;
11596 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11597 DECL_THIS_EXTERN (decl
) = 1;
11599 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11600 DECL_THIS_STATIC (decl
) = 1;
11602 /* Record constancy and volatility. There's no need to do this
11603 when processing a template; we'll do this for the instantiated
11604 declaration based on the type of DECL. */
11605 if (!processing_template_decl
)
11606 c_apply_type_quals_to_decl (type_quals
, decl
);
11612 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11613 An empty exprlist is a parmlist. An exprlist which
11614 contains only identifiers at the global level
11615 is a parmlist. Otherwise, it is an exprlist. */
11618 parmlist_is_exprlist (exprs
)
11621 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11624 if (toplevel_bindings_p ())
11626 /* At the global level, if these are all identifiers,
11627 then it is a parmlist. */
11630 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11632 exprs
= TREE_CHAIN (exprs
);
11639 /* Subroutine of start_function. Ensure that each of the parameter
11640 types (as listed in PARMS) is complete, as is required for a
11641 function definition. */
11644 require_complete_types_for_parms (parms
)
11647 for (; parms
; parms
= TREE_CHAIN (parms
))
11649 if (VOID_TYPE_P (TREE_TYPE (parms
)))
11650 /* grokparms will have already issued an error */
11651 TREE_TYPE (parms
) = error_mark_node
;
11652 else if (complete_type_or_else (TREE_TYPE (parms
), parms
))
11653 layout_decl (parms
, 0);
11655 TREE_TYPE (parms
) = error_mark_node
;
11659 /* Returns non-zero if T is a local variable. */
11662 local_variable_p (t
)
11665 if ((TREE_CODE (t
) == VAR_DECL
11666 /* A VAR_DECL with a context that is a _TYPE is a static data
11668 && !TYPE_P (CP_DECL_CONTEXT (t
))
11669 /* Any other non-local variable must be at namespace scope. */
11670 && !DECL_NAMESPACE_SCOPE_P (t
))
11671 || (TREE_CODE (t
) == PARM_DECL
))
11677 /* Returns non-zero if T is an automatic local variable or a label.
11678 (These are the declarations that need to be remapped when the code
11679 containing them is duplicated.) */
11682 nonstatic_local_decl_p (t
)
11685 return ((local_variable_p (t
) && !TREE_STATIC (t
))
11686 || TREE_CODE (t
) == LABEL_DECL
11687 || TREE_CODE (t
) == RESULT_DECL
);
11690 /* Like local_variable_p, but suitable for use as a tree-walking
11694 local_variable_p_walkfn (tp
, walk_subtrees
, data
)
11696 int *walk_subtrees ATTRIBUTE_UNUSED
;
11697 void *data ATTRIBUTE_UNUSED
;
11699 return ((local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
11700 ? *tp
: NULL_TREE
);
11703 /* Check that ARG, which is a default-argument expression for a
11704 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11705 something goes wrong. DECL may also be a _TYPE node, rather than a
11706 DECL, if there is no DECL available. */
11709 check_default_argument (decl
, arg
)
11716 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11717 /* We get a DEFAULT_ARG when looking at an in-class declaration
11718 with a default argument. Ignore the argument for now; we'll
11719 deal with it after the class is complete. */
11722 if (processing_template_decl
|| uses_template_parms (arg
))
11723 /* We don't do anything checking until instantiation-time. Note
11724 that there may be uninstantiated arguments even for an
11725 instantiated function, since default arguments are not
11726 instantiated until they are needed. */
11735 decl_type
= TREE_TYPE (decl
);
11737 if (arg
== error_mark_node
11738 || decl
== error_mark_node
11739 || TREE_TYPE (arg
) == error_mark_node
11740 || decl_type
== error_mark_node
)
11741 /* Something already went wrong. There's no need to check
11743 return error_mark_node
;
11745 /* [dcl.fct.default]
11747 A default argument expression is implicitly converted to the
11749 if (!TREE_TYPE (arg
)
11750 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11753 cp_error ("default argument for `%#D' has type `%T'",
11754 decl
, TREE_TYPE (arg
));
11756 cp_error ("default argument for parameter of type `%T' has type `%T'",
11757 decl_type
, TREE_TYPE (arg
));
11759 return error_mark_node
;
11762 /* [dcl.fct.default]
11764 Local variables shall not be used in default argument
11767 The keyword `this' shall not be used in a default argument of a
11768 member function. */
11769 var
= walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
,
11773 cp_error ("default argument `%E' uses local variable `%D'",
11775 return error_mark_node
;
11782 /* Decode the list of parameter types for a function type.
11783 Given the list of things declared inside the parens,
11784 return a list of types.
11786 We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11787 flag. If unset, we append void_list_node. A parmlist declared
11788 as `(void)' is accepted as the empty parmlist.
11790 Also set last_function_parms to the chain of PARM_DECLs. */
11793 grokparms (first_parm
)
11796 tree result
= NULL_TREE
;
11797 tree decls
= NULL_TREE
;
11798 int ellipsis
= !first_parm
|| PARMLIST_ELLIPSIS_P (first_parm
);
11802 my_friendly_assert (!first_parm
|| TREE_PARMLIST (first_parm
), 20001115);
11804 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
11806 tree type
= NULL_TREE
;
11807 register tree decl
= TREE_VALUE (parm
);
11808 tree init
= TREE_PURPOSE (parm
);
11810 chain
= TREE_CHAIN (parm
);
11811 /* @@ weak defense against parse errors. */
11812 if (TREE_CODE (decl
) != VOID_TYPE
11813 && TREE_CODE (decl
) != TREE_LIST
)
11815 /* Give various messages as the need arises. */
11816 if (TREE_CODE (decl
) == STRING_CST
)
11817 cp_error ("invalid string constant `%E'", decl
);
11818 else if (TREE_CODE (decl
) == INTEGER_CST
)
11819 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11823 if (parm
== void_list_node
)
11826 decl
= grokdeclarator (TREE_VALUE (decl
), TREE_PURPOSE (decl
),
11827 PARM
, init
!= NULL_TREE
, NULL_TREE
);
11828 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11831 type
= TREE_TYPE (decl
);
11832 if (VOID_TYPE_P (type
))
11834 if (same_type_p (type
, void_type_node
)
11835 && !DECL_NAME (decl
) && !result
&& !chain
&& !ellipsis
)
11836 /* this is a parmlist of `(void)', which is ok. */
11838 incomplete_type_error (decl
, type
);
11839 /* It's not a good idea to actually create parameters of
11840 type `void'; other parts of the compiler assume that a
11841 void type terminates the parameter list. */
11842 type
= error_mark_node
;
11843 TREE_TYPE (decl
) = error_mark_node
;
11846 if (type
!= error_mark_node
)
11848 /* Top-level qualifiers on the parameters are
11849 ignored for function types. */
11850 type
= TYPE_MAIN_VARIANT (type
);
11851 if (TREE_CODE (type
) == METHOD_TYPE
)
11853 cp_error ("parameter `%D' invalidly declared method type", decl
);
11854 type
= build_pointer_type (type
);
11855 TREE_TYPE (decl
) = type
;
11857 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11859 cp_error ("parameter `%D' invalidly declared offset type", decl
);
11860 type
= build_pointer_type (type
);
11861 TREE_TYPE (decl
) = type
;
11863 else if (abstract_virtuals_error (decl
, type
))
11864 any_error
= 1; /* Seems like a good idea. */
11865 else if (POINTER_TYPE_P (type
))
11867 /* [dcl.fct]/6, parameter types cannot contain pointers
11868 (references) to arrays of unknown bound. */
11869 tree t
= TREE_TYPE (type
);
11870 int ptr
= TYPE_PTR_P (type
);
11874 if (TYPE_PTR_P (t
))
11876 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11878 else if (!TYPE_DOMAIN (t
))
11882 if (TREE_CODE (t
) == ARRAY_TYPE
)
11883 cp_error ("parameter `%D' includes %s to array of unknown bound `%T'",
11884 decl
, ptr
? "pointer" : "reference", t
);
11887 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
11888 if (PROMOTE_PROTOTYPES
11889 && (TREE_CODE (type
) == INTEGER_TYPE
11890 || TREE_CODE (type
) == ENUMERAL_TYPE
)
11891 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
11892 DECL_ARG_TYPE (decl
) = integer_type_node
;
11893 if (!any_error
&& init
)
11894 init
= check_default_argument (decl
, init
);
11899 TREE_CHAIN (decl
) = decls
;
11901 result
= tree_cons (init
, type
, result
);
11903 decls
= nreverse (decls
);
11904 result
= nreverse (result
);
11906 result
= chainon (result
, void_list_node
);
11907 last_function_parms
= decls
;
11913 /* D is a constructor or overloaded `operator='. Returns non-zero if
11914 D's arguments allow it to be a copy constructor, or copy assignment
11923 if (!DECL_FUNCTION_MEMBER_P (d
))
11926 t
= FUNCTION_ARG_CHAIN (d
);
11927 if (DECL_CONSTRUCTOR_P (d
) && DECL_HAS_IN_CHARGE_PARM_P (d
))
11928 t
= TREE_CHAIN (t
);
11929 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
11930 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
11931 == DECL_CONTEXT (d
))
11932 && (TREE_CHAIN (t
) == NULL_TREE
11933 || TREE_CHAIN (t
) == void_list_node
11934 || TREE_PURPOSE (TREE_CHAIN (t
))))
11939 /* These memoizing functions keep track of special properties which
11940 a class may have. `grok_ctor_properties' notices whether a class
11941 has a constructor of the form X(X&), and also complains
11942 if the class has a constructor of the form X(X).
11943 `grok_op_properties' takes notice of the various forms of
11944 operator= which are defined, as well as what sorts of type conversion
11945 may apply. Both functions take a FUNCTION_DECL as an argument. */
11948 grok_ctor_properties (ctype
, decl
)
11951 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
11952 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
11954 /* When a type has virtual baseclasses, a magical first int argument is
11955 added to any ctor so we can tell if the class has been initialized
11956 yet. This could screw things up in this function, so we deliberately
11957 ignore the leading int if we're in that situation. */
11958 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
11960 my_friendly_assert (parmtypes
11961 && TREE_VALUE (parmtypes
) == integer_type_node
,
11963 parmtypes
= TREE_CHAIN (parmtypes
);
11964 parmtype
= TREE_VALUE (parmtypes
);
11969 A non-template constructor for class X is a copy constructor if
11970 its first parameter is of type X&, const X&, volatile X& or const
11971 volatile X&, and either there are no other parameters or else all
11972 other parameters have default arguments. */
11973 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
11974 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
11975 && sufficient_parms_p (TREE_CHAIN (parmtypes
))
11976 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
11977 && is_member_template (DECL_TI_TEMPLATE (decl
))))
11979 TYPE_HAS_INIT_REF (ctype
) = 1;
11980 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
11981 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
11985 A declaration of a constructor for a class X is ill-formed if its
11986 first parameter is of type (optionally cv-qualified) X and either
11987 there are no other parameters or else all other parameters have
11990 We *don't* complain about member template instantiations that
11991 have this form, though; they can occur as we try to decide what
11992 constructor to use during overload resolution. Since overload
11993 resolution will never prefer such a constructor to the
11994 non-template copy constructor (which is either explicitly or
11995 implicitly defined), there's no need to worry about their
11996 existence. Theoretically, they should never even be
11997 instantiated, but that's hard to forestall. */
11998 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
11999 && sufficient_parms_p (TREE_CHAIN (parmtypes
))
12000 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12001 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12003 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12005 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
12008 else if (TREE_CODE (parmtype
) == VOID_TYPE
12009 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
12010 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
12015 /* An operator with this code is unary, but can also be binary. */
12019 enum tree_code code
;
12021 return (code
== INDIRECT_REF
12022 || code
== ADDR_EXPR
12023 || code
== CONVERT_EXPR
12024 || code
== NEGATE_EXPR
12025 || code
== PREINCREMENT_EXPR
12026 || code
== PREDECREMENT_EXPR
);
12029 /* An operator with this name can only be unary. */
12033 enum tree_code code
;
12035 return (code
== TRUTH_NOT_EXPR
12036 || code
== BIT_NOT_EXPR
12037 || code
== COMPONENT_REF
12038 || code
== TYPE_EXPR
);
12041 /* Do a little sanity-checking on how they declared their operator. */
12044 grok_op_properties (decl
, virtualp
, friendp
)
12046 int virtualp
, friendp
;
12048 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12050 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12051 tree name
= DECL_NAME (decl
);
12052 enum tree_code operator_code
;
12055 /* Count the number of arguments. */
12056 for (argtype
= argtypes
, arity
= 0;
12057 argtype
&& argtype
!= void_list_node
;
12058 argtype
= TREE_CHAIN (argtype
))
12061 if (current_class_type
== NULL_TREE
)
12064 if (DECL_CONV_FN_P (decl
))
12065 operator_code
= TYPE_EXPR
;
12069 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P) \
12070 if (ansi_opname (CODE) == name) \
12072 operator_code = CODE; \
12075 else if (ansi_assopname (CODE) == name) \
12077 operator_code = CODE; \
12078 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12082 #include "operators.def"
12083 #undef DEF_OPERATOR
12085 my_friendly_abort (20000527);
12088 my_friendly_assert (operator_code
!= LAST_CPLUS_TREE_CODE
, 20000526);
12089 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12093 switch (operator_code
)
12096 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
12100 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
12103 case COMPONENT_REF
:
12105 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
12109 TYPE_HAS_NEW_OPERATOR (current_class_type
) = 1;
12113 TYPE_GETS_DELETE (current_class_type
) |= 1;
12117 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type
) = 1;
12120 case VEC_DELETE_EXPR
:
12121 TYPE_GETS_DELETE (current_class_type
) |= 2;
12129 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12131 /* When the compiler encounters the definition of A::operator new, it
12132 doesn't look at the class declaration to find out if it's static. */
12134 revert_static_member_fn (decl
);
12136 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12138 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12141 revert_static_member_fn (decl
);
12143 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12147 /* An operator function must either be a non-static member function
12148 or have at least one parameter of a class, a reference to a class,
12149 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12150 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12152 if (operator_code
== TYPE_EXPR
12153 || operator_code
== CALL_EXPR
12154 || operator_code
== COMPONENT_REF
12155 || operator_code
== ARRAY_REF
12156 || operator_code
== NOP_EXPR
)
12157 cp_error ("`%D' must be a nonstatic member function", decl
);
12162 if (DECL_STATIC_FUNCTION_P (decl
))
12163 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
12166 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
12168 tree arg
= TREE_VALUE (p
);
12169 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
12170 arg
= TREE_TYPE (arg
);
12172 /* This lets bad template code slip through. */
12173 if (IS_AGGR_TYPE (arg
)
12174 || TREE_CODE (arg
) == ENUMERAL_TYPE
12175 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
12176 || TREE_CODE (arg
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12180 ("`%D' must have an argument of class or enumerated type",
12187 if (operator_code
== CALL_EXPR
)
12188 return; /* No restrictions on args. */
12190 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
12192 tree t
= TREE_TYPE (name
);
12195 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12196 const char *what
= 0;
12199 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12201 if (TREE_CODE (t
) == VOID_TYPE
)
12203 else if (t
== current_class_type
)
12204 what
= "the same type";
12205 /* Don't force t to be complete here. */
12206 else if (IS_AGGR_TYPE (t
)
12207 && COMPLETE_TYPE_P (t
)
12208 && DERIVED_FROM_P (t
, current_class_type
))
12209 what
= "a base class";
12212 warning ("conversion to %s%s will never use a type conversion operator",
12213 ref
? "a reference to " : "", what
);
12217 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
12218 && operator_code
== NOP_EXPR
)
12222 if (arity
!= 2 && methodp
)
12224 cp_error ("`%D' must take exactly one argument", decl
);
12227 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12231 A user-declared copy assignment operator X::operator= is
12232 a non-static non-template member function of class X with
12233 exactly one parameter of type X, X&, const X&, volatile
12234 X& or const volatile X&. */
12235 if (copy_assignment_arg_p (parmtype
, virtualp
)
12236 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12237 && is_member_template (DECL_TI_TEMPLATE (decl
)))
12240 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12241 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12242 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12243 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12246 else if (operator_code
== COND_EXPR
)
12249 cp_error ("ISO C++ prohibits overloading operator ?:");
12251 else if (ambi_op_p (operator_code
))
12254 /* We pick the one-argument operator codes by default, so
12255 we don't have to change anything. */
12257 else if (arity
== 2)
12259 /* If we thought this was a unary operator, we now know
12260 it to be a binary operator. */
12261 switch (operator_code
)
12264 operator_code
= MULT_EXPR
;
12268 operator_code
= BIT_AND_EXPR
;
12272 operator_code
= PLUS_EXPR
;
12276 operator_code
= MINUS_EXPR
;
12279 case PREINCREMENT_EXPR
:
12280 operator_code
= POSTINCREMENT_EXPR
;
12283 case PREDECREMENT_EXPR
:
12284 operator_code
= POSTDECREMENT_EXPR
;
12288 my_friendly_abort (20000527);
12291 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12293 if ((operator_code
== POSTINCREMENT_EXPR
12294 || operator_code
== POSTDECREMENT_EXPR
)
12295 && ! processing_template_decl
12296 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12299 cp_error ("postfix `%D' must take `int' as its argument",
12303 ("postfix `%D' must take `int' as its second argument",
12310 cp_error ("`%D' must take either zero or one argument", decl
);
12312 cp_error ("`%D' must take either one or two arguments", decl
);
12315 /* More Effective C++ rule 6. */
12317 && (operator_code
== POSTINCREMENT_EXPR
12318 || operator_code
== POSTDECREMENT_EXPR
12319 || operator_code
== PREINCREMENT_EXPR
12320 || operator_code
== PREDECREMENT_EXPR
))
12322 tree arg
= TREE_VALUE (argtypes
);
12323 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12324 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12325 arg
= TREE_TYPE (arg
);
12326 arg
= TYPE_MAIN_VARIANT (arg
);
12327 if (operator_code
== PREINCREMENT_EXPR
12328 || operator_code
== PREDECREMENT_EXPR
)
12330 if (TREE_CODE (ret
) != REFERENCE_TYPE
12331 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12333 cp_warning ("prefix `%D' should return `%T'", decl
,
12334 build_reference_type (arg
));
12338 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12339 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12343 else if (unary_op_p (operator_code
))
12348 cp_error ("`%D' must take `void'", decl
);
12350 cp_error ("`%D' must take exactly one argument", decl
);
12353 else /* if (binary_op_p (operator_code)) */
12358 cp_error ("`%D' must take exactly one argument", decl
);
12360 cp_error ("`%D' must take exactly two arguments", decl
);
12363 /* More Effective C++ rule 7. */
12365 && (operator_code
== TRUTH_ANDIF_EXPR
12366 || operator_code
== TRUTH_ORIF_EXPR
12367 || operator_code
== COMPOUND_EXPR
))
12368 cp_warning ("user-defined `%D' always evaluates both arguments",
12372 /* Effective C++ rule 23. */
12375 && (operator_code
== PLUS_EXPR
12376 || operator_code
== MINUS_EXPR
12377 || operator_code
== TRUNC_DIV_EXPR
12378 || operator_code
== MULT_EXPR
)
12379 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12380 cp_warning ("`%D' should return by value", decl
);
12383 for (; argtypes
&& argtypes
!= void_list_node
;
12384 argtypes
= TREE_CHAIN (argtypes
))
12385 if (TREE_PURPOSE (argtypes
))
12387 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12388 if (operator_code
== POSTINCREMENT_EXPR
12389 || operator_code
== POSTDECREMENT_EXPR
)
12392 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12395 cp_error ("`%D' cannot have default arguments", decl
);
12401 static const char *
12403 enum tag_types code
;
12416 my_friendly_abort (981122);
12420 /* Get the struct, enum or union (CODE says which) with tag NAME.
12421 Define the tag as a forward-reference if it is not defined.
12423 C++: If a class derivation is given, process it here, and report
12424 an error if multiple derivation declarations are not identical.
12426 If this is a definition, come in through xref_tag and only look in
12427 the current frame for the name (since C++ allows new names in any
12431 xref_tag (code_type_node
, name
, globalize
)
12432 tree code_type_node
;
12436 enum tag_types tag_code
;
12437 enum tree_code code
;
12438 register tree ref
, t
;
12439 struct binding_level
*b
= current_binding_level
;
12441 tree attributes
= NULL_TREE
;
12442 tree context
= NULL_TREE
;
12444 /* If we are called from the parser, code_type_node will sometimes be a
12445 TREE_LIST. This indicates that the user wrote
12446 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12448 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12450 attributes
= TREE_PURPOSE (code_type_node
);
12451 code_type_node
= TREE_VALUE (code_type_node
);
12454 tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12459 code
= RECORD_TYPE
;
12465 code
= ENUMERAL_TYPE
;
12468 my_friendly_abort (18);
12471 /* If a cross reference is requested, look up the type
12472 already defined for this tag and return it. */
12476 name
= TYPE_IDENTIFIER (t
);
12480 t
= IDENTIFIER_TYPE_VALUE (name
);
12482 /* Warn about 'friend struct Inherited;' doing the wrong thing. */
12483 if (t
&& globalize
&& TREE_CODE (t
) == TYPENAME_TYPE
)
12485 static int explained
;
12487 cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12488 to refer to the inherited type, say `%s %T::%T'%s",
12489 tag_name (tag_code
), name
, tag_name (tag_code
),
12490 constructor_name (current_class_type
), TYPE_IDENTIFIER (t
),
12492 (names from dependent base classes are not visible to unqualified name lookup)"
12498 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12499 && TREE_CODE (t
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
12504 /* If we know we are defining this tag, only look it up in
12505 this scope and don't try to find it as a type. */
12506 ref
= lookup_tag (code
, name
, b
, 1);
12512 /* [dcl.type.elab] If the identifier resolves to a
12513 typedef-name or a template type-parameter, the
12514 elaborated-type-specifier is ill-formed. */
12515 if (t
!= TYPE_MAIN_VARIANT (t
)
12516 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12517 cp_pedwarn ("using typedef-name `%D' after `%s'",
12518 TYPE_NAME (t
), tag_name (tag_code
));
12519 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12520 cp_error ("using template type parameter `%T' after `%s'",
12521 t
, tag_name (tag_code
));
12526 ref
= lookup_tag (code
, name
, b
, 0);
12530 /* Try finding it as a type declaration. If that wins,
12532 ref
= lookup_name (name
, 1);
12534 if (ref
!= NULL_TREE
12535 && processing_template_decl
12536 && DECL_CLASS_TEMPLATE_P (ref
)
12537 && template_class_depth (current_class_type
) == 0)
12538 /* Since GLOBALIZE is true, we're declaring a global
12539 template, so we want this type. */
12540 ref
= DECL_TEMPLATE_RESULT (ref
);
12542 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12543 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12544 ref
= TREE_TYPE (ref
);
12549 if (ref
&& current_class_type
12550 && template_class_depth (current_class_type
)
12551 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12553 /* Since GLOBALIZE is non-zero, we are not looking at a
12554 definition of this tag. Since, in addition, we are currently
12555 processing a (member) template declaration of a template
12556 class, we must be very careful; consider:
12563 { template <class V>
12564 friend struct S1; };
12566 Here, the S2::S1 declaration should not be confused with the
12567 outer declaration. In particular, the inner version should
12568 have a template parameter of level 2, not level 1. This
12569 would be particularly important if the member declaration
12572 template <class V = U> friend struct S1;
12574 say, when we should tsubst into `U' when instantiating
12575 S2. On the other hand, when presented with:
12585 we must find the inner binding eventually. We
12586 accomplish this by making sure that the new type we
12587 create to represent this declaration has the right
12589 context
= TYPE_CONTEXT (ref
);
12596 /* If no such tag is yet defined, create a forward-reference node
12597 and record it as the "definition".
12598 When a real declaration of this type is found,
12599 the forward-reference will be altered into a real type. */
12600 if (code
== ENUMERAL_TYPE
)
12602 cp_error ("use of enum `%#D' without previous declaration", name
);
12604 ref
= make_node (ENUMERAL_TYPE
);
12606 /* Give the type a default layout like unsigned int
12607 to avoid crashing if it does not get defined. */
12608 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12609 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12610 TYPE_USER_ALIGN (ref
) = 0;
12611 TREE_UNSIGNED (ref
) = 1;
12612 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12613 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12614 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12616 /* Enable us to recognize when a type is created in class context.
12617 To do nested classes correctly, this should probably be cleared
12618 out when we leave this classes scope. Currently this in only
12619 done in `start_enum'. */
12621 pushtag (name
, ref
, globalize
);
12625 struct binding_level
*old_b
= class_binding_level
;
12627 ref
= make_aggr_type (code
);
12628 TYPE_CONTEXT (ref
) = context
;
12630 #ifdef NONNESTED_CLASSES
12631 /* Class types don't nest the way enums do. */
12632 class_binding_level
= (struct binding_level
*)0;
12634 pushtag (name
, ref
, globalize
);
12635 class_binding_level
= old_b
;
12640 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12641 redeclare_class_template (ref
, current_template_parms
);
12644 /* Until the type is defined, tentatively accept whatever
12645 structure tag the user hands us. */
12646 if (!COMPLETE_TYPE_P (ref
)
12647 && ref
!= current_class_type
12648 /* Have to check this, in case we have contradictory tag info. */
12649 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12651 if (tag_code
== class_type
)
12652 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12653 else if (tag_code
== record_type
)
12654 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12657 TREE_TYPE (ref
) = attributes
;
12663 xref_tag_from_type (old
, id
, globalize
)
12667 tree code_type_node
;
12669 if (TREE_CODE (old
) == RECORD_TYPE
)
12670 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12671 ? class_type_node
: record_type_node
);
12673 code_type_node
= union_type_node
;
12675 if (id
== NULL_TREE
)
12676 id
= TYPE_IDENTIFIER (old
);
12678 return xref_tag (code_type_node
, id
, globalize
);
12681 /* REF is a type (named NAME), for which we have just seen some
12682 baseclasses. BINFO is a list of those baseclasses; the
12683 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12684 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12685 struct, or union. */
12688 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12689 tree code_type_node
;
12693 /* In the declaration `A : X, Y, ... Z' we mark all the types
12694 (A, X, Y, ..., Z) so we can check for duplicates. */
12699 enum tag_types tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12701 if (tag_code
== union_type
)
12703 cp_error ("derived union `%T' invalid", ref
);
12707 len
= list_length (binfo
);
12709 /* First, make sure that any templates in base-classes are
12710 instantiated. This ensures that if we call ourselves recursively
12711 we do not get confused about which classes are marked and which
12713 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12714 complete_type (TREE_VALUE (base
));
12716 SET_CLASSTYPE_MARKED (ref
);
12717 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
12719 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
12721 /* The base of a derived struct is public by default. */
12723 = (TREE_PURPOSE (binfo
) == access_public_node
12724 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12725 || (tag_code
!= class_type
12726 && (TREE_PURPOSE (binfo
) == access_default_node
12727 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
12729 = (TREE_PURPOSE (binfo
) == access_protected_node
12730 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
12732 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
12733 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
12734 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12735 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
12736 tree basetype
= TREE_VALUE (binfo
);
12739 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
12740 basetype
= TREE_TYPE (basetype
);
12742 || (TREE_CODE (basetype
) != RECORD_TYPE
12743 && TREE_CODE (basetype
) != TYPENAME_TYPE
12744 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
12745 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
))
12747 cp_error ("base type `%T' fails to be a struct or class type",
12748 TREE_VALUE (binfo
));
12752 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
12754 /* This code replaces similar code in layout_basetypes.
12755 We put the complete_type first for implicit `typename'. */
12756 if (!COMPLETE_TYPE_P (basetype
)
12757 && ! (current_template_parms
&& uses_template_parms (basetype
)))
12759 cp_error ("base class `%T' has incomplete type", basetype
);
12764 if (CLASSTYPE_MARKED (basetype
))
12766 if (basetype
== ref
)
12767 cp_error ("recursive type `%T' undefined", basetype
);
12769 cp_error ("duplicate base type `%T' invalid", basetype
);
12773 if (TYPE_FOR_JAVA (basetype
)
12774 && (current_lang_stack
12775 == &VARRAY_TREE (current_lang_base
, 0)))
12776 TYPE_FOR_JAVA (ref
) = 1;
12778 /* Note that the BINFO records which describe individual
12779 inheritances are *not* shared in the lattice! They
12780 cannot be shared because a given baseclass may be
12781 inherited with different `accessibility' by different
12782 derived classes. (Each BINFO record describing an
12783 individual inheritance contains flags which say what
12784 the `accessibility' of that particular inheritance is.) */
12787 = make_binfo (size_zero_node
, basetype
,
12788 CLASS_TYPE_P (basetype
)
12789 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
12790 CLASS_TYPE_P (basetype
)
12791 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
12793 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
12794 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
12795 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
12796 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
12797 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
12799 /* We need to unshare the binfos now so that lookups during class
12800 definition work. */
12801 unshare_base_binfos (base_binfo
);
12803 SET_CLASSTYPE_MARKED (basetype
);
12805 /* We are free to modify these bits because they are meaningless
12806 at top level, and BASETYPE is a top-level type. */
12807 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
12809 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
12810 /* Converting to a virtual base class requires looking
12811 up the offset of the virtual base. */
12812 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
12815 if (CLASS_TYPE_P (basetype
))
12817 TYPE_HAS_NEW_OPERATOR (ref
)
12818 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12819 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12820 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12821 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12822 /* If the base-class uses multiple inheritance, so do we. */
12823 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
12824 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
12825 /* Likewise, if converting to a base of the base may require
12826 code, then we may need to generate code to convert to a
12828 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
)
12829 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
);
12836 TREE_VEC_LENGTH (binfos
) = i
;
12838 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
12842 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
12843 /* If there is more than one non-empty they cannot be at the same
12845 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
12848 /* Unmark all the types. */
12850 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
12851 CLEAR_CLASSTYPE_MARKED (ref
);
12853 /* Now that we know all the base-classes, set up the list of virtual
12855 get_vbase_types (ref
);
12859 /* Begin compiling the definition of an enumeration type.
12860 NAME is its name (or null if anonymous).
12861 Returns the type object, as yet incomplete.
12862 Also records info about it so that build_enumerator
12863 may be used to declare the individual values as they are read. */
12869 register tree enumtype
= NULL_TREE
;
12870 struct binding_level
*b
= current_binding_level
;
12872 /* If this is the real definition for a previous forward reference,
12873 fill in the contents in the same object that used to be the
12874 forward reference. */
12876 if (name
!= NULL_TREE
)
12877 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
12879 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12881 cp_error ("multiple definition of `%#T'", enumtype
);
12882 cp_error_at ("previous definition here", enumtype
);
12883 /* Clear out TYPE_VALUES, and start again. */
12884 TYPE_VALUES (enumtype
) = NULL_TREE
;
12888 enumtype
= make_node (ENUMERAL_TYPE
);
12889 pushtag (name
, enumtype
, 0);
12892 if (current_class_type
)
12893 TREE_ADDRESSABLE (b
->tags
) = 1;
12895 GNU_xref_decl (current_function_decl
, enumtype
);
12899 /* After processing and defining all the values of an enumeration type,
12900 install their decls in the enumeration type and finish it off.
12901 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12902 Returns ENUMTYPE. */
12905 finish_enum (enumtype
)
12908 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
12909 /* Calculate the maximum value of any enumerator in this type. */
12911 tree values
= TYPE_VALUES (enumtype
);
12916 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
12921 /* The TREE_VALUE is a CONST_DECL for this enumeration
12923 decl
= TREE_VALUE (pair
);
12927 Following the closing brace of an enum-specifier, each
12928 enumerator has the type of its enumeration. Prior to the
12929 closing brace, the type of each enumerator is the type of
12930 its initializing value. */
12931 TREE_TYPE (decl
) = enumtype
;
12933 /* The DECL_INITIAL will be NULL if we are processing a
12934 template declaration and this enumeration constant had no
12935 explicit initializer. */
12936 value
= DECL_INITIAL (decl
);
12937 if (value
&& !processing_template_decl
)
12939 /* Set the TREE_TYPE for the VALUE as well. That's so
12940 that when we call decl_constant_value we get an
12941 entity of the right type (but with the constant
12942 value). Since we shouldn't ever call
12943 decl_constant_value on a template type, there's no
12944 reason to do that when processing_template_decl.
12945 And, if the expression is something like a
12946 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12947 wreak havoc on the intended type of the expression.
12949 Of course, there's also no point in trying to compute
12950 minimum or maximum values if we're in a template. */
12951 TREE_TYPE (value
) = enumtype
;
12954 minnode
= maxnode
= value
;
12955 else if (tree_int_cst_lt (maxnode
, value
))
12957 else if (tree_int_cst_lt (value
, minnode
))
12961 if (processing_template_decl
)
12962 /* If this is just a template, leave the CONST_DECL
12963 alone. That way tsubst_copy will find CONST_DECLs for
12964 CONST_DECLs, and not INTEGER_CSTs. */
12967 /* In the list we're building up, we want the enumeration
12968 values, not the CONST_DECLs. */
12969 TREE_VALUE (pair
) = value
;
12973 maxnode
= minnode
= integer_zero_node
;
12975 TYPE_VALUES (enumtype
) = nreverse (values
);
12977 if (processing_template_decl
)
12979 tree scope
= current_scope ();
12980 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
12981 add_stmt (build_min (TAG_DEFN
, enumtype
));
12985 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12986 int lowprec
= min_precision (minnode
, unsignedp
);
12987 int highprec
= min_precision (maxnode
, unsignedp
);
12988 int precision
= MAX (lowprec
, highprec
);
12991 TYPE_SIZE (enumtype
) = NULL_TREE
;
12993 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12995 TYPE_PRECISION (enumtype
) = precision
;
12997 fixup_unsigned_type (enumtype
);
12999 fixup_signed_type (enumtype
);
13001 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
13002 /* Use the width of the narrowest normal C type which is wide
13004 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
13007 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
13009 TYPE_SIZE (enumtype
) = 0;
13010 layout_type (enumtype
);
13012 /* Fix up all variant types of this enum type. */
13013 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
13014 tem
= TYPE_NEXT_VARIANT (tem
))
13016 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
13017 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
13018 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
13019 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
13020 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
13021 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
13022 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
13023 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
13024 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
13025 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
13028 /* Finish debugging output for this type. */
13029 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13035 /* Build and install a CONST_DECL for an enumeration constant of the
13036 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13037 Assignment of sequential values by default is handled here. */
13040 build_enumerator (name
, value
, enumtype
)
13050 /* Remove no-op casts from the value. */
13052 STRIP_TYPE_NOPS (value
);
13054 if (! processing_template_decl
)
13056 /* Validate and default VALUE. */
13057 if (value
!= NULL_TREE
)
13059 value
= decl_constant_value (value
);
13061 if (TREE_CODE (value
) == INTEGER_CST
)
13063 value
= default_conversion (value
);
13064 constant_expression_warning (value
);
13068 cp_error ("enumerator value for `%D' not integer constant", name
);
13073 /* Default based on previous value. */
13074 if (value
== NULL_TREE
&& ! processing_template_decl
)
13078 if (TYPE_VALUES (enumtype
))
13080 /* The next value is the previous value ... */
13081 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13082 /* ... plus one. */
13083 value
= cp_build_binary_op (PLUS_EXPR
,
13087 if (tree_int_cst_lt (value
, prev_value
))
13088 cp_error ("overflow in enumeration values at `%D'", name
);
13091 value
= integer_zero_node
;
13094 /* Remove no-op casts from the value. */
13096 STRIP_TYPE_NOPS (value
);
13098 /* To fix MAX_VAL enum consts. (bkoz) */
13099 TREE_TYPE (value
) = integer_type_node
;
13103 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13104 Even in other cases, we will later (in finish_enum) be setting
13105 the type of VALUE. But, we don't need to make a copy if this
13106 VALUE is one of the enumeration constants for this same
13107 enumeration type. */
13108 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13109 if (TREE_VALUE (values
) == value
)
13111 /* If we didn't break out of the loop, then we do need a copy. */
13112 if (!values
&& value
)
13113 value
= copy_node (value
);
13115 /* C++ associates enums with global, function, or class declarations. */
13116 context
= current_scope ();
13118 /* Build the actual enumeration constant. Note that the enumeration
13119 constants have the type of their initializers until the
13120 enumeration is complete:
13124 Following the closing brace of an enum-specifier, each enumer-
13125 ator has the type of its enumeration. Prior to the closing
13126 brace, the type of each enumerator is the type of its
13127 initializing value.
13129 In finish_enum we will reset the type. Of course, if we're
13130 processing a template, there may be no value. */
13131 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13133 if (context
&& context
== current_class_type
)
13134 /* This enum declaration is local to the class. We need the full
13135 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13136 decl
= build_lang_decl (CONST_DECL
, name
, type
);
13138 /* It's a global enum, or it's local to a function. (Note local to
13139 a function could mean local to a class method. */
13140 decl
= build_decl (CONST_DECL
, name
, type
);
13142 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
13143 DECL_INITIAL (decl
) = value
;
13144 TREE_READONLY (decl
) = 1;
13146 if (context
&& context
== current_class_type
)
13147 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13148 on the TYPE_FIELDS list for `S'. (That's so that you can say
13149 things like `S::i' later.) */
13150 finish_member_declaration (decl
);
13154 GNU_xref_decl (current_function_decl
, decl
);
13157 /* Add this enumeration constant to the list for this type. */
13158 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13162 /* We're defining DECL. Make sure that it's type is OK. */
13165 check_function_type (decl
, current_function_parms
)
13167 tree current_function_parms
;
13169 tree fntype
= TREE_TYPE (decl
);
13170 tree return_type
= complete_type (TREE_TYPE (fntype
));
13172 /* In a function definition, arg types must be complete. */
13173 require_complete_types_for_parms (current_function_parms
);
13175 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13177 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
13179 /* Make it return void instead, but don't change the
13180 type of the DECL_RESULT, in case we have a named return value. */
13181 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13183 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
13185 = build_cplus_method_type (ctype
,
13187 FUNCTION_ARG_CHAIN (decl
));
13191 = build_function_type (void_type_node
,
13192 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
13194 = build_exception_variant (fntype
,
13195 TYPE_RAISES_EXCEPTIONS (fntype
));
13198 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13201 /* Create the FUNCTION_DECL for a function definition.
13202 DECLSPECS and DECLARATOR are the parts of the declaration;
13203 they describe the function's name and the type it returns,
13204 but twisted together in a fashion that parallels the syntax of C.
13206 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13207 DECLARATOR is really the DECL for the function we are about to
13208 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13209 indicating that the function is an inline defined in-class.
13211 This function creates a binding context for the function body
13212 as well as setting up the FUNCTION_DECL in current_function_decl.
13214 Returns 1 on success. If the DECLARATOR is not suitable for a function
13215 (it defines a datum instead), we return 0, which tells
13216 yyparse to report a parse error.
13218 For C++, we must first check whether that datum makes any sense.
13219 For example, "class A local_a(1,2);" means that variable local_a
13220 is an aggregate of type A, which should have a constructor
13221 applied to it with the argument list [1, 2]. */
13224 start_function (declspecs
, declarator
, attrs
, flags
)
13225 tree declspecs
, declarator
, attrs
;
13229 tree ctype
= NULL_TREE
;
13232 extern int have_extern_spec
;
13233 extern int used_extern_spec
;
13234 int doing_friend
= 0;
13235 struct binding_level
*bl
;
13236 tree current_function_parms
;
13238 /* Sanity check. */
13239 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
13240 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
13242 /* This should only be done once on the top most decl. */
13243 if (have_extern_spec
&& !used_extern_spec
)
13245 declspecs
= tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
13246 used_extern_spec
= 1;
13249 if (flags
& SF_PRE_PARSED
)
13251 decl1
= declarator
;
13253 fntype
= TREE_TYPE (decl1
);
13254 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13255 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13257 /* ISO C++ 11.4/5. A friend function defined in a class is in
13258 the (lexical) scope of the class in which it is defined. */
13259 if (!ctype
&& DECL_FRIEND_P (decl1
))
13261 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13263 /* CTYPE could be null here if we're dealing with a template;
13264 for example, `inline friend float foo()' inside a template
13265 will have no CTYPE set. */
13266 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13272 last_function_parms
= DECL_ARGUMENTS (decl1
);
13273 last_function_parm_tags
= NULL_TREE
;
13277 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
13278 /* If the declarator is not suitable for a function definition,
13279 cause a syntax error. */
13280 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13282 fntype
= TREE_TYPE (decl1
);
13284 restype
= TREE_TYPE (fntype
);
13285 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13287 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13288 shadow_tag (build_tree_list (NULL_TREE
, restype
));
13289 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13290 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13291 fntype
= build_function_type (integer_type_node
,
13292 TYPE_ARG_TYPES (fntype
));
13294 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13296 TYPE_ARG_TYPES (fntype
));
13297 TREE_TYPE (decl1
) = fntype
;
13300 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13301 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13302 else if (DECL_MAIN_P (decl1
))
13304 /* If this doesn't return integer_type, complain. */
13305 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13307 if (pedantic
|| warn_return_type
)
13308 pedwarn ("return type for `main' changed to `int'");
13309 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13314 /* Sometimes we don't notice that a function is a static member, and
13315 build a METHOD_TYPE for it. Fix that up now. */
13316 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13317 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
13319 revert_static_member_fn (decl1
);
13320 last_function_parms
= TREE_CHAIN (last_function_parms
);
13324 /* Warn if function was previously implicitly declared
13325 (but not if we warned then). */
13326 if (! warn_implicit
13327 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13328 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13330 /* Set up current_class_type, and enter the scope of the class, if
13333 push_nested_class (ctype
, 1);
13334 else if (DECL_STATIC_FUNCTION_P (decl1
))
13335 push_nested_class (DECL_CONTEXT (decl1
), 2);
13337 /* Now that we have entered the scope of the class, we must restore
13338 the bindings for any template parameters surrounding DECL1, if it
13339 is an inline member template. (Order is important; consider the
13340 case where a template parameter has the same name as a field of
13341 the class.) It is not until after this point that
13342 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13343 if (flags
& SF_INCLASS_INLINE
)
13344 maybe_begin_member_template_processing (decl1
);
13346 /* Effective C++ rule 15. */
13348 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13349 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13350 cp_warning ("`operator=' should return a reference to `*this'");
13352 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13353 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13354 if (!DECL_INITIAL (decl1
))
13355 DECL_INITIAL (decl1
) = error_mark_node
;
13357 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13358 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13361 /* This function exists in static storage.
13362 (This does not mean `static' in the C sense!) */
13363 TREE_STATIC (decl1
) = 1;
13365 /* We must call push_template_decl after current_class_type is set
13366 up. (If we are processing inline definitions after exiting a
13367 class scope, current_class_type will be NULL_TREE until set above
13368 by push_nested_class.) */
13369 if (processing_template_decl
)
13370 decl1
= push_template_decl (decl1
);
13372 /* We are now in the scope of the function being defined. */
13373 current_function_decl
= decl1
;
13375 /* Save the parm names or decls from this function's declarator
13376 where store_parm_decls will find them. */
13377 current_function_parms
= last_function_parms
;
13378 current_function_parm_tags
= last_function_parm_tags
;
13380 /* Make sure the parameter and return types are reasonable. When
13381 you declare a function, these types can be incomplete, but they
13382 must be complete when you define the function. */
13383 if (! processing_template_decl
)
13384 check_function_type (decl1
, current_function_parms
);
13386 /* Build the return declaration for the function. */
13387 restype
= TREE_TYPE (fntype
);
13388 if (!processing_template_decl
)
13390 if (!DECL_RESULT (decl1
))
13392 DECL_RESULT (decl1
)
13393 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13394 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype
),
13395 DECL_RESULT (decl1
));
13399 /* Just use `void'. Nobody will ever look at this anyhow. */
13400 DECL_RESULT (decl1
) = build_decl (RESULT_DECL
, 0, void_type_node
);
13402 /* Initialize RTL machinery. We cannot do this until
13403 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13404 even when processing a template; this is how we get
13405 CFUN set up, and our per-function variables initialized.
13406 FIXME factor out the non-RTL stuff. */
13407 bl
= current_binding_level
;
13408 init_function_start (decl1
, input_filename
, lineno
);
13409 current_binding_level
= bl
;
13411 /* Even though we're inside a function body, we still don't want to
13412 call expand_expr to calculate the size of a variable-sized array.
13413 We haven't necessarily assigned RTL to all variables yet, so it's
13414 not safe to try to expand expressions involving them. */
13415 immediate_size_expand
= 0;
13416 cfun
->x_dont_save_pending_sizes_p
= 1;
13418 /* Start the statement-tree, start the tree now. */
13419 begin_stmt_tree (&DECL_SAVED_TREE (decl1
));
13421 /* Let the user know we're compiling this function. */
13422 announce_function (decl1
);
13424 /* Record the decl so that the function name is defined.
13425 If we already have a decl for this name, and it is a FUNCTION_DECL,
13426 use the old decl. */
13427 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13429 /* A specialization is not used to guide overload resolution. */
13430 if (!DECL_TEMPLATE_SPECIALIZATION (decl1
)
13431 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13432 decl1
= pushdecl (decl1
);
13435 /* We need to set the DECL_CONTEXT. */
13436 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13437 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13438 /* And make sure we have enough default args. */
13439 check_default_args (decl1
);
13441 fntype
= TREE_TYPE (decl1
);
13444 /* Reset these in case the call to pushdecl changed them. */
13445 current_function_decl
= decl1
;
13446 cfun
->decl
= decl1
;
13448 /* If we are (erroneously) defining a function that we have already
13449 defined before, wipe out what we knew before. */
13450 if (!DECL_PENDING_INLINE_P (decl1
)
13451 && DECL_SAVED_FUNCTION_DATA (decl1
))
13453 free (DECL_SAVED_FUNCTION_DATA (decl1
));
13454 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13457 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13459 /* We know that this was set up by `grokclassfn'. We do not
13460 wait until `store_parm_decls', since evil parse errors may
13461 never get us to that point. Here we keep the consistency
13462 between `current_class_type' and `current_class_ptr'. */
13463 tree t
= DECL_ARGUMENTS (decl1
);
13465 my_friendly_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
,
13467 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
13470 cp_function_chain
->x_current_class_ref
13471 = build_indirect_ref (t
, NULL_PTR
);
13472 cp_function_chain
->x_current_class_ptr
= t
;
13474 /* Constructors and destructors need to know whether they're "in
13475 charge" of initializing virtual base classes. */
13476 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13477 current_in_charge_parm
= TREE_CHAIN (t
);
13480 if (DECL_INTERFACE_KNOWN (decl1
))
13482 tree ctx
= decl_function_context (decl1
);
13484 if (DECL_NOT_REALLY_EXTERN (decl1
))
13485 DECL_EXTERNAL (decl1
) = 0;
13487 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13488 && TREE_PUBLIC (ctx
))
13489 /* This is a function in a local class in an extern inline
13491 comdat_linkage (decl1
);
13493 /* If this function belongs to an interface, it is public.
13494 If it belongs to someone else's interface, it is also external.
13495 This only affects inlines and template instantiations. */
13496 else if (interface_unknown
== 0
13497 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13498 || flag_alt_external_templates
))
13500 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13501 || processing_template_decl
)
13503 DECL_EXTERNAL (decl1
)
13505 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13506 && !DECL_VINDEX (decl1
)));
13508 /* For WIN32 we also want to put these in linkonce sections. */
13509 maybe_make_one_only (decl1
);
13512 DECL_EXTERNAL (decl1
) = 0;
13513 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13514 DECL_INTERFACE_KNOWN (decl1
) = 1;
13516 else if (interface_unknown
&& interface_only
13517 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13518 || flag_alt_external_templates
))
13520 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13521 interface, we will have interface_only set but not
13522 interface_known. In that case, we don't want to use the normal
13523 heuristics because someone will supply a #pragma implementation
13524 elsewhere, and deducing it here would produce a conflict. */
13525 comdat_linkage (decl1
);
13526 DECL_EXTERNAL (decl1
) = 0;
13527 DECL_INTERFACE_KNOWN (decl1
) = 1;
13528 DECL_DEFER_OUTPUT (decl1
) = 1;
13532 /* This is a definition, not a reference.
13533 So clear DECL_EXTERNAL. */
13534 DECL_EXTERNAL (decl1
) = 0;
13536 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13537 && ! DECL_INTERFACE_KNOWN (decl1
)
13538 /* Don't try to defer nested functions for now. */
13539 && ! decl_function_context (decl1
))
13540 DECL_DEFER_OUTPUT (decl1
) = 1;
13542 DECL_INTERFACE_KNOWN (decl1
) = 1;
13546 current_binding_level
->parm_flag
= 1;
13549 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13551 /* We need to do this even if we aren't expanding yet so that
13552 assemble_external works. */
13553 make_decl_rtl (decl1
, NULL
);
13555 /* Promote the value to int before returning it. */
13556 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13557 restype
= type_promotes_to (restype
);
13559 /* If this fcn was already referenced via a block-scope `extern' decl
13560 (or an implicit decl), propagate certain information about the usage. */
13561 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13562 TREE_ADDRESSABLE (decl1
) = 1;
13564 if (DECL_RESULT (decl1
) == NULL_TREE
)
13566 DECL_RESULT (decl1
)
13567 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13568 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13569 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13574 if (DECL_DESTRUCTOR_P (decl1
))
13576 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13577 DECL_CONTEXT (dtor_label
) = current_function_decl
;
13580 store_parm_decls (current_function_parms
);
13585 /* Store the parameter declarations into the current function declaration.
13586 This is called after parsing the parameter declarations, before
13587 digesting the body of the function.
13589 Also install to binding contour return value identifier, if any. */
13592 store_parm_decls (current_function_parms
)
13593 tree current_function_parms
;
13595 register tree fndecl
= current_function_decl
;
13596 register tree parm
;
13597 int parms_have_cleanups
= 0;
13598 tree cleanups
= NULL_TREE
;
13600 /* This is a list of types declared among parms in a prototype. */
13601 tree parmtags
= current_function_parm_tags
;
13603 /* This is a chain of any other decls that came in among the parm
13604 declarations. If a parm is declared with enum {foo, bar} x;
13605 then CONST_DECLs for foo and bar are put here. */
13606 tree nonparms
= NULL_TREE
;
13608 if (current_function_parms
)
13610 /* This case is when the function was defined with an ANSI prototype.
13611 The parms already have decls, so we need not do anything here
13612 except record them as in effect
13613 and complain if any redundant old-style parm decls were written. */
13615 tree specparms
= current_function_parms
;
13618 /* Must clear this because it might contain TYPE_DECLs declared
13620 storedecls (NULL_TREE
);
13622 /* If we're doing semantic analysis, then we'll call pushdecl
13623 for each of these. We must do them in reverse order so that
13624 they end in the correct forward order. */
13625 specparms
= nreverse (specparms
);
13627 for (parm
= specparms
; parm
; parm
= next
)
13629 next
= TREE_CHAIN (parm
);
13630 if (TREE_CODE (parm
) == PARM_DECL
)
13634 if (DECL_NAME (parm
) == NULL_TREE
13635 || TREE_CODE (parm
) != VOID_TYPE
)
13638 cp_error ("parameter `%D' declared void", parm
);
13640 cleanup
= (processing_template_decl
13642 : maybe_build_cleanup (parm
));
13645 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13649 /* If we find an enum constant or a type tag,
13650 put it aside for the moment. */
13651 TREE_CHAIN (parm
) = NULL_TREE
;
13652 nonparms
= chainon (nonparms
, parm
);
13656 /* Get the decls in their original chain order and record in the
13657 function. This is all and only the PARM_DECLs that were
13658 pushed into scope by the loop above. */
13659 DECL_ARGUMENTS (fndecl
) = getdecls ();
13660 storetags (chainon (parmtags
, gettags ()));
13663 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13665 /* Now store the final chain of decls for the arguments
13666 as the decl-chain of the current lexical scope.
13667 Put the enumerators in as well, at the front so that
13668 DECL_ARGUMENTS is not modified. */
13669 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13671 /* Now that we have initialized the parms, we can start their
13672 cleanups. We cannot do this before, since expand_decl_cleanup
13673 should not be called before the parm can be used. */
13676 finish_decl_cleanup (TREE_PURPOSE (cleanups
),
13677 TREE_VALUE (cleanups
));
13678 cleanups
= TREE_CHAIN (cleanups
);
13681 /* Create a binding contour which can be used to catch
13682 cleanup-generated temporaries. */
13683 if (parms_have_cleanups
)
13686 /* Do the starting of the exception specifications, if we have any. */
13687 if (flag_exceptions
&& !processing_template_decl
13688 && flag_enforce_eh_specs
13689 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13690 current_eh_spec_try_block
= expand_start_eh_spec ();
13694 /* We have finished doing semantic analysis on DECL, but have not yet
13695 generated RTL for its body. Save away our current state, so that
13696 when we want to generate RTL later we know what to do. */
13699 save_function_data (decl
)
13702 struct cp_language_function
*f
;
13704 /* Save the language-specific per-function data so that we can
13705 get it back when we really expand this function. */
13706 my_friendly_assert (!DECL_PENDING_INLINE_P (decl
),
13710 f
= ((struct cp_language_function
*)
13711 xmalloc (sizeof (struct cp_language_function
)));
13712 memcpy (f
, cp_function_chain
, sizeof (struct cp_language_function
));
13713 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13715 /* Clear out the bits we don't need. */
13716 f
->base
.x_stmt_tree
.x_last_stmt
= NULL_TREE
;
13717 f
->base
.x_stmt_tree
.x_last_expr_type
= NULL_TREE
;
13718 f
->x_named_label_uses
= NULL
;
13719 f
->bindings
= NULL
;
13721 /* When we get back here again, we will be expanding. */
13722 f
->x_expanding_p
= 1;
13724 /* If we've already decided that we cannot inline this function, we
13725 must remember that fact when we actually go to expand the
13727 f
->cannot_inline
= current_function_cannot_inline
;
13730 /* At the end of every constructor we generate to code to return
13731 `this'. Do that now. */
13734 finish_constructor_body ()
13736 /* Any return from a constructor will end up here. */
13738 add_stmt (build_stmt (LABEL_STMT
, ctor_label
));
13740 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13741 generate the return, rather than a goto to CTOR_LABEL. */
13742 ctor_label
= NULL_TREE
;
13743 /* In check_return_expr we translate an empty return from a
13744 constructor to a return of `this'. */
13745 finish_return_stmt (NULL_TREE
);
13746 /* Mark the end of the constructor. */
13747 add_stmt (build_stmt (CTOR_STMT
));
13750 /* At the end of every destructor we generate code to restore virtual
13751 function tables to the values desired by base classes and to call
13752 to base class destructors. Do that now. */
13755 finish_destructor_body ()
13757 tree compound_stmt
;
13760 /* Create a block to contain all the extra code. */
13761 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
13763 /* Any return from a destructor will end up here. */
13764 add_stmt (build_stmt (LABEL_STMT
, dtor_label
));
13766 /* Generate the code to call destructor on base class. If this
13767 destructor belongs to a class with virtual functions, then set
13768 the virtual function table pointer to represent the type of our
13771 /* This side-effect makes call to `build_delete' generate the code
13772 we have to have at the end of this destructor. `build_delete'
13773 will set the flag again. */
13774 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
13776 exprstmt
= build_delete (current_class_type
,
13778 sfk_base_destructor
,
13779 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
13782 if (exprstmt
!= error_mark_node
13783 && (TREE_CODE (exprstmt
) != NOP_EXPR
13784 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
13785 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
13787 if (exprstmt
!= void_zero_node
)
13788 /* Don't call `expand_expr_stmt' if we're not going to do
13789 anything, since -Wall will give a diagnostic. */
13790 finish_expr_stmt (exprstmt
);
13792 /* Run destructors for all virtual baseclasses. */
13793 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
13798 if_stmt
= begin_if_stmt ();
13799 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
13800 current_in_charge_parm
,
13804 vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
13805 /* The CLASSTYPE_VBASECLASSES list is in initialization
13806 order, so we have to march through it in reverse order. */
13807 for (vbases
= nreverse (copy_list (vbases
));
13809 vbases
= TREE_CHAIN (vbases
))
13811 tree vbase
= TREE_VALUE (vbases
);
13812 tree base_type
= BINFO_TYPE (vbase
);
13814 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type
))
13816 tree base_ptr_type
= build_pointer_type (base_type
);
13817 tree expr
= current_class_ptr
;
13819 /* Convert to the basetype here, as we know the layout is
13820 fixed. What is more, if we let build_method_call do it,
13821 it will use the vtable, which may have been clobbered
13822 by the deletion of our primary base. */
13824 expr
= build1 (NOP_EXPR
, base_ptr_type
, expr
);
13825 expr
= build (PLUS_EXPR
, base_ptr_type
, expr
,
13826 BINFO_OFFSET (vbase
));
13827 expr
= build_indirect_ref (expr
, NULL
);
13828 expr
= build_method_call (expr
, base_dtor_identifier
,
13831 finish_expr_stmt (expr
);
13835 finish_then_clause (if_stmt
);
13840 /* In a virtual destructor, we must call delete. */
13841 if (DECL_VIRTUAL_P (current_function_decl
))
13844 tree virtual_size
= c_sizeof (current_class_type
);
13848 At the point of definition of a virtual destructor (including
13849 an implicit definition), non-placement operator delete shall
13850 be looked up in the scope of the destructor's class and if
13851 found shall be accessible and unambiguous. */
13852 exprstmt
= build_op_delete_call
13853 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
13854 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
13856 if_stmt
= begin_if_stmt ();
13857 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
13858 current_in_charge_parm
,
13861 finish_expr_stmt (exprstmt
);
13862 finish_then_clause (if_stmt
);
13866 /* Close the block we started above. */
13867 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
13870 /* Finish up a function declaration and compile that function
13871 all the way to assembler language output. The free the storage
13872 for the function definition.
13874 FLAGS is a bitwise or of the following values:
13876 An extra call to poplevel (and expand_end_bindings) must be
13877 made to take care of the binding contour for the base
13878 initializers. This is only relevant for constructors.
13880 We just finished processing the body of an in-class inline
13881 function definition. (This processing will have taken place
13882 after the class definition is complete.) */
13885 finish_function (flags
)
13888 register tree fndecl
= current_function_decl
;
13889 tree fntype
, ctype
= NULL_TREE
;
13890 int call_poplevel
= (flags
& 1) != 0;
13891 int inclass_inline
= (flags
& 2) != 0;
13894 /* When we get some parse errors, we can end up without a
13895 current_function_decl, so cope. */
13896 if (fndecl
== NULL_TREE
)
13897 return error_mark_node
;
13899 nested
= function_depth
> 1;
13900 fntype
= TREE_TYPE (fndecl
);
13902 /* TREE_READONLY (fndecl) = 1;
13903 This caused &foo to be of type ptr-to-const-function
13904 which then got a warning when stored in a ptr-to-function variable. */
13906 my_friendly_assert (building_stmt_tree (), 20000911);
13908 /* For a cloned function, we've already got all the code we need;
13909 there's no need to add any extra bits. */
13910 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13912 if (DECL_CONSTRUCTOR_P (fndecl
))
13914 finish_constructor_body ();
13918 else if (DECL_DESTRUCTOR_P (fndecl
) && !processing_template_decl
)
13919 finish_destructor_body ();
13920 else if (DECL_MAIN_P (fndecl
))
13922 /* Make it so that `main' always returns 0 by default. */
13924 finish_return_stmt (integer_one_node
);
13926 finish_return_stmt (integer_zero_node
);
13930 /* Finish dealing with exception specifiers. */
13931 if (flag_exceptions
&& !processing_template_decl
13932 && flag_enforce_eh_specs
13933 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13934 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13935 (TREE_TYPE (current_function_decl
)),
13936 current_eh_spec_try_block
);
13939 /* If we're saving up tree structure, tie off the function now. */
13940 finish_stmt_tree (&DECL_SAVED_TREE (fndecl
));
13942 /* This must come after expand_function_end because cleanups might
13943 have declarations (from inline functions) that need to go into
13944 this function's blocks. */
13945 if (current_binding_level
->parm_flag
!= 1)
13946 my_friendly_abort (122);
13947 poplevel (1, 0, 1);
13949 /* Remember that we were in class scope. */
13950 if (current_class_name
)
13951 ctype
= current_class_type
;
13953 /* Must mark the RESULT_DECL as being in this function. */
13954 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13956 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13957 to the FUNCTION_DECL node itself. */
13958 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13960 /* Save away current state, if appropriate. */
13961 if (!processing_template_decl
)
13962 save_function_data (fndecl
);
13964 /* If this function calls `setjmp' it cannot be inlined. When
13965 `longjmp' is called it is not guaranteed to restore the value of
13966 local variables that have been modified since the call to
13967 `setjmp'. So, if were to inline this function into some caller
13968 `c', then when we `longjmp', we might not restore all variables
13969 in `c'. (It might seem, at first blush, that there's no way for
13970 this function to modify local variables in `c', but their
13971 addresses may have been stored somewhere accessible to this
13973 if (!processing_template_decl
&& calls_setjmp_p (fndecl
))
13974 DECL_UNINLINABLE (fndecl
) = 1;
13976 /* Clear out memory we no longer need. */
13977 free_after_parsing (cfun
);
13978 /* Since we never call rest_of_compilation, we never clear
13979 CFUN. Do so explicitly. */
13980 free_after_compilation (cfun
);
13983 /* If this is a in-class inline definition, we may have to pop the
13984 bindings for the template parameters that we added in
13985 maybe_begin_member_template_processing when start_function was
13987 if (inclass_inline
)
13988 maybe_end_member_template_processing ();
13990 /* Leave the scope of the class. */
13992 pop_nested_class ();
13998 /* Let the error reporting routines know that we're outside a
13999 function. For a nested function, this value is used in
14000 pop_cp_function_context and then reset via pop_function_context. */
14001 current_function_decl
= NULL_TREE
;
14006 /* Create the FUNCTION_DECL for a function definition.
14007 DECLSPECS and DECLARATOR are the parts of the declaration;
14008 they describe the return type and the name of the function,
14009 but twisted together in a fashion that parallels the syntax of C.
14011 This function creates a binding context for the function body
14012 as well as setting up the FUNCTION_DECL in current_function_decl.
14014 Returns a FUNCTION_DECL on success.
14016 If the DECLARATOR is not suitable for a function (it defines a datum
14017 instead), we return 0, which tells yyparse to report a parse error.
14019 May return void_type_node indicating that this method is actually
14020 a friend. See grokfield for more details.
14022 Came here with a `.pushlevel' .
14024 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14025 CHANGES TO CODE IN `grokfield'. */
14028 start_method (declspecs
, declarator
, attrlist
)
14029 tree declarator
, declspecs
, attrlist
;
14031 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14034 /* Something too ugly to handle. */
14035 if (fndecl
== NULL_TREE
)
14038 /* Pass friends other than inline friend functions back. */
14039 if (fndecl
== void_type_node
)
14042 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14043 /* Not a function, tell parser to report parse error. */
14046 if (DECL_IN_AGGR_P (fndecl
))
14048 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14050 if (DECL_CONTEXT (fndecl
)
14051 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14052 cp_error ("`%D' is already defined in class `%T'", fndecl
,
14053 DECL_CONTEXT (fndecl
));
14055 return void_type_node
;
14058 check_template_shadow (fndecl
);
14060 DECL_THIS_INLINE (fndecl
) = 1;
14062 if (flag_default_inline
)
14063 DECL_INLINE (fndecl
) = 1;
14065 /* We process method specializations in finish_struct_1. */
14066 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14067 fndecl
= push_template_decl (fndecl
);
14069 if (! DECL_FRIEND_P (fndecl
))
14071 if (TREE_CHAIN (fndecl
))
14073 fndecl
= copy_node (fndecl
);
14074 TREE_CHAIN (fndecl
) = NULL_TREE
;
14077 if (DECL_CONSTRUCTOR_P (fndecl
))
14079 if (! grok_ctor_properties (current_class_type
, fndecl
))
14080 return void_type_node
;
14082 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14083 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14086 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
14088 /* Make a place for the parms */
14090 current_binding_level
->parm_flag
= 1;
14092 DECL_IN_AGGR_P (fndecl
) = 1;
14096 /* Go through the motions of finishing a function definition.
14097 We don't compile this method until after the whole class has
14100 FINISH_METHOD must return something that looks as though it
14101 came from GROKFIELD (since we are defining a method, after all).
14103 This is called after parsing the body of the function definition.
14104 STMTS is the chain of statements that makes up the function body.
14106 DECL is the ..._DECL that `start_method' provided. */
14109 finish_method (decl
)
14112 register tree fndecl
= decl
;
14115 register tree link
;
14117 if (decl
== void_type_node
)
14120 old_initial
= DECL_INITIAL (fndecl
);
14122 /* Undo the level for the parms (from start_method).
14123 This is like poplevel, but it causes nothing to be
14124 saved. Saving information here confuses symbol-table
14125 output routines. Besides, this information will
14126 be correctly output when this method is actually
14129 /* Clear out the meanings of the local variables of this level;
14130 also record in each decl which block it belongs to. */
14132 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14134 if (DECL_NAME (link
) != NULL_TREE
)
14135 pop_binding (DECL_NAME (link
), link
);
14136 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14137 DECL_CONTEXT (link
) = NULL_TREE
;
14140 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14141 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14142 current_binding_level
->parm_flag
,
14143 current_binding_level
->keep
);
14145 poplevel (0, 0, 0);
14147 DECL_INITIAL (fndecl
) = old_initial
;
14149 /* We used to check if the context of FNDECL was different from
14150 current_class_type as another way to get inside here. This didn't work
14151 for String.cc in libg++. */
14152 if (DECL_FRIEND_P (fndecl
))
14154 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14155 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14156 decl
= void_type_node
;
14162 /* Called when a new struct TYPE is defined.
14163 If this structure or union completes the type of any previous
14164 variable declaration, lay it out and output its rtl. */
14167 hack_incomplete_structures (type
)
14171 struct binding_level
*level
;
14173 if (!type
) /* Don't do this for class templates. */
14176 if (namespace_bindings_p ())
14179 list
= &namespace_scope_incomplete
;
14183 level
= innermost_nonclass_level ();
14184 list
= &level
->incomplete
;
14191 tree decl
= TREE_VALUE (*list
);
14192 if ((decl
&& TREE_TYPE (decl
) == type
)
14193 || (TREE_TYPE (decl
)
14194 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14195 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14197 int toplevel
= toplevel_bindings_p ();
14198 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14199 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14200 layout_type (TREE_TYPE (decl
));
14201 layout_decl (decl
, 0);
14202 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14206 expand_decl (decl
);
14207 cleanup
= maybe_build_cleanup (decl
);
14208 expand_decl_init (decl
);
14209 if (! expand_decl_cleanup (decl
, cleanup
))
14210 cp_error ("parser lost in parsing declaration of `%D'",
14213 *list
= TREE_CHAIN (*list
);
14216 list
= &TREE_CHAIN (*list
);
14219 /* Keep looking through artificial binding levels generated
14220 for local variables. */
14221 if (level
&& level
->keep
== 2)
14223 level
= level
->level_chain
;
14224 list
= &level
->incomplete
;
14231 /* If DECL is of a type which needs a cleanup, build that cleanup
14235 maybe_build_cleanup (decl
)
14238 tree type
= TREE_TYPE (decl
);
14240 if (type
!= error_mark_node
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14242 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14245 if (TREE_CODE (type
) == ARRAY_TYPE
)
14249 mark_addressable (decl
);
14250 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14253 /* Optimize for space over speed here. */
14254 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14255 || flag_expensive_optimizations
)
14256 flags
|= LOOKUP_NONVIRTUAL
;
14258 rval
= build_delete (TREE_TYPE (rval
), rval
,
14259 sfk_complete_destructor
, flags
, 0);
14261 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14262 && ! TYPE_HAS_DESTRUCTOR (type
))
14263 rval
= build_compound_expr (tree_cons (NULL_TREE
, rval
,
14264 build_tree_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14271 /* When a stmt has been parsed, this function is called. */
14276 /* Always assume this statement was not an expression statement. If
14277 it actually was an expression statement, its our callers
14278 responsibility to fix this up. */
14279 last_expr_type
= NULL_TREE
;
14282 /* DECL was originally constructed as a non-static member function,
14283 but turned out to be static. Update it accordingly. */
14286 revert_static_member_fn (decl
)
14290 tree function
= TREE_TYPE (decl
);
14291 tree args
= TYPE_ARG_TYPES (function
);
14293 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14294 != TYPE_UNQUALIFIED
)
14295 cp_error ("static member function `%#D' declared with type qualifiers",
14298 args
= TREE_CHAIN (args
);
14299 tmp
= build_function_type (TREE_TYPE (function
), args
);
14300 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14301 tmp
= build_exception_variant (tmp
,
14302 TYPE_RAISES_EXCEPTIONS (function
));
14303 TREE_TYPE (decl
) = tmp
;
14304 if (DECL_ARGUMENTS (decl
))
14305 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
14306 DECL_STATIC_FUNCTION_P (decl
) = 1;
14309 /* Initialize the variables used during compilation of a C++
14313 push_cp_function_context (f
)
14314 struct function
*f
;
14316 struct cp_language_function
*p
14317 = ((struct cp_language_function
*)
14318 xcalloc (1, sizeof (struct cp_language_function
)));
14319 f
->language
= (struct language_function
*) p
;
14321 /* It takes an explicit call to expand_body to generate RTL for a
14325 /* Whenever we start a new function, we destroy temporaries in the
14327 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14330 /* Free the language-specific parts of F, now that we've finished
14331 compiling the function. */
14334 pop_cp_function_context (f
)
14335 struct function
*f
;
14338 free (f
->language
);
14342 /* Mark P for GC. */
14345 mark_lang_function (p
)
14346 struct cp_language_function
*p
;
14351 mark_c_language_function (&p
->base
);
14353 ggc_mark_tree (p
->x_ctor_label
);
14354 ggc_mark_tree (p
->x_dtor_label
);
14355 ggc_mark_tree (p
->x_current_class_ptr
);
14356 ggc_mark_tree (p
->x_current_class_ref
);
14357 ggc_mark_tree (p
->x_eh_spec_try_block
);
14359 mark_named_label_lists (&p
->x_named_labels
, &p
->x_named_label_uses
);
14360 mark_binding_level (&p
->bindings
);
14363 /* Mark the language-specific data in F for GC. */
14366 mark_cp_function_context (f
)
14367 struct function
*f
;
14369 mark_lang_function ((struct cp_language_function
*) f
->language
);
14376 enum tree_code code
= TREE_CODE (t
);
14377 if (code
== IDENTIFIER_NODE
)
14379 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
14380 struct lang_id2
*li2
= li
->x
;
14381 ggc_mark_tree (li
->namespace_bindings
);
14382 ggc_mark_tree (li
->bindings
);
14383 ggc_mark_tree (li
->class_value
);
14384 ggc_mark_tree (li
->class_template_info
);
14388 ggc_mark_tree (li2
->label_value
);
14389 ggc_mark_tree (li2
->implicit_decl
);
14390 ggc_mark_tree (li2
->error_locus
);
14393 else if (code
== CPLUS_BINDING
)
14395 if (BINDING_HAS_LEVEL_P (t
))
14396 mark_binding_level (&BINDING_LEVEL (t
));
14398 ggc_mark_tree (BINDING_SCOPE (t
));
14399 ggc_mark_tree (BINDING_VALUE (t
));
14401 else if (code
== OVERLOAD
)
14402 ggc_mark_tree (OVL_FUNCTION (t
));
14403 else if (code
== TEMPLATE_PARM_INDEX
)
14404 ggc_mark_tree (TEMPLATE_PARM_DECL (t
));
14405 else if (TREE_CODE_CLASS (code
) == 'd')
14407 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
14412 c_mark_lang_decl (&ld
->decl_flags
.base
);
14413 if (!DECL_GLOBAL_CTOR_P (t
)
14414 && !DECL_GLOBAL_DTOR_P (t
)
14415 && !DECL_THUNK_P (t
))
14416 ggc_mark_tree (ld
->decl_flags
.u2
.access
);
14417 else if (DECL_THUNK_P (t
))
14418 ggc_mark_tree (ld
->decl_flags
.u2
.vcall_offset
);
14419 if (TREE_CODE (t
) != NAMESPACE_DECL
)
14420 ggc_mark_tree (ld
->decl_flags
.u
.template_info
);
14422 mark_binding_level (&NAMESPACE_LEVEL (t
));
14423 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
14425 ggc_mark_tree (ld
->befriending_classes
);
14426 ggc_mark_tree (ld
->context
);
14427 ggc_mark_tree (ld
->cloned_function
);
14428 if (!DECL_OVERLOADED_OPERATOR_P (t
))
14429 ggc_mark_tree (ld
->u2
.vtt_parm
);
14430 if (TREE_CODE (t
) == TYPE_DECL
)
14431 ggc_mark_tree (ld
->u
.sorted_fields
);
14432 else if (TREE_CODE (t
) == FUNCTION_DECL
14433 && !DECL_PENDING_INLINE_P (t
))
14434 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t
));
14438 else if (TREE_CODE_CLASS (code
) == 't')
14440 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
14442 if (lt
&& !(TREE_CODE (t
) == POINTER_TYPE
14443 && TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
))
14446 ggc_mark_tree (lt
->primary_base
);
14447 ggc_mark_tree (lt
->vfields
);
14448 ggc_mark_tree (lt
->vbases
);
14449 ggc_mark_tree (lt
->tags
);
14450 ggc_mark_tree (lt
->size
);
14451 ggc_mark_tree (lt
->pure_virtuals
);
14452 ggc_mark_tree (lt
->friend_classes
);
14453 ggc_mark_tree (lt
->rtti
);
14454 ggc_mark_tree (lt
->methods
);
14455 ggc_mark_tree (lt
->template_info
);
14456 ggc_mark_tree (lt
->befriending_classes
);
14459 /* In the case of pointer-to-member function types, the
14460 TYPE_LANG_SPECIFIC is really just a tree. */
14461 ggc_mark_tree ((tree
) lt
);
14465 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14466 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
14469 identifier_global_value (t
)
14472 return IDENTIFIER_GLOBAL_VALUE (t
);
14475 /* Build the void_list_node (void_type_node having been created). */
14477 build_void_list_node ()
14479 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14480 TREE_PARMLIST (t
) = 1;
14485 cp_missing_noreturn_ok_p (decl
)
14488 /* A missing noreturn is ok for the `main' function. */
14489 return MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl
));