1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* Process declarations and symbol lookup for C front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
47 extern int current_class_depth
;
49 extern tree global_namespace
;
51 extern int (*valid_lang_attribute
) PARAMS ((tree
, tree
, tree
, tree
));
53 /* Use garbage collection. */
57 #ifndef BOOL_TYPE_SIZE
58 #ifdef SLOW_BYTE_ACCESS
59 /* In the new ABI, `bool' has size and alignment `1', on all
61 #define BOOL_TYPE_SIZE \
62 ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
64 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
68 /* We let tm.h override the types used here, to handle trivial differences
69 such as the choice of unsigned int or long unsigned int for size_t.
70 When machines start needing nontrivial differences in the size type,
71 it would be best to do something here to figure out automatically
72 from other information what type to use. */
75 #define SIZE_TYPE "long unsigned int"
79 #define PTRDIFF_TYPE "long int"
83 #define WCHAR_TYPE "int"
86 static tree grokparms
PARAMS ((tree
, int));
87 static const char *redeclaration_error_message
PARAMS ((tree
, tree
));
89 static void push_binding_level
PARAMS ((struct binding_level
*, int,
91 static void pop_binding_level
PARAMS ((void));
92 static void suspend_binding_level
PARAMS ((void));
93 static void resume_binding_level
PARAMS ((struct binding_level
*));
94 static struct binding_level
*make_binding_level
PARAMS ((void));
95 static void declare_namespace_level
PARAMS ((void));
96 static int decl_jump_unsafe
PARAMS ((tree
));
97 static void storedecls
PARAMS ((tree
));
98 static void require_complete_types_for_parms
PARAMS ((tree
));
99 static int ambi_op_p
PARAMS ((enum tree_code
));
100 static int unary_op_p
PARAMS ((enum tree_code
));
101 static tree store_bindings
PARAMS ((tree
, tree
));
102 static tree lookup_tag_reverse
PARAMS ((tree
, tree
));
103 static tree obscure_complex_init
PARAMS ((tree
, tree
));
104 static tree lookup_name_real
PARAMS ((tree
, int, int, int));
105 static void warn_extern_redeclared_static
PARAMS ((tree
, tree
));
106 static void grok_reference_init
PARAMS ((tree
, tree
, tree
));
107 static tree grokfndecl
PARAMS ((tree
, tree
, tree
, tree
, int,
108 enum overload_flags
, tree
,
109 tree
, int, int, int, int, int, int, tree
));
110 static tree grokvardecl
PARAMS ((tree
, tree
, RID_BIT_TYPE
*, int, int, tree
));
111 static tree lookup_tag
PARAMS ((enum tree_code
, tree
,
112 struct binding_level
*, int));
113 static void set_identifier_type_value_with_scope
114 PARAMS ((tree
, tree
, struct binding_level
*));
115 static void record_builtin_type
PARAMS ((enum rid
, const char *, tree
));
116 static void record_unknown_type
PARAMS ((tree
, const char *));
117 static tree build_library_fn_1
PARAMS ((tree
, enum tree_code
, tree
));
118 static int member_function_or_else
PARAMS ((tree
, tree
, enum overload_flags
));
119 static void bad_specifiers
PARAMS ((tree
, const char *, int, int, int, int,
121 static tree maybe_process_template_type_declaration
PARAMS ((tree
, int, struct binding_level
*));
122 static void check_for_uninitialized_const_var
PARAMS ((tree
));
123 static unsigned long typename_hash
PARAMS ((hash_table_key
));
124 static boolean typename_compare
PARAMS ((hash_table_key
, hash_table_key
));
125 static void push_binding
PARAMS ((tree
, tree
, struct binding_level
*));
126 static int add_binding
PARAMS ((tree
, tree
));
127 static void pop_binding
PARAMS ((tree
, tree
));
128 static tree local_variable_p_walkfn
PARAMS ((tree
*, int *, void *));
129 static tree find_binding
PARAMS ((tree
, tree
));
130 static tree select_decl
PARAMS ((tree
, int));
131 static int lookup_flags
PARAMS ((int, int));
132 static tree qualify_lookup
PARAMS ((tree
, int));
133 static tree record_builtin_java_type
PARAMS ((const char *, int));
134 static const char *tag_name
PARAMS ((enum tag_types code
));
135 static void find_class_binding_level
PARAMS ((void));
136 static struct binding_level
*innermost_nonclass_level
PARAMS ((void));
137 static void warn_about_implicit_typename_lookup
PARAMS ((tree
, tree
));
138 static int walk_namespaces_r
PARAMS ((tree
, walk_namespaces_fn
, void *));
139 static int walk_globals_r
PARAMS ((tree
, void *));
140 static void add_decl_to_level
PARAMS ((tree
, struct binding_level
*));
141 static tree make_label_decl
PARAMS ((tree
, int));
142 static void use_label
PARAMS ((tree
));
143 static void check_previous_goto_1
PARAMS ((tree
, struct binding_level
*, tree
,
145 static void check_previous_goto
PARAMS ((struct named_label_use_list
*));
146 static void check_switch_goto
PARAMS ((struct binding_level
*));
147 static void check_previous_gotos
PARAMS ((tree
));
148 static void pop_label
PARAMS ((tree
, tree
));
149 static void pop_labels
PARAMS ((tree
));
150 static void maybe_deduce_size_from_array_init
PARAMS ((tree
, tree
));
151 static void layout_var_decl
PARAMS ((tree
));
152 static void maybe_commonize_var
PARAMS ((tree
));
153 static tree check_initializer
PARAMS ((tree
, tree
));
154 static void make_rtl_for_nonlocal_decl
PARAMS ((tree
, tree
, const char *));
155 static void push_cp_function_context
PARAMS ((struct function
*));
156 static void pop_cp_function_context
PARAMS ((struct function
*));
157 static void mark_binding_level
PARAMS ((void *));
158 static void mark_named_label_lists
PARAMS ((void *, void *));
159 static void mark_cp_function_context
PARAMS ((struct function
*));
160 static void mark_saved_scope
PARAMS ((void *));
161 static void mark_lang_function
PARAMS ((struct cp_language_function
*));
162 static void save_function_data
PARAMS ((tree
));
163 static void check_function_type
PARAMS ((tree
, tree
));
164 static void destroy_local_var
PARAMS ((tree
));
165 static void finish_constructor_body
PARAMS ((void));
166 static void finish_destructor_body
PARAMS ((void));
167 static tree create_array_type_for_decl
PARAMS ((tree
, tree
, tree
));
168 static tree get_atexit_node
PARAMS ((void));
169 static tree get_dso_handle_node
PARAMS ((void));
170 static tree start_cleanup_fn
PARAMS ((void));
171 static void end_cleanup_fn
PARAMS ((void));
172 static tree cp_make_fname_decl
PARAMS ((tree
, const char *, int));
173 static void initialize_predefined_identifiers
PARAMS ((void));
174 static tree check_special_function_return_type
175 PARAMS ((special_function_kind
, tree
, tree
, tree
));
176 static tree push_cp_library_fn
PARAMS ((enum tree_code
, tree
));
177 static tree build_cp_library_fn
PARAMS ((tree
, enum tree_code
, tree
));
178 static void store_parm_decls
PARAMS ((tree
));
180 #if defined (DEBUG_CP_BINDING_LEVELS)
181 static void indent
PARAMS ((void));
184 /* Erroneous argument lists can use this *IFF* they do not modify it. */
185 tree error_mark_list
;
187 /* The following symbols are subsumed in the cp_global_trees array, and
188 listed here individually for documentation purposes.
191 tree wchar_decl_node;
193 tree vtable_entry_type;
194 tree delta_type_node;
197 tree __baselist_desc_type_node;
198 tree __i_desc_type_node, __m_desc_type_node;
199 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
201 tree __t_desc_type_node;
203 tree __tp_desc_type_node;
205 tree ti_desc_type_node;
206 tree bltn_desc_type_node, ptr_desc_type_node;
207 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
208 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
209 tree ptm_desc_type_node;
210 tree base_desc_type_node;
212 Not needed yet? May be needed one day?
213 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
214 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
215 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
218 tree class_type_node, record_type_node, union_type_node, enum_type_node;
219 tree unknown_type_node;
221 Array type `vtable_entry_type[]'
224 tree vtbl_ptr_type_node;
231 A FUNCTION_DECL which can call `abort'. Not necessarily the
232 one that the user will declare, but sufficient to be called
233 by routines that want to abort the program.
237 The FUNCTION_DECL for the default `::operator delete'.
239 tree global_delete_fndecl;
242 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
247 tree cp_global_trees
[CPTI_MAX
];
249 /* Indicates that there is a type value in some namespace, although
250 that is not necessarily in scope at the moment. */
252 static tree global_type_node
;
257 /* Expect only namespace names now. */
258 static int only_namespace_names
;
260 /* Used only for jumps to as-yet undefined labels, since jumps to
261 defined labels can have their validity checked immediately. */
263 struct named_label_use_list
265 struct binding_level
*binding_level
;
268 const char *filename_o_goto
;
270 struct named_label_use_list
*next
;
273 #define named_label_uses cp_function_chain->x_named_label_uses
275 /* A list of objects which have constructors or destructors
276 which reside in the global scope. The decl is stored in
277 the TREE_VALUE slot and the initializer is stored
278 in the TREE_PURPOSE slot. */
279 tree static_aggregates
;
283 /* A node for the integer constants 2, and 3. */
285 tree integer_two_node
, integer_three_node
;
287 /* Parsing a function declarator leaves here a chain of structure
288 and enum types declared in the parmlist. */
290 static tree last_function_parm_tags
;
292 /* Similar, for last_function_parm_tags. */
293 tree last_function_parms
;
294 static tree current_function_parm_tags
;
296 /* A list of all LABEL_DECLs in the function that have names. Here so
297 we can clear out their names' definitions at the end of the
298 function, and so we can check the validity of jumps to these labels. */
300 struct named_label_list
302 struct binding_level
*binding_level
;
308 struct named_label_list
*next
;
311 #define named_labels cp_function_chain->x_named_labels
313 /* Set to 0 at beginning of a function definition, and whenever
314 a label (case or named) is defined. Set to value of expression
315 returned from function when that value can be transformed into
316 a named return value. */
318 tree current_function_return_value
;
320 /* Nonzero means use the ISO C94 dialect of C. */
324 /* Nonzero means use the ISO C99 dialect of C. */
328 /* Nonzero means we are a hosted implementation for code shared with C. */
332 /* Nonzero means add default format_arg attributes for functions not
335 int flag_noniso_default_format_attributes
= 1;
337 /* Nonzero means give `double' the same size as `float'. */
339 extern int flag_short_double
;
341 /* Nonzero means don't recognize any builtin functions. */
343 extern int flag_no_builtin
;
345 /* Nonzero means don't recognize the non-ANSI builtin functions.
348 extern int flag_no_nonansi_builtin
;
350 /* Nonzero if we want to conserve space in the .o files. We do this
351 by putting uninitialized data and runtime initialized data into
352 .common instead of .data at the expense of not flagging multiple
354 extern int flag_conserve_space
;
356 /* C and C++ flags are in decl2.c. */
358 /* Flag used when debugging spew.c */
360 extern int spew_debug
;
362 /* A expression of value 0 with the same precision as a sizetype
364 tree signed_size_zero_node
;
366 /* The name of the anonymous namespace, throughout this translation
368 tree anonymous_namespace_name
;
370 /* The number of function bodies which we are currently processing.
371 (Zero if we are at namespace scope, one inside the body of a
372 function, two inside the body of a function in a local class, etc.) */
375 /* For each binding contour we allocate a binding_level structure
376 which records the names defined in that contour.
379 1) one for each function definition,
380 where internal declarations of the parameters appear.
381 2) one for each compound statement,
382 to record its declarations.
384 The current meaning of a name can be found by searching the levels
385 from the current one out to the global one.
387 Off to the side, may be the class_binding_level. This exists only
388 to catch class-local declarations. It is otherwise nonexistent.
390 Also there may be binding levels that catch cleanups that must be
391 run when exceptions occur. Thus, to see whether a name is bound in
392 the current scope, it is not enough to look in the
393 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
396 /* Note that the information in the `names' component of the global contour
397 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
401 /* A chain of _DECL nodes for all variables, constants, functions,
402 and typedef types. These are in the reverse of the order
403 supplied. There may be OVERLOADs on this list, too, but they
404 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
407 /* A list of structure, union and enum definitions, for looking up
409 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
410 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
411 or ENUMERAL_TYPE node.
413 C++: the TREE_VALUE nodes can be simple types for
414 component_bindings. */
417 /* A list of USING_DECL nodes. */
420 /* A list of used namespaces. PURPOSE is the namespace,
421 VALUE the common ancestor with this binding_level's namespace. */
422 tree using_directives
;
424 /* If this binding level is the binding level for a class, then
425 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
426 is the name of an entity bound in the class; the TREE_VALUE is
427 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
428 when leaving class scope, we can restore the
429 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
430 the DECL bound by this name in the class. */
433 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
434 is used for all binding levels. */
437 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
438 label in this scope. The TREE_PURPOSE is the previous value of
439 the IDENTIFIER_LABEL VALUE. */
440 tree shadowed_labels
;
442 /* For each level (except not the global one),
443 a chain of BLOCK nodes for all the levels
444 that were entered and exited one level down. */
447 /* The _TYPE node for this level, if parm_flag == 2. */
450 /* The binding level which this one is contained in (inherits from). */
451 struct binding_level
*level_chain
;
453 /* List of decls in `names' that have incomplete
454 structure or union types. */
457 /* List of VAR_DECLS saved from a previous for statement.
458 These would be dead in ISO-conforming code, but might
459 be referenced in ARM-era code. These are stored in a
460 TREE_LIST; the TREE_VALUE is the actual declaration. */
461 tree dead_vars_from_for
;
463 /* 1 for the level that holds the parameters of a function.
464 2 for the level that holds a class declaration. */
465 unsigned parm_flag
: 2;
467 /* 1 means make a BLOCK for this level regardless of all else.
468 2 for temporary binding contours created by the compiler. */
471 /* Nonzero if this level "doesn't exist" for tags. */
472 unsigned tag_transparent
: 1;
474 /* Nonzero if this level can safely have additional
475 cleanup-needing variables added to it. */
476 unsigned more_cleanups_ok
: 1;
477 unsigned have_cleanups
: 1;
479 /* Nonzero if this scope is for storing the decls for template
480 parameters and generic decls; these decls will be discarded and
481 replaced with a TEMPLATE_DECL. */
482 unsigned template_parms_p
: 1;
484 /* Nonzero if this scope corresponds to the `<>' in a
485 `template <>' clause. Whenever this flag is set,
486 TEMPLATE_PARMS_P will be set as well. */
487 unsigned template_spec_p
: 1;
489 /* This is set for a namespace binding level. */
490 unsigned namespace_p
: 1;
492 /* True if this level is that of a for-statement where we need to
493 worry about ambiguous (ARM or ISO) scope rules. */
494 unsigned is_for_scope
: 1;
496 /* True if this level corresponds to an EH region, as for a try block.
497 Currently this information is only available while building the
499 unsigned eh_region
: 1;
501 /* Four bits left for this word. */
503 #if defined(DEBUG_CP_BINDING_LEVELS)
504 /* Binding depth at which this level began. */
505 unsigned binding_depth
;
506 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
509 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
511 /* The binding level currently in effect. */
513 #define current_binding_level \
515 ? cp_function_chain->bindings \
516 : scope_chain->bindings)
518 /* The binding level of the current class, if any. */
520 #define class_binding_level scope_chain->class_bindings
522 /* A chain of binding_level structures awaiting reuse. */
524 static struct binding_level
*free_binding_level
;
526 /* The outermost binding level, for names of file scope.
527 This is created when the compiler is started and exists
528 through the entire run. */
530 static struct binding_level
*global_binding_level
;
532 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
534 static int keep_next_level_flag
;
536 #if defined(DEBUG_CP_BINDING_LEVELS)
537 static int binding_depth
= 0;
538 static int is_class_level
= 0;
545 for (i
= 0; i
< binding_depth
*2; i
++)
548 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
550 static tree pushdecl_with_scope
PARAMS ((tree
, struct binding_level
*));
553 push_binding_level (newlevel
, tag_transparent
, keep
)
554 struct binding_level
*newlevel
;
555 int tag_transparent
, keep
;
557 /* Add this level to the front of the chain (stack) of levels that
559 bzero ((char*) newlevel
, sizeof (struct binding_level
));
560 newlevel
->level_chain
= current_binding_level
;
561 current_binding_level
= newlevel
;
562 newlevel
->tag_transparent
= tag_transparent
;
563 newlevel
->more_cleanups_ok
= 1;
565 newlevel
->keep
= keep
;
566 #if defined(DEBUG_CP_BINDING_LEVELS)
567 newlevel
->binding_depth
= binding_depth
;
569 fprintf (stderr
, "push %s level 0x%08x line %d\n",
570 (is_class_level
) ? "class" : "block", newlevel
, lineno
);
573 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
576 /* Find the innermost enclosing class scope, and reset
577 CLASS_BINDING_LEVEL appropriately. */
580 find_class_binding_level ()
582 struct binding_level
*level
= current_binding_level
;
584 while (level
&& level
->parm_flag
!= 2)
585 level
= level
->level_chain
;
586 if (level
&& level
->parm_flag
== 2)
587 class_binding_level
= level
;
589 class_binding_level
= 0;
595 if (global_binding_level
)
597 /* Cannot pop a level, if there are none left to pop. */
598 if (current_binding_level
== global_binding_level
)
599 my_friendly_abort (123);
601 /* Pop the current level, and free the structure for reuse. */
602 #if defined(DEBUG_CP_BINDING_LEVELS)
605 fprintf (stderr
, "pop %s level 0x%08x line %d\n",
606 (is_class_level
) ? "class" : "block",
607 current_binding_level
, lineno
);
608 if (is_class_level
!= (current_binding_level
== class_binding_level
))
611 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
614 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
616 register struct binding_level
*level
= current_binding_level
;
617 current_binding_level
= current_binding_level
->level_chain
;
618 level
->level_chain
= free_binding_level
;
619 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
620 if (level
->binding_depth
!= binding_depth
)
622 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
623 free_binding_level
= level
;
624 find_class_binding_level ();
629 suspend_binding_level ()
631 if (class_binding_level
)
632 current_binding_level
= class_binding_level
;
634 if (global_binding_level
)
636 /* Cannot suspend a level, if there are none left to suspend. */
637 if (current_binding_level
== global_binding_level
)
638 my_friendly_abort (123);
640 /* Suspend the current level. */
641 #if defined(DEBUG_CP_BINDING_LEVELS)
644 fprintf (stderr
, "suspend %s level 0x%08x line %d\n",
645 (is_class_level
) ? "class" : "block",
646 current_binding_level
, lineno
);
647 if (is_class_level
!= (current_binding_level
== class_binding_level
))
650 fprintf (stderr
, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
653 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
654 current_binding_level
= current_binding_level
->level_chain
;
655 find_class_binding_level ();
659 resume_binding_level (b
)
660 struct binding_level
*b
;
662 /* Resuming binding levels is meant only for namespaces,
663 and those cannot nest into classes. */
664 my_friendly_assert(!class_binding_level
, 386);
665 /* Also, resuming a non-directly nested namespace is a no-no. */
666 my_friendly_assert(b
->level_chain
== current_binding_level
, 386);
667 current_binding_level
= b
;
668 #if defined(DEBUG_CP_BINDING_LEVELS)
669 b
->binding_depth
= binding_depth
;
671 fprintf (stderr
, "resume %s level 0x%08x line %d\n",
672 (is_class_level
) ? "class" : "block", b
, lineno
);
675 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
678 /* Create a new `struct binding_level'. */
681 struct binding_level
*
682 make_binding_level ()
685 return (struct binding_level
*) xmalloc (sizeof (struct binding_level
));
688 /* Nonzero if we are currently in the global binding level. */
693 return current_binding_level
== global_binding_level
;
696 /* Return the innermost binding level that is not for a class scope. */
698 static struct binding_level
*
699 innermost_nonclass_level ()
701 struct binding_level
*b
;
703 b
= current_binding_level
;
704 while (b
->parm_flag
== 2)
710 /* Nonzero if we are currently in a toplevel binding level. This
711 means either the global binding level or a namespace in a toplevel
712 binding level. Since there are no non-toplevel namespace levels,
713 this really means any namespace or template parameter level. We
714 also include a class whose context is toplevel. */
717 toplevel_bindings_p ()
719 struct binding_level
*b
= innermost_nonclass_level ();
721 return b
->namespace_p
|| b
->template_parms_p
;
724 /* Nonzero if this is a namespace scope, or if we are defining a class
725 which is itself at namespace scope, or whose enclosing class is
726 such a class, etc. */
729 namespace_bindings_p ()
731 struct binding_level
*b
= innermost_nonclass_level ();
733 return b
->namespace_p
;
736 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
737 unconditionally. Otherwise, use the normal logic to decide whether
738 or not to create a BLOCK. */
741 keep_next_level (keep
)
744 keep_next_level_flag
= keep
;
747 /* Nonzero if the current level needs to have a BLOCK made. */
752 return (current_binding_level
->blocks
!= NULL_TREE
753 || current_binding_level
->keep
754 || current_binding_level
->names
!= NULL_TREE
755 || (current_binding_level
->tags
!= NULL_TREE
756 && !current_binding_level
->tag_transparent
));
760 declare_namespace_level ()
762 current_binding_level
->namespace_p
= 1;
765 /* Returns non-zero if this scope was created to store template
769 template_parm_scope_p ()
771 return current_binding_level
->template_parms_p
;
774 /* Returns the kind of template specialization we are currently
775 processing, given that it's declaration contained N_CLASS_SCOPES
776 explicit scope qualifications. */
779 current_tmpl_spec_kind (n_class_scopes
)
782 int n_template_parm_scopes
= 0;
783 int seen_specialization_p
= 0;
784 int innermost_specialization_p
= 0;
785 struct binding_level
*b
;
787 /* Scan through the template parameter scopes. */
788 for (b
= current_binding_level
; b
->template_parms_p
; b
= b
->level_chain
)
790 /* If we see a specialization scope inside a parameter scope,
791 then something is wrong. That corresponds to a declaration
794 template <class T> template <> ...
796 which is always illegal since [temp.expl.spec] forbids the
797 specialization of a class member template if the enclosing
798 class templates are not explicitly specialized as well. */
799 if (b
->template_spec_p
)
801 if (n_template_parm_scopes
== 0)
802 innermost_specialization_p
= 1;
804 seen_specialization_p
= 1;
806 else if (seen_specialization_p
== 1)
807 return tsk_invalid_member_spec
;
809 ++n_template_parm_scopes
;
812 /* Handle explicit instantiations. */
813 if (processing_explicit_instantiation
)
815 if (n_template_parm_scopes
!= 0)
816 /* We've seen a template parameter list during an explicit
817 instantiation. For example:
819 template <class T> template void f(int);
821 This is erroneous. */
822 return tsk_invalid_expl_inst
;
824 return tsk_expl_inst
;
827 if (n_template_parm_scopes
< n_class_scopes
)
828 /* We've not seen enough template headers to match all the
829 specialized classes present. For example:
831 template <class T> void R<T>::S<T>::f(int);
833 This is illegal; there needs to be one set of template
834 parameters for each class. */
835 return tsk_insufficient_parms
;
836 else if (n_template_parm_scopes
== n_class_scopes
)
837 /* We're processing a non-template declaration (even though it may
838 be a member of a template class.) For example:
840 template <class T> void S<T>::f(int);
842 The `class T' maches the `S<T>', leaving no template headers
843 corresponding to the `f'. */
845 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
846 /* We've got too many template headers. For example:
848 template <> template <class T> void f (T);
850 There need to be more enclosing classes. */
851 return tsk_excessive_parms
;
853 /* This must be a template. It's of the form:
855 template <class T> template <class U> void S<T>::f(U);
857 This is a specialization if the innermost level was a
858 specialization; otherwise it's just a definition of the
860 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
864 set_class_shadows (shadows
)
867 class_binding_level
->class_shadowed
= shadows
;
870 /* Enter a new binding level.
871 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
872 not for that of tags. */
875 pushlevel (tag_transparent
)
878 struct binding_level
*newlevel
;
880 if (cfun
&& !doing_semantic_analysis_p ())
883 /* Reuse or create a struct for this binding level. */
884 #if defined(DEBUG_CP_BINDING_LEVELS)
886 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
887 if (free_binding_level
)
888 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
890 newlevel
= free_binding_level
;
891 free_binding_level
= free_binding_level
->level_chain
;
894 newlevel
= make_binding_level ();
896 push_binding_level (newlevel
, tag_transparent
, keep_next_level_flag
);
897 GNU_xref_start_scope ((HOST_WIDE_INT
) newlevel
);
898 keep_next_level_flag
= 0;
901 /* Enter a new scope. The KIND indicates what kind of scope is being
912 case sk_template_spec
:
913 current_binding_level
->template_spec_p
= 1;
916 case sk_template_parms
:
917 current_binding_level
->template_parms_p
= 1;
921 my_friendly_abort (20000309);
925 /* Exit the current scope. */
934 note_level_for_for ()
936 current_binding_level
->is_for_scope
= 1;
939 /* Record that the current binding level represents a try block. */
944 current_binding_level
->eh_region
= 1;
947 /* For a binding between a name and an entity at a block scope,
948 this is the `struct binding_level' for the block. */
949 #define BINDING_LEVEL(NODE) \
950 (((struct tree_binding*)NODE)->scope.level)
952 /* Make DECL the innermost binding for ID. The LEVEL is the binding
953 level at which this declaration is being bound. */
956 push_binding (id
, decl
, level
)
959 struct binding_level
* level
;
963 binding
= make_node (CPLUS_BINDING
);
965 /* Now, fill in the binding information. */
966 BINDING_VALUE (binding
) = decl
;
967 BINDING_TYPE (binding
) = NULL_TREE
;
968 BINDING_LEVEL (binding
) = level
;
969 INHERITED_VALUE_BINDING_P (binding
) = 0;
970 LOCAL_BINDING_P (binding
) = (level
!= class_binding_level
);
971 BINDING_HAS_LEVEL_P (binding
) = 1;
973 /* And put it on the front of the list of bindings for ID. */
974 TREE_CHAIN (binding
) = IDENTIFIER_BINDING (id
);
975 IDENTIFIER_BINDING (id
) = binding
;
978 /* ID is already bound in the current scope. But, DECL is an
979 additional binding for ID in the same scope. This is the `struct
980 stat' hack whereby a non-typedef class-name or enum-name can be
981 bound at the same level as some other kind of entity. It's the
982 responsibility of the caller to check that inserting this name is
983 legal here. Returns nonzero if the new binding was successful. */
985 add_binding (id
, decl
)
989 tree binding
= IDENTIFIER_BINDING (id
);
992 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (decl
))
993 /* The new name is the type name. */
994 BINDING_TYPE (binding
) = decl
;
995 else if (!BINDING_VALUE (binding
))
996 /* This situation arises when push_class_level_binding moves an
997 inherited type-binding out of the way to make room for a new
999 BINDING_VALUE (binding
) = decl
;
1000 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1001 && DECL_ARTIFICIAL (BINDING_VALUE (binding
)))
1003 /* The old binding was a type name. It was placed in
1004 BINDING_VALUE because it was thought, at the point it was
1005 declared, to be the only entity with such a name. Move the
1006 type name into the type slot; it is now hidden by the new
1008 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
1009 BINDING_VALUE (binding
) = decl
;
1010 INHERITED_VALUE_BINDING_P (binding
) = 0;
1012 else if (TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
1013 && TREE_CODE (decl
) == TYPE_DECL
1014 && DECL_NAME (decl
) == DECL_NAME (BINDING_VALUE (binding
))
1015 && same_type_p (TREE_TYPE (decl
),
1016 TREE_TYPE (BINDING_VALUE (binding
))))
1017 /* We have two typedef-names, both naming the same type to have
1018 the same name. This is OK because of:
1022 In a given scope, a typedef specifier can be used to redefine
1023 the name of any type declared in that scope to refer to the
1024 type to which it already refers. */
1026 /* There can be two block-scope declarations of the same variable,
1027 so long as they are `extern' declarations. */
1028 else if (TREE_CODE (decl
) == VAR_DECL
1029 && TREE_CODE (BINDING_VALUE (binding
)) == VAR_DECL
1030 && DECL_EXTERNAL (decl
)
1031 && DECL_EXTERNAL (BINDING_VALUE (binding
)))
1033 duplicate_decls (decl
, BINDING_VALUE (binding
));
1038 cp_error ("declaration of `%#D'", decl
);
1039 cp_error_at ("conflicts with previous declaration `%#D'",
1040 BINDING_VALUE (binding
));
1047 /* Add DECL to the list of things declared in B. */
1050 add_decl_to_level (decl
, b
)
1052 struct binding_level
*b
;
1054 /* We build up the list in reverse order, and reverse it later if
1056 TREE_CHAIN (decl
) = b
->names
;
1060 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1061 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1062 doesn't really belong to this binding level, that it got here
1063 through a using-declaration. */
1066 push_local_binding (id
, decl
, flags
)
1071 struct binding_level
*b
;
1073 /* Skip over any local classes. This makes sense if we call
1074 push_local_binding with a friend decl of a local class. */
1075 b
= current_binding_level
;
1076 while (b
->parm_flag
== 2)
1079 if (lookup_name_current_level (id
))
1081 /* Supplement the existing binding. */
1082 if (!add_binding (id
, decl
))
1083 /* It didn't work. Something else must be bound at this
1084 level. Do not add DECL to the list of things to pop
1089 /* Create a new binding. */
1090 push_binding (id
, decl
, b
);
1092 if (TREE_CODE (decl
) == OVERLOAD
|| (flags
& PUSH_USING
))
1093 /* We must put the OVERLOAD into a TREE_LIST since the
1094 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1095 decls that got here through a using-declaration. */
1096 decl
= build_tree_list (NULL_TREE
, decl
);
1098 /* And put DECL on the list of things declared by the current
1100 add_decl_to_level (decl
, b
);
1103 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1104 binding was successful. */
1107 push_class_binding (id
, decl
)
1112 tree binding
= IDENTIFIER_BINDING (id
);
1115 /* Note that we declared this value so that we can issue an error if
1116 this an illegal redeclaration of a name already used for some
1118 note_name_declared_in_class (id
, decl
);
1120 if (binding
&& BINDING_LEVEL (binding
) == class_binding_level
)
1121 /* Supplement the existing binding. */
1122 result
= add_binding (id
, decl
);
1124 /* Create a new binding. */
1125 push_binding (id
, decl
, class_binding_level
);
1127 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1128 class-level declaration. Note that we do not use DECL here
1129 because of the possibility of the `struct stat' hack; if DECL is
1130 a class-name or enum-name we might prefer a field-name, or some
1132 IDENTIFIER_CLASS_VALUE (id
) = BINDING_VALUE (IDENTIFIER_BINDING (id
));
1134 /* If this is a binding from a base class, mark it as such. */
1135 binding
= IDENTIFIER_BINDING (id
);
1136 if (BINDING_VALUE (binding
) == decl
&& TREE_CODE (decl
) != TREE_LIST
)
1138 /* Any implicit typename must be from a base-class. The
1139 context for an implicit typename declaration is always
1140 the derived class in which the lookup was done, so the checks
1141 based on the context of DECL below will not trigger. */
1142 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl
))
1143 INHERITED_VALUE_BINDING_P (binding
) = 1;
1146 if (TREE_CODE (decl
) == OVERLOAD
)
1147 context
= CP_DECL_CONTEXT (OVL_CURRENT (decl
));
1150 my_friendly_assert (DECL_P (decl
), 0);
1151 context
= CP_DECL_CONTEXT (decl
);
1154 if (is_properly_derived_from (current_class_type
, context
))
1155 INHERITED_VALUE_BINDING_P (binding
) = 1;
1157 INHERITED_VALUE_BINDING_P (binding
) = 0;
1160 else if (BINDING_VALUE (binding
) == decl
)
1161 /* We only encounter a TREE_LIST when push_class_decls detects an
1162 ambiguity. Such an ambiguity can be overridden by a definition
1164 INHERITED_VALUE_BINDING_P (binding
) = 1;
1169 /* Remove the binding for DECL which should be the innermost binding
1173 pop_binding (id
, decl
)
1179 if (id
== NULL_TREE
)
1180 /* It's easiest to write the loops that call this function without
1181 checking whether or not the entities involved have names. We
1182 get here for such an entity. */
1185 /* Get the innermost binding for ID. */
1186 binding
= IDENTIFIER_BINDING (id
);
1188 /* The name should be bound. */
1189 my_friendly_assert (binding
!= NULL_TREE
, 0);
1191 /* The DECL will be either the ordinary binding or the type
1192 binding for this identifier. Remove that binding. */
1193 if (BINDING_VALUE (binding
) == decl
)
1194 BINDING_VALUE (binding
) = NULL_TREE
;
1195 else if (BINDING_TYPE (binding
) == decl
)
1196 BINDING_TYPE (binding
) = NULL_TREE
;
1198 my_friendly_abort (0);
1200 if (!BINDING_VALUE (binding
) && !BINDING_TYPE (binding
))
1201 /* We're completely done with the innermost binding for this
1202 identifier. Unhook it from the list of bindings. */
1203 IDENTIFIER_BINDING (id
) = TREE_CHAIN (binding
);
1206 /* When a label goes out of scope, check to see if that label was used
1207 in a valid manner, and issue any appropriate warnings or errors. */
1210 pop_label (label
, old_value
)
1214 if (!processing_template_decl
&& doing_semantic_analysis_p ())
1216 if (DECL_INITIAL (label
) == NULL_TREE
)
1218 cp_error_at ("label `%D' used but not defined", label
);
1219 /* Avoid crashing later. */
1220 define_label (input_filename
, 1, DECL_NAME (label
));
1222 else if (warn_unused_label
&& !TREE_USED (label
))
1223 cp_warning_at ("label `%D' defined but not used", label
);
1226 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
1229 /* At the end of a function, all labels declared within the function
1230 go out of scope. BLOCK is the top-level block for the
1237 struct named_label_list
*link
;
1239 /* Clear out the definitions of all label names, since their scopes
1241 for (link
= named_labels
; link
; link
= link
->next
)
1243 pop_label (link
->label_decl
, link
->old_value
);
1244 /* Put the labels into the "variables" of the top-level block,
1245 so debugger can see them. */
1246 TREE_CHAIN (link
->label_decl
) = BLOCK_VARS (block
);
1247 BLOCK_VARS (block
) = link
->label_decl
;
1250 named_labels
= NULL
;
1253 /* Exit a binding level.
1254 Pop the level off, and restore the state of the identifier-decl mappings
1255 that were in effect when this level was entered.
1257 If KEEP == 1, this level had explicit declarations, so
1258 and create a "block" (a BLOCK node) for the level
1259 to record its declarations and subblocks for symbol table output.
1261 If FUNCTIONBODY is nonzero, this level is the body of a function,
1262 so create a block as if KEEP were set and also clear out all
1265 If REVERSE is nonzero, reverse the order of decls before putting
1266 them into the BLOCK. */
1269 poplevel (keep
, reverse
, functionbody
)
1275 /* The chain of decls was accumulated in reverse order.
1276 Put it into forward order, just for cleanliness. */
1278 int tmp
= functionbody
;
1279 int real_functionbody
;
1282 tree block
= NULL_TREE
;
1284 int leaving_for_scope
;
1286 if (cfun
&& !doing_semantic_analysis_p ())
1289 my_friendly_assert (current_binding_level
->parm_flag
!= 2,
1292 real_functionbody
= (current_binding_level
->keep
== 2
1293 ? ((functionbody
= 0), tmp
) : functionbody
);
1294 tags
= functionbody
>= 0 ? current_binding_level
->tags
: 0;
1295 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
1297 my_friendly_assert (!current_binding_level
->class_shadowed
,
1300 /* We used to use KEEP == 2 to indicate that the new block should go
1301 at the beginning of the list of blocks at this binding level,
1302 rather than the end. This hack is no longer used. */
1303 my_friendly_assert (keep
== 0 || keep
== 1, 0);
1305 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
1306 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
1307 current_binding_level
->parm_flag
,
1308 current_binding_level
->keep
);
1310 if (current_binding_level
->keep
== 1)
1313 /* Any uses of undefined labels, and any defined labels, now operate
1314 under constraints of next binding contour. */
1315 if (cfun
&& !functionbody
)
1317 struct binding_level
*level_chain
;
1318 level_chain
= current_binding_level
->level_chain
;
1321 struct named_label_use_list
*uses
;
1322 struct named_label_list
*labels
;
1323 for (labels
= named_labels
; labels
; labels
= labels
->next
)
1324 if (labels
->binding_level
== current_binding_level
)
1327 if (current_binding_level
->eh_region
)
1328 labels
->eh_region
= 1;
1329 for (decl
= labels
->names_in_scope
; decl
;
1330 decl
= TREE_CHAIN (decl
))
1331 if (decl_jump_unsafe (decl
))
1332 labels
->bad_decls
= tree_cons (NULL_TREE
, decl
,
1334 labels
->binding_level
= level_chain
;
1335 labels
->names_in_scope
= level_chain
->names
;
1338 for (uses
= named_label_uses
; uses
; uses
= uses
->next
)
1339 if (uses
->binding_level
== current_binding_level
)
1341 uses
->binding_level
= level_chain
;
1342 uses
->names_in_scope
= level_chain
->names
;
1347 /* Get the decls in the order they were written.
1348 Usually current_binding_level->names is in reverse order.
1349 But parameter decls were previously put in forward order. */
1352 current_binding_level
->names
1353 = decls
= nreverse (current_binding_level
->names
);
1355 decls
= current_binding_level
->names
;
1357 /* Output any nested inline functions within this block
1358 if they weren't already output. */
1359 for (decl
= decls
; decl
; decl
= TREE_CHAIN (decl
))
1360 if (TREE_CODE (decl
) == FUNCTION_DECL
1361 && ! TREE_ASM_WRITTEN (decl
)
1362 && DECL_INITIAL (decl
) != NULL_TREE
1363 && TREE_ADDRESSABLE (decl
)
1364 && decl_function_context (decl
) == current_function_decl
)
1366 /* If this decl was copied from a file-scope decl
1367 on account of a block-scope extern decl,
1368 propagate TREE_ADDRESSABLE to the file-scope decl. */
1369 if (DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
1370 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl
)) = 1;
1373 push_function_context ();
1374 output_inline_function (decl
);
1375 pop_function_context ();
1379 /* When not in function-at-a-time mode, expand_end_bindings will
1380 warn about unused variables. But, in function-at-a-time mode
1381 expand_end_bindings is not passed the list of variables in the
1382 current scope, and therefore no warning is emitted. So, we
1383 explicitly warn here. */
1384 if (!processing_template_decl
)
1385 warn_about_unused_variables (getdecls ());
1387 /* If there were any declarations or structure tags in that level,
1388 or if this level is a function body,
1389 create a BLOCK to record them for the life of this function. */
1391 if (keep
== 1 || functionbody
)
1392 block
= make_node (BLOCK
);
1393 if (block
!= NULL_TREE
)
1395 BLOCK_VARS (block
) = decls
;
1396 BLOCK_SUBBLOCKS (block
) = subblocks
;
1399 /* In each subblock, record that this is its superior. */
1401 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
1402 BLOCK_SUPERCONTEXT (link
) = block
;
1404 /* We still support the old for-scope rules, whereby the variables
1405 in a for-init statement were in scope after the for-statement
1406 ended. We only use the new rules in flag_new_for_scope is
1409 = current_binding_level
->is_for_scope
&& flag_new_for_scope
== 1;
1411 /* Remove declarations for all the DECLs in this level. */
1412 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
1414 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
1415 && DECL_NAME (link
))
1418 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link
)));
1422 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link
));
1424 ns_binding
= NULL_TREE
;
1427 && (BINDING_LEVEL (outer_binding
)
1428 == current_binding_level
->level_chain
))
1429 /* We have something like:
1434 and we are leaving the `for' scope. There's no reason to
1435 keep the binding of the inner `i' in this case. */
1436 pop_binding (DECL_NAME (link
), link
);
1437 else if ((outer_binding
1438 && (TREE_CODE (BINDING_VALUE (outer_binding
))
1441 && TREE_CODE (ns_binding
) == TYPE_DECL
))
1442 /* Here, we have something like:
1450 We must pop the for-scope binding so we know what's a
1451 type and what isn't. */
1452 pop_binding (DECL_NAME (link
), link
);
1455 /* Mark this VAR_DECL as dead so that we can tell we left it
1456 there only for backward compatibility. */
1457 DECL_DEAD_FOR_LOCAL (link
) = 1;
1459 /* Keep track of what should of have happenned when we
1460 popped the binding. */
1461 if (outer_binding
&& BINDING_VALUE (outer_binding
))
1462 DECL_SHADOWED_FOR_VAR (link
)
1463 = BINDING_VALUE (outer_binding
);
1465 /* Add it to the list of dead variables in the next
1466 outermost binding to that we can remove these when we
1467 leave that binding. */
1468 current_binding_level
->level_chain
->dead_vars_from_for
1469 = tree_cons (NULL_TREE
, link
,
1470 current_binding_level
->level_chain
->
1471 dead_vars_from_for
);
1473 /* Although we don't pop the CPLUS_BINDING, we do clear
1474 its BINDING_LEVEL since the level is going away now. */
1475 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link
)))
1481 /* Remove the binding. */
1483 if (TREE_CODE (decl
) == TREE_LIST
)
1484 decl
= TREE_VALUE (decl
);
1486 pop_binding (DECL_NAME (decl
), decl
);
1487 else if (TREE_CODE (decl
) == OVERLOAD
)
1488 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
1490 my_friendly_abort (0);
1494 /* Remove declarations for any `for' variables from inner scopes
1495 that we kept around. */
1496 for (link
= current_binding_level
->dead_vars_from_for
;
1497 link
; link
= TREE_CHAIN (link
))
1498 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
1500 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1501 for (link
= current_binding_level
->type_shadowed
;
1502 link
; link
= TREE_CHAIN (link
))
1503 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
1505 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1506 for (link
= current_binding_level
->shadowed_labels
;
1508 link
= TREE_CHAIN (link
))
1509 pop_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
1511 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1512 list if a `using' declaration put them there. The debugging
1513 back-ends won't understand OVERLOAD, so we remove them here.
1514 Because the BLOCK_VARS are (temporarily) shared with
1515 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1516 popped all the bindings. */
1521 for (d
= &BLOCK_VARS (block
); *d
; )
1523 if (TREE_CODE (*d
) == TREE_LIST
)
1524 *d
= TREE_CHAIN (*d
);
1526 d
= &TREE_CHAIN (*d
);
1530 /* If the level being exited is the top level of a function,
1531 check over all the labels. */
1534 /* Since this is the top level block of a function, the vars are
1535 the function's parameters. Don't leave them in the BLOCK
1536 because they are found in the FUNCTION_DECL instead. */
1537 BLOCK_VARS (block
) = 0;
1541 tmp
= current_binding_level
->keep
;
1543 pop_binding_level ();
1545 DECL_INITIAL (current_function_decl
) = block
;
1547 current_binding_level
->blocks
1548 = chainon (current_binding_level
->blocks
, block
);
1550 /* If we did not make a block for the level just exited,
1551 any blocks made for inner levels
1552 (since they cannot be recorded as subblocks in that level)
1553 must be carried forward so they will later become subblocks
1554 of something else. */
1556 current_binding_level
->blocks
1557 = chainon (current_binding_level
->blocks
, subblocks
);
1559 /* Each and every BLOCK node created here in `poplevel' is important
1560 (e.g. for proper debugging information) so if we created one
1561 earlier, mark it as "used". */
1563 TREE_USED (block
) = 1;
1565 /* Take care of compiler's internal binding structures. */
1571 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1574 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts
)) = block
;
1575 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts
)) = block
;
1578 block
= poplevel (keep
, reverse
, functionbody
);
1584 /* Delete the node BLOCK from the current binding level.
1585 This is used for the block inside a stmt expr ({...})
1586 so that the block can be reinserted where appropriate. */
1589 delete_block (block
)
1593 if (current_binding_level
->blocks
== block
)
1594 current_binding_level
->blocks
= TREE_CHAIN (block
);
1595 for (t
= current_binding_level
->blocks
; t
;)
1597 if (TREE_CHAIN (t
) == block
)
1598 TREE_CHAIN (t
) = TREE_CHAIN (block
);
1602 TREE_CHAIN (block
) = NULL_TREE
;
1603 /* Clear TREE_USED which is always set by poplevel.
1604 The flag is set again if insert_block is called. */
1605 TREE_USED (block
) = 0;
1608 /* Insert BLOCK at the end of the list of subblocks of the
1609 current binding level. This is used when a BIND_EXPR is expanded,
1610 to handle the BLOCK node inside the BIND_EXPR. */
1613 insert_block (block
)
1616 TREE_USED (block
) = 1;
1617 current_binding_level
->blocks
1618 = chainon (current_binding_level
->blocks
, block
);
1621 /* Set the BLOCK node for the innermost scope
1622 (the one we are currently in). */
1626 tree block ATTRIBUTE_UNUSED
;
1628 /* The RTL expansion machinery requires us to provide this callback,
1629 but it is not applicable in function-at-a-time mode. */
1630 my_friendly_assert (cfun
&& !doing_semantic_analysis_p (), 20000911);
1633 /* Do a pushlevel for class declarations. */
1638 register struct binding_level
*newlevel
;
1640 /* Reuse or create a struct for this binding level. */
1641 #if defined(DEBUG_CP_BINDING_LEVELS)
1643 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1644 if (free_binding_level
)
1645 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1647 newlevel
= free_binding_level
;
1648 free_binding_level
= free_binding_level
->level_chain
;
1651 newlevel
= make_binding_level ();
1653 #if defined(DEBUG_CP_BINDING_LEVELS)
1655 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1657 push_binding_level (newlevel
, 0, 0);
1659 class_binding_level
= current_binding_level
;
1660 class_binding_level
->parm_flag
= 2;
1661 class_binding_level
->this_class
= current_class_type
;
1664 /* ...and a poplevel for class declarations. */
1669 register struct binding_level
*level
= class_binding_level
;
1672 my_friendly_assert (level
!= 0, 354);
1674 /* If we're leaving a toplevel class, don't bother to do the setting
1675 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1676 shouldn't even be used when current_class_type isn't set, and second,
1677 if we don't touch it here, we're able to use the cache effect if the
1678 next time we're entering a class scope, it is the same class. */
1679 if (current_class_depth
!= 1)
1681 struct binding_level
* b
;
1683 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1684 for (shadowed
= level
->class_shadowed
;
1686 shadowed
= TREE_CHAIN (shadowed
))
1687 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
)) = NULL_TREE
;
1689 /* Find the next enclosing class, and recreate
1690 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1691 b
= level
->level_chain
;
1692 while (b
&& b
->parm_flag
!= 2)
1696 for (shadowed
= b
->class_shadowed
;
1698 shadowed
= TREE_CHAIN (shadowed
))
1702 t
= IDENTIFIER_BINDING (TREE_PURPOSE (shadowed
));
1703 while (t
&& BINDING_LEVEL (t
) != b
)
1707 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed
))
1708 = BINDING_VALUE (t
);
1712 /* Remember to save what IDENTIFIER's were bound in this scope so we
1713 can recover from cache misses. */
1715 previous_class_type
= current_class_type
;
1716 previous_class_values
= class_binding_level
->class_shadowed
;
1718 for (shadowed
= level
->type_shadowed
;
1720 shadowed
= TREE_CHAIN (shadowed
))
1721 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed
), TREE_VALUE (shadowed
));
1723 /* Remove the bindings for all of the class-level declarations. */
1724 for (shadowed
= level
->class_shadowed
;
1726 shadowed
= TREE_CHAIN (shadowed
))
1727 pop_binding (TREE_PURPOSE (shadowed
), TREE_TYPE (shadowed
));
1729 GNU_xref_end_scope ((HOST_WIDE_INT
) class_binding_level
,
1730 (HOST_WIDE_INT
) class_binding_level
->level_chain
,
1731 class_binding_level
->parm_flag
,
1732 class_binding_level
->keep
);
1734 /* Now, pop out of the binding level which we created up in the
1735 `pushlevel_class' routine. */
1736 #if defined(DEBUG_CP_BINDING_LEVELS)
1738 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1740 pop_binding_level ();
1743 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1744 for any names in enclosing classes. */
1747 clear_identifier_class_values ()
1751 if (!class_binding_level
)
1754 for (t
= class_binding_level
->class_shadowed
;
1757 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t
)) = NULL_TREE
;
1760 /* Returns non-zero if T is a virtual function table. */
1763 vtable_decl_p (t
, data
)
1765 void *data ATTRIBUTE_UNUSED
;
1767 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
1770 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1774 vtype_decl_p (t
, data
)
1776 void *data ATTRIBUTE_UNUSED
;
1778 return (TREE_CODE (t
) == TYPE_DECL
1779 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
1780 && TYPE_POLYMORPHIC_P (TREE_TYPE (t
)));
1783 /* Return the declarations that are members of the namespace NS. */
1786 cp_namespace_decls (ns
)
1789 return NAMESPACE_LEVEL (ns
)->names
;
1792 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1793 itself, calling F for each. The DATA is passed to F as well. */
1796 walk_namespaces_r (namespace, f
, data
)
1798 walk_namespaces_fn f
;
1804 result
|= (*f
) (namespace, data
);
1806 for (current
= cp_namespace_decls (namespace);
1808 current
= TREE_CHAIN (current
))
1810 if (TREE_CODE (current
) != NAMESPACE_DECL
1811 || DECL_NAMESPACE_ALIAS (current
))
1813 if (!DECL_LANG_SPECIFIC (current
))
1816 my_friendly_assert (current
== std_node
, 393);
1820 /* We found a namespace. */
1821 result
|= walk_namespaces_r (current
, f
, data
);
1827 /* Walk all the namespaces, calling F for each. The DATA is passed to
1831 walk_namespaces (f
, data
)
1832 walk_namespaces_fn f
;
1835 return walk_namespaces_r (global_namespace
, f
, data
);
1838 struct walk_globals_data
{
1839 walk_globals_pred p
;
1844 /* Walk the global declarations in NAMESPACE. Whenever one is found
1845 for which P returns non-zero, call F with its address. If any call
1846 to F returns a non-zero value, return a non-zero value. */
1849 walk_globals_r (namespace, data
)
1853 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
1854 walk_globals_pred p
= wgd
->p
;
1855 walk_globals_fn f
= wgd
->f
;
1856 void *d
= wgd
->data
;
1860 t
= &NAMESPACE_LEVEL (namespace)->names
;
1867 result
|= (*f
) (t
, d
);
1869 /* If F changed *T, then *T still points at the next item to
1872 t
= &TREE_CHAIN (*t
);
1878 /* Walk the global declarations. Whenever one is found for which P
1879 returns non-zero, call F with its address. If any call to F
1880 returns a non-zero value, return a non-zero value. */
1883 walk_globals (p
, f
, data
)
1884 walk_globals_pred p
;
1888 struct walk_globals_data wgd
;
1893 return walk_namespaces (walk_globals_r
, &wgd
);
1896 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1897 DATA is non-NULL, this is the last time we will call
1898 wrapup_global_declarations for this NAMESPACE. */
1901 wrapup_globals_for_namespace (namespace, data
)
1905 tree globals
= cp_namespace_decls (namespace);
1906 int len
= list_length (globals
);
1907 tree
*vec
= (tree
*) alloca (sizeof (tree
) * len
);
1911 int last_time
= (data
!= 0);
1913 if (last_time
&& namespace == global_namespace
)
1914 /* Let compile_file handle the global namespace. */
1917 /* Process the decls in reverse order--earliest first.
1918 Put them into VEC from back to front, then take out from front. */
1920 for (i
= 0, decl
= globals
; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1922 /* Pretend we've output an unused static variable. This ensures
1923 that the toplevel __FUNCTION__ etc won't be emitted, unless
1925 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_ARTIFICIAL (decl
)
1926 && !TREE_PUBLIC (decl
) && !TREE_USED (decl
))
1928 TREE_ASM_WRITTEN (decl
) = 1;
1929 DECL_IGNORED_P (decl
) = 1;
1931 vec
[len
- i
- 1] = decl
;
1936 check_global_declarations (vec
, len
);
1940 /* Temporarily mark vtables as external. That prevents
1941 wrapup_global_declarations from writing them out; we must process
1942 them ourselves in finish_vtable_vardecl. */
1943 for (i
= 0; i
< len
; ++i
)
1944 if (vtable_decl_p (vec
[i
], /*data=*/0) && !DECL_EXTERNAL (vec
[i
]))
1946 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 1;
1947 DECL_EXTERNAL (vec
[i
]) = 1;
1950 /* Write out any globals that need to be output. */
1951 result
= wrapup_global_declarations (vec
, len
);
1953 /* Undo the hack to DECL_EXTERNAL above. */
1954 for (i
= 0; i
< len
; ++i
)
1955 if (vtable_decl_p (vec
[i
], /*data=*/0)
1956 && DECL_NOT_REALLY_EXTERN (vec
[i
]))
1958 DECL_NOT_REALLY_EXTERN (vec
[i
]) = 0;
1959 DECL_EXTERNAL (vec
[i
]) = 0;
1966 /* Mark ARG (which is really a struct binding_level **) for GC. */
1969 mark_binding_level (arg
)
1972 struct binding_level
*lvl
= *(struct binding_level
**)arg
;
1974 for (; lvl
; lvl
= lvl
->level_chain
)
1976 ggc_mark_tree (lvl
->names
);
1977 ggc_mark_tree (lvl
->tags
);
1978 ggc_mark_tree (lvl
->usings
);
1979 ggc_mark_tree (lvl
->using_directives
);
1980 ggc_mark_tree (lvl
->class_shadowed
);
1981 ggc_mark_tree (lvl
->type_shadowed
);
1982 ggc_mark_tree (lvl
->shadowed_labels
);
1983 ggc_mark_tree (lvl
->blocks
);
1984 ggc_mark_tree (lvl
->this_class
);
1985 ggc_mark_tree (lvl
->incomplete
);
1986 ggc_mark_tree (lvl
->dead_vars_from_for
);
1991 mark_named_label_lists (labs
, uses
)
1995 struct named_label_list
*l
= *(struct named_label_list
**)labs
;
1996 struct named_label_use_list
*u
= *(struct named_label_use_list
**)uses
;
1998 for (; l
; l
= l
->next
)
2001 mark_binding_level (l
->binding_level
);
2002 ggc_mark_tree (l
->old_value
);
2003 ggc_mark_tree (l
->label_decl
);
2004 ggc_mark_tree (l
->bad_decls
);
2007 for (; u
; u
= u
->next
)
2011 /* For debugging. */
2012 static int no_print_functions
= 0;
2013 static int no_print_builtins
= 0;
2016 print_binding_level (lvl
)
2017 struct binding_level
*lvl
;
2021 fprintf (stderr
, " blocks=");
2022 fprintf (stderr
, HOST_PTR_PRINTF
, lvl
->blocks
);
2023 fprintf (stderr
, " n_incomplete=%d parm_flag=%d keep=%d",
2024 list_length (lvl
->incomplete
), lvl
->parm_flag
, lvl
->keep
);
2025 if (lvl
->tag_transparent
)
2026 fprintf (stderr
, " tag-transparent");
2027 if (lvl
->more_cleanups_ok
)
2028 fprintf (stderr
, " more-cleanups-ok");
2029 if (lvl
->have_cleanups
)
2030 fprintf (stderr
, " have-cleanups");
2031 fprintf (stderr
, "\n");
2034 fprintf (stderr
, " names:\t");
2035 /* We can probably fit 3 names to a line? */
2036 for (t
= lvl
->names
; t
; t
= TREE_CHAIN (t
))
2038 if (no_print_functions
&& (TREE_CODE (t
) == FUNCTION_DECL
))
2040 if (no_print_builtins
2041 && (TREE_CODE (t
) == TYPE_DECL
)
2042 && (!strcmp (DECL_SOURCE_FILE (t
),"<built-in>")))
2045 /* Function decls tend to have longer names. */
2046 if (TREE_CODE (t
) == FUNCTION_DECL
)
2053 fprintf (stderr
, "\n\t");
2056 print_node_brief (stderr
, "", t
, 0);
2057 if (t
== error_mark_node
)
2061 fprintf (stderr
, "\n");
2065 fprintf (stderr
, " tags:\t");
2067 for (t
= lvl
->tags
; t
; t
= TREE_CHAIN (t
))
2069 if (TREE_PURPOSE (t
) == NULL_TREE
)
2071 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2078 fprintf (stderr
, "\n\t");
2081 if (TREE_PURPOSE (t
) == NULL_TREE
)
2083 print_node_brief (stderr
, "<unnamed-typedef", TREE_VALUE (t
), 0);
2084 fprintf (stderr
, ">");
2086 else if (TREE_PURPOSE (t
) == TYPE_IDENTIFIER (TREE_VALUE (t
)))
2087 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2090 print_node_brief (stderr
, "<typedef", TREE_PURPOSE (t
), 0);
2091 print_node_brief (stderr
, "", TREE_VALUE (t
), 0);
2092 fprintf (stderr
, ">");
2096 fprintf (stderr
, "\n");
2098 if (lvl
->class_shadowed
)
2100 fprintf (stderr
, " class-shadowed:");
2101 for (t
= lvl
->class_shadowed
; t
; t
= TREE_CHAIN (t
))
2103 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2105 fprintf (stderr
, "\n");
2107 if (lvl
->type_shadowed
)
2109 fprintf (stderr
, " type-shadowed:");
2110 for (t
= lvl
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2112 fprintf (stderr
, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t
)));
2114 fprintf (stderr
, "\n");
2119 print_other_binding_stack (stack
)
2120 struct binding_level
*stack
;
2122 struct binding_level
*level
;
2123 for (level
= stack
; level
!= global_binding_level
; level
= level
->level_chain
)
2125 fprintf (stderr
, "binding level ");
2126 fprintf (stderr
, HOST_PTR_PRINTF
, level
);
2127 fprintf (stderr
, "\n");
2128 print_binding_level (level
);
2133 print_binding_stack ()
2135 struct binding_level
*b
;
2136 fprintf (stderr
, "current_binding_level=");
2137 fprintf (stderr
, HOST_PTR_PRINTF
, current_binding_level
);
2138 fprintf (stderr
, "\nclass_binding_level=");
2139 fprintf (stderr
, HOST_PTR_PRINTF
, class_binding_level
);
2140 fprintf (stderr
, "\nglobal_binding_level=");
2141 fprintf (stderr
, HOST_PTR_PRINTF
, global_binding_level
);
2142 fprintf (stderr
, "\n");
2143 if (class_binding_level
)
2145 for (b
= class_binding_level
; b
; b
= b
->level_chain
)
2146 if (b
== current_binding_level
)
2149 b
= class_binding_level
;
2151 b
= current_binding_level
;
2154 b
= current_binding_level
;
2155 print_other_binding_stack (b
);
2156 fprintf (stderr
, "global:\n");
2157 print_binding_level (global_binding_level
);
2160 /* Namespace binding access routines: The namespace_bindings field of
2161 the identifier is polymorphic, with three possible values:
2162 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2163 indicating the BINDING_VALUE of global_namespace. */
2165 /* Check whether the a binding for the name to scope is known.
2166 Assumes that the bindings of the name are already a list
2167 of bindings. Returns the binding found, or NULL_TREE. */
2170 find_binding (name
, scope
)
2174 tree iter
, prev
= NULL_TREE
;
2176 scope
= ORIGINAL_NAMESPACE (scope
);
2178 for (iter
= IDENTIFIER_NAMESPACE_BINDINGS (name
); iter
;
2179 iter
= TREE_CHAIN (iter
))
2181 my_friendly_assert (TREE_CODE (iter
) == CPLUS_BINDING
, 374);
2182 if (BINDING_SCOPE (iter
) == scope
)
2184 /* Move binding found to the front of the list, so
2185 subsequent lookups will find it faster. */
2188 TREE_CHAIN (prev
) = TREE_CHAIN (iter
);
2189 TREE_CHAIN (iter
) = IDENTIFIER_NAMESPACE_BINDINGS (name
);
2190 IDENTIFIER_NAMESPACE_BINDINGS (name
) = iter
;
2199 /* Always returns a binding for name in scope. If the
2200 namespace_bindings is not a list, convert it to one first.
2201 If no binding is found, make a new one. */
2204 binding_for_name (name
, scope
)
2208 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2211 scope
= ORIGINAL_NAMESPACE (scope
);
2213 if (b
&& TREE_CODE (b
) != CPLUS_BINDING
)
2215 /* Get rid of optimization for global scope. */
2216 IDENTIFIER_NAMESPACE_BINDINGS (name
) = NULL_TREE
;
2217 BINDING_VALUE (binding_for_name (name
, global_namespace
)) = b
;
2218 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2220 if (b
&& (result
= find_binding (name
, scope
)))
2222 /* Not found, make a new one. */
2223 result
= make_node (CPLUS_BINDING
);
2224 TREE_CHAIN (result
) = b
;
2225 IDENTIFIER_NAMESPACE_BINDINGS (name
) = result
;
2226 BINDING_SCOPE (result
) = scope
;
2227 BINDING_TYPE (result
) = NULL_TREE
;
2228 BINDING_VALUE (result
) = NULL_TREE
;
2232 /* Return the binding value for name in scope, considering that
2233 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2236 namespace_binding (name
, scope
)
2240 tree b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2243 if (scope
== NULL_TREE
)
2244 scope
= global_namespace
;
2245 if (TREE_CODE (b
) != CPLUS_BINDING
)
2246 return (scope
== global_namespace
) ? b
: NULL_TREE
;
2247 name
= find_binding (name
,scope
);
2248 if (name
== NULL_TREE
)
2250 return BINDING_VALUE (name
);
2253 /* Set the binding value for name in scope. If modifying the binding
2254 of global_namespace is attempted, try to optimize it. */
2257 set_namespace_binding (name
, scope
, val
)
2264 if (scope
== NULL_TREE
)
2265 scope
= global_namespace
;
2267 if (scope
== global_namespace
)
2269 b
= IDENTIFIER_NAMESPACE_BINDINGS (name
);
2270 if (b
== NULL_TREE
|| TREE_CODE (b
) != CPLUS_BINDING
)
2272 IDENTIFIER_NAMESPACE_BINDINGS (name
) = val
;
2276 b
= binding_for_name (name
, scope
);
2277 BINDING_VALUE (b
) = val
;
2280 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2281 select a name that is unique to this compilation unit. */
2284 push_namespace (name
)
2289 int implicit_use
= 0;
2291 if (!global_namespace
)
2293 /* This must be ::. */
2294 my_friendly_assert (name
== get_identifier ("::"), 377);
2299 /* The name of anonymous namespace is unique for the translation
2301 if (!anonymous_namespace_name
)
2302 anonymous_namespace_name
= get_file_function_name ('N');
2303 name
= anonymous_namespace_name
;
2304 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2306 /* Reopening anonymous namespace. */
2310 else if (current_namespace
== global_namespace
2311 && name
== DECL_NAME (std_node
))
2318 /* Check whether this is an extended namespace definition. */
2319 d
= IDENTIFIER_NAMESPACE_VALUE (name
);
2320 if (d
!= NULL_TREE
&& TREE_CODE (d
) == NAMESPACE_DECL
)
2323 if (DECL_NAMESPACE_ALIAS (d
))
2325 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2326 d
, DECL_NAMESPACE_ALIAS (d
));
2327 d
= DECL_NAMESPACE_ALIAS (d
);
2334 /* Make a new namespace, binding the name to it. */
2335 d
= build_lang_decl (NAMESPACE_DECL
, name
, void_type_node
);
2336 /* The global namespace is not pushed, and the global binding
2337 level is set elsewhere. */
2340 DECL_CONTEXT (d
) = FROB_CONTEXT (current_namespace
);
2343 declare_namespace_level ();
2344 NAMESPACE_LEVEL (d
) = current_binding_level
;
2348 resume_binding_level (NAMESPACE_LEVEL (d
));
2351 do_using_directive (d
);
2352 /* Enter the name space. */
2353 current_namespace
= d
;
2356 /* Pop from the scope of the current namespace. */
2361 if (current_namespace
== global_namespace
)
2363 my_friendly_assert (in_std
>0, 980421);
2367 current_namespace
= CP_DECL_CONTEXT (current_namespace
);
2368 /* The binding level is not popped, as it might be re-opened later. */
2369 suspend_binding_level ();
2372 /* Push into the scope of the namespace NS, even if it is deeply
2373 nested within another namespace. */
2376 push_nested_namespace (ns
)
2379 if (ns
== global_namespace
)
2380 push_to_top_level ();
2383 push_nested_namespace (CP_DECL_CONTEXT (ns
));
2384 push_namespace (DECL_NAME (ns
));
2388 /* Pop back from the scope of the namespace NS, which was previously
2389 entered with push_nested_namespace. */
2392 pop_nested_namespace (ns
)
2395 while (ns
!= global_namespace
)
2398 ns
= CP_DECL_CONTEXT (ns
);
2401 pop_from_top_level ();
2405 /* Subroutines for reverting temporarily to top-level for instantiation
2406 of templates and such. We actually need to clear out the class- and
2407 local-value slots of all identifiers, so that only the global values
2408 are at all visible. Simply setting current_binding_level to the global
2409 scope isn't enough, because more binding levels may be pushed. */
2410 struct saved_scope
*scope_chain
;
2412 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2415 mark_saved_scope (arg
)
2418 struct saved_scope
*t
= *(struct saved_scope
**)arg
;
2421 mark_binding_level (&t
->class_bindings
);
2422 ggc_mark_tree (t
->old_bindings
);
2423 ggc_mark_tree (t
->old_namespace
);
2424 ggc_mark_tree (t
->class_name
);
2425 ggc_mark_tree (t
->class_type
);
2426 ggc_mark_tree (t
->access_specifier
);
2427 ggc_mark_tree (t
->function_decl
);
2429 ggc_mark_tree_varray (t
->lang_base
);
2430 ggc_mark_tree (t
->lang_name
);
2431 ggc_mark_tree (t
->template_parms
);
2432 ggc_mark_tree (t
->x_previous_class_type
);
2433 ggc_mark_tree (t
->x_previous_class_values
);
2434 ggc_mark_tree (t
->x_saved_tree
);
2435 ggc_mark_tree (t
->incomplete
);
2436 ggc_mark_tree (t
->lookups
);
2438 mark_stmt_tree (&t
->x_stmt_tree
);
2439 mark_binding_level (&t
->bindings
);
2445 store_bindings (names
, old_bindings
)
2446 tree names
, old_bindings
;
2449 for (t
= names
; t
; t
= TREE_CHAIN (t
))
2451 tree binding
, t1
, id
;
2453 if (TREE_CODE (t
) == TREE_LIST
)
2454 id
= TREE_PURPOSE (t
);
2459 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2460 we have no IDENTIFIER_BINDING if we have left the class
2461 scope, but cached the class-level declarations. */
2462 || !(IDENTIFIER_BINDING (id
) || IDENTIFIER_CLASS_VALUE (id
)))
2465 for (t1
= old_bindings
; t1
; t1
= TREE_CHAIN (t1
))
2466 if (TREE_VEC_ELT (t1
, 0) == id
)
2469 binding
= make_tree_vec (4);
2473 my_friendly_assert (TREE_CODE (id
) == IDENTIFIER_NODE
, 135);
2474 TREE_VEC_ELT (binding
, 0) = id
;
2475 TREE_VEC_ELT (binding
, 1) = REAL_IDENTIFIER_TYPE_VALUE (id
);
2476 TREE_VEC_ELT (binding
, 2) = IDENTIFIER_BINDING (id
);
2477 TREE_VEC_ELT (binding
, 3) = IDENTIFIER_CLASS_VALUE (id
);
2478 IDENTIFIER_BINDING (id
) = NULL_TREE
;
2479 IDENTIFIER_CLASS_VALUE (id
) = NULL_TREE
;
2481 TREE_CHAIN (binding
) = old_bindings
;
2482 old_bindings
= binding
;
2486 return old_bindings
;
2490 maybe_push_to_top_level (pseudo
)
2493 struct saved_scope
*s
;
2494 struct binding_level
*b
;
2498 s
= (struct saved_scope
*) xcalloc (1, sizeof (struct saved_scope
));
2500 b
= scope_chain
? current_binding_level
: 0;
2502 /* If we're in the middle of some function, save our state. */
2506 push_function_context_to (NULL_TREE
);
2511 old_bindings
= NULL_TREE
;
2512 if (scope_chain
&& previous_class_type
)
2513 old_bindings
= store_bindings (previous_class_values
, old_bindings
);
2515 /* Have to include global_binding_level, because class-level decls
2516 aren't listed anywhere useful. */
2517 for (; b
; b
= b
->level_chain
)
2521 /* Template IDs are inserted into the global level. If they were
2522 inserted into namespace level, finish_file wouldn't find them
2523 when doing pending instantiations. Therefore, don't stop at
2524 namespace level, but continue until :: . */
2525 if (b
== global_binding_level
|| (pseudo
&& b
->template_parms_p
))
2528 old_bindings
= store_bindings (b
->names
, old_bindings
);
2529 /* We also need to check class_shadowed to save class-level type
2530 bindings, since pushclass doesn't fill in b->names. */
2531 if (b
->parm_flag
== 2)
2532 old_bindings
= store_bindings (b
->class_shadowed
, old_bindings
);
2534 /* Unwind type-value slots back to top level. */
2535 for (t
= b
->type_shadowed
; t
; t
= TREE_CHAIN (t
))
2536 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t
), TREE_VALUE (t
));
2538 s
->prev
= scope_chain
;
2539 s
->old_bindings
= old_bindings
;
2541 s
->need_pop_function_context
= need_pop
;
2542 s
->function_decl
= current_function_decl
;
2545 current_function_decl
= NULL_TREE
;
2546 VARRAY_TREE_INIT (current_lang_base
, 10, "current_lang_base");
2547 current_lang_stack
= &VARRAY_TREE (current_lang_base
, 0);
2548 current_lang_name
= lang_name_cplusplus
;
2549 current_namespace
= global_namespace
;
2553 push_to_top_level ()
2555 maybe_push_to_top_level (0);
2559 pop_from_top_level ()
2561 struct saved_scope
*s
= scope_chain
;
2564 /* Clear out class-level bindings cache. */
2565 if (previous_class_type
)
2566 invalidate_class_lookup_cache ();
2568 VARRAY_FREE (current_lang_base
);
2570 scope_chain
= s
->prev
;
2571 for (t
= s
->old_bindings
; t
; t
= TREE_CHAIN (t
))
2573 tree id
= TREE_VEC_ELT (t
, 0);
2576 SET_IDENTIFIER_TYPE_VALUE (id
, TREE_VEC_ELT (t
, 1));
2577 IDENTIFIER_BINDING (id
) = TREE_VEC_ELT (t
, 2);
2578 IDENTIFIER_CLASS_VALUE (id
) = TREE_VEC_ELT (t
, 3);
2582 /* If we were in the middle of compiling a function, restore our
2584 if (s
->need_pop_function_context
)
2585 pop_function_context_from (NULL_TREE
);
2586 current_function_decl
= s
->function_decl
;
2591 /* Push a definition of struct, union or enum tag "name".
2592 into binding_level "b". "type" should be the type node,
2593 We assume that the tag "name" is not already defined.
2595 Note that the definition may really be just a forward reference.
2596 In that case, the TYPE_SIZE will be a NULL_TREE.
2598 C++ gratuitously puts all these tags in the name space. */
2600 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2601 record the shadowed value for this binding contour. TYPE is
2602 the type that ID maps to. */
2605 set_identifier_type_value_with_scope (id
, type
, b
)
2608 struct binding_level
*b
;
2610 if (!b
->namespace_p
)
2612 /* Shadow the marker, not the real thing, so that the marker
2613 gets restored later. */
2614 tree old_type_value
= REAL_IDENTIFIER_TYPE_VALUE (id
);
2616 = tree_cons (id
, old_type_value
, b
->type_shadowed
);
2620 tree binding
= binding_for_name (id
, current_namespace
);
2621 BINDING_TYPE (binding
) = type
;
2622 /* Store marker instead of real type. */
2623 type
= global_type_node
;
2625 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
2628 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2631 set_identifier_type_value (id
, type
)
2635 set_identifier_type_value_with_scope (id
, type
, current_binding_level
);
2638 /* Return the type associated with id. */
2641 identifier_type_value (id
)
2644 /* There is no type with that name, anywhere. */
2645 if (REAL_IDENTIFIER_TYPE_VALUE (id
) == NULL_TREE
)
2647 /* This is not the type marker, but the real thing. */
2648 if (REAL_IDENTIFIER_TYPE_VALUE (id
) != global_type_node
)
2649 return REAL_IDENTIFIER_TYPE_VALUE (id
);
2650 /* Have to search for it. It must be on the global level, now.
2651 Ask lookup_name not to return non-types. */
2652 id
= lookup_name_real (id
, 2, 1, 0);
2654 return TREE_TYPE (id
);
2658 /* Pop off extraneous binding levels left over due to syntax errors.
2660 We don't pop past namespaces, as they might be valid. */
2665 #ifdef DEBUG_CP_BINDING_LEVELS
2666 fprintf (stderr
, "XXX entering pop_everything ()\n");
2668 while (!toplevel_bindings_p ())
2670 if (current_binding_level
->parm_flag
== 2)
2671 pop_nested_class ();
2675 #ifdef DEBUG_CP_BINDING_LEVELS
2676 fprintf (stderr
, "XXX leaving pop_everything ()\n");
2680 /* The type TYPE is being declared. If it is a class template, or a
2681 specialization of a class template, do any processing required and
2682 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2683 being declared a friend. B is the binding level at which this TYPE
2686 Returns the TYPE_DECL for TYPE, which may have been altered by this
2690 maybe_process_template_type_declaration (type
, globalize
, b
)
2693 struct binding_level
* b
;
2695 tree decl
= TYPE_NAME (type
);
2697 if (processing_template_parmlist
)
2698 /* You can't declare a new template type in a template parameter
2699 list. But, you can declare a non-template type:
2701 template <class A*> struct S;
2703 is a forward-declaration of `A'. */
2707 maybe_check_template_type (type
);
2709 my_friendly_assert (IS_AGGR_TYPE (type
)
2710 || TREE_CODE (type
) == ENUMERAL_TYPE
, 0);
2713 if (processing_template_decl
)
2715 /* This may change after the call to
2716 push_template_decl_real, but we want the original value. */
2717 tree name
= DECL_NAME (decl
);
2719 decl
= push_template_decl_real (decl
, globalize
);
2720 /* If the current binding level is the binding level for the
2721 template parameters (see the comment in
2722 begin_template_parm_list) and the enclosing level is a class
2723 scope, and we're not looking at a friend, push the
2724 declaration of the member class into the class scope. In the
2725 friend case, push_template_decl will already have put the
2726 friend into global scope, if appropriate. */
2727 if (TREE_CODE (type
) != ENUMERAL_TYPE
2728 && !globalize
&& b
->template_parms_p
2729 && b
->level_chain
->parm_flag
== 2)
2731 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type
));
2732 /* Put this tag on the list of tags for the class, since
2733 that won't happen below because B is not the class
2734 binding level, but is instead the pseudo-global level. */
2735 b
->level_chain
->tags
=
2736 tree_cons (name
, type
, b
->level_chain
->tags
);
2737 if (!COMPLETE_TYPE_P (current_class_type
))
2738 CLASSTYPE_TAGS (current_class_type
) = b
->level_chain
->tags
;
2746 /* In C++, you don't have to write `struct S' to refer to `S'; you
2747 can just use `S'. We accomplish this by creating a TYPE_DECL as
2748 if the user had written `typedef struct S S'. Create and return
2749 the TYPE_DECL for TYPE. */
2752 create_implicit_typedef (name
, type
)
2758 decl
= build_decl (TYPE_DECL
, name
, type
);
2759 DECL_ARTIFICIAL (decl
) = 1;
2760 /* There are other implicit type declarations, like the one *within*
2761 a class that allows you to write `S::S'. We must distinguish
2763 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
2764 TYPE_NAME (type
) = decl
;
2769 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2770 Normally put it into the inner-most non-tag-transparent scope,
2771 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2772 The latter is needed for implicit declarations. */
2775 pushtag (name
, type
, globalize
)
2779 register struct binding_level
*b
;
2781 b
= current_binding_level
;
2782 while (b
->tag_transparent
2783 || (globalize
&& b
->parm_flag
== 2))
2786 b
->tags
= tree_cons (name
, type
, b
->tags
);
2790 /* Do C++ gratuitous typedefing. */
2791 if (IDENTIFIER_TYPE_VALUE (name
) != type
)
2793 register tree d
= NULL_TREE
;
2795 tree context
= TYPE_CONTEXT (type
);
2799 tree cs
= current_scope ();
2803 else if (cs
!= NULL_TREE
&& TYPE_P (cs
))
2804 /* When declaring a friend class of a local class, we want
2805 to inject the newly named class into the scope
2806 containing the local class, not the namespace scope. */
2807 context
= decl_function_context (get_type_decl (cs
));
2810 context
= current_namespace
;
2812 if ((b
->template_parms_p
&& b
->level_chain
->parm_flag
== 2)
2813 || b
->parm_flag
== 2)
2816 if (current_lang_name
== lang_name_java
)
2817 TYPE_FOR_JAVA (type
) = 1;
2819 d
= create_implicit_typedef (name
, type
);
2820 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2822 set_identifier_type_value_with_scope (name
, type
, b
);
2824 d
= maybe_process_template_type_declaration (type
,
2827 if (b
->parm_flag
== 2)
2829 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2830 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2831 class. But if it's a member template class, we
2832 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2834 finish_member_declaration (d
);
2836 pushdecl_class_level (d
);
2839 d
= pushdecl_with_scope (d
, b
);
2841 if (ANON_AGGRNAME_P (name
))
2842 DECL_IGNORED_P (d
) = 1;
2844 TYPE_CONTEXT (type
) = DECL_CONTEXT (d
);
2845 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
2847 /* If this is a local class, keep track of it. We need this
2848 information for name-mangling, and so that it is possible to find
2849 all function definitions in a translation unit in a convenient
2850 way. (It's otherwise tricky to find a member function definition
2851 it's only pointed to from within a local class.) */
2852 if (TYPE_CONTEXT (type
)
2853 && TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
2854 && !processing_template_decl
)
2855 VARRAY_PUSH_TREE (local_classes
, type
);
2857 if (!uses_template_parms (type
))
2860 DECL_ASSEMBLER_NAME (d
) = mangle_type (type
);
2862 DECL_ASSEMBLER_NAME (d
)
2863 = get_identifier (build_overload_name (type
, 1, 1));
2866 if (b
->parm_flag
== 2)
2868 if (!COMPLETE_TYPE_P (current_class_type
))
2869 CLASSTYPE_TAGS (current_class_type
) = b
->tags
;
2873 if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2874 /* Use the canonical TYPE_DECL for this node. */
2875 TYPE_STUB_DECL (type
) = TYPE_NAME (type
);
2878 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2879 will be the tagged type we just added to the current
2880 binding level. This fake NULL-named TYPE_DECL node helps
2881 dwarfout.c to know when it needs to output a
2882 representation of a tagged type, and it also gives us a
2883 convenient place to record the "scope start" address for
2886 tree d
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
2887 TYPE_STUB_DECL (type
) = pushdecl_with_scope (d
, b
);
2891 /* Counter used to create anonymous type names. */
2893 static int anon_cnt
= 0;
2895 /* Return an IDENTIFIER which can be used as a name for
2896 anonymous structs and unions. */
2903 sprintf (buf
, ANON_AGGRNAME_FORMAT
, anon_cnt
++);
2904 return get_identifier (buf
);
2907 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2908 This keeps dbxout from getting confused. */
2913 register struct binding_level
*b
;
2915 static int last_cnt
= 0;
2917 /* Fast out if no new anon names were declared. */
2918 if (last_cnt
== anon_cnt
)
2921 b
= current_binding_level
;
2922 while (b
->tag_transparent
)
2927 /* A NULL purpose means we have already processed all tags
2928 from here to the end of the list. */
2929 if (TREE_PURPOSE (tags
) == NULL_TREE
)
2931 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags
)))
2932 TREE_PURPOSE (tags
) = NULL_TREE
;
2933 tags
= TREE_CHAIN (tags
);
2935 last_cnt
= anon_cnt
;
2938 /* Subroutine of duplicate_decls: return truthvalue of whether
2939 or not types of these decls match.
2941 For C++, we must compare the parameter list so that `int' can match
2942 `int&' in a parameter position, but `int&' is not confused with
2946 decls_match (newdecl
, olddecl
)
2947 tree newdecl
, olddecl
;
2951 if (newdecl
== olddecl
)
2954 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
2955 /* If the two DECLs are not even the same kind of thing, we're not
2956 interested in their types. */
2959 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2961 tree f1
= TREE_TYPE (newdecl
);
2962 tree f2
= TREE_TYPE (olddecl
);
2963 tree p1
= TYPE_ARG_TYPES (f1
);
2964 tree p2
= TYPE_ARG_TYPES (f2
);
2966 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
2967 && ! (DECL_EXTERN_C_P (newdecl
)
2968 && DECL_EXTERN_C_P (olddecl
)))
2971 if (TREE_CODE (f1
) != TREE_CODE (f2
))
2974 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
2976 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
2977 && (DECL_BUILT_IN (olddecl
)
2978 #ifndef NO_IMPLICIT_EXTERN_C
2979 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
2980 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
2984 types_match
= self_promoting_args_p (p1
);
2985 if (p1
== void_list_node
)
2986 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
2988 #ifndef NO_IMPLICIT_EXTERN_C
2989 else if (p1
== NULL_TREE
2990 && (DECL_EXTERN_C_P (olddecl
)
2991 && DECL_IN_SYSTEM_HEADER (olddecl
)
2992 && !DECL_CLASS_SCOPE_P (olddecl
))
2993 && (DECL_EXTERN_C_P (newdecl
)
2994 && DECL_IN_SYSTEM_HEADER (newdecl
)
2995 && !DECL_CLASS_SCOPE_P (newdecl
)))
2997 types_match
= self_promoting_args_p (p2
);
2998 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
3002 types_match
= compparms (p1
, p2
);
3007 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3009 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3010 DECL_TEMPLATE_PARMS (olddecl
)))
3013 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
3014 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
3017 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3020 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
3021 DECL_TEMPLATE_RESULT (newdecl
));
3025 if (TREE_TYPE (newdecl
) == error_mark_node
)
3026 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
3027 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
3028 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
3029 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
3032 types_match
= comptypes (TREE_TYPE (newdecl
),
3033 TREE_TYPE (olddecl
),
3034 COMPARE_REDECLARATION
);
3040 /* If NEWDECL is `static' and an `extern' was seen previously,
3041 warn about it. OLDDECL is the previous declaration.
3043 Note that this does not apply to the C++ case of declaring
3044 a variable `extern const' and then later `const'.
3046 Don't complain about built-in functions, since they are beyond
3047 the user's control. */
3050 warn_extern_redeclared_static (newdecl
, olddecl
)
3051 tree newdecl
, olddecl
;
3053 static const char *explicit_extern_static_warning
3054 = "`%D' was declared `extern' and later `static'";
3055 static const char *implicit_extern_static_warning
3056 = "`%D' was declared implicitly `extern' and later `static'";
3060 if (TREE_CODE (newdecl
) == TYPE_DECL
3061 || TREE_CODE (newdecl
) == TEMPLATE_DECL
3062 || TREE_CODE (newdecl
) == CONST_DECL
)
3065 /* Don't get confused by static member functions; that's a different
3067 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3068 && DECL_STATIC_FUNCTION_P (newdecl
))
3071 /* If the old declaration was `static', or the new one isn't, then
3072 then everything is OK. */
3073 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
3076 /* It's OK to declare a builtin function as `static'. */
3077 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3078 && DECL_ARTIFICIAL (olddecl
))
3081 name
= DECL_ASSEMBLER_NAME (newdecl
);
3082 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name
)
3083 ? implicit_extern_static_warning
3084 : explicit_extern_static_warning
, newdecl
);
3085 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
3088 /* Handle when a new declaration NEWDECL has the same name as an old
3089 one OLDDECL in the same binding contour. Prints an error message
3092 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3093 Otherwise, return 0. */
3096 duplicate_decls (newdecl
, olddecl
)
3097 tree newdecl
, olddecl
;
3099 unsigned olddecl_uid
= DECL_UID (olddecl
);
3100 int olddecl_friend
= 0, types_match
= 0;
3101 int new_defines_function
= 0;
3103 if (newdecl
== olddecl
)
3106 types_match
= decls_match (newdecl
, olddecl
);
3108 /* If either the type of the new decl or the type of the old decl is an
3109 error_mark_node, then that implies that we have already issued an
3110 error (earlier) for some bogus type specification, and in that case,
3111 it is rather pointless to harass the user with yet more error message
3112 about the same declaration, so just pretend the types match here. */
3113 if (TREE_TYPE (newdecl
) == error_mark_node
3114 || TREE_TYPE (olddecl
) == error_mark_node
)
3117 /* Check for redeclaration and other discrepancies. */
3118 if (TREE_CODE (olddecl
) == FUNCTION_DECL
3119 && DECL_ARTIFICIAL (olddecl
))
3121 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
3123 /* If you declare a built-in or predefined function name as static,
3124 the old definition is overridden, but optionally warn this was a
3125 bad choice of name. */
3126 if (! TREE_PUBLIC (newdecl
))
3129 cp_warning ("shadowing %s function `%#D'",
3130 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3132 /* Discard the old built-in function. */
3135 /* If the built-in is not ansi, then programs can override
3136 it even globally without an error. */
3137 else if (! DECL_BUILT_IN (olddecl
))
3138 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3142 cp_error ("declaration of `%#D'", newdecl
);
3143 cp_error ("conflicts with built-in declaration `%#D'",
3148 else if (!types_match
)
3150 if ((DECL_EXTERN_C_P (newdecl
)
3151 && DECL_EXTERN_C_P (olddecl
))
3152 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3153 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3155 /* A near match; override the builtin. */
3157 if (TREE_PUBLIC (newdecl
))
3159 cp_warning ("new declaration `%#D'", newdecl
);
3160 cp_warning ("ambiguates built-in declaration `%#D'",
3163 else if (warn_shadow
)
3164 cp_warning ("shadowing %s function `%#D'",
3165 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
3169 /* Discard the old built-in function. */
3173 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
3175 /* If a builtin function is redeclared as `static', merge
3176 the declarations, but make the original one static. */
3177 DECL_THIS_STATIC (olddecl
) = 1;
3178 TREE_PUBLIC (olddecl
) = 0;
3180 /* Make the old declaration consistent with the new one so
3181 that all remnants of the builtin-ness of this function
3182 will be banished. */
3183 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3184 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3185 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3186 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl
),
3190 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
3192 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
3193 && TREE_CODE (newdecl
) != TYPE_DECL
3194 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
3195 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
3196 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
3197 && TREE_CODE (olddecl
) != TYPE_DECL
3198 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
3199 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
3202 /* We do nothing special here, because C++ does such nasty
3203 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3204 get shadowed, and know that if we need to find a TYPE_DECL
3205 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3206 slot of the identifier. */
3210 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
3211 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
3212 || (TREE_CODE (olddecl
) == FUNCTION_DECL
3213 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
3216 cp_error ("`%#D' redeclared as different kind of symbol", newdecl
);
3217 if (TREE_CODE (olddecl
) == TREE_LIST
)
3218 olddecl
= TREE_VALUE (olddecl
);
3219 cp_error_at ("previous declaration of `%#D'", olddecl
);
3221 /* New decl is completely inconsistent with the old one =>
3222 tell caller to replace the old one. */
3226 else if (!types_match
)
3228 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
3229 /* These are certainly not duplicate declarations; they're
3230 from different scopes. */
3233 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3235 /* The name of a class template may not be declared to refer to
3236 any other template, class, function, object, namespace, value,
3237 or type in the same scope. */
3238 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
3239 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
3241 cp_error ("declaration of template `%#D'", newdecl
);
3242 cp_error_at ("conflicts with previous declaration `%#D'",
3245 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
3246 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
3247 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
3248 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
3249 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
3250 DECL_TEMPLATE_PARMS (olddecl
)))
3252 cp_error ("new declaration `%#D'", newdecl
);
3253 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3257 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3259 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
3261 cp_error ("declaration of C function `%#D' conflicts with",
3263 cp_error_at ("previous declaration `%#D' here", olddecl
);
3265 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
3266 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
3268 cp_error ("new declaration `%#D'", newdecl
);
3269 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
3275 /* Already complained about this, so don't do so again. */
3276 else if (current_class_type
== NULL_TREE
3277 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl
)) != current_class_type
)
3279 cp_error ("conflicting types for `%#D'", newdecl
);
3280 cp_error_at ("previous declaration as `%#D'", olddecl
);
3283 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3284 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
3285 && (!DECL_TEMPLATE_INFO (newdecl
)
3286 || (DECL_TI_TEMPLATE (newdecl
)
3287 != DECL_TI_TEMPLATE (olddecl
))))
3288 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
3289 && (!DECL_TEMPLATE_INFO (olddecl
)
3290 || (DECL_TI_TEMPLATE (olddecl
)
3291 != DECL_TI_TEMPLATE (newdecl
))))))
3292 /* It's OK to have a template specialization and a non-template
3293 with the same type, or to have specializations of two
3294 different templates with the same type. Note that if one is a
3295 specialization, and the other is an instantiation of the same
3296 template, that we do not exit at this point. That situation
3297 can occur if we instantiate a template class, and then
3298 specialize one of its methods. This situation is legal, but
3299 the declarations must be merged in the usual way. */
3301 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3302 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
3303 && !DECL_USE_TEMPLATE (newdecl
))
3304 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
3305 && !DECL_USE_TEMPLATE (olddecl
))))
3306 /* One of the declarations is a template instantiation, and the
3307 other is not a template at all. That's OK. */
3309 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
3310 && DECL_NAMESPACE_ALIAS (newdecl
)
3311 && DECL_NAMESPACE_ALIAS (newdecl
) == DECL_NAMESPACE_ALIAS (olddecl
))
3312 /* Redeclaration of namespace alias, ignore it. */
3316 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
3319 cp_error (errmsg
, newdecl
);
3320 if (DECL_NAME (olddecl
) != NULL_TREE
)
3321 cp_error_at ((DECL_INITIAL (olddecl
)
3322 && namespace_bindings_p ())
3323 ? "`%#D' previously defined here"
3324 : "`%#D' previously declared here", olddecl
);
3326 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3327 && DECL_INITIAL (olddecl
) != NULL_TREE
3328 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
3329 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
3331 /* Prototype decl follows defn w/o prototype. */
3332 cp_warning_at ("prototype for `%#D'", newdecl
);
3333 cp_warning_at ("follows non-prototype definition here", olddecl
);
3335 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
3336 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
3338 /* extern "C" int foo ();
3339 int foo () { bar (); }
3341 if (current_lang_stack
3342 == &VARRAY_TREE (current_lang_base
, 0))
3343 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3346 cp_error_at ("previous declaration of `%#D' with %L linkage",
3347 olddecl
, DECL_LANGUAGE (olddecl
));
3348 cp_error ("conflicts with new declaration with %L linkage",
3349 DECL_LANGUAGE (newdecl
));
3353 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
3355 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
3357 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
3358 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
3361 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
3362 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
3364 for (; t1
&& t1
!= void_list_node
;
3365 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
3366 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
3368 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
3373 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3375 cp_pedwarn_at ("after previous specification in `%#D'",
3381 cp_error ("default argument given for parameter %d of `%#D'",
3383 cp_error_at ("after previous specification in `%#D'",
3388 if (DECL_THIS_INLINE (newdecl
) && ! DECL_THIS_INLINE (olddecl
)
3389 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
3391 cp_warning ("`%#D' was used before it was declared inline",
3393 cp_warning_at ("previous non-inline declaration here",
3399 /* If new decl is `static' and an `extern' was seen previously,
3401 warn_extern_redeclared_static (newdecl
, olddecl
);
3403 /* We have committed to returning 1 at this point. */
3404 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3406 /* Now that functions must hold information normally held
3407 by field decls, there is extra work to do so that
3408 declaration information does not get destroyed during
3410 if (DECL_VINDEX (olddecl
))
3411 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
3412 if (DECL_VIRTUAL_CONTEXT (olddecl
))
3413 DECL_VIRTUAL_CONTEXT (newdecl
) = DECL_VIRTUAL_CONTEXT (olddecl
);
3414 if (DECL_CONTEXT (olddecl
))
3415 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
3416 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
3417 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
3418 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
3419 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
3420 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
3421 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
3422 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
3423 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
3424 DECL_LANG_SPECIFIC (newdecl
)->u2
= DECL_LANG_SPECIFIC (olddecl
)->u2
;
3425 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
3427 /* Optionally warn about more than one declaration for the same
3428 name, but don't warn about a function declaration followed by a
3430 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
3431 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
3432 /* Don't warn about extern decl followed by definition. */
3433 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
3434 /* Don't warn about friends, let add_friend take care of it. */
3435 && ! DECL_FRIEND_P (newdecl
))
3437 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl
);
3438 cp_warning_at ("previous declaration of `%D'", olddecl
);
3442 /* Deal with C++: must preserve virtual function table size. */
3443 if (TREE_CODE (olddecl
) == TYPE_DECL
)
3445 register tree newtype
= TREE_TYPE (newdecl
);
3446 register tree oldtype
= TREE_TYPE (olddecl
);
3448 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
3449 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
3451 CLASSTYPE_VSIZE (newtype
) = CLASSTYPE_VSIZE (oldtype
);
3452 CLASSTYPE_FRIEND_CLASSES (newtype
)
3453 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
3456 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
3459 /* Copy all the DECL_... slots specified in the new decl
3460 except for any that we copy here from the old type. */
3461 DECL_MACHINE_ATTRIBUTES (newdecl
)
3462 = merge_machine_decl_attributes (olddecl
, newdecl
);
3464 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
3466 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
3467 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
3468 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
3469 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
3476 /* Automatically handles default parameters. */
3477 tree oldtype
= TREE_TYPE (olddecl
);
3480 /* Merge the data types specified in the two decls. */
3481 newtype
= common_type (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
3483 /* If common_type produces a non-typedef type, just use the old type. */
3484 if (TREE_CODE (newdecl
) == TYPE_DECL
3485 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
3488 if (TREE_CODE (newdecl
) == VAR_DECL
)
3489 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
3490 /* Do this after calling `common_type' so that default
3491 parameters don't confuse us. */
3492 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
3493 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
3494 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
3496 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
3497 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
3498 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
3499 TYPE_RAISES_EXCEPTIONS (oldtype
));
3501 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
3502 && DECL_SOURCE_LINE (olddecl
) != 0
3504 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
3505 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
3507 cp_error ("declaration of `%F' throws different exceptions",
3509 cp_error_at ("than previous declaration `%F'", olddecl
);
3512 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
3514 /* Lay the type out, unless already done. */
3515 if (! same_type_p (newtype
, oldtype
)
3516 && TREE_TYPE (newdecl
) != error_mark_node
3517 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3518 layout_type (TREE_TYPE (newdecl
));
3520 if ((TREE_CODE (newdecl
) == VAR_DECL
3521 || TREE_CODE (newdecl
) == PARM_DECL
3522 || TREE_CODE (newdecl
) == RESULT_DECL
3523 || TREE_CODE (newdecl
) == FIELD_DECL
3524 || TREE_CODE (newdecl
) == TYPE_DECL
)
3525 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
3526 layout_decl (newdecl
, 0);
3528 /* Merge the type qualifiers. */
3529 if (TREE_READONLY (newdecl
))
3530 TREE_READONLY (olddecl
) = 1;
3531 if (TREE_THIS_VOLATILE (newdecl
))
3532 TREE_THIS_VOLATILE (olddecl
) = 1;
3534 /* Merge the initialization information. */
3535 if (DECL_INITIAL (newdecl
) == NULL_TREE
3536 && DECL_INITIAL (olddecl
) != NULL_TREE
)
3538 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3539 DECL_SOURCE_FILE (newdecl
) = DECL_SOURCE_FILE (olddecl
);
3540 DECL_SOURCE_LINE (newdecl
) = DECL_SOURCE_LINE (olddecl
);
3541 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
3542 && DECL_LANG_SPECIFIC (newdecl
)
3543 && DECL_LANG_SPECIFIC (olddecl
))
3544 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
3547 /* Merge the section attribute.
3548 We want to issue an error if the sections conflict but that must be
3549 done later in decl_attributes since we are called before attributes
3551 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
3552 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
3554 /* Keep the old rtl since we can safely use it. */
3555 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3557 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3559 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
3560 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
3561 DECL_NO_CHECK_MEMORY_USAGE (newdecl
)
3562 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl
);
3563 DECL_NO_LIMIT_STACK (newdecl
)
3564 |= DECL_NO_LIMIT_STACK (olddecl
);
3567 /* If cannot merge, then use the new type and qualifiers,
3568 and don't preserve the old rtl. */
3571 /* Clean out any memory we had of the old declaration. */
3572 tree oldstatic
= value_member (olddecl
, static_aggregates
);
3574 TREE_VALUE (oldstatic
) = error_mark_node
;
3576 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
3577 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
3578 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
3579 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
3582 /* Merge the storage class information. */
3583 DECL_WEAK (newdecl
) |= DECL_WEAK (olddecl
);
3584 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
3585 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
3586 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
3587 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
3588 if (! DECL_EXTERNAL (olddecl
))
3589 DECL_EXTERNAL (newdecl
) = 0;
3591 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
3593 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
3594 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
3595 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
3596 DECL_TEMPLATE_INSTANTIATED (newdecl
)
3597 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
3598 /* Don't really know how much of the language-specific
3599 values we should copy from old to new. */
3600 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
3601 DECL_ACCESS (newdecl
) = DECL_ACCESS (olddecl
);
3602 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
3603 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
3604 olddecl_friend
= DECL_FRIEND_P (olddecl
);
3606 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3607 if (TREE_CODE (newdecl
) == FUNCTION_DECL
3608 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
3609 DECL_BEFRIENDING_CLASSES (newdecl
)
3610 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
3611 DECL_BEFRIENDING_CLASSES (olddecl
));
3614 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3616 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
3617 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
3619 /* If newdecl is not a specialization, then it is not a
3620 template-related function at all. And that means that we
3621 shoud have exited above, returning 0. */
3622 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
3625 if (TREE_USED (olddecl
))
3626 /* From [temp.expl.spec]:
3628 If a template, a member template or the member of a class
3629 template is explicitly specialized then that
3630 specialization shall be declared before the first use of
3631 that specialization that would cause an implicit
3632 instantiation to take place, in every translation unit in
3633 which such a use occurs. */
3634 cp_error ("explicit specialization of %D after first use",
3637 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
3639 DECL_THIS_INLINE (newdecl
) |= DECL_THIS_INLINE (olddecl
);
3641 /* If either decl says `inline', this fn is inline, unless its
3642 definition was passed already. */
3643 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
3644 DECL_INLINE (olddecl
) = 1;
3645 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
3649 DECL_LANGUAGE (olddecl
) = DECL_LANGUAGE (newdecl
);
3650 DECL_ASSEMBLER_NAME (olddecl
) = DECL_ASSEMBLER_NAME (newdecl
);
3651 DECL_RTL (olddecl
) = DECL_RTL (newdecl
);
3653 if (! types_match
|| new_defines_function
)
3655 /* These need to be copied so that the names are available.
3656 Note that if the types do match, we'll preserve inline
3657 info and other bits, but if not, we won't. */
3658 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
3659 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
3661 if (new_defines_function
)
3662 /* If defining a function declared with other language
3663 linkage, use the previously declared language linkage. */
3664 DECL_LANGUAGE (newdecl
) = DECL_LANGUAGE (olddecl
);
3665 else if (types_match
)
3667 /* If redeclaring a builtin function, and not a definition,
3668 it stays built in. */
3669 if (DECL_BUILT_IN (olddecl
))
3671 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
3672 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
3673 /* If we're keeping the built-in definition, keep the rtl,
3674 regardless of declaration matches. */
3675 DECL_RTL (newdecl
) = DECL_RTL (olddecl
);
3678 DECL_FRAME_SIZE (newdecl
) = DECL_FRAME_SIZE (olddecl
);
3680 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
3681 if ((DECL_SAVED_INSNS (newdecl
) = DECL_SAVED_INSNS (olddecl
)))
3682 /* Previously saved insns go together with
3683 the function's previous definition. */
3684 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
3685 /* Don't clear out the arguments if we're redefining a function. */
3686 if (DECL_ARGUMENTS (olddecl
))
3687 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
3691 if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
3693 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
3696 /* Now preserve various other info from the definition. */
3697 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
3698 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
3699 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
3700 DECL_ASSEMBLER_NAME (newdecl
) = DECL_ASSEMBLER_NAME (olddecl
);
3702 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
3706 function_size
= sizeof (struct tree_decl
);
3708 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3709 (char *) olddecl
+ sizeof (struct tree_common
),
3710 function_size
- sizeof (struct tree_common
));
3712 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
3714 /* If newdecl is a template instantiation, it is possible that
3715 the following sequence of events has occurred:
3717 o A friend function was declared in a class template. The
3718 class template was instantiated.
3720 o The instantiation of the friend declaration was
3721 recorded on the instantiation list, and is newdecl.
3723 o Later, however, instantiate_class_template called pushdecl
3724 on the newdecl to perform name injection. But, pushdecl in
3725 turn called duplicate_decls when it discovered that another
3726 declaration of a global function with the same name already
3729 o Here, in duplicate_decls, we decided to clobber newdecl.
3731 If we're going to do that, we'd better make sure that
3732 olddecl, and not newdecl, is on the list of
3733 instantiations so that if we try to do the instantiation
3734 again we won't get the clobbered declaration. */
3736 tree tmpl
= DECL_TI_TEMPLATE (newdecl
);
3737 tree decls
= DECL_TEMPLATE_SPECIALIZATIONS (tmpl
);
3739 for (; decls
; decls
= TREE_CHAIN (decls
))
3740 if (TREE_VALUE (decls
) == newdecl
)
3741 TREE_VALUE (decls
) = olddecl
;
3746 bcopy ((char *) newdecl
+ sizeof (struct tree_common
),
3747 (char *) olddecl
+ sizeof (struct tree_common
),
3748 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
3749 + tree_code_length
[(int)TREE_CODE (newdecl
)] * sizeof (char *));
3752 DECL_UID (olddecl
) = olddecl_uid
;
3754 DECL_FRIEND_P (olddecl
) = 1;
3756 /* NEWDECL contains the merged attribute lists.
3757 Update OLDDECL to be the same. */
3758 DECL_MACHINE_ATTRIBUTES (olddecl
) = DECL_MACHINE_ATTRIBUTES (newdecl
);
3763 /* Record a decl-node X as belonging to the current lexical scope.
3764 Check for errors (such as an incompatible declaration for the same
3765 name already seen in the same scope).
3767 Returns either X or an old decl for the same name.
3768 If an old decl is returned, it may have been smashed
3769 to agree with what X says. */
3777 int need_new_binding
;
3779 /* We shouldn't be calling pushdecl when we're generating RTL for a
3780 function that we already did semantic analysis on previously. */
3781 my_friendly_assert (!cfun
|| doing_semantic_analysis_p (),
3784 need_new_binding
= 1;
3786 if (DECL_TEMPLATE_PARM_P (x
))
3787 /* Template parameters have no context; they are not X::T even
3788 when declared within a class or namespace. */
3792 if (current_function_decl
&& x
!= current_function_decl
3793 /* A local declaration for a function doesn't constitute
3795 && !(TREE_CODE (x
) == FUNCTION_DECL
&& !DECL_INITIAL (x
))
3796 /* A local declaration for an `extern' variable is in the
3797 scope of the current namespace, not the current
3799 && !(TREE_CODE (x
) == VAR_DECL
&& DECL_EXTERNAL (x
))
3800 && !DECL_CONTEXT (x
))
3801 DECL_CONTEXT (x
) = current_function_decl
;
3803 /* If this is the declaration for a namespace-scope function,
3804 but the declaration itself is in a local scope, mark the
3806 if (TREE_CODE (x
) == FUNCTION_DECL
3807 && DECL_NAMESPACE_SCOPE_P (x
)
3808 && current_function_decl
3809 && x
!= current_function_decl
)
3810 DECL_LOCAL_FUNCTION_P (x
) = 1;
3813 name
= DECL_NAME (x
);
3816 int different_binding_level
= 0;
3818 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3819 name
= TREE_OPERAND (name
, 0);
3821 /* In case this decl was explicitly namespace-qualified, look it
3822 up in its namespace context. */
3823 if (TREE_CODE (x
) == VAR_DECL
&& DECL_NAMESPACE_SCOPE_P (x
)
3824 && namespace_bindings_p ())
3825 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3827 t
= lookup_name_current_level (name
);
3829 /* [basic.link] If there is a visible declaration of an entity
3830 with linkage having the same name and type, ignoring entities
3831 declared outside the innermost enclosing namespace scope, the
3832 block scope declaration declares that same entity and
3833 receives the linkage of the previous declaration. */
3834 if (! t
&& current_function_decl
&& x
!= current_function_decl
3835 && (TREE_CODE (x
) == FUNCTION_DECL
|| TREE_CODE (x
) == VAR_DECL
)
3836 && DECL_EXTERNAL (x
))
3838 /* Look in block scope. */
3839 t
= IDENTIFIER_VALUE (name
);
3840 /* Or in the innermost namespace. */
3842 t
= namespace_binding (name
, DECL_CONTEXT (x
));
3843 /* Does it have linkage? */
3844 if (t
&& ! (TREE_STATIC (t
) || DECL_EXTERNAL (t
)))
3847 different_binding_level
= 1;
3850 /* If we are declaring a function, and the result of name-lookup
3851 was an OVERLOAD, look for an overloaded instance that is
3852 actually the same as the function we are declaring. (If
3853 there is one, we have to merge our declaration with the
3854 previous declaration.) */
3855 if (t
&& TREE_CODE (t
) == OVERLOAD
)
3859 if (TREE_CODE (x
) == FUNCTION_DECL
)
3860 for (match
= t
; match
; match
= OVL_NEXT (match
))
3862 if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t
))
3863 == DECL_ASSEMBLER_NAME (x
))
3867 /* Just choose one. */
3871 t
= OVL_CURRENT (match
);
3876 if (t
== error_mark_node
)
3878 /* error_mark_node is 0 for a while during initialization! */
3880 cp_error_at ("`%#D' used prior to declaration", x
);
3882 else if (t
!= NULL_TREE
)
3884 if (different_binding_level
)
3886 if (decls_match (x
, t
))
3887 /* The standard only says that the local extern
3888 inherits linkage from the previous decl; in
3889 particular, default args are not shared. It would
3890 be nice to propagate inlining info, though. FIXME. */
3891 TREE_PUBLIC (x
) = TREE_PUBLIC (t
);
3893 else if (TREE_CODE (t
) == PARM_DECL
)
3895 if (DECL_CONTEXT (t
) == NULL_TREE
)
3896 fatal ("parse errors have confused me too much");
3898 /* Check for duplicate params. */
3899 if (duplicate_decls (x
, t
))
3902 else if ((DECL_EXTERN_C_FUNCTION_P (x
)
3903 || DECL_FUNCTION_TEMPLATE_P (x
))
3904 && is_overloaded_fn (t
))
3905 /* Don't do anything just yet. */;
3906 else if (t
== wchar_decl_node
)
3908 if (pedantic
&& ! DECL_IN_SYSTEM_HEADER (x
))
3909 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x
));
3911 /* Throw away the redeclaration. */
3914 else if (TREE_CODE (t
) != TREE_CODE (x
))
3916 if (duplicate_decls (x
, t
))
3919 else if (duplicate_decls (x
, t
))
3921 if (TREE_CODE (t
) == TYPE_DECL
)
3922 SET_IDENTIFIER_TYPE_VALUE (name
, TREE_TYPE (t
));
3923 else if (TREE_CODE (t
) == FUNCTION_DECL
)
3924 check_default_args (t
);
3928 else if (DECL_MAIN_P (x
))
3930 /* A redeclaration of main, but not a duplicate of the
3935 This function shall not be overloaded. */
3936 cp_error_at ("invalid redeclaration of `%D'", t
);
3937 cp_error ("as `%D'", x
);
3938 /* We don't try to push this declaration since that
3944 check_template_shadow (x
);
3946 /* If this is a function conjured up by the backend, massage it
3947 so it looks friendly. */
3948 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_LANG_SPECIFIC (x
))
3950 retrofit_lang_decl (x
);
3951 DECL_LANGUAGE (x
) = lang_c
;
3954 if (DECL_NON_THUNK_FUNCTION_P (x
) && ! DECL_FUNCTION_MEMBER_P (x
))
3956 t
= push_overloaded_decl (x
, PUSH_LOCAL
);
3959 if (!namespace_bindings_p ())
3960 /* We do not need to create a binding for this name;
3961 push_overloaded_decl will have already done so if
3963 need_new_binding
= 0;
3965 else if (DECL_FUNCTION_TEMPLATE_P (x
) && DECL_NAMESPACE_SCOPE_P (x
))
3967 t
= push_overloaded_decl (x
, PUSH_GLOBAL
);
3969 add_decl_to_level (x
, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t
)));
3973 /* If declaring a type as a typedef, copy the type (unless we're
3974 at line 0), and install this TYPE_DECL as the new type's typedef
3975 name. See the extensive comment in ../c-decl.c (pushdecl). */
3976 if (TREE_CODE (x
) == TYPE_DECL
)
3978 tree type
= TREE_TYPE (x
);
3979 if (DECL_SOURCE_LINE (x
) == 0)
3981 if (TYPE_NAME (type
) == 0)
3982 TYPE_NAME (type
) = x
;
3984 else if (type
!= error_mark_node
&& TYPE_NAME (type
) != x
3985 /* We don't want to copy the type when all we're
3986 doing is making a TYPE_DECL for the purposes of
3988 && (!TYPE_NAME (type
)
3989 || TYPE_NAME (type
) != DECL_ABSTRACT_ORIGIN (x
)))
3991 DECL_ORIGINAL_TYPE (x
) = type
;
3992 type
= build_type_copy (type
);
3993 TYPE_STUB_DECL (type
) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x
));
3994 TYPE_NAME (type
) = x
;
3995 TREE_TYPE (x
) = type
;
3998 if (type
!= error_mark_node
4000 && TYPE_IDENTIFIER (type
))
4001 set_identifier_type_value_with_scope (DECL_NAME (x
), type
,
4002 current_binding_level
);
4006 /* Multiple external decls of the same identifier ought to match.
4008 We get warnings about inline functions where they are defined.
4009 We get warnings about other functions from push_overloaded_decl.
4011 Avoid duplicate warnings where they are used. */
4012 if (TREE_PUBLIC (x
) && TREE_CODE (x
) != FUNCTION_DECL
)
4016 decl
= IDENTIFIER_NAMESPACE_VALUE (name
);
4017 if (decl
&& TREE_CODE (decl
) == OVERLOAD
)
4018 decl
= OVL_FUNCTION (decl
);
4020 if (decl
&& decl
!= error_mark_node
4021 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
))
4022 /* If different sort of thing, we already gave an error. */
4023 && TREE_CODE (decl
) == TREE_CODE (x
)
4024 && !same_type_p (TREE_TYPE (x
), TREE_TYPE (decl
)))
4026 cp_pedwarn ("type mismatch with previous external decl", x
);
4027 cp_pedwarn_at ("previous external decl of `%#D'", decl
);
4031 /* This name is new in its binding level.
4032 Install the new declaration and return it. */
4033 if (namespace_bindings_p ())
4035 /* Install a global value. */
4037 /* If the first global decl has external linkage,
4038 warn if we later see static one. */
4039 if (IDENTIFIER_GLOBAL_VALUE (name
) == NULL_TREE
&& TREE_PUBLIC (x
))
4040 TREE_PUBLIC (name
) = 1;
4042 /* Bind the mangled name for the entity. In the future, we
4043 should not need to do this; mangled names are an
4044 implementation detail of which the front-end should not
4045 need to be aware. */
4046 if (!(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)
4048 /* For an ordinary function, we create a binding from
4049 the mangled name (i.e., NAME) to the DECL. But, for
4050 an `extern "C"' function, the mangled name and the
4051 ordinary name are the same so we need not do this. */
4052 && !DECL_EXTERN_C_FUNCTION_P (x
))
4056 if (TREE_CODE (x
) == TYPE_DECL
|| TREE_CODE (x
) == VAR_DECL
4057 || TREE_CODE (x
) == NAMESPACE_DECL
)
4058 mangled_name
= name
;
4060 mangled_name
= DECL_ASSEMBLER_NAME (x
);
4062 if (TREE_CODE (x
) == FUNCTION_DECL
)
4064 ((IDENTIFIER_GLOBAL_VALUE (mangled_name
) == NULL_TREE
)
4065 || (IDENTIFIER_GLOBAL_VALUE (mangled_name
) == x
), 378);
4066 SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name
, x
);
4069 /* Don't forget if the function was used via an implicit decl. */
4070 if (IDENTIFIER_IMPLICIT_DECL (name
)
4071 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name
)))
4074 /* Don't forget if its address was taken in that way. */
4075 if (IDENTIFIER_IMPLICIT_DECL (name
)
4076 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name
)))
4077 TREE_ADDRESSABLE (x
) = 1;
4079 /* Warn about mismatches against previous implicit decl. */
4080 if (IDENTIFIER_IMPLICIT_DECL (name
) != NULL_TREE
4081 /* If this real decl matches the implicit, don't complain. */
4082 && ! (TREE_CODE (x
) == FUNCTION_DECL
4083 && TREE_TYPE (TREE_TYPE (x
)) == integer_type_node
))
4085 ("`%D' was previously implicitly declared to return `int'", x
);
4087 /* If new decl is `static' and an `extern' was seen previously,
4089 if (x
!= NULL_TREE
&& t
!= NULL_TREE
&& decls_match (x
, t
))
4090 warn_extern_redeclared_static (x
, t
);
4094 /* Here to install a non-global value. */
4095 tree oldlocal
= IDENTIFIER_VALUE (name
);
4096 tree oldglobal
= IDENTIFIER_NAMESPACE_VALUE (name
);
4098 if (need_new_binding
)
4100 push_local_binding (name
, x
, 0);
4101 /* Because push_local_binding will hook X on to the
4102 current_binding_level's name list, we don't want to
4103 do that again below. */
4104 need_new_binding
= 0;
4107 /* If this is a TYPE_DECL, push it into the type value slot. */
4108 if (TREE_CODE (x
) == TYPE_DECL
)
4109 set_identifier_type_value_with_scope (name
, TREE_TYPE (x
),
4110 current_binding_level
);
4112 /* Clear out any TYPE_DECL shadowed by a namespace so that
4113 we won't think this is a type. The C struct hack doesn't
4114 go through namespaces. */
4115 if (TREE_CODE (x
) == NAMESPACE_DECL
)
4116 set_identifier_type_value_with_scope (name
, NULL_TREE
,
4117 current_binding_level
);
4124 && TREE_CODE (oldlocal
) == VAR_DECL
4125 && DECL_DEAD_FOR_LOCAL (oldlocal
))
4126 oldlocal
= DECL_SHADOWED_FOR_VAR (oldlocal
);
4128 if (oldlocal
== NULL_TREE
)
4129 oldlocal
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d
));
4132 /* If this is an extern function declaration, see if we
4133 have a global definition or declaration for the function. */
4134 if (oldlocal
== NULL_TREE
4135 && DECL_EXTERNAL (x
)
4136 && oldglobal
!= NULL_TREE
4137 && TREE_CODE (x
) == FUNCTION_DECL
4138 && TREE_CODE (oldglobal
) == FUNCTION_DECL
)
4140 /* We have one. Their types must agree. */
4141 if (decls_match (x
, oldglobal
))
4145 cp_warning ("extern declaration of `%#D' doesn't match", x
);
4146 cp_warning_at ("global declaration `%#D'", oldglobal
);
4149 /* If we have a local external declaration,
4150 and no file-scope declaration has yet been seen,
4151 then if we later have a file-scope decl it must not be static. */
4152 if (oldlocal
== NULL_TREE
4153 && oldglobal
== NULL_TREE
4154 && DECL_EXTERNAL (x
)
4156 TREE_PUBLIC (name
) = 1;
4158 /* Warn if shadowing an argument at the top level of the body. */
4159 if (oldlocal
!= NULL_TREE
&& !DECL_EXTERNAL (x
)
4160 /* Inline decls shadow nothing. */
4161 && !DECL_FROM_INLINE (x
)
4162 && TREE_CODE (oldlocal
) == PARM_DECL
4163 /* Don't complain if it's from an enclosing function. */
4164 && DECL_CONTEXT (oldlocal
) == current_function_decl
4165 && TREE_CODE (x
) != PARM_DECL
)
4167 /* Go to where the parms should be and see if we
4169 struct binding_level
*b
= current_binding_level
->level_chain
;
4175 if (b
->parm_flag
== 1)
4176 cp_error ("declaration of `%#D' shadows a parameter", name
);
4179 /* Maybe warn if shadowing something else. */
4180 if (warn_shadow
&& !DECL_EXTERNAL (x
)
4181 /* Inline decls shadow nothing. */
4182 && !DECL_FROM_INLINE (x
)
4183 /* No shadow warnings for internally generated vars. */
4184 && ! DECL_ARTIFICIAL (x
)
4185 /* No shadow warnings for vars made for inlining. */
4186 && ! DECL_FROM_INLINE (x
))
4188 if (oldlocal
!= NULL_TREE
&& TREE_CODE (oldlocal
) == PARM_DECL
)
4189 warning ("declaration of `%s' shadows a parameter",
4190 IDENTIFIER_POINTER (name
));
4191 else if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
4192 && current_class_ptr
4193 && !TREE_STATIC (name
))
4194 warning ("declaration of `%s' shadows a member of `this'",
4195 IDENTIFIER_POINTER (name
));
4196 else if (oldlocal
!= NULL_TREE
)
4197 warning ("declaration of `%s' shadows previous local",
4198 IDENTIFIER_POINTER (name
));
4199 else if (oldglobal
!= NULL_TREE
)
4200 /* XXX shadow warnings in outer-more namespaces */
4201 warning ("declaration of `%s' shadows global declaration",
4202 IDENTIFIER_POINTER (name
));
4206 if (TREE_CODE (x
) == FUNCTION_DECL
)
4207 check_default_args (x
);
4209 /* Keep count of variables in this level with incomplete type. */
4210 if (TREE_CODE (x
) == VAR_DECL
4211 && TREE_TYPE (x
) != error_mark_node
4212 && ((!COMPLETE_TYPE_P (TREE_TYPE (x
))
4213 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x
), ARRAY_TYPE
))
4214 /* RTTI TD entries are created while defining the type_info. */
4215 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x
))
4216 && TYPE_BEING_DEFINED (TREE_TYPE (x
)))))
4218 if (namespace_bindings_p ())
4219 namespace_scope_incomplete
4220 = tree_cons (NULL_TREE
, x
, namespace_scope_incomplete
);
4222 current_binding_level
->incomplete
4223 = tree_cons (NULL_TREE
, x
, current_binding_level
->incomplete
);
4227 if (need_new_binding
)
4228 add_decl_to_level (x
,
4229 DECL_NAMESPACE_SCOPE_P (x
)
4230 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x
))
4231 : current_binding_level
);
4236 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4237 caller to set DECL_CONTEXT properly. */
4240 pushdecl_with_scope (x
, level
)
4242 struct binding_level
*level
;
4244 register struct binding_level
*b
;
4245 tree function_decl
= current_function_decl
;
4247 current_function_decl
= NULL_TREE
;
4248 if (level
->parm_flag
== 2)
4250 b
= class_binding_level
;
4251 class_binding_level
= level
;
4252 pushdecl_class_level (x
);
4253 class_binding_level
= b
;
4257 b
= current_binding_level
;
4258 current_binding_level
= level
;
4260 current_binding_level
= b
;
4262 current_function_decl
= function_decl
;
4266 /* Like pushdecl, only it places X in the current namespace,
4270 pushdecl_namespace_level (x
)
4273 register struct binding_level
*b
= current_binding_level
;
4276 t
= pushdecl_with_scope (x
, NAMESPACE_LEVEL (current_namespace
));
4278 /* Now, the type_shadowed stack may screw us. Munge it so it does
4280 if (TREE_CODE (x
) == TYPE_DECL
)
4282 tree name
= DECL_NAME (x
);
4284 tree
*ptr
= (tree
*)0;
4285 for (; b
!= global_binding_level
; b
= b
->level_chain
)
4287 tree shadowed
= b
->type_shadowed
;
4288 for (; shadowed
; shadowed
= TREE_CHAIN (shadowed
))
4289 if (TREE_PURPOSE (shadowed
) == name
)
4291 ptr
= &TREE_VALUE (shadowed
);
4292 /* Can't break out of the loop here because sometimes
4293 a binding level will have duplicate bindings for
4294 PT names. It's gross, but I haven't time to fix it. */
4297 newval
= TREE_TYPE (x
);
4298 if (ptr
== (tree
*)0)
4300 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4301 up here if this is changed to an assertion. --KR */
4302 SET_IDENTIFIER_TYPE_VALUE (name
, newval
);
4312 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4316 pushdecl_top_level (x
)
4319 push_to_top_level ();
4320 x
= pushdecl_namespace_level (x
);
4321 pop_from_top_level ();
4325 /* Make the declaration of X appear in CLASS scope. */
4328 pushdecl_class_level (x
)
4331 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4332 scope looks for the pre-mangled name. */
4335 if (TREE_CODE (x
) == OVERLOAD
)
4336 x
= OVL_CURRENT (x
);
4337 name
= DECL_NAME (x
);
4341 push_class_level_binding (name
, x
);
4342 if (TREE_CODE (x
) == TYPE_DECL
)
4343 set_identifier_type_value (name
, TREE_TYPE (x
));
4345 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x
)))
4349 for (f
= TYPE_FIELDS (TREE_TYPE (x
));
4352 pushdecl_class_level (f
);
4356 /* Enter DECL into the symbol table, if that's appropriate. Returns
4357 DECL, or a modified version thereof. */
4360 maybe_push_decl (decl
)
4363 tree type
= TREE_TYPE (decl
);
4365 /* Add this decl to the current binding level, but not if it comes
4366 from another scope, e.g. a static member variable. TEM may equal
4367 DECL or it may be a previous decl of the same name. */
4368 if (decl
== error_mark_node
4369 || (TREE_CODE (decl
) != PARM_DECL
4370 && DECL_CONTEXT (decl
) != NULL_TREE
4371 /* Definitions of namespace members outside their namespace are
4373 && TREE_CODE (DECL_CONTEXT (decl
)) != NAMESPACE_DECL
)
4374 || (TREE_CODE (decl
) == TEMPLATE_DECL
&& !namespace_bindings_p ())
4375 || TREE_CODE (type
) == UNKNOWN_TYPE
4376 /* The declaration of a template specialization does not affect
4377 the functions available for overload resolution, so we do not
4379 || (TREE_CODE (decl
) == FUNCTION_DECL
4380 && DECL_TEMPLATE_SPECIALIZATION (decl
)))
4383 return pushdecl (decl
);
4386 /* Make the declaration(s) of X appear in CLASS scope
4387 under the name NAME. */
4390 push_class_level_binding (name
, x
)
4395 /* The class_binding_level will be NULL if x is a template
4396 parameter name in a member template. */
4397 if (!class_binding_level
)
4400 /* Make sure that this new member does not have the same name
4401 as a template parameter. */
4402 if (TYPE_BEING_DEFINED (current_class_type
))
4403 check_template_shadow (x
);
4405 /* If this declaration shadows a declaration from an enclosing
4406 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4407 we leave this class. Record the shadowed declaration here. */
4408 binding
= IDENTIFIER_BINDING (name
);
4410 && ((TREE_CODE (x
) == OVERLOAD
4411 && BINDING_VALUE (binding
)
4412 && is_overloaded_fn (BINDING_VALUE (binding
)))
4413 || INHERITED_VALUE_BINDING_P (binding
)))
4418 /* If the old binding was from a base class, and was for a tag
4419 name, slide it over to make room for the new binding. The
4420 old binding is still visible if explicitly qualified with a
4422 if (INHERITED_VALUE_BINDING_P (binding
)
4423 && BINDING_VALUE (binding
)
4424 && TREE_CODE (BINDING_VALUE (binding
)) == TYPE_DECL
4425 && DECL_ARTIFICIAL (BINDING_VALUE (binding
))
4426 && !(TREE_CODE (x
) == TYPE_DECL
&& DECL_ARTIFICIAL (x
)))
4428 old_decl
= BINDING_TYPE (binding
);
4429 BINDING_TYPE (binding
) = BINDING_VALUE (binding
);
4430 BINDING_VALUE (binding
) = NULL_TREE
;
4431 INHERITED_VALUE_BINDING_P (binding
) = 0;
4434 old_decl
= BINDING_VALUE (binding
);
4436 /* There was already a binding for X containing fewer
4437 functions than are named in X. Find the previous
4438 declaration of X on the class-shadowed list, and update it. */
4439 for (shadow
= class_binding_level
->class_shadowed
;
4441 shadow
= TREE_CHAIN (shadow
))
4442 if (TREE_PURPOSE (shadow
) == name
4443 && TREE_TYPE (shadow
) == old_decl
)
4445 BINDING_VALUE (binding
) = x
;
4446 INHERITED_VALUE_BINDING_P (binding
) = 0;
4447 TREE_TYPE (shadow
) = x
;
4452 /* If we didn't replace an existing binding, put the binding on the
4453 stack of bindings for the identifier, and update
4454 IDENTIFIER_CLASS_VALUE. */
4455 if (push_class_binding (name
, x
))
4457 class_binding_level
->class_shadowed
4458 = tree_cons (name
, IDENTIFIER_CLASS_VALUE (name
),
4459 class_binding_level
->class_shadowed
);
4460 /* Record the value we are binding NAME to so that we can know
4461 what to pop later. */
4462 TREE_TYPE (class_binding_level
->class_shadowed
) = x
;
4466 /* Insert another USING_DECL into the current binding level, returning
4467 this declaration. If this is a redeclaration, do nothing, and
4468 return NULL_TREE if this not in namespace scope (in namespace
4469 scope, a using decl might extend any previous bindings). */
4472 push_using_decl (scope
, name
)
4478 my_friendly_assert (TREE_CODE (scope
) == NAMESPACE_DECL
, 383);
4479 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 384);
4480 for (decl
= current_binding_level
->usings
; decl
; decl
= TREE_CHAIN (decl
))
4481 if (DECL_INITIAL (decl
) == scope
&& DECL_NAME (decl
) == name
)
4484 return namespace_bindings_p () ? decl
: NULL_TREE
;
4485 decl
= build_lang_decl (USING_DECL
, name
, void_type_node
);
4486 DECL_INITIAL (decl
) = scope
;
4487 TREE_CHAIN (decl
) = current_binding_level
->usings
;
4488 current_binding_level
->usings
= decl
;
4492 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4493 changed (i.e. there was already a directive), or the fresh
4494 TREE_LIST otherwise. */
4497 push_using_directive (used
)
4500 tree ud
= current_binding_level
->using_directives
;
4501 tree iter
, ancestor
;
4503 /* Check if we already have this. */
4504 if (purpose_member (used
, ud
) != NULL_TREE
)
4507 /* Recursively add all namespaces used. */
4508 for (iter
= DECL_NAMESPACE_USING (used
); iter
; iter
= TREE_CHAIN (iter
))
4509 push_using_directive (TREE_PURPOSE (iter
));
4511 ancestor
= namespace_ancestor (current_decl_namespace (), used
);
4512 ud
= current_binding_level
->using_directives
;
4513 ud
= tree_cons (used
, ancestor
, ud
);
4514 current_binding_level
->using_directives
= ud
;
4518 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4519 other definitions already in place. We get around this by making
4520 the value of the identifier point to a list of all the things that
4521 want to be referenced by that name. It is then up to the users of
4522 that name to decide what to do with that list.
4524 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4525 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4527 FLAGS is a bitwise-or of the following values:
4528 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4530 PUSH_USING: DECL is being pushed as the result of a using
4533 The value returned may be a previous declaration if we guessed wrong
4534 about what language DECL should belong to (C or C++). Otherwise,
4535 it's always DECL (and never something that's not a _DECL). */
4538 push_overloaded_decl (decl
, flags
)
4542 tree name
= DECL_NAME (decl
);
4545 int doing_global
= (namespace_bindings_p () || !(flags
& PUSH_LOCAL
));
4548 old
= namespace_binding (name
, DECL_CONTEXT (decl
));
4550 old
= lookup_name_current_level (name
);
4554 if (TREE_CODE (old
) == TYPE_DECL
&& DECL_ARTIFICIAL (old
))
4556 tree t
= TREE_TYPE (old
);
4557 if (IS_AGGR_TYPE (t
) && warn_shadow
4558 && (! DECL_IN_SYSTEM_HEADER (decl
)
4559 || ! DECL_IN_SYSTEM_HEADER (old
)))
4560 cp_warning ("`%#D' hides constructor for `%#T'", decl
, t
);
4563 else if (is_overloaded_fn (old
))
4567 for (tmp
= old
; tmp
; tmp
= OVL_NEXT (tmp
))
4569 tree fn
= OVL_CURRENT (tmp
);
4571 if (TREE_CODE (tmp
) == OVERLOAD
&& OVL_USED (tmp
)
4572 && !(flags
& PUSH_USING
)
4573 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn
)),
4574 TYPE_ARG_TYPES (TREE_TYPE (decl
))))
4575 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4578 if (duplicate_decls (decl
, fn
))
4582 else if (old
== error_mark_node
)
4583 /* Ignore the undefined symbol marker. */
4587 cp_error_at ("previous non-function declaration `%#D'", old
);
4588 cp_error ("conflicts with function declaration `%#D'", decl
);
4593 if (old
|| TREE_CODE (decl
) == TEMPLATE_DECL
)
4595 if (old
&& TREE_CODE (old
) != OVERLOAD
)
4596 new_binding
= ovl_cons (decl
, ovl_cons (old
, NULL_TREE
));
4598 new_binding
= ovl_cons (decl
, old
);
4599 if (flags
& PUSH_USING
)
4600 OVL_USED (new_binding
) = 1;
4603 /* NAME is not ambiguous. */
4607 set_namespace_binding (name
, current_namespace
, new_binding
);
4610 /* We only create an OVERLOAD if there was a previous binding at
4611 this level, or if decl is a template. In the former case, we
4612 need to remove the old binding and replace it with the new
4613 binding. We must also run through the NAMES on the binding
4614 level where the name was bound to update the chain. */
4616 if (TREE_CODE (new_binding
) == OVERLOAD
&& old
)
4620 for (d
= &BINDING_LEVEL (IDENTIFIER_BINDING (name
))->names
;
4622 d
= &TREE_CHAIN (*d
))
4624 || (TREE_CODE (*d
) == TREE_LIST
4625 && TREE_VALUE (*d
) == old
))
4627 if (TREE_CODE (*d
) == TREE_LIST
)
4628 /* Just replace the old binding with the new. */
4629 TREE_VALUE (*d
) = new_binding
;
4631 /* Build a TREE_LIST to wrap the OVERLOAD. */
4632 *d
= tree_cons (NULL_TREE
, new_binding
,
4635 /* And update the CPLUS_BINDING node. */
4636 BINDING_VALUE (IDENTIFIER_BINDING (name
))
4641 /* We should always find a previous binding in this case. */
4642 my_friendly_abort (0);
4645 /* Install the new binding. */
4646 push_local_binding (name
, new_binding
, flags
);
4652 /* Generate an implicit declaration for identifier FUNCTIONID
4653 as a function of type int (). Print a warning if appropriate. */
4656 implicitly_declare (functionid
)
4661 /* We used to reuse an old implicit decl here,
4662 but this loses with inline functions because it can clobber
4663 the saved decl chains. */
4664 decl
= build_lang_decl (FUNCTION_DECL
, functionid
, default_function_type
);
4666 DECL_EXTERNAL (decl
) = 1;
4667 TREE_PUBLIC (decl
) = 1;
4669 /* ISO standard says implicit declarations are in the innermost block.
4670 So we record the decl in the standard fashion. */
4672 rest_of_decl_compilation (decl
, NULL_PTR
, 0, 0);
4675 /* Only one warning per identifier. */
4676 && IDENTIFIER_IMPLICIT_DECL (functionid
) == NULL_TREE
)
4678 cp_pedwarn ("implicit declaration of function `%#D'", decl
);
4681 SET_IDENTIFIER_IMPLICIT_DECL (functionid
, decl
);
4686 /* Return zero if the declaration NEWDECL is valid
4687 when the declaration OLDDECL (assumed to be for the same name)
4688 has already been seen.
4689 Otherwise return an error message format string with a %s
4690 where the identifier should go. */
4693 redeclaration_error_message (newdecl
, olddecl
)
4694 tree newdecl
, olddecl
;
4696 if (TREE_CODE (newdecl
) == TYPE_DECL
)
4698 /* Because C++ can put things into name space for free,
4699 constructs like "typedef struct foo { ... } foo"
4700 would look like an erroneous redeclaration. */
4701 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
4704 return "redefinition of `%#D'";
4706 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
4708 /* If this is a pure function, its olddecl will actually be
4709 the original initialization to `0' (which we force to call
4710 abort()). Don't complain about redefinition in this case. */
4711 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
))
4714 /* If both functions come from different namespaces, this is not
4715 a redeclaration - this is a conflict with a used function. */
4716 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
4717 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
4718 return "`%D' conflicts with used function";
4720 /* We'll complain about linkage mismatches in
4721 warn_extern_redeclared_static. */
4723 /* Defining the same name twice is no good. */
4724 if (DECL_INITIAL (olddecl
) != NULL_TREE
4725 && DECL_INITIAL (newdecl
) != NULL_TREE
)
4727 if (DECL_NAME (olddecl
) == NULL_TREE
)
4728 return "`%#D' not declared in class";
4730 return "redefinition of `%#D'";
4734 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
4736 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
4737 && (DECL_TEMPLATE_RESULT (newdecl
)
4738 != DECL_TEMPLATE_RESULT (olddecl
))
4739 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
))
4740 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)))
4741 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
4742 && COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
4743 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
))))
4744 return "redefinition of `%#D'";
4747 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
4749 /* Objects declared at top level: */
4750 /* If at least one is a reference, it's ok. */
4751 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
4753 /* Reject two definitions. */
4754 return "redefinition of `%#D'";
4758 /* Objects declared with block scope: */
4759 /* Reject two definitions, and reject a definition
4760 together with an external reference. */
4761 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
4762 return "redeclaration of `%#D'";
4767 /* Create a new label, named ID. */
4770 make_label_decl (id
, local_p
)
4776 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
4778 /* Make sure every label has an rtx. */
4781 DECL_CONTEXT (decl
) = current_function_decl
;
4782 DECL_MODE (decl
) = VOIDmode
;
4783 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
4785 /* Say where one reference is to the label, for the sake of the
4786 error if it is not defined. */
4787 DECL_SOURCE_LINE (decl
) = lineno
;
4788 DECL_SOURCE_FILE (decl
) = input_filename
;
4790 /* Record the fact that this identifier is bound to this label. */
4791 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
4796 /* Record this label on the list of used labels so that we can check
4797 at the end of the function to see whether or not the label was
4798 actually defined, and so we can check when the label is defined whether
4799 this use is valid. */
4805 if (named_label_uses
== NULL
4806 || named_label_uses
->names_in_scope
!= current_binding_level
->names
4807 || named_label_uses
->label_decl
!= decl
)
4809 struct named_label_use_list
*new_ent
;
4810 new_ent
= ((struct named_label_use_list
*)
4811 ggc_alloc (sizeof (struct named_label_use_list
)));
4812 new_ent
->label_decl
= decl
;
4813 new_ent
->names_in_scope
= current_binding_level
->names
;
4814 new_ent
->binding_level
= current_binding_level
;
4815 new_ent
->lineno_o_goto
= lineno
;
4816 new_ent
->filename_o_goto
= input_filename
;
4817 new_ent
->next
= named_label_uses
;
4818 named_label_uses
= new_ent
;
4822 /* Look for a label named ID in the current function. If one cannot
4823 be found, create one. (We keep track of used, but undefined,
4824 labels, and complain about them at the end of a function.) */
4831 struct named_label_list
*ent
;
4833 /* You can't use labels at global scope. */
4834 if (current_function_decl
== NULL_TREE
)
4836 error ("label `%s' referenced outside of any function",
4837 IDENTIFIER_POINTER (id
));
4841 /* See if we've already got this label. */
4842 decl
= IDENTIFIER_LABEL_VALUE (id
);
4843 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
4846 /* Record this label on the list of labels used in this function.
4847 We do this before calling make_label_decl so that we get the
4848 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4849 ent
= ((struct named_label_list
*)
4850 ggc_alloc_cleared (sizeof (struct named_label_list
)));
4851 ent
->old_value
= IDENTIFIER_LABEL_VALUE (id
);
4852 ent
->next
= named_labels
;
4855 /* We need a new label. */
4856 decl
= make_label_decl (id
, /*local_p=*/0);
4858 /* Now fill in the information we didn't have before. */
4859 ent
->label_decl
= decl
;
4864 /* Declare a local label named ID. */
4867 declare_local_label (id
)
4872 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4873 this scope we can restore the old value of
4874 IDENTIFIER_TYPE_VALUE. */
4875 current_binding_level
->shadowed_labels
4876 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
4877 current_binding_level
->shadowed_labels
);
4878 /* Look for the label. */
4879 decl
= make_label_decl (id
, /*local_p=*/1);
4880 /* Now fill in the information we didn't have before. */
4881 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
4886 /* Returns nonzero if it is ill-formed to jump past the declaration of
4887 DECL. Returns 2 if it's also a real problem. */
4890 decl_jump_unsafe (decl
)
4893 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
4896 if (DECL_INITIAL (decl
) == NULL_TREE
4897 && pod_type_p (TREE_TYPE (decl
)))
4900 /* This is really only important if we're crossing an initialization.
4901 The POD stuff is just pedantry; why should it matter if the class
4902 contains a field of pointer to member type? */
4903 if (DECL_INITIAL (decl
)
4904 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
4909 /* Check that a single previously seen jump to a newly defined label
4910 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4911 the jump context; NAMES are the names in scope in LEVEL at the jump
4912 context; FILE and LINE are the source position of the jump or 0. */
4915 check_previous_goto_1 (decl
, level
, names
, file
, line
)
4917 struct binding_level
*level
;
4924 struct binding_level
*b
= current_binding_level
;
4925 for (; b
; b
= b
->level_chain
)
4927 tree new_decls
= b
->names
;
4928 tree old_decls
= (b
== level
? names
: NULL_TREE
);
4929 for (; new_decls
!= old_decls
;
4930 new_decls
= TREE_CHAIN (new_decls
))
4932 int problem
= decl_jump_unsafe (new_decls
);
4939 cp_pedwarn ("jump to label `%D'", decl
);
4941 pedwarn ("jump to case label");
4944 pedwarn_with_file_and_line (file
, line
, " from here");
4948 if (problem
> 1 && DECL_ARTIFICIAL (new_decls
))
4949 /* Can't skip init of __exception_info. */
4950 cp_error_at (" enters catch block", new_decls
);
4951 else if (problem
> 1)
4952 cp_error_at (" crosses initialization of `%#D'",
4955 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4961 if (b
->eh_region
&& ! saw_eh
)
4966 cp_pedwarn ("jump to label `%D'", decl
);
4968 pedwarn ("jump to case label");
4971 pedwarn_with_file_and_line (file
, line
, " from here");
4974 error (" enters try block");
4981 check_previous_goto (use
)
4982 struct named_label_use_list
*use
;
4984 check_previous_goto_1 (use
->label_decl
, use
->binding_level
,
4985 use
->names_in_scope
, use
->filename_o_goto
,
4986 use
->lineno_o_goto
);
4990 check_switch_goto (level
)
4991 struct binding_level
*level
;
4993 check_previous_goto_1 (NULL_TREE
, level
, level
->names
, NULL
, 0);
4996 /* Check that any previously seen jumps to a newly defined label DECL
4997 are OK. Called by define_label. */
5000 check_previous_gotos (decl
)
5003 struct named_label_use_list
**usep
;
5005 if (! TREE_USED (decl
))
5008 for (usep
= &named_label_uses
; *usep
; )
5010 struct named_label_use_list
*use
= *usep
;
5011 if (use
->label_decl
== decl
)
5013 check_previous_goto (use
);
5017 usep
= &(use
->next
);
5021 /* Check that a new jump to a label DECL is OK. Called by
5022 finish_goto_stmt. */
5030 struct named_label_list
*lab
;
5032 /* We can't know where a computed goto is jumping. So we assume
5034 if (! DECL_P (decl
))
5037 /* If the label hasn't been defined yet, defer checking. */
5038 if (! DECL_INITIAL (decl
))
5044 for (lab
= named_labels
; lab
; lab
= lab
->next
)
5045 if (decl
== lab
->label_decl
)
5048 /* If the label is not on named_labels it's a gcc local label, so
5049 it must be in an outer scope, so jumping to it is always OK. */
5053 if ((lab
->eh_region
|| lab
->bad_decls
) && !identified
)
5055 cp_pedwarn_at ("jump to label `%D'", decl
);
5056 pedwarn (" from here");
5060 for (bad
= lab
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
5062 tree b
= TREE_VALUE (bad
);
5063 int u
= decl_jump_unsafe (b
);
5065 if (u
> 1 && DECL_ARTIFICIAL (b
))
5066 /* Can't skip init of __exception_info. */
5067 cp_error_at (" enters catch block", b
);
5069 cp_error_at (" skips initialization of `%#D'", b
);
5071 cp_pedwarn_at (" enters scope of non-POD `%#D'", b
);
5075 error (" enters try block");
5078 /* Define a label, specifying the location in the source file.
5079 Return the LABEL_DECL node for the label, if the definition is valid.
5080 Otherwise return 0. */
5083 define_label (filename
, line
, name
)
5084 const char *filename
;
5088 tree decl
= lookup_label (name
);
5089 struct named_label_list
*ent
;
5091 for (ent
= named_labels
; ent
; ent
= ent
->next
)
5092 if (ent
->label_decl
== decl
)
5095 /* After labels, make any new cleanups go into their
5096 own new (temporary) binding contour. */
5097 current_binding_level
->more_cleanups_ok
= 0;
5099 if (name
== get_identifier ("wchar_t"))
5100 cp_pedwarn ("label named wchar_t");
5102 if (DECL_INITIAL (decl
) != NULL_TREE
)
5104 cp_error ("duplicate label `%D'", decl
);
5109 /* Mark label as having been defined. */
5110 DECL_INITIAL (decl
) = error_mark_node
;
5111 /* Say where in the source. */
5112 DECL_SOURCE_FILE (decl
) = filename
;
5113 DECL_SOURCE_LINE (decl
) = line
;
5116 ent
->names_in_scope
= current_binding_level
->names
;
5117 ent
->binding_level
= current_binding_level
;
5119 check_previous_gotos (decl
);
5120 current_function_return_value
= NULL_TREE
;
5127 struct binding_level
*level
;
5128 struct cp_switch
*next
;
5129 /* The SWITCH_STMT being built. */
5131 /* A splay-tree mapping the low element of a case range to the high
5132 element, or NULL_TREE if there is no high element. Used to
5133 determine whether or not a new case label duplicates an old case
5134 label. We need a tree, rather than simply a hash table, because
5135 of the GNU case range extension. */
5139 /* A stack of the currently active switch statements. The innermost
5140 switch statement is on the top of the stack. There is no need to
5141 mark the stack for garbage collection because it is only active
5142 during the processing of the body of a function, and we never
5143 collect at that point. */
5145 static struct cp_switch
*switch_stack
;
5147 /* Called right after a switch-statement condition is parsed.
5148 SWITCH_STMT is the switch statement being parsed. */
5151 push_switch (switch_stmt
)
5155 = (struct cp_switch
*) xmalloc (sizeof (struct cp_switch
));
5156 p
->level
= current_binding_level
;
5157 p
->next
= switch_stack
;
5158 p
->switch_stmt
= switch_stmt
;
5159 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
5166 struct cp_switch
*cs
;
5169 splay_tree_delete (cs
->cases
);
5170 switch_stack
= switch_stack
->next
;
5174 /* Note that we've seen a definition of a case label, and complain if this
5175 is a bad place for one. */
5178 finish_case_label (low_value
, high_value
)
5187 error ("case label not within a switch statement");
5189 cp_error ("case label `%E' not within a switch statement",
5192 error ("`default' label not within a switch statement");
5196 if (processing_template_decl
)
5200 /* For templates, just add the case label; we'll do semantic
5201 analysis at instantiation-time. */
5202 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5203 add_stmt (build_case_label (low_value
, high_value
, label
));
5207 /* Find the condition on which this switch statement depends. */
5208 cond
= SWITCH_COND (switch_stack
->switch_stmt
);
5209 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
5210 cond
= TREE_VALUE (cond
);
5212 c_add_case_label (switch_stack
->cases
, cond
, low_value
, high_value
);
5214 check_switch_goto (switch_stack
->level
);
5216 /* After labels, make any new cleanups go into their
5217 own new (temporary) binding contour. */
5218 current_binding_level
->more_cleanups_ok
= 0;
5219 current_function_return_value
= NULL_TREE
;
5222 /* Return the list of declarations of the current level.
5223 Note that this list is in reverse order unless/until
5224 you nreverse it; and when you do nreverse it, you must
5225 store the result back using `storedecls' or you will lose. */
5230 return current_binding_level
->names
;
5233 /* Return the list of type-tags (for structs, etc) of the current level. */
5238 return current_binding_level
->tags
;
5241 /* Store the list of declarations of the current level.
5242 This is done for the parameter declarations of a function being defined,
5243 after they are modified in the light of any missing parameters. */
5249 current_binding_level
->names
= decls
;
5252 /* Similarly, store the list of tags of the current level. */
5258 current_binding_level
->tags
= tags
;
5261 /* Given NAME, an IDENTIFIER_NODE,
5262 return the structure (or union or enum) definition for that name.
5263 Searches binding levels from BINDING_LEVEL up to the global level.
5264 If THISLEVEL_ONLY is nonzero, searches only the specified context
5265 (but skips any tag-transparent contexts to find one that is
5266 meaningful for tags).
5267 FORM says which kind of type the caller wants;
5268 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5269 If the wrong kind of type is found, and it's not a template, an error is
5273 lookup_tag (form
, name
, binding_level
, thislevel_only
)
5274 enum tree_code form
;
5276 struct binding_level
*binding_level
;
5279 register struct binding_level
*level
;
5280 /* Non-zero if, we should look past a template parameter level, even
5281 if THISLEVEL_ONLY. */
5282 int allow_template_parms_p
= 1;
5284 for (level
= binding_level
; level
; level
= level
->level_chain
)
5287 if (ANON_AGGRNAME_P (name
))
5288 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5290 /* There's no need for error checking here, because
5291 anon names are unique throughout the compilation. */
5292 if (TYPE_IDENTIFIER (TREE_VALUE (tail
)) == name
)
5293 return TREE_VALUE (tail
);
5295 else if (level
->namespace_p
)
5296 /* Do namespace lookup. */
5297 for (tail
= current_namespace
; 1; tail
= CP_DECL_CONTEXT (tail
))
5299 tree old
= binding_for_name (name
, tail
);
5301 /* If we just skipped past a template parameter level,
5302 even though THISLEVEL_ONLY, and we find a template
5303 class declaration, then we use the _TYPE node for the
5304 template. See the example below. */
5305 if (thislevel_only
&& !allow_template_parms_p
5306 && old
&& BINDING_VALUE (old
)
5307 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old
)))
5308 old
= TREE_TYPE (BINDING_VALUE (old
));
5310 old
= BINDING_TYPE (old
);
5312 /* If it has an original type, it is a typedef, and we
5313 should not return it. */
5314 if (old
&& DECL_ORIGINAL_TYPE (TYPE_NAME (old
)))
5316 if (old
&& TREE_CODE (old
) != form
5317 && !(form
!= ENUMERAL_TYPE
&& TREE_CODE (old
) == TEMPLATE_DECL
))
5319 cp_error ("`%#D' redeclared as %C", old
, form
);
5324 if (thislevel_only
|| tail
== global_namespace
)
5328 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5330 if (TREE_PURPOSE (tail
) == name
)
5332 enum tree_code code
= TREE_CODE (TREE_VALUE (tail
));
5333 /* Should tighten this up; it'll probably permit
5334 UNION_TYPE and a struct template, for example. */
5336 && !(form
!= ENUMERAL_TYPE
&& code
== TEMPLATE_DECL
))
5338 /* Definition isn't the kind we were looking for. */
5339 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail
),
5343 return TREE_VALUE (tail
);
5346 if (thislevel_only
&& ! level
->tag_transparent
)
5348 if (level
->template_parms_p
&& allow_template_parms_p
)
5350 /* We must deal with cases like this:
5352 template <class T> struct S;
5353 template <class T> struct S {};
5355 When looking up `S', for the second declaration, we
5356 would like to find the first declaration. But, we
5357 are in the pseudo-global level created for the
5358 template parameters, rather than the (surrounding)
5359 namespace level. Thus, we keep going one more level,
5360 even though THISLEVEL_ONLY is non-zero. */
5361 allow_template_parms_p
= 0;
5373 set_current_level_tags_transparency (tags_transparent
)
5374 int tags_transparent
;
5376 current_binding_level
->tag_transparent
= tags_transparent
;
5380 /* Given a type, find the tag that was defined for it and return the tag name.
5381 Otherwise return 0. However, the value can never be 0
5382 in the cases in which this is used.
5384 C++: If NAME is non-zero, this is the new name to install. This is
5385 done when replacing anonymous tags with real tag names. */
5388 lookup_tag_reverse (type
, name
)
5392 register struct binding_level
*level
;
5394 for (level
= current_binding_level
; level
; level
= level
->level_chain
)
5397 for (tail
= level
->tags
; tail
; tail
= TREE_CHAIN (tail
))
5399 if (TREE_VALUE (tail
) == type
)
5402 TREE_PURPOSE (tail
) = name
;
5403 return TREE_PURPOSE (tail
);
5410 /* Look up NAME in the NAMESPACE. */
5413 lookup_namespace_name (namespace, name
)
5414 tree
namespace, name
;
5417 tree template_id
= NULL_TREE
;
5419 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL
, 370);
5421 if (TREE_CODE (name
) == NAMESPACE_DECL
)
5422 /* This happens for A::B<int> when B is a namespace. */
5424 else if (TREE_CODE (name
) == TEMPLATE_DECL
)
5426 /* This happens for A::B where B is a template, and there are no
5427 template arguments. */
5428 cp_error ("invalid use of `%D'", name
);
5429 return error_mark_node
;
5432 namespace = ORIGINAL_NAMESPACE (namespace);
5434 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5437 name
= TREE_OPERAND (name
, 0);
5438 if (TREE_CODE (name
) == OVERLOAD
)
5439 name
= DECL_NAME (OVL_CURRENT (name
));
5440 else if (DECL_P (name
))
5441 name
= DECL_NAME (name
);
5444 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 373);
5446 val
= make_node (CPLUS_BINDING
);
5447 if (!qualified_lookup_using_namespace (name
, namespace, val
, 0))
5448 return error_mark_node
;
5450 if (BINDING_VALUE (val
))
5452 val
= BINDING_VALUE (val
);
5456 if (DECL_CLASS_TEMPLATE_P (val
))
5457 val
= lookup_template_class (val
,
5458 TREE_OPERAND (template_id
, 1),
5459 /*in_decl=*/NULL_TREE
,
5460 /*context=*/NULL_TREE
,
5461 /*entering_scope=*/0);
5462 else if (DECL_FUNCTION_TEMPLATE_P (val
)
5463 || TREE_CODE (val
) == OVERLOAD
)
5464 val
= lookup_template_function (val
,
5465 TREE_OPERAND (template_id
, 1));
5468 cp_error ("`%D::%D' is not a template",
5470 return error_mark_node
;
5474 /* If we have a single function from a using decl, pull it out. */
5475 if (TREE_CODE (val
) == OVERLOAD
&& ! really_overloaded_fn (val
))
5476 val
= OVL_FUNCTION (val
);
5480 cp_error ("`%D' undeclared in namespace `%D'", name
, namespace);
5481 return error_mark_node
;
5484 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5486 static unsigned long
5494 hash
= (((unsigned long) TYPE_CONTEXT (t
))
5495 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t
))));
5500 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5503 typename_compare (k1
, k2
)
5514 d1
= TYPE_NAME (t1
);
5515 d2
= TYPE_NAME (t2
);
5517 return (DECL_NAME (d1
) == DECL_NAME (d2
)
5518 && same_type_p (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
))
5519 && ((TREE_TYPE (t1
) != NULL_TREE
)
5520 == (TREE_TYPE (t2
) != NULL_TREE
))
5521 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
5522 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
5525 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5526 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5527 is non-NULL, this type is being created by the implicit typename
5528 extension, and BASE_TYPE is a type named `t' in some base class of
5529 `T' which depends on template parameters.
5531 Returns the new TYPENAME_TYPE. */
5534 build_typename_type (context
, name
, fullname
, base_type
)
5542 struct hash_entry
* e
;
5544 static struct hash_table ht
;
5548 static struct hash_table
*h
= &ht
;
5549 if (!hash_table_init (&ht
, &hash_newfunc
, &typename_hash
,
5551 fatal ("virtual memory exhausted");
5552 ggc_add_tree_hash_table_root (&h
, 1);
5555 /* Build the TYPENAME_TYPE. */
5556 t
= make_aggr_type (TYPENAME_TYPE
);
5557 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
5558 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
5559 TREE_TYPE (t
) = base_type
;
5561 /* Build the corresponding TYPE_DECL. */
5562 d
= build_decl (TYPE_DECL
, name
, t
);
5563 TYPE_NAME (TREE_TYPE (d
)) = d
;
5564 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
5565 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
5566 DECL_ARTIFICIAL (d
) = 1;
5568 /* See if we already have this type. */
5569 e
= hash_lookup (&ht
, t
, /*create=*/false, /*copy=*/0);
5573 /* Insert the type into the table. */
5574 hash_lookup (&ht
, t
, /*create=*/true, /*copy=*/0);
5579 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5580 unless an error occurs, in which case error_mark_node is returned.
5581 If COMPLAIN zero, don't complain about any errors that occur. */
5584 make_typename_type (context
, name
, complain
)
5592 if (!(TYPE_LANG_SPECIFIC (name
)
5593 && (CLASSTYPE_IS_TEMPLATE (name
)
5594 || CLASSTYPE_USE_TEMPLATE (name
))))
5595 name
= TYPE_IDENTIFIER (name
);
5597 /* Create a TEMPLATE_ID_EXPR for the type. */
5598 name
= build_nt (TEMPLATE_ID_EXPR
,
5599 CLASSTYPE_TI_TEMPLATE (name
),
5600 CLASSTYPE_TI_ARGS (name
));
5602 else if (TREE_CODE (name
) == TYPE_DECL
)
5603 name
= DECL_NAME (name
);
5607 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
5609 name
= TREE_OPERAND (name
, 0);
5610 if (TREE_CODE (name
) == TEMPLATE_DECL
)
5611 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
5613 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
5614 my_friendly_abort (2000);
5616 if (TREE_CODE (context
) == NAMESPACE_DECL
)
5618 /* We can get here from typename_sub0 in the explicit_template_type
5619 expansion. Just fail. */
5621 cp_error ("no class template named `%#T' in `%#T'",
5623 return error_mark_node
;
5626 if (! uses_template_parms (context
)
5627 || currently_open_class (context
))
5629 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
5631 tree tmpl
= NULL_TREE
;
5632 if (IS_AGGR_TYPE (context
))
5633 tmpl
= lookup_field (context
, name
, 0, 0);
5634 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
5637 cp_error ("no class template named `%#T' in `%#T'",
5639 return error_mark_node
;
5642 return lookup_template_class (tmpl
,
5643 TREE_OPERAND (fullname
, 1),
5645 /*entering_scope=*/0);
5651 if (!IS_AGGR_TYPE (context
))
5654 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5655 return error_mark_node
;
5658 t
= lookup_field (context
, name
, 0, 1);
5660 return TREE_TYPE (t
);
5664 /* If the CONTEXT is not a template type, then either the field is
5665 there now or its never going to be. */
5666 if (!uses_template_parms (context
))
5669 cp_error ("no type named `%#T' in `%#T'", name
, context
);
5670 return error_mark_node
;
5674 return build_typename_type (context
, name
, fullname
, NULL_TREE
);
5677 /* Select the right _DECL from multiple choices. */
5680 select_decl (binding
, flags
)
5685 val
= BINDING_VALUE (binding
);
5686 if (LOOKUP_NAMESPACES_ONLY (flags
))
5688 /* We are not interested in types. */
5689 if (val
&& TREE_CODE (val
) == NAMESPACE_DECL
)
5694 /* If we could have a type and
5695 we have nothing or we need a type and have none. */
5696 if (BINDING_TYPE (binding
)
5697 && (!val
|| ((flags
& LOOKUP_PREFER_TYPES
)
5698 && TREE_CODE (val
) != TYPE_DECL
)))
5699 val
= TYPE_STUB_DECL (BINDING_TYPE (binding
));
5700 /* Don't return non-types if we really prefer types. */
5701 else if (val
&& LOOKUP_TYPES_ONLY (flags
) && TREE_CODE (val
) != TYPE_DECL
5702 && (TREE_CODE (val
) != TEMPLATE_DECL
5703 || !DECL_CLASS_TEMPLATE_P (val
)))
5709 /* Unscoped lookup of a global: iterate over current namespaces,
5710 considering using-directives. If SPACESP is non-NULL, store a list
5711 of the namespaces we've considered in it. */
5714 unqualified_namespace_lookup (name
, flags
, spacesp
)
5719 tree b
= make_node (CPLUS_BINDING
);
5720 tree initial
= current_decl_namespace();
5721 tree scope
= initial
;
5723 struct binding_level
*level
;
5724 tree val
= NULL_TREE
;
5727 *spacesp
= NULL_TREE
;
5729 for (; !val
; scope
= CP_DECL_CONTEXT (scope
))
5732 *spacesp
= tree_cons (scope
, NULL_TREE
, *spacesp
);
5733 val
= binding_for_name (name
, scope
);
5735 /* Initialize binding for this context. */
5736 BINDING_VALUE (b
) = BINDING_VALUE (val
);
5737 BINDING_TYPE (b
) = BINDING_TYPE (val
);
5739 /* Add all _DECLs seen through local using-directives. */
5740 for (level
= current_binding_level
;
5741 !level
->namespace_p
;
5742 level
= level
->level_chain
)
5743 if (!lookup_using_namespace (name
, b
, level
->using_directives
,
5744 scope
, flags
, spacesp
))
5745 /* Give up because of error. */
5746 return error_mark_node
;
5748 /* Add all _DECLs seen through global using-directives. */
5749 /* XXX local and global using lists should work equally. */
5753 if (!lookup_using_namespace (name
, b
, DECL_NAMESPACE_USING (siter
),
5754 scope
, flags
, spacesp
))
5755 /* Give up because of error. */
5756 return error_mark_node
;
5757 if (siter
== scope
) break;
5758 siter
= CP_DECL_CONTEXT (siter
);
5761 val
= select_decl (b
, flags
);
5762 if (scope
== global_namespace
)
5768 /* Combine prefer_type and namespaces_only into flags. */
5771 lookup_flags (prefer_type
, namespaces_only
)
5772 int prefer_type
, namespaces_only
;
5774 if (namespaces_only
)
5775 return LOOKUP_PREFER_NAMESPACES
;
5776 if (prefer_type
> 1)
5777 return LOOKUP_PREFER_TYPES
;
5778 if (prefer_type
> 0)
5779 return LOOKUP_PREFER_BOTH
;
5783 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5784 ignore it or not. Subroutine of lookup_name_real. */
5787 qualify_lookup (val
, flags
)
5791 if (val
== NULL_TREE
)
5793 if ((flags
& LOOKUP_PREFER_NAMESPACES
) && TREE_CODE (val
) == NAMESPACE_DECL
)
5795 if ((flags
& LOOKUP_PREFER_TYPES
)
5796 && (TREE_CODE (val
) == TYPE_DECL
5797 || ((flags
& LOOKUP_TEMPLATES_EXPECTED
)
5798 && DECL_CLASS_TEMPLATE_P (val
))))
5800 if (flags
& (LOOKUP_PREFER_NAMESPACES
| LOOKUP_PREFER_TYPES
))
5805 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5809 warn_about_implicit_typename_lookup (typename
, binding
)
5813 tree subtype
= TREE_TYPE (TREE_TYPE (typename
));
5814 tree name
= DECL_NAME (typename
);
5816 if (! (TREE_CODE (binding
) == TEMPLATE_DECL
5817 && CLASSTYPE_TEMPLATE_INFO (subtype
)
5818 && CLASSTYPE_TI_TEMPLATE (subtype
) == binding
)
5819 && ! (TREE_CODE (binding
) == TYPE_DECL
5820 && same_type_p (TREE_TYPE (binding
), subtype
)))
5822 cp_warning ("lookup of `%D' finds `%#D'",
5824 cp_warning (" instead of `%D' from dependent base class",
5826 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5827 constructor_name (current_class_type
), name
);
5831 /* Look up NAME in the current binding level and its superiors in the
5832 namespace of variables, functions and typedefs. Return a ..._DECL
5833 node of some kind representing its definition if there is only one
5834 such declaration, or return a TREE_LIST with all the overloaded
5835 definitions if there are many, or return 0 if it is undefined.
5837 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5838 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5839 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5840 Otherwise we prefer non-TYPE_DECLs.
5842 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5843 using IDENTIFIER_CLASS_VALUE. */
5846 lookup_name_real (name
, prefer_type
, nonclass
, namespaces_only
)
5848 int prefer_type
, nonclass
, namespaces_only
;
5851 tree val
= NULL_TREE
;
5853 tree from_obj
= NULL_TREE
;
5855 int val_is_implicit_typename
= 0;
5857 /* Hack: copy flag set by parser, if set. */
5858 if (only_namespace_names
)
5859 namespaces_only
= 1;
5861 if (prefer_type
== -2)
5863 extern int looking_for_typename
;
5864 tree type
= NULL_TREE
;
5867 prefer_type
= looking_for_typename
;
5869 flags
= lookup_flags (prefer_type
, namespaces_only
);
5870 /* If the next thing is '<', class templates are types. */
5871 if (looking_for_template
)
5872 flags
|= LOOKUP_TEMPLATES_EXPECTED
;
5874 /* std:: becomes :: for now. */
5875 if (got_scope
== std_node
)
5876 got_scope
= void_type_node
;
5880 else if (got_object
!= error_mark_node
)
5885 if (type
== error_mark_node
)
5886 return error_mark_node
;
5887 if (TREE_CODE (type
) == TYPENAME_TYPE
&& TREE_TYPE (type
))
5888 type
= TREE_TYPE (type
);
5891 type
= complete_type (type
);
5893 if (TREE_CODE (type
) == VOID_TYPE
)
5894 type
= global_namespace
;
5895 if (TREE_CODE (type
) == NAMESPACE_DECL
)
5897 val
= make_node (CPLUS_BINDING
);
5898 flags
|= LOOKUP_COMPLAIN
;
5899 if (!qualified_lookup_using_namespace (name
, type
, val
, flags
))
5901 val
= select_decl (val
, flags
);
5903 else if (! IS_AGGR_TYPE (type
)
5904 || TREE_CODE (type
) == TEMPLATE_TYPE_PARM
5905 || TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
5906 || TREE_CODE (type
) == TYPENAME_TYPE
)
5907 /* Someone else will give an error about this if needed. */
5909 else if (type
== current_class_type
)
5910 val
= IDENTIFIER_CLASS_VALUE (name
);
5913 val
= lookup_member (type
, name
, 0, prefer_type
);
5914 type_access_control (type
, val
);
5916 /* Restore the containing TYPENAME_TYPE if we looked
5917 through it before. */
5918 if (got_scope
&& got_scope
!= type
5919 && val
&& TREE_CODE (val
) == TYPE_DECL
5920 && TREE_CODE (TREE_TYPE (val
)) == TYPENAME_TYPE
)
5921 TYPE_CONTEXT (TREE_TYPE (val
)) = got_scope
;
5929 else if (got_object
&& val
)
5934 flags
= lookup_flags (prefer_type
, namespaces_only
);
5935 /* If we're not parsing, we need to complain. */
5936 flags
|= LOOKUP_COMPLAIN
;
5939 /* First, look in non-namespace scopes. */
5941 if (current_class_type
== NULL_TREE
)
5944 for (t
= IDENTIFIER_BINDING (name
); t
; t
= TREE_CHAIN (t
))
5948 if (!LOCAL_BINDING_P (t
) && nonclass
)
5949 /* We're not looking for class-scoped bindings, so keep going. */
5952 /* If this is the kind of thing we're looking for, we're done. */
5953 if (qualify_lookup (BINDING_VALUE (t
), flags
))
5954 binding
= BINDING_VALUE (t
);
5955 else if ((flags
& LOOKUP_PREFER_TYPES
)
5956 && qualify_lookup (BINDING_TYPE (t
), flags
))
5957 binding
= BINDING_TYPE (t
);
5959 binding
= NULL_TREE
;
5961 /* Handle access control on types from enclosing or base classes. */
5962 if (binding
&& ! yylex
5963 && BINDING_LEVEL (t
) && BINDING_LEVEL (t
)->parm_flag
== 2)
5964 type_access_control (BINDING_LEVEL (t
)->this_class
, binding
);
5967 && (!val
|| !IMPLICIT_TYPENAME_TYPE_DECL_P (binding
)))
5969 if (val_is_implicit_typename
&& !yylex
)
5970 warn_about_implicit_typename_lookup (val
, binding
);
5972 val_is_implicit_typename
5973 = IMPLICIT_TYPENAME_TYPE_DECL_P (val
);
5974 if (!val_is_implicit_typename
)
5979 /* Now lookup in namespace scopes. */
5980 if (!val
|| val_is_implicit_typename
)
5982 t
= unqualified_namespace_lookup (name
, flags
, 0);
5985 if (val_is_implicit_typename
&& !yylex
)
5986 warn_about_implicit_typename_lookup (val
, t
);
5994 /* This should only warn about types used in qualified-ids. */
5995 if (from_obj
&& from_obj
!= val
)
5997 if (looking_for_typename
&& TREE_CODE (from_obj
) == TYPE_DECL
5998 && TREE_CODE (val
) == TYPE_DECL
5999 && TREE_TYPE (from_obj
) != TREE_TYPE (val
))
6001 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
6002 name
, got_object
, TREE_TYPE (from_obj
));
6003 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
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 ()
6296 int wchar_type_size
;
6297 tree array_domain_type
;
6299 /* Check to see that the user did not specify an invalid combination
6300 of command-line options. */
6301 if (flag_new_abi
&& !flag_vtable_thunks
)
6302 fatal ("the new ABI requires vtable thunks");
6304 /* Create all the identifiers we need. */
6305 initialize_predefined_identifiers ();
6307 /* Fill in back-end hooks. */
6308 init_lang_status
= &push_cp_function_context
;
6309 free_lang_status
= &pop_cp_function_context
;
6310 mark_lang_status
= &mark_cp_function_context
;
6311 lang_safe_from_p
= &c_safe_from_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 /* Define `int' and `char' first so that dbx will output them first. */
6352 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
6353 record_builtin_type (RID_CHAR
, "char", char_type_node
);
6355 /* `signed' is the same as `int' */
6356 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
6357 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
6358 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
6359 record_builtin_type (RID_MAX
, "long unsigned int",
6360 long_unsigned_type_node
);
6361 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
6362 record_builtin_type (RID_MAX
, "long long int",
6363 long_long_integer_type_node
);
6364 record_builtin_type (RID_MAX
, "long long unsigned int",
6365 long_long_unsigned_type_node
);
6366 record_builtin_type (RID_MAX
, "long long unsigned",
6367 long_long_unsigned_type_node
);
6368 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
6369 record_builtin_type (RID_MAX
, "short unsigned int",
6370 short_unsigned_type_node
);
6371 record_builtin_type (RID_MAX
, "unsigned short",
6372 short_unsigned_type_node
);
6375 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE
)));
6377 /* Define both `signed char' and `unsigned char'. */
6378 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
6379 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
6381 /* `unsigned long' is the standard type for sizeof.
6382 Note that stddef.h uses `unsigned long',
6383 and this must agree, even if long and int are the same size. */
6385 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE
))));
6387 /* Create the widest literal types. */
6388 widest_integer_literal_type_node
= make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
6389 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6390 widest_integer_literal_type_node
));
6392 widest_unsigned_literal_type_node
= make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
6393 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
6394 widest_unsigned_literal_type_node
));
6396 /* These are types that type_for_size and type_for_mode use. */
6397 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
6398 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
6399 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
6400 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
6401 #if HOST_BITS_PER_WIDE_INT >= 64
6402 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
6404 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
6405 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
6406 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
6407 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
6408 #if HOST_BITS_PER_WIDE_INT >= 64
6409 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
6412 build_common_tree_nodes_2 (flag_short_double
);
6414 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
6415 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
6416 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
6417 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
6418 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
6419 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
6420 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
6421 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
6423 integer_two_node
= build_int_2 (2, 0);
6424 TREE_TYPE (integer_two_node
) = integer_type_node
;
6425 integer_three_node
= build_int_2 (3, 0);
6426 TREE_TYPE (integer_three_node
) = integer_type_node
;
6428 boolean_type_node
= make_unsigned_type (BOOL_TYPE_SIZE
);
6429 TREE_SET_CODE (boolean_type_node
, BOOLEAN_TYPE
);
6430 TYPE_MAX_VALUE (boolean_type_node
) = build_int_2 (1, 0);
6431 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node
)) = boolean_type_node
;
6432 TYPE_PRECISION (boolean_type_node
) = 1;
6433 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
6434 boolean_false_node
= build_int_2 (0, 0);
6435 TREE_TYPE (boolean_false_node
) = boolean_type_node
;
6436 boolean_true_node
= build_int_2 (1, 0);
6437 TREE_TYPE (boolean_true_node
) = boolean_type_node
;
6439 signed_size_zero_node
= build_int_2 (0, 0);
6440 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
6441 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
6442 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
6444 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
6445 complex_integer_type_node
));
6446 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
6447 complex_float_type_node
));
6448 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
6449 complex_double_type_node
));
6450 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
6451 complex_long_double_type_node
));
6453 TREE_TYPE (signed_size_zero_node
) = make_signed_type (TYPE_PRECISION (sizetype
));
6455 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
6456 void_list_node
= build_tree_list (NULL_TREE
, void_type_node
);
6457 TREE_PARMLIST (void_list_node
) = 1;
6459 string_type_node
= build_pointer_type (char_type_node
);
6460 const_string_type_node
6461 = build_pointer_type (build_qualified_type (char_type_node
,
6463 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
6465 record_builtin_type (RID_MAX
, NULL_PTR
, string_type_node
);
6468 /* Make a type to be the domain of a few array types
6469 whose domains don't really matter.
6470 200 is small enough that it always fits in size_t. */
6471 array_domain_type
= build_index_type (build_int_2 (200, 0));
6473 /* Make a type for arrays of characters.
6474 With luck nothing will ever really depend on the length of this
6476 char_array_type_node
6477 = build_array_type (char_type_node
, array_domain_type
);
6479 /* Likewise for arrays of ints. */
6481 = build_array_type (integer_type_node
, array_domain_type
);
6484 delta_type_node
= ptrdiff_type_node
;
6485 else if (flag_huge_objects
)
6486 delta_type_node
= long_integer_type_node
;
6488 delta_type_node
= short_integer_type_node
;
6491 vtable_index_type
= ptrdiff_type_node
;
6493 vtable_index_type
= delta_type_node
;
6495 default_function_type
6496 = build_function_type (integer_type_node
, NULL_TREE
);
6498 ptr_type_node
= build_pointer_type (void_type_node
);
6500 = build_pointer_type (build_qualified_type (void_type_node
,
6502 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
6503 c_common_nodes_and_builtins (1, flag_no_builtin
, flag_no_nonansi_builtin
);
6504 lang_type_promotes_to
= convert_type_from_ellipsis
;
6507 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6509 /* C++ extensions */
6511 unknown_type_node
= make_node (UNKNOWN_TYPE
);
6512 record_unknown_type (unknown_type_node
, "unknown type");
6514 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6515 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
6517 TREE_TYPE (null_node
) = type_for_size (POINTER_SIZE
, 0);
6519 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6521 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
6522 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
6524 /* This is special for C++ so functions can be overloaded. */
6525 wchar_type_node
= get_identifier (flag_short_wchar
6526 ? "short unsigned int"
6528 wchar_type_node
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node
));
6529 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
6530 if (TREE_UNSIGNED (wchar_type_node
))
6531 wchar_type_node
= make_signed_type (wchar_type_size
);
6533 wchar_type_node
= make_unsigned_type (wchar_type_size
);
6534 record_builtin_type (RID_WCHAR
, "__wchar_t", wchar_type_node
);
6536 /* Artificial declaration of wchar_t -- can be bashed */
6537 wchar_decl_node
= build_decl (TYPE_DECL
, get_identifier ("wchar_t"),
6539 pushdecl (wchar_decl_node
);
6541 /* This is for wide string constants. */
6542 wchar_array_type_node
6543 = build_array_type (wchar_type_node
, array_domain_type
);
6545 if (flag_vtable_thunks
)
6547 /* Make sure we get a unique function type, so we can give
6548 its pointer type a name. (This wins for gdb.) */
6549 tree vfunc_type
= make_node (FUNCTION_TYPE
);
6550 TREE_TYPE (vfunc_type
) = integer_type_node
;
6551 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
6552 layout_type (vfunc_type
);
6554 vtable_entry_type
= build_pointer_type (vfunc_type
);
6558 vtable_entry_type
= make_aggr_type (RECORD_TYPE
);
6559 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
6561 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
6563 fields
[2] = build_decl (FIELD_DECL
, pfn_identifier
,
6565 finish_builtin_type (vtable_entry_type
, VTBL_PTR_TYPE
, fields
, 2,
6568 /* Make this part of an invisible union. */
6569 fields
[3] = copy_node (fields
[2]);
6570 TREE_TYPE (fields
[3]) = delta_type_node
;
6571 DECL_NAME (fields
[3]) = delta2_identifier
;
6572 DECL_MODE (fields
[3]) = TYPE_MODE (delta_type_node
);
6573 DECL_SIZE (fields
[3]) = TYPE_SIZE (delta_type_node
);
6574 DECL_SIZE_UNIT (fields
[3]) = TYPE_SIZE_UNIT (delta_type_node
);
6575 TREE_UNSIGNED (fields
[3]) = 0;
6576 TREE_CHAIN (fields
[2]) = fields
[3];
6577 vtable_entry_type
= build_qualified_type (vtable_entry_type
,
6580 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
6583 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
6584 layout_type (vtbl_type_node
);
6585 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
6586 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_type_node
);
6587 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
6588 layout_type (vtbl_ptr_type_node
);
6589 record_builtin_type (RID_MAX
, NULL_PTR
, vtbl_ptr_type_node
);
6591 std_node
= build_decl (NAMESPACE_DECL
,
6593 ? get_identifier ("fake std") : std_identifier
,
6595 pushdecl (std_node
);
6599 push_namespace (get_identifier ("__cxxabiv1"));
6600 abi_node
= current_namespace
;
6604 global_type_node
= make_node (LANG_TYPE
);
6605 record_unknown_type (global_type_node
, "global type");
6608 current_lang_name
= lang_name_cplusplus
;
6611 tree bad_alloc_type_node
, newtype
, deltype
;
6613 push_namespace (get_identifier ("std"));
6614 bad_alloc_type_node
= xref_tag
6615 (class_type_node
, get_identifier ("bad_alloc"), 1);
6618 newtype
= build_exception_variant
6619 (ptr_ftype_sizetype
, add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1));
6620 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
6621 push_cp_library_fn (NEW_EXPR
, newtype
);
6622 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
6623 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
6624 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
6628 = build_library_fn_ptr ("__pure_virtual", void_ftype
);
6630 /* Perform other language dependent initializations. */
6631 init_class_processing ();
6632 init_init_processing ();
6633 init_search_processing ();
6634 init_rtti_processing ();
6636 if (flag_exceptions
)
6637 init_exception_processing ();
6640 flag_inline_functions
= 0;
6643 if (! supports_one_only ())
6646 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6647 function_id_node
= get_identifier ("__FUNCTION__");
6648 pretty_function_id_node
= get_identifier ("__PRETTY_FUNCTION__");
6649 func_id_node
= get_identifier ("__func__");
6651 make_fname_decl
= cp_make_fname_decl
;
6652 declare_function_name ();
6654 /* Prepare to check format strings against argument lists. */
6655 init_function_format_info ();
6657 /* Show we use EH for cleanups. */
6658 using_eh_for_cleanups ();
6660 valid_lang_attribute
= cp_valid_lang_attribute
;
6662 /* Maintain consistency. Perhaps we should just complain if they
6663 say -fwritable-strings? */
6664 if (flag_writable_strings
)
6665 flag_const_strings
= 0;
6667 /* Add GC roots for all of our global variables. */
6668 ggc_add_tree_root (c_global_trees
, sizeof c_global_trees
/ sizeof(tree
));
6669 ggc_add_tree_root (cp_global_trees
, sizeof cp_global_trees
/ sizeof(tree
));
6670 ggc_add_tree_root (&integer_three_node
, 1);
6671 ggc_add_tree_root (&integer_two_node
, 1);
6672 ggc_add_tree_root (&signed_size_zero_node
, 1);
6673 ggc_add_tree_root (&size_one_node
, 1);
6674 ggc_add_tree_root (&size_zero_node
, 1);
6675 ggc_add_root (&global_binding_level
, 1, sizeof global_binding_level
,
6676 mark_binding_level
);
6677 ggc_add_root (&scope_chain
, 1, sizeof scope_chain
, &mark_saved_scope
);
6678 ggc_add_tree_root (&static_ctors
, 1);
6679 ggc_add_tree_root (&static_dtors
, 1);
6680 ggc_add_tree_root (&lastiddecl
, 1);
6682 ggc_add_tree_root (&last_function_parm_tags
, 1);
6683 ggc_add_tree_root (¤t_function_return_value
, 1);
6684 ggc_add_tree_root (¤t_function_parm_tags
, 1);
6685 ggc_add_tree_root (&last_function_parms
, 1);
6686 ggc_add_tree_root (&error_mark_list
, 1);
6688 ggc_add_tree_root (&global_namespace
, 1);
6689 ggc_add_tree_root (&global_type_node
, 1);
6690 ggc_add_tree_root (&anonymous_namespace_name
, 1);
6692 ggc_add_tree_root (&got_object
, 1);
6693 ggc_add_tree_root (&got_scope
, 1);
6695 ggc_add_tree_root (¤t_lang_name
, 1);
6696 ggc_add_tree_root (&static_aggregates
, 1);
6699 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6700 decl, NAME is the initialization string and TYPE_DEP indicates whether
6701 NAME depended on the type of the function. We make use of that to detect
6702 __PRETTY_FUNCTION__ inside a template fn. Because we build a tree for
6703 the function before emitting any of it, we don't need to treat the
6704 VAR_DECL specially. We can decide whether to emit it later, if it was
6708 cp_make_fname_decl (id
, name
, type_dep
)
6713 tree decl
, type
, init
;
6714 size_t length
= strlen (name
);
6715 tree domain
= NULL_TREE
;
6717 if (!processing_template_decl
)
6720 domain
= build_index_type (build_int_2 (length
, 0));
6722 type
= build_cplus_array_type
6723 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
6726 decl
= build_decl (VAR_DECL
, id
, type
);
6727 TREE_STATIC (decl
) = 1;
6728 TREE_READONLY (decl
) = 1;
6729 DECL_SOURCE_LINE (decl
) = 0;
6730 DECL_ARTIFICIAL (decl
) = 1;
6731 DECL_IN_SYSTEM_HEADER (decl
) = 1;
6733 if (processing_template_decl
)
6734 decl
= push_template_decl (decl
);
6737 init
= build (FUNCTION_NAME
, type
);
6738 DECL_PRETTY_FUNCTION_P (decl
) = 1;
6742 init
= build_string (length
+ 1, name
);
6743 TREE_TYPE (init
) = type
;
6745 DECL_INITIAL (decl
) = init
;
6746 cp_finish_decl (decl
, init
, NULL_TREE
, LOOKUP_ONLYCONVERTING
);
6748 /* We will have to make sure we only emit this, if it is actually used. */
6752 /* Entry point for the benefit of c_common_nodes_and_builtins.
6754 Make a definition for a builtin function named NAME and whose data type
6755 is TYPE. TYPE should be a function type with argument types.
6757 CLASS and CODE tell later passes how to compile calls to this function.
6758 See tree.h for possible values.
6760 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6761 the name to be called if we can't opencode the function. */
6764 builtin_function (name
, type
, code
, class, libname
)
6768 enum built_in_class
class;
6769 const char *libname
;
6771 tree decl
= build_library_fn_1 (get_identifier (name
), ERROR_MARK
, type
);
6772 DECL_BUILT_IN_CLASS (decl
) = class;
6773 DECL_FUNCTION_CODE (decl
) = code
;
6775 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 392);
6777 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6778 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6779 function in the namespace. */
6782 DECL_ASSEMBLER_NAME (decl
) = get_identifier (libname
);
6783 make_function_rtl (decl
);
6785 /* Warn if a function in the namespace for users
6786 is used without an occasion to consider it declared. */
6787 if (name
[0] != '_' || name
[1] != '_')
6788 DECL_ANTICIPATED (decl
) = 1;
6793 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6794 function. Not called directly. */
6797 build_library_fn_1 (name
, operator_code
, type
)
6799 enum tree_code operator_code
;
6802 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
6803 DECL_EXTERNAL (fn
) = 1;
6804 TREE_PUBLIC (fn
) = 1;
6805 DECL_ARTIFICIAL (fn
) = 1;
6806 TREE_NOTHROW (fn
) = 1;
6807 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
6811 /* Returns the _DECL for a library function with C linkage.
6812 We assume that such functions never throw; if this is incorrect,
6813 callers should unset TREE_NOTHROW. */
6816 build_library_fn (name
, type
)
6820 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
6821 make_function_rtl (fn
);
6825 /* Returns the _DECL for a library function with C++ linkage. */
6828 build_cp_library_fn (name
, operator_code
, type
)
6830 enum tree_code operator_code
;
6833 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
6834 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
6835 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
6836 set_mangled_name_for_decl (fn
);
6837 make_function_rtl (fn
);
6841 /* Like build_library_fn, but takes a C string instead of an
6845 build_library_fn_ptr (name
, type
)
6849 return build_library_fn (get_identifier (name
), type
);
6852 /* Like build_cp_library_fn, but takes a C string instead of an
6856 build_cp_library_fn_ptr (name
, type
)
6860 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
6863 /* Like build_library_fn, but also pushes the function so that we will
6864 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6867 push_library_fn (name
, type
)
6870 tree fn
= build_library_fn (name
, type
);
6871 pushdecl_top_level (fn
);
6875 /* Like build_cp_library_fn, but also pushes the function so that it
6876 will be found by normal lookup. */
6879 push_cp_library_fn (operator_code
, type
)
6880 enum tree_code operator_code
;
6883 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
6890 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6894 push_void_library_fn (name
, parmtypes
)
6895 tree name
, parmtypes
;
6897 tree type
= build_function_type (void_type_node
, parmtypes
);
6898 return push_library_fn (name
, type
);
6901 /* Like push_library_fn, but also note that this function throws
6902 and does not return. Used for __throw_foo and the like. */
6905 push_throw_library_fn (name
, type
)
6908 tree fn
= push_library_fn (name
, type
);
6909 TREE_THIS_VOLATILE (fn
) = 1;
6910 TREE_NOTHROW (fn
) = 0;
6914 /* When we call finish_struct for an anonymous union, we create
6915 default copy constructors and such. But, an anonymous union
6916 shouldn't have such things; this function undoes the damage to the
6917 anonymous union type T.
6919 (The reason that we create the synthesized methods is that we don't
6920 distinguish `union { int i; }' from `typedef union { int i; } U'.
6921 The first is an anonymous union; the second is just an ordinary
6925 fixup_anonymous_aggr (t
)
6930 /* Wipe out memory of synthesized methods */
6931 TYPE_HAS_CONSTRUCTOR (t
) = 0;
6932 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
6933 TYPE_HAS_INIT_REF (t
) = 0;
6934 TYPE_HAS_CONST_INIT_REF (t
) = 0;
6935 TYPE_HAS_ASSIGN_REF (t
) = 0;
6936 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
6938 /* Splice the implicitly generated functions out of the TYPE_METHODS
6940 q
= &TYPE_METHODS (t
);
6943 if (DECL_ARTIFICIAL (*q
))
6944 *q
= TREE_CHAIN (*q
);
6946 q
= &TREE_CHAIN (*q
);
6949 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6950 if (TYPE_METHODS (t
))
6951 error ("an anonymous union cannot have function members");
6954 /* Make sure that a declaration with no declarator is well-formed, i.e.
6955 just defines a tagged type or anonymous union.
6957 Returns the type defined, if any. */
6960 check_tag_decl (declspecs
)
6965 tree ob_modifier
= NULL_TREE
;
6967 register tree t
= NULL_TREE
;
6969 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
6971 register tree value
= TREE_VALUE (link
);
6974 || (TREE_CODE (value
) == IDENTIFIER_NODE
6975 && IDENTIFIER_GLOBAL_VALUE (value
)
6976 && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value
))))
6980 if ((TREE_CODE (value
) != TYPENAME_TYPE
&& IS_AGGR_TYPE (value
))
6981 || TREE_CODE (value
) == ENUMERAL_TYPE
)
6983 my_friendly_assert (TYPE_MAIN_DECL (value
) != NULL_TREE
, 261);
6987 else if (value
== ridpointers
[(int) RID_FRIEND
])
6989 if (current_class_type
== NULL_TREE
6990 || current_scope () != current_class_type
)
6991 ob_modifier
= value
;
6995 else if (value
== ridpointers
[(int) RID_STATIC
]
6996 || value
== ridpointers
[(int) RID_EXTERN
]
6997 || value
== ridpointers
[(int) RID_AUTO
]
6998 || value
== ridpointers
[(int) RID_REGISTER
]
6999 || value
== ridpointers
[(int) RID_INLINE
]
7000 || value
== ridpointers
[(int) RID_VIRTUAL
]
7001 || value
== ridpointers
[(int) RID_CONST
]
7002 || value
== ridpointers
[(int) RID_VOLATILE
]
7003 || value
== ridpointers
[(int) RID_EXPLICIT
])
7004 ob_modifier
= value
;
7008 error ("multiple types in one declaration");
7010 if (t
== NULL_TREE
&& ! saw_friend
)
7011 pedwarn ("declaration does not declare anything");
7013 /* Check for an anonymous union. We're careful
7014 accessing TYPE_IDENTIFIER because some built-in types, like
7015 pointer-to-member types, do not have TYPE_NAME. */
7016 else if (t
&& IS_AGGR_TYPE_CODE (TREE_CODE (t
))
7018 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
7020 /* Anonymous unions are objects, so they can have specifiers. */;
7021 SET_ANON_AGGR_TYPE_P (t
);
7023 if (TREE_CODE (t
) != UNION_TYPE
&& pedantic
&& ! in_system_header
)
7024 pedwarn ("ISO C++ prohibits anonymous structs");
7027 else if (ob_modifier
)
7029 if (ob_modifier
== ridpointers
[(int) RID_INLINE
]
7030 || ob_modifier
== ridpointers
[(int) RID_VIRTUAL
])
7031 cp_error ("`%D' can only be specified for functions", ob_modifier
);
7032 else if (ob_modifier
== ridpointers
[(int) RID_FRIEND
])
7033 cp_error ("`%D' can only be specified inside a class", ob_modifier
);
7034 else if (ob_modifier
== ridpointers
[(int) RID_EXPLICIT
])
7035 cp_error ("`%D' can only be specified for constructors",
7038 cp_error ("`%D' can only be specified for objects and functions",
7045 /* Called when a declaration is seen that contains no names to declare.
7046 If its type is a reference to a structure, union or enum inherited
7047 from a containing scope, shadow that tag name for the current scope
7048 with a forward reference.
7049 If its type defines a new named structure or union
7050 or defines an enum, it is valid but we need not do anything here.
7051 Otherwise, it is an error.
7053 C++: may have to grok the declspecs to learn about static,
7054 complain for anonymous unions. */
7057 shadow_tag (declspecs
)
7060 tree t
= check_tag_decl (declspecs
);
7063 maybe_process_partial_specialization (t
);
7065 /* This is where the variables in an anonymous union are
7066 declared. An anonymous union declaration looks like:
7068 because there is no declarator after the union, the parser
7069 sends that declaration here. */
7070 if (t
&& ANON_AGGR_TYPE_P (t
))
7072 fixup_anonymous_aggr (t
);
7074 if (TYPE_FIELDS (t
))
7076 tree decl
= grokdeclarator (NULL_TREE
, declspecs
, NORMAL
, 0,
7078 finish_anon_union (decl
);
7083 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
7086 groktypename (typename
)
7089 if (TREE_CODE (typename
) != TREE_LIST
)
7091 return grokdeclarator (TREE_VALUE (typename
),
7092 TREE_PURPOSE (typename
),
7093 TYPENAME
, 0, NULL_TREE
);
7096 /* Decode a declarator in an ordinary declaration or data definition.
7097 This is called as soon as the type information and variable name
7098 have been parsed, before parsing the initializer if any.
7099 Here we create the ..._DECL node, fill in its type,
7100 and put it on the list of decls for the current context.
7101 The ..._DECL node is returned as the value.
7103 Exception: for arrays where the length is not specified,
7104 the type is left null, to be filled in by `cp_finish_decl'.
7106 Function definitions do not come here; they go to start_function
7107 instead. However, external and forward declarations of functions
7108 do go through here. Structure field declarations are done by
7109 grokfield and not through here. */
7112 start_decl (declarator
, declspecs
, initialized
, attributes
, prefix_attributes
)
7113 tree declarator
, declspecs
;
7115 tree attributes
, prefix_attributes
;
7118 register tree type
, tem
;
7120 extern int have_extern_spec
;
7121 extern int used_extern_spec
;
7125 /* See code below that used this. */
7126 int init_written
= initialized
;
7129 /* This should only be done once on the top most decl. */
7130 if (have_extern_spec
&& !used_extern_spec
)
7132 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"),
7134 used_extern_spec
= 1;
7137 if (attributes
|| prefix_attributes
)
7138 attrlist
= build_tree_list (attributes
, prefix_attributes
);
7140 attrlist
= NULL_TREE
;
7142 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
7145 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
7148 type
= TREE_TYPE (decl
);
7150 if (type
== error_mark_node
)
7153 context
= DECL_CONTEXT (decl
);
7155 if (initialized
&& context
&& TREE_CODE (context
) == NAMESPACE_DECL
7156 && context
!= current_namespace
&& TREE_CODE (decl
) == VAR_DECL
)
7158 /* When parsing the initializer, lookup should use the object's
7160 push_decl_namespace (context
);
7163 /* We are only interested in class contexts, later. */
7164 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
7165 context
= NULL_TREE
;
7168 /* Is it valid for this decl to have an initializer at all?
7169 If not, set INITIALIZED to zero, which will indirectly
7170 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7171 switch (TREE_CODE (decl
))
7174 /* typedef foo = bar means give foo the same type as bar.
7175 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7176 Any other case of an initialization in a TYPE_DECL is an error. */
7177 if (pedantic
|| list_length (declspecs
) > 1)
7179 cp_error ("typedef `%D' is initialized", decl
);
7185 cp_error ("function `%#D' is initialized like a variable", decl
);
7195 if (! toplevel_bindings_p ()
7196 && DECL_EXTERNAL (decl
))
7197 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7199 DECL_EXTERNAL (decl
) = 0;
7200 if (toplevel_bindings_p ())
7201 TREE_STATIC (decl
) = 1;
7203 /* Tell `pushdecl' this is an initialized decl
7204 even though we don't yet have the initializer expression.
7205 Also tell `cp_finish_decl' it may store the real initializer. */
7206 DECL_INITIAL (decl
) = error_mark_node
;
7209 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7210 SET_DEFAULT_DECL_ATTRIBUTES (decl
, attributes
);
7213 /* Set attributes here so if duplicate decl, will have proper attributes. */
7214 cplus_decl_attributes (decl
, attributes
, prefix_attributes
);
7216 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
7218 push_nested_class (context
, 2);
7220 if (TREE_CODE (decl
) == VAR_DECL
)
7222 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, 0);
7223 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
7224 cp_error ("`%#D' is not a static member of `%#T'", decl
, context
);
7227 if (DECL_CONTEXT (field
) != context
)
7229 cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7230 DECL_CONTEXT (field
), DECL_NAME (decl
),
7231 context
, DECL_NAME (decl
));
7232 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
7234 /* Static data member are tricky; an in-class initialization
7235 still doesn't provide a definition, so the in-class
7236 declaration will have DECL_EXTERNAL set, but will have an
7237 initialization. Thus, duplicate_decls won't warn
7238 about this situation, and so we check here. */
7239 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
7240 cp_error ("duplicate initialization of %D", decl
);
7241 if (duplicate_decls (decl
, field
))
7247 tree field
= check_classfn (context
, decl
);
7248 if (field
&& duplicate_decls (decl
, field
))
7252 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7253 DECL_IN_AGGR_P (decl
) = 0;
7254 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
7255 || CLASSTYPE_TEMPLATE_INSTANTIATION (context
))
7257 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
7258 /* [temp.expl.spec] An explicit specialization of a static data
7259 member of a template is a definition if the declaration
7260 includes an initializer; otherwise, it is a declaration.
7262 We check for processing_specialization so this only applies
7263 to the new specialization syntax. */
7264 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
7265 DECL_EXTERNAL (decl
) = 1;
7268 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
7269 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7273 /* Enter this declaration into the symbol table. */
7274 tem
= maybe_push_decl (decl
);
7276 if (processing_template_decl
)
7277 tem
= push_template_decl (tem
);
7279 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7280 /* Tell the back-end to use or not use .common as appropriate. If we say
7281 -fconserve-space, we want this to save .data space, at the expense of
7282 wrong semantics. If we say -fno-conserve-space, we want this to
7283 produce errors about redefs; to do this we force variables into the
7285 DECL_COMMON (tem
) = flag_conserve_space
|| ! TREE_PUBLIC (tem
);
7288 if (! processing_template_decl
)
7298 tree type
= TREE_TYPE (decl
);
7299 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
7301 if (type
== error_mark_node
)
7304 /* If this type of object needs a cleanup, but we're not allowed to
7305 add any more objects with cleanups to the current scope, create a
7306 new binding level. */
7307 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7308 && current_binding_level
->more_cleanups_ok
== 0)
7310 keep_next_level (2);
7313 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7317 /* Is it valid for this decl to have an initializer at all?
7318 If not, set INITIALIZED to zero, which will indirectly
7319 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7321 /* Don't allow initializations for incomplete types except for
7322 arrays which might be completed by the initialization. */
7323 if (COMPLETE_TYPE_P (complete_type (type
)))
7324 ; /* A complete type is ok. */
7325 else if (TREE_CODE (type
) != ARRAY_TYPE
)
7327 cp_error ("variable `%#D' has initializer but incomplete type",
7330 type
= TREE_TYPE (decl
) = error_mark_node
;
7332 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
7334 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
7335 cp_error ("elements of array `%#D' have incomplete type", decl
);
7336 /* else we already gave an error in start_decl. */
7342 && TREE_CODE (decl
) != TYPE_DECL
7343 && TREE_CODE (decl
) != TEMPLATE_DECL
7344 && type
!= error_mark_node
7345 && IS_AGGR_TYPE (type
)
7346 && ! DECL_EXTERNAL (decl
))
7348 if ((! processing_template_decl
|| ! uses_template_parms (type
))
7349 && !COMPLETE_TYPE_P (complete_type (type
)))
7351 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7353 /* Change the type so that assemble_variable will give
7354 DECL an rtl we can live with: (mem (const_int 0)). */
7355 type
= TREE_TYPE (decl
) = error_mark_node
;
7359 /* If any base type in the hierarchy of TYPE needs a constructor,
7360 then we set initialized to 1. This way any nodes which are
7361 created for the purposes of initializing this aggregate
7362 will live as long as it does. This is necessary for global
7363 aggregates which do not have their initializers processed until
7364 the end of the file. */
7365 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
7370 DECL_INITIAL (decl
) = NULL_TREE
;
7373 /* Handle initialization of references.
7374 These three arguments are from `cp_finish_decl', and have the
7375 same meaning here that they do there.
7377 Quotes on semantics can be found in ARM 8.4.3. */
7380 grok_reference_init (decl
, type
, init
)
7381 tree decl
, type
, init
;
7385 if (init
== NULL_TREE
)
7387 if ((DECL_LANG_SPECIFIC (decl
) == 0
7388 || DECL_IN_AGGR_P (decl
) == 0)
7389 && ! DECL_THIS_EXTERN (decl
))
7390 cp_error ("`%D' declared as reference but not initialized", decl
);
7394 if (init
== error_mark_node
)
7397 if (TREE_CODE (init
) == CONSTRUCTOR
)
7399 cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl
);
7403 if (TREE_CODE (init
) == TREE_LIST
)
7404 init
= build_compound_expr (init
);
7406 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
7407 init
= convert_from_reference (init
);
7409 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
7410 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
7412 /* Note: default conversion is only called in very special cases. */
7413 init
= default_conversion (init
);
7416 /* Convert INIT to the reference type TYPE. This may involve the
7417 creation of a temporary, whose lifetime must be the same as that
7418 of the reference. If so, a DECL_STMT for the temporary will be
7419 added just after the DECL_STMT for DECL. That's why we don't set
7420 DECL_INITIAL for local references (instead assigning to them
7421 explicitly); we need to allow the temporary to be initialized
7423 tmp
= convert_to_reference
7424 (type
, init
, CONV_IMPLICIT
,
7425 LOOKUP_ONLYCONVERTING
|LOOKUP_SPECULATIVELY
|LOOKUP_NORMAL
|DIRECT_BIND
,
7428 if (tmp
== error_mark_node
)
7430 else if (tmp
!= NULL_TREE
)
7433 tmp
= save_expr (tmp
);
7434 if (building_stmt_tree ())
7436 /* Initialize the declaration. */
7437 tmp
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, tmp
);
7438 finish_expr_stmt (tmp
);
7441 DECL_INITIAL (decl
) = tmp
;
7445 cp_error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
7449 if (TREE_STATIC (decl
) && ! TREE_CONSTANT (DECL_INITIAL (decl
)))
7451 expand_static_init (decl
, DECL_INITIAL (decl
));
7452 DECL_INITIAL (decl
) = NULL_TREE
;
7457 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7458 mucking with forces it does not comprehend (i.e. initialization with a
7459 constructor). If we are at global scope and won't go into COMMON, fill
7460 it in with a dummy CONSTRUCTOR to force the variable into .data;
7461 otherwise we can use error_mark_node. */
7464 obscure_complex_init (decl
, init
)
7467 if (! flag_no_inline
&& TREE_STATIC (decl
))
7469 if (extract_init (decl
, init
))
7473 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7474 if (toplevel_bindings_p () && ! DECL_COMMON (decl
))
7475 DECL_INITIAL (decl
) = build (CONSTRUCTOR
, TREE_TYPE (decl
), NULL_TREE
,
7479 DECL_INITIAL (decl
) = error_mark_node
;
7484 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7485 array until we finish parsing the initializer. If that's the
7486 situation we're in, update DECL accordingly. */
7489 maybe_deduce_size_from_array_init (decl
, init
)
7493 tree type
= TREE_TYPE (decl
);
7495 if (TREE_CODE (type
) == ARRAY_TYPE
7496 && TYPE_DOMAIN (type
) == NULL_TREE
7497 && TREE_CODE (decl
) != TYPE_DECL
)
7499 /* do_default is really a C-ism to deal with tentative definitions.
7500 But let's leave it here to ease the eventual merge. */
7501 int do_default
= !DECL_EXTERNAL (decl
);
7502 tree initializer
= init
? init
: DECL_INITIAL (decl
);
7503 int failure
= complete_array_type (type
, initializer
, do_default
);
7506 cp_error ("initializer fails to determine size of `%D'", decl
);
7511 cp_error ("array size missing in `%D'", decl
);
7512 /* If a `static' var's size isn't known, make it extern as
7513 well as static, so it does not get allocated. If it's not
7514 `static', then don't mark it extern; finish_incomplete_decl
7515 will give it a default size and it will get allocated. */
7516 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
7517 DECL_EXTERNAL (decl
) = 1;
7520 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
7521 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
7523 cp_error ("zero-size array `%D'", decl
);
7525 layout_decl (decl
, 0);
7529 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7530 any appropriate error messages regarding the layout. */
7533 layout_var_decl (decl
)
7536 tree type
= TREE_TYPE (decl
);
7538 tree ttype
= target_type (type
);
7541 /* If we haven't already layed out this declaration, do so now.
7542 Note that we must not call complete type for an external object
7543 because it's type might involve templates that we are not
7544 supposed to isntantiate yet. (And it's perfectly legal to say
7545 `extern X x' for some incomplete type `X'.) */
7546 if (!DECL_EXTERNAL (decl
))
7547 complete_type (type
);
7548 if (!DECL_SIZE (decl
) && COMPLETE_TYPE_P (type
))
7549 layout_decl (decl
, 0);
7551 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
7553 /* An automatic variable with an incomplete type: that is an error.
7554 Don't talk about array types here, since we took care of that
7555 message in grokdeclarator. */
7556 cp_error ("storage size of `%D' isn't known", decl
);
7557 TREE_TYPE (decl
) = error_mark_node
;
7560 /* Keep this code around in case we later want to control debug info
7561 based on whether a type is "used". (jason 1999-11-11) */
7563 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
7564 /* Let debugger know it should output info for this type. */
7565 note_debug_info_needed (ttype
);
7567 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
7568 note_debug_info_needed (DECL_CONTEXT (decl
));
7571 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
7572 && DECL_SIZE (decl
) != NULL_TREE
7573 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
7575 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
7576 constant_expression_warning (DECL_SIZE (decl
));
7578 cp_error ("storage size of `%D' isn't constant", decl
);
7582 /* If a local static variable is declared in an inline function, or if
7583 we have a weak definition, we must endeavor to create only one
7584 instance of the variable at link-time. */
7587 maybe_commonize_var (decl
)
7590 /* Static data in a function with comdat linkage also has comdat
7592 if (TREE_STATIC (decl
)
7593 /* Don't mess with __FUNCTION__. */
7594 && ! DECL_ARTIFICIAL (decl
)
7595 && current_function_decl
7596 && DECL_CONTEXT (decl
) == current_function_decl
7597 && (DECL_THIS_INLINE (current_function_decl
)
7598 || DECL_TEMPLATE_INSTANTIATION (current_function_decl
))
7599 && TREE_PUBLIC (current_function_decl
))
7601 /* Rather than try to get this right with inlining, we suppress
7602 inlining of such functions. */
7603 current_function_cannot_inline
7604 = "function with static variable cannot be inline";
7606 /* If flag_weak, we don't need to mess with this, as we can just
7607 make the function weak, and let it refer to its unique local
7608 copy. This works because we don't allow the function to be
7612 if (DECL_INTERFACE_KNOWN (current_function_decl
))
7614 TREE_PUBLIC (decl
) = 1;
7615 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (current_function_decl
);
7617 else if (DECL_INITIAL (decl
) == NULL_TREE
7618 || DECL_INITIAL (decl
) == error_mark_node
)
7620 TREE_PUBLIC (decl
) = 1;
7621 DECL_COMMON (decl
) = 1;
7623 /* else we lose. We can only do this if we can use common,
7624 which we can't if it has been initialized. */
7626 if (TREE_PUBLIC (decl
))
7627 DECL_ASSEMBLER_NAME (decl
)
7628 = build_static_name (current_function_decl
, DECL_NAME (decl
));
7631 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
7632 cp_warning_at (" you can work around this by removing the initializer", decl
);
7636 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
7637 /* Set it up again; we might have set DECL_INITIAL since the last
7639 comdat_linkage (decl
);
7642 /* Issue an error message if DECL is an uninitialized const variable. */
7645 check_for_uninitialized_const_var (decl
)
7648 tree type
= TREE_TYPE (decl
);
7650 /* ``Unless explicitly declared extern, a const object does not have
7651 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7653 if (TREE_CODE (decl
) == VAR_DECL
7654 && TREE_CODE (type
) != REFERENCE_TYPE
7655 && CP_TYPE_CONST_P (type
)
7656 && !TYPE_NEEDS_CONSTRUCTING (type
)
7657 && !DECL_INITIAL (decl
))
7658 cp_error ("uninitialized const `%D'", decl
);
7661 /* Verify INIT (the initializer for DECL), and record the
7662 initialization in DECL_INITIAL, if appropriate. Returns a new
7666 check_initializer (decl
, init
)
7672 if (TREE_CODE (decl
) == FIELD_DECL
)
7675 type
= TREE_TYPE (decl
);
7677 /* If `start_decl' didn't like having an initialization, ignore it now. */
7678 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
7681 /* Check the initializer. */
7684 /* Things that are going to be initialized need to have complete
7686 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
7688 if (type
== error_mark_node
)
7689 /* We will have already complained. */
7691 else if (COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
7693 cp_error ("variable-sized object `%D' may not be initialized", decl
);
7696 else if (TREE_CODE (type
) == ARRAY_TYPE
7697 && !COMPLETE_TYPE_P (TREE_TYPE (type
)))
7699 cp_error ("elements of array `%#D' have incomplete type", decl
);
7702 else if (!COMPLETE_TYPE_P (type
))
7704 cp_error ("`%D' has incomplete type", decl
);
7705 TREE_TYPE (decl
) = error_mark_node
;
7710 if (TREE_CODE (decl
) == CONST_DECL
)
7712 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
7714 DECL_INITIAL (decl
) = init
;
7716 /* This will keep us from needing to worry about our obstacks. */
7717 my_friendly_assert (init
!= NULL_TREE
, 149);
7720 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
7722 if (TREE_STATIC (decl
))
7723 make_decl_rtl (decl
, NULL_PTR
, toplevel_bindings_p ());
7724 grok_reference_init (decl
, type
, init
);
7729 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
7731 if (TREE_CODE (type
) == ARRAY_TYPE
)
7732 init
= digest_init (type
, init
, (tree
*) 0);
7733 else if (TREE_CODE (init
) == CONSTRUCTOR
7734 && TREE_HAS_CONSTRUCTOR (init
))
7736 if (TYPE_NON_AGGREGATE_CLASS (type
))
7738 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7740 init
= error_mark_node
;
7743 goto dont_use_constructor
;
7748 dont_use_constructor
:
7749 if (TREE_CODE (init
) != TREE_VEC
)
7750 init
= store_init_value (decl
, init
);
7754 /* We must hide the initializer so that expand_decl
7755 won't try to do something it does not understand. */
7756 init
= obscure_complex_init (decl
, init
);
7758 else if (DECL_EXTERNAL (decl
))
7760 else if (TYPE_P (type
)
7761 && (IS_AGGR_TYPE (type
) || TYPE_NEEDS_CONSTRUCTING (type
)))
7763 tree core_type
= strip_array_types (type
);
7765 if (! TYPE_NEEDS_CONSTRUCTING (core_type
))
7767 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
7768 cp_error ("structure `%D' with uninitialized const members", decl
);
7769 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
7770 cp_error ("structure `%D' with uninitialized reference members",
7774 check_for_uninitialized_const_var (decl
);
7776 if (COMPLETE_TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
7777 init
= obscure_complex_init (decl
, NULL_TREE
);
7781 check_for_uninitialized_const_var (decl
);
7786 /* If DECL is not a local variable, give it RTL. */
7789 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
)
7792 const char *asmspec
;
7794 int toplev
= toplevel_bindings_p ();
7797 /* Handle non-variables up front. */
7798 if (TREE_CODE (decl
) != VAR_DECL
)
7800 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7804 /* If we see a class member here, it should be a static data
7806 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
7808 my_friendly_assert (TREE_STATIC (decl
), 19990828);
7809 /* An in-class declaration of a static data member should be
7810 external; it is only a declaration, and not a definition. */
7811 if (init
== NULL_TREE
)
7812 my_friendly_assert (DECL_EXTERNAL (decl
), 20000723);
7815 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7817 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
7819 /* We don't create any RTL for local variables. */
7820 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7823 /* We defer emission of local statics until the corresponding
7824 DECL_STMT is expanded. */
7825 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
7827 /* We try to defer namespace-scope static constants so that they are
7828 not emitted into the object file unncessarily. */
7829 if (!DECL_VIRTUAL_P (decl
)
7830 && TREE_READONLY (decl
)
7831 && DECL_INITIAL (decl
) != NULL_TREE
7832 && DECL_INITIAL (decl
) != error_mark_node
7833 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
7835 && !TREE_PUBLIC (decl
))
7837 /* Fool with the linkage according to #pragma interface. */
7838 if (!interface_unknown
)
7840 TREE_PUBLIC (decl
) = 1;
7841 DECL_EXTERNAL (decl
) = interface_only
;
7847 /* If we're deferring the variable, just make RTL. Do not actually
7848 emit the variable. */
7850 make_decl_rtl (decl
, asmspec
, toplev
);
7851 /* If we're not deferring, go ahead and assemble the variable. */
7853 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
7856 /* The old ARM scoping rules injected variables declared in the
7857 initialization statement of a for-statement into the surrounding
7858 scope. We support this usage, in order to be backward-compatible.
7859 DECL is a just-declared VAR_DECL; if necessary inject its
7860 declaration into the surrounding scope. */
7863 maybe_inject_for_scope_var (decl
)
7866 if (!DECL_NAME (decl
))
7869 if (current_binding_level
->is_for_scope
)
7871 struct binding_level
*outer
7872 = current_binding_level
->level_chain
;
7874 /* Check to see if the same name is already bound at the outer
7875 level, either because it was directly declared, or because a
7876 dead for-decl got preserved. In either case, the code would
7877 not have been valid under the ARM scope rules, so clear
7878 is_for_scope for the current_binding_level.
7880 Otherwise, we need to preserve the temp slot for decl to last
7881 into the outer binding level. */
7884 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl
)));
7886 if (outer_binding
&& BINDING_LEVEL (outer_binding
) == outer
7887 && (TREE_CODE (BINDING_VALUE (outer_binding
))
7889 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding
)))
7891 BINDING_VALUE (outer_binding
)
7892 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding
));
7893 current_binding_level
->is_for_scope
= 0;
7895 else if (DECL_IN_MEMORY_P (decl
))
7896 preserve_temp_slots (DECL_RTL (decl
));
7900 /* Generate code to initialize DECL (a local variable). */
7903 initialize_local_var (decl
, init
, flags
)
7908 tree type
= TREE_TYPE (decl
);
7910 /* If the type is bogus, don't bother initializing the variable. */
7911 if (type
== error_mark_node
)
7914 if (DECL_SIZE (decl
) == NULL_TREE
&& !TREE_STATIC (decl
))
7916 /* If we used it already as memory, it must stay in memory. */
7917 DECL_INITIAL (decl
) = NULL_TREE
;
7918 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
7921 /* Local statics are handled differently from ordinary automatic
7923 if (TREE_STATIC (decl
))
7925 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
7926 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
7927 expand_static_init (decl
, init
);
7931 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
7935 /* Compute and store the initial value. */
7936 already_used
= TREE_USED (decl
) || TREE_USED (type
);
7938 if (init
|| TYPE_NEEDS_CONSTRUCTING (type
))
7940 int saved_stmts_are_full_exprs_p
;
7942 my_friendly_assert (building_stmt_tree (), 20000906);
7943 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
7944 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
7945 finish_expr_stmt (build_aggr_init (decl
, init
, flags
));
7946 current_stmt_tree ()->stmts_are_full_exprs_p
=
7947 saved_stmts_are_full_exprs_p
;
7950 /* Set this to 0 so we can tell whether an aggregate which was
7951 initialized was ever used. Don't do this if it has a
7952 destructor, so we don't complain about the 'resource
7953 allocation is initialization' idiom. Now set
7954 attribute((unused)) on types so decls of that type will be
7955 marked used. (see TREE_USED, above.) */
7956 if (TYPE_NEEDS_CONSTRUCTING (type
)
7958 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
7959 && DECL_NAME (decl
))
7960 TREE_USED (decl
) = 0;
7961 else if (already_used
)
7962 TREE_USED (decl
) = 1;
7966 /* Generate code to destroy DECL (a local variable). */
7969 destroy_local_var (decl
)
7972 tree type
= TREE_TYPE (decl
);
7975 /* Only variables get cleaned up. */
7976 if (TREE_CODE (decl
) != VAR_DECL
)
7979 /* And only things with destructors need cleaning up. */
7980 if (type
== error_mark_node
7981 || TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7984 if (TREE_CODE (decl
) == VAR_DECL
&&
7985 (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
)))
7986 /* We don't clean up things that aren't defined in this
7987 translation unit, or that need a static cleanup. The latter
7988 are handled by finish_file. */
7991 /* Compute the cleanup. */
7992 cleanup
= maybe_build_cleanup (decl
);
7994 /* Record the cleanup required for this declaration. */
7995 if (DECL_SIZE (decl
) && TREE_TYPE (decl
) != error_mark_node
7997 finish_decl_cleanup (decl
, cleanup
);
8000 /* Finish processing of a declaration;
8001 install its line number and initial value.
8002 If the length of an array type is not known before,
8003 it must be determined now, from the initial value, or it is an error.
8005 INIT holds the value of an initializer that should be allowed to escape
8008 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8009 if the (init) syntax was used. */
8012 cp_finish_decl (decl
, init
, asmspec_tree
, flags
)
8018 tree ttype
= NULL_TREE
;
8019 const char *asmspec
= NULL
;
8020 int was_readonly
= 0;
8025 error ("assignment (not initialization) in declaration");
8029 /* If a name was specified, get the string. */
8031 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
8033 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
8035 cp_error ("cannot initialize `%D' to namespace `%D'",
8040 if (current_class_type
8041 && CP_DECL_CONTEXT (decl
) == current_class_type
8042 && TYPE_BEING_DEFINED (current_class_type
)
8043 && (DECL_INITIAL (decl
) || init
))
8044 DECL_DEFINED_IN_CLASS_P (decl
) = 1;
8046 if (TREE_CODE (decl
) == VAR_DECL
8047 && DECL_CONTEXT (decl
)
8048 && TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
8049 && DECL_CONTEXT (decl
) != current_namespace
8052 /* Leave the namespace of the object. */
8053 pop_decl_namespace ();
8056 type
= TREE_TYPE (decl
);
8058 if (type
== error_mark_node
)
8061 /* Add this declaration to the statement-tree. */
8062 if (building_stmt_tree ()
8063 && at_function_scope_p ()
8064 && TREE_CODE (decl
) != RESULT_DECL
)
8065 add_decl_stmt (decl
);
8067 if (TYPE_HAS_MUTABLE_P (type
))
8068 TREE_READONLY (decl
) = 0;
8070 if (processing_template_decl
)
8072 if (init
&& DECL_INITIAL (decl
))
8073 DECL_INITIAL (decl
) = init
;
8077 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8078 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
8080 /* Take care of TYPE_DECLs up front. */
8081 if (TREE_CODE (decl
) == TYPE_DECL
)
8083 if (init
&& DECL_INITIAL (decl
))
8085 /* typedef foo = bar; store the type of bar as the type of foo. */
8086 TREE_TYPE (decl
) = type
= TREE_TYPE (init
);
8087 DECL_INITIAL (decl
) = init
= NULL_TREE
;
8089 if (type
!= error_mark_node
8090 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
8092 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
8093 cp_warning ("shadowing previous type declaration of `%#D'", decl
);
8094 set_identifier_type_value (DECL_NAME (decl
), type
);
8095 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
8097 GNU_xref_decl (current_function_decl
, decl
);
8099 /* If we have installed this as the canonical typedef for this
8100 type, and that type has not been defined yet, delay emitting
8101 the debug information for it, as we will emit it later. */
8102 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
8103 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
8104 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
8106 rest_of_decl_compilation (decl
, NULL_PTR
,
8107 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
8111 if (TREE_CODE (decl
) != FUNCTION_DECL
)
8112 ttype
= target_type (type
);
8114 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
)
8115 && TYPE_NEEDS_CONSTRUCTING (type
))
8117 /* Currently, GNU C++ puts constants in text space, making them
8118 impossible to initialize. In the future, one would hope for
8119 an operating system which understood the difference between
8120 initialization and the running of a program. */
8122 TREE_READONLY (decl
) = 0;
8125 if (TREE_CODE (decl
) == FIELD_DECL
&& asmspec
)
8127 /* This must override the asm specifier which was placed by
8128 grokclassfn. Lay this out fresh. */
8129 DECL_RTL (TREE_TYPE (decl
)) = NULL_RTX
;
8130 DECL_ASSEMBLER_NAME (decl
) = get_identifier (asmspec
);
8131 make_decl_rtl (decl
, asmspec
, 0);
8134 /* Deduce size of array from initialization, if not already known. */
8135 maybe_deduce_size_from_array_init (decl
, init
);
8136 init
= check_initializer (decl
, init
);
8138 GNU_xref_decl (current_function_decl
, decl
);
8140 if (TREE_CODE (decl
) == VAR_DECL
)
8141 layout_var_decl (decl
);
8143 /* Output the assembler code and/or RTL code for variables and functions,
8144 unless the type is an undefined structure or union.
8145 If not, it will get done when the type is completed. */
8146 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
8147 || TREE_CODE (decl
) == RESULT_DECL
)
8149 if (TREE_CODE (decl
) == VAR_DECL
)
8150 maybe_commonize_var (decl
);
8152 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
8154 if (TREE_CODE (type
) == FUNCTION_TYPE
8155 || TREE_CODE (type
) == METHOD_TYPE
)
8156 abstract_virtuals_error (decl
,
8157 strip_array_types (TREE_TYPE (type
)));
8159 abstract_virtuals_error (decl
, strip_array_types (type
));
8161 if (TREE_CODE (decl
) == FUNCTION_DECL
)
8163 else if (DECL_EXTERNAL (decl
)
8164 && ! (DECL_LANG_SPECIFIC (decl
)
8165 && DECL_NOT_REALLY_EXTERN (decl
)))
8168 DECL_INITIAL (decl
) = init
;
8170 else if (TREE_CODE (CP_DECL_CONTEXT (decl
)) == FUNCTION_DECL
)
8172 /* This is a local declaration. */
8173 if (doing_semantic_analysis_p ())
8174 maybe_inject_for_scope_var (decl
);
8175 /* Initialize the local variable. But, if we're building a
8176 statement-tree, we'll do the initialization when we
8178 if (processing_template_decl
)
8180 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
8181 DECL_INITIAL (decl
) = init
;
8185 /* If we're not building RTL, then we need to do so
8187 my_friendly_assert (building_stmt_tree (), 20000906);
8188 /* Initialize the variable. */
8189 initialize_local_var (decl
, init
, flags
);
8190 /* Clean up the variable. */
8191 destroy_local_var (decl
);
8194 else if (TREE_STATIC (decl
) && type
!= error_mark_node
)
8196 /* Cleanups for static variables are handled by `finish_file'. */
8197 if (TYPE_NEEDS_CONSTRUCTING (type
) || init
!= NULL_TREE
8198 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
8199 expand_static_init (decl
, init
);
8203 /* Undo call to `pushclass' that was done in `start_decl'
8204 due to initialization of qualified member variable.
8205 I.e., Foo::x = 10; */
8207 tree context
= CP_DECL_CONTEXT (decl
);
8210 && (TREE_CODE (decl
) == VAR_DECL
8211 /* We also have a pushclass done that we need to undo here
8212 if we're at top level and declare a method. */
8213 || TREE_CODE (decl
) == FUNCTION_DECL
)
8214 /* If size hasn't been set, we're still defining it,
8215 and therefore inside the class body; don't pop
8216 the binding level.. */
8217 && COMPLETE_TYPE_P (context
)
8218 && context
== current_class_type
)
8219 pop_nested_class ();
8226 TREE_READONLY (decl
) = 1;
8229 /* This is here for a midend callback from c-common.c */
8232 finish_decl (decl
, init
, asmspec_tree
)
8236 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
8239 /* Returns a declaration for a VAR_DECL as if:
8241 extern "C" TYPE NAME;
8243 had been seen. Used to create compiler-generated global
8247 declare_global_var (name
, type
)
8253 push_to_top_level ();
8254 decl
= build_decl (VAR_DECL
, name
, type
);
8255 TREE_PUBLIC (decl
) = 1;
8256 DECL_EXTERNAL (decl
) = 1;
8257 DECL_ARTIFICIAL (decl
) = 1;
8259 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
8260 pop_from_top_level ();
8265 /* Returns a pointer to the `atexit' function. Note that if
8266 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8267 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8281 if (flag_use_cxa_atexit
)
8283 /* The declaration for `__cxa_atexit' is:
8285 int __cxa_atexit (void (*)(void *), void *, void *)
8287 We build up the argument types and then then function type
8290 /* First, build the pointer-to-function type for the first
8292 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8293 fn_type
= build_function_type (void_type_node
, arg_types
);
8294 fn_ptr_type
= build_pointer_type (fn_type
);
8295 /* Then, build the rest of the argument types. */
8296 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
8297 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
8298 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
8299 /* And the final __cxa_atexit type. */
8300 fn_type
= build_function_type (integer_type_node
, arg_types
);
8301 fn_ptr_type
= build_pointer_type (fn_type
);
8302 name
= "__cxa_atexit";
8306 /* The declaration for `atexit' is:
8308 int atexit (void (*)());
8310 We build up the argument types and then then function type
8312 fn_type
= build_function_type (void_type_node
, void_list_node
);
8313 fn_ptr_type
= build_pointer_type (fn_type
);
8314 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
8315 /* Build the final atexit type. */
8316 fn_type
= build_function_type (integer_type_node
, arg_types
);
8320 /* Now, build the function declaration. */
8321 push_lang_context (lang_name_c
);
8322 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
8323 mark_used (atexit_fndecl
);
8324 pop_lang_context ();
8325 atexit_node
= default_conversion (atexit_fndecl
);
8330 /* Returns the __dso_handle VAR_DECL. */
8333 get_dso_handle_node ()
8335 if (dso_handle_node
)
8336 return dso_handle_node
;
8338 /* Declare the variable. */
8339 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
8342 return dso_handle_node
;
8345 /* Begin a new function with internal linkage whose job will be simply
8346 to destroy some particular variable. */
8351 static int counter
= 0;
8352 int old_interface_unknown
= interface_unknown
;
8358 push_to_top_level ();
8360 /* No need to mangle this. */
8361 push_lang_context (lang_name_c
);
8363 interface_unknown
= 1;
8365 /* Build the parameter-types. */
8366 parmtypes
= void_list_node
;
8367 /* Functions passed to __cxa_atexit take an additional parameter.
8368 We'll just ignore it. After we implement the new calling
8369 convention for destructors, we can eliminate the use of
8370 additional cleanup functions entirely in the -fnew-abi case. */
8371 if (flag_use_cxa_atexit
)
8372 parmtypes
= tree_cons (NULL_TREE
, ptr_type_node
, parmtypes
);
8373 /* Build the function type itself. */
8374 fntype
= build_function_type (void_type_node
, parmtypes
);
8375 /* Build the name of the function. */
8376 sprintf (name
, "__tcf_%d", counter
++);
8377 /* Build the function declaration. */
8378 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
8379 /* It's a function with internal linkage, generated by the
8381 TREE_PUBLIC (fndecl
) = 0;
8382 DECL_ARTIFICIAL (fndecl
) = 1;
8383 /* Make the function `inline' so that it is only emitted if it is
8384 actually needed. It is unlikely that it will be inlined, since
8385 it is only called via a function pointer, but we avoid unncessary
8386 emissions this way. */
8387 DECL_INLINE (fndecl
) = 1;
8388 /* Build the parameter. */
8389 if (flag_use_cxa_atexit
)
8393 parmdecl
= build_decl (PARM_DECL
, NULL_TREE
, ptr_type_node
);
8394 DECL_CONTEXT (parmdecl
) = fndecl
;
8395 DECL_ARG_TYPE (parmdecl
) = ptr_type_node
;
8396 TREE_USED (parmdecl
) = 1;
8397 DECL_ARGUMENTS (fndecl
) = parmdecl
;
8401 start_function (/*specs=*/NULL_TREE
, fndecl
, NULL_TREE
, SF_PRE_PARSED
);
8404 interface_unknown
= old_interface_unknown
;
8406 pop_lang_context ();
8408 return current_function_decl
;
8411 /* Finish the cleanup function begun by start_cleanup_fn. */
8418 expand_body (finish_function (0));
8420 pop_from_top_level ();
8423 /* Generate code to handle the destruction of DECL, an object with
8424 static storage duration. */
8427 register_dtor_fn (decl
)
8435 int saved_flag_access_control
;
8437 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
8440 /* Call build_cleanup before we enter the anonymous function so that
8441 any access checks will be done relative to the current scope,
8442 rather than the scope of the anonymous function. */
8443 build_cleanup (decl
);
8445 /* Now start the function. */
8446 cleanup
= start_cleanup_fn ();
8448 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8449 to the original function, rather than the anonymous one. That
8450 will make the back-end think that nested functions are in use,
8451 which causes confusion. */
8452 saved_flag_access_control
= flag_access_control
;
8453 flag_access_control
= 0;
8454 fcall
= build_cleanup (decl
);
8455 flag_access_control
= saved_flag_access_control
;
8457 /* Create the body of the anonymous function. */
8458 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
8459 finish_expr_stmt (fcall
);
8460 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
8463 /* Call atexit with the cleanup function. */
8464 mark_addressable (cleanup
);
8465 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
8466 if (flag_use_cxa_atexit
)
8468 args
= tree_cons (NULL_TREE
, get_dso_handle_node (), NULL_TREE
);
8469 args
= tree_cons (NULL_TREE
, null_pointer_node
, args
);
8470 args
= tree_cons (NULL_TREE
, cleanup
, args
);
8473 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
8474 finish_expr_stmt (build_function_call (get_atexit_node (), args
));
8478 expand_static_init (decl
, init
)
8482 tree oldstatic
= value_member (decl
, static_aggregates
);
8486 if (TREE_PURPOSE (oldstatic
) && init
!= NULL_TREE
)
8487 cp_error ("multiple initializations given for `%D'", decl
);
8489 else if (! toplevel_bindings_p ())
8491 /* Emit code to perform this initialization but once. */
8498 /* Emit code to perform this initialization but once. This code
8501 static int guard = 0;
8503 // Do initialization.
8505 // Register variable for destruction at end of program.
8508 Note that the `temp' variable is only set to 1 *after* the
8509 initialization is complete. This ensures that an exception,
8510 thrown during the construction, will cause the variable to
8511 reinitialized when we pass through this code again, as per:
8515 If the initialization exits by throwing an exception, the
8516 initialization is not complete, so it will be tried again
8517 the next time control enters the declaration.
8519 In theory, this process should be thread-safe, too; multiple
8520 threads should not be able to initialize the variable more
8521 than once. We don't yet attempt to ensure thread-safety. */
8523 /* Create the guard variable. */
8524 guard
= get_guard (decl
);
8526 /* Begin the conditional initialization. */
8527 if_stmt
= begin_if_stmt ();
8528 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
8529 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
8531 /* Do the initialization itself. */
8532 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
8533 || (init
&& TREE_CODE (init
) == TREE_LIST
))
8534 assignment
= build_aggr_init (decl
, init
, 0);
8536 /* The initialization we're doing here is just a bitwise
8538 assignment
= build (INIT_EXPR
, TREE_TYPE (decl
), decl
, init
);
8540 assignment
= NULL_TREE
;
8542 /* Once the assignment is complete, set TEMP to 1. Since the
8543 construction of the static object is complete at this point,
8544 we want to make sure TEMP is set to 1 even if a temporary
8545 constructed during the initialization throws an exception
8546 when it is destroyed. So, we combine the initialization and
8547 the assignment to TEMP into a single expression, ensuring
8548 that when we call finish_expr_stmt the cleanups will not be
8549 run until after TEMP is set to 1. */
8550 guard_init
= set_guard (guard
);
8553 assignment
= tree_cons (NULL_TREE
, assignment
,
8554 build_tree_list (NULL_TREE
,
8556 assignment
= build_compound_expr (assignment
);
8559 assignment
= guard_init
;
8560 finish_expr_stmt (assignment
);
8562 /* Use atexit to register a function for destroying this static
8564 register_dtor_fn (decl
);
8566 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
8567 finish_then_clause (if_stmt
);
8571 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
8574 /* Finish the declaration of a catch-parameter. */
8577 start_handler_parms (declspecs
, declarator
)
8584 decl
= grokdeclarator (declarator
, declspecs
, CATCHPARM
,
8586 if (decl
== NULL_TREE
)
8587 error ("invalid catch parameter");
8596 /* Make TYPE a complete type based on INITIAL_VALUE.
8597 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8598 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8601 complete_array_type (type
, initial_value
, do_default
)
8602 tree type
, initial_value
;
8605 register tree maxindex
= NULL_TREE
;
8610 /* An array of character type can be initialized from a
8611 brace-enclosed string constant. */
8612 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
8613 && TREE_CODE (initial_value
) == CONSTRUCTOR
8614 && CONSTRUCTOR_ELTS (initial_value
)
8615 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
)))
8617 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value
)) == NULL_TREE
)
8618 initial_value
= TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
));
8620 /* Note MAXINDEX is really the maximum index, one less than the
8622 if (TREE_CODE (initial_value
) == STRING_CST
)
8625 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
8626 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
8629 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
8631 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
8633 maxindex
= ssize_int (-1);
8634 for (; elts
; elts
= TREE_CHAIN (elts
))
8636 if (TREE_PURPOSE (elts
))
8637 maxindex
= TREE_PURPOSE (elts
);
8639 maxindex
= size_binop (PLUS_EXPR
, maxindex
, ssize_int (1));
8641 maxindex
= copy_node (maxindex
);
8645 /* Make an error message unless that happened already. */
8646 if (initial_value
!= error_mark_node
)
8649 initial_value
= NULL_TREE
;
8651 /* Prevent further error messages. */
8652 maxindex
= build_int_2 (0, 0);
8659 maxindex
= build_int_2 (0, 0);
8668 domain
= build_index_type (maxindex
);
8669 TYPE_DOMAIN (type
) = domain
;
8671 if (! TREE_TYPE (maxindex
))
8672 TREE_TYPE (maxindex
) = domain
;
8674 itype
= TREE_TYPE (initial_value
);
8677 if (itype
&& !TYPE_DOMAIN (itype
))
8678 TYPE_DOMAIN (itype
) = domain
;
8679 /* The type of the main variant should never be used for arrays
8680 of different sizes. It should only ever be completed with the
8681 size of the array. */
8682 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
8683 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
8686 /* Lay out the type now that we can get the real answer. */
8693 /* Return zero if something is declared to be a member of type
8694 CTYPE when in the context of CUR_TYPE. STRING is the error
8695 message to print in that case. Otherwise, quietly return 1. */
8698 member_function_or_else (ctype
, cur_type
, flags
)
8699 tree ctype
, cur_type
;
8700 enum overload_flags flags
;
8702 if (ctype
&& ctype
!= cur_type
)
8704 if (flags
== DTOR_FLAG
)
8705 cp_error ("destructor for alien class `%T' cannot be a member",
8708 cp_error ("constructor for alien class `%T' cannot be a member",
8715 /* Subroutine of `grokdeclarator'. */
8717 /* Generate errors possibly applicable for a given set of specifiers.
8718 This is for ARM $7.1.2. */
8721 bad_specifiers (object
, type
, virtualp
, quals
, inlinep
, friendp
, raises
)
8724 int virtualp
, quals
, friendp
, raises
, inlinep
;
8727 cp_error ("`%D' declared as a `virtual' %s", object
, type
);
8729 cp_error ("`%D' declared as an `inline' %s", object
, type
);
8731 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8734 cp_error_at ("`%D' declared as a friend", object
);
8736 cp_error_at ("`%D' declared with an exception specification", object
);
8739 /* CTYPE is class type, or null if non-class.
8740 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8742 DECLARATOR is the function's name.
8743 VIRTUALP is truthvalue of whether the function is virtual or not.
8744 FLAGS are to be passed through to `grokclassfn'.
8745 QUALS are qualifiers indicating whether the function is `const'
8747 RAISES is a list of exceptions that this function can raise.
8748 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8749 not look, and -1 if we should not call `grokclassfn' at all.
8751 Returns `NULL_TREE' if something goes wrong, after issuing
8752 applicable error messages. */
8755 grokfndecl (ctype
, type
, declarator
, orig_declarator
, virtualp
, flags
, quals
,
8756 raises
, check
, friendp
, publicp
, inlinep
, funcdef_flag
,
8757 template_count
, in_namespace
)
8760 tree orig_declarator
;
8762 enum overload_flags flags
;
8764 int check
, friendp
, publicp
, inlinep
, funcdef_flag
, template_count
;
8768 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
8769 int has_default_arg
= 0;
8773 cname
= TREE_CODE (TYPE_NAME (ctype
)) == TYPE_DECL
8774 ? TYPE_IDENTIFIER (ctype
) : TYPE_NAME (ctype
);
8780 type
= build_exception_variant (type
, raises
);
8783 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
8784 /* Propagate volatile out from type to decl. */
8785 if (TYPE_VOLATILE (type
))
8786 TREE_THIS_VOLATILE (decl
) = 1;
8788 /* If this decl has namespace scope, set that up. */
8790 set_decl_namespace (decl
, in_namespace
, friendp
);
8792 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8794 /* `main' and builtins have implicit 'C' linkage. */
8795 if ((MAIN_NAME_P (declarator
)
8796 || (IDENTIFIER_LENGTH (declarator
) > 10
8797 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8798 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8799 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
8800 && current_lang_name
== lang_name_cplusplus
8801 && ctype
== NULL_TREE
8802 /* NULL_TREE means global namespace. */
8803 && DECL_CONTEXT (decl
) == NULL_TREE
)
8804 DECL_LANGUAGE (decl
) = lang_c
;
8806 /* Should probably propagate const out from type to decl I bet (mrs). */
8809 DECL_STATIC_FUNCTION_P (decl
) = 1;
8810 DECL_CONTEXT (decl
) = ctype
;
8814 DECL_CONTEXT (decl
) = ctype
;
8816 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8818 if (processing_template_decl
)
8819 error ("cannot declare `::main' to be a template");
8821 error ("cannot declare `::main' to be inline");
8823 error ("cannot declare `::main' to be static");
8824 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8826 error ("`main' must return `int'");
8831 /* Members of anonymous types and local classes have no linkage; make
8833 if (ctype
&& (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype
))
8834 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8839 /* [basic.link]: A name with no linkage (notably, the name of a class
8840 or enumeration declared in a local scope) shall not be used to
8841 declare an entity with linkage.
8843 Only check this for public decls for now. */
8844 t
= no_linkage_check (TREE_TYPE (decl
));
8847 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
8849 if (DECL_EXTERN_C_P (decl
))
8850 /* Allow this; it's pretty common in C. */;
8852 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8856 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8861 TREE_PUBLIC (decl
) = publicp
;
8864 DECL_INTERFACE_KNOWN (decl
) = 1;
8865 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8869 DECL_THIS_INLINE (decl
) = DECL_INLINE (decl
) = 1;
8871 DECL_EXTERNAL (decl
) = 1;
8872 if (quals
!= NULL_TREE
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8874 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8875 (ctype
? "static " : "non-"), decl
, TREE_VALUE (quals
));
8879 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
8880 grok_op_properties (decl
, virtualp
, check
< 0);
8882 if (ctype
&& decl_function_context (decl
))
8883 DECL_NO_STATIC_CHAIN (decl
) = 1;
8885 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8886 if (TREE_PURPOSE (t
)
8887 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8889 has_default_arg
= 1;
8894 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
8898 ("defining explicit specialization `%D' in friend declaration",
8902 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8904 /* Something like `template <class T> friend void f<T>()'. */
8905 cp_error ("invalid use of template-id `%D' in declaration of primary template",
8911 /* A friend declaration of the form friend void f<>(). Record
8912 the information in the TEMPLATE_ID_EXPR. */
8913 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8914 DECL_TEMPLATE_INFO (decl
)
8915 = tree_cons (TREE_OPERAND (orig_declarator
, 0),
8916 TREE_OPERAND (orig_declarator
, 1),
8919 if (has_default_arg
)
8921 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8928 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8935 if (has_default_arg
)
8936 add_defarg_fn (decl
);
8938 /* Plain overloading: will not be grok'd by grokclassfn. */
8939 if (! ctype
&& ! processing_template_decl
8940 && !DECL_EXTERN_C_P (decl
)
8941 && (! DECL_USE_TEMPLATE (decl
) || name_mangling_version
< 1))
8942 set_mangled_name_for_decl (decl
);
8945 /* Make the init_value nonzero so pushdecl knows this is not
8946 tentative. error_mark_node is replaced later with the BLOCK. */
8947 DECL_INITIAL (decl
) = error_mark_node
;
8949 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8950 TREE_NOTHROW (decl
) = 1;
8952 /* Caller will do the rest of this. */
8956 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name (cname
) == declarator
)
8957 DECL_CONSTRUCTOR_P (decl
) = 1;
8959 /* Function gets the ugly name, field gets the nice one. This call
8960 may change the type of the function (because of default
8962 if (ctype
!= NULL_TREE
)
8963 grokclassfn (ctype
, decl
, flags
, quals
);
8965 decl
= check_explicit_specialization (orig_declarator
, decl
,
8967 2 * (funcdef_flag
!= 0) +
8968 4 * (friendp
!= 0));
8969 if (decl
== error_mark_node
)
8972 if (ctype
!= NULL_TREE
8973 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8978 old_decl
= check_classfn (ctype
, decl
);
8980 if (old_decl
&& TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8981 /* Because grokfndecl is always supposed to return a
8982 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8983 here. We depend on our callers to figure out that its
8984 really a template that's being returned. */
8985 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8987 if (old_decl
&& DECL_STATIC_FUNCTION_P (old_decl
)
8988 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8990 /* Remove the `this' parm added by grokclassfn.
8991 XXX Isn't this done in start_function, too? */
8992 revert_static_member_fn (decl
);
8993 last_function_parms
= TREE_CHAIN (last_function_parms
);
8995 if (old_decl
&& DECL_ARTIFICIAL (old_decl
))
8996 cp_error ("definition of implicitly-declared `%D'", old_decl
);
9000 /* Since we've smashed OLD_DECL to its
9001 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9002 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
9003 decl
= DECL_TEMPLATE_RESULT (decl
);
9005 /* Attempt to merge the declarations. This can fail, in
9006 the case of some illegal specialization declarations. */
9007 if (!duplicate_decls (decl
, old_decl
))
9008 cp_error ("no `%#D' member function declared in class `%T'",
9014 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
9017 if (ctype
== NULL_TREE
|| check
)
9022 DECL_VIRTUAL_P (decl
) = 1;
9023 if (DECL_VINDEX (decl
) == NULL_TREE
)
9024 DECL_VINDEX (decl
) = error_mark_node
;
9025 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl
)) = 1;
9032 grokvardecl (type
, declarator
, specbits_in
, initialized
, constp
, in_namespace
)
9035 RID_BIT_TYPE
*specbits_in
;
9041 RID_BIT_TYPE specbits
;
9043 specbits
= *specbits_in
;
9045 if (TREE_CODE (type
) == OFFSET_TYPE
)
9047 /* If you declare a static member so that it
9048 can be initialized, the code will reach here. */
9049 tree basetype
= TYPE_OFFSET_BASETYPE (type
);
9050 type
= TREE_TYPE (type
);
9051 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
9052 DECL_CONTEXT (decl
) = basetype
;
9053 /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
9055 if (!uses_template_parms (decl
))
9058 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9060 DECL_ASSEMBLER_NAME (decl
) = build_static_name (basetype
,
9069 context
= in_namespace
;
9070 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN
, specbits
))
9071 context
= current_namespace
;
9073 context
= NULL_TREE
;
9075 if (processing_template_decl
&& context
)
9076 /* For global variables, declared in a template, we need the
9078 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
9080 decl
= build_decl (VAR_DECL
, declarator
, type
);
9083 set_decl_namespace (decl
, context
, 0);
9085 context
= DECL_CONTEXT (decl
);
9086 if (declarator
&& context
&& current_lang_name
!= lang_name_c
)
9089 DECL_ASSEMBLER_NAME (decl
) = mangle_decl (decl
);
9091 DECL_ASSEMBLER_NAME (decl
)
9092 = build_static_name (context
, declarator
);
9097 set_decl_namespace (decl
, in_namespace
, 0);
9099 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
9101 DECL_THIS_EXTERN (decl
) = 1;
9102 DECL_EXTERNAL (decl
) = !initialized
;
9105 /* In class context, static means one per class,
9106 public access, and static storage. */
9107 if (DECL_CLASS_SCOPE_P (decl
))
9109 TREE_PUBLIC (decl
) = 1;
9110 TREE_STATIC (decl
) = 1;
9111 DECL_EXTERNAL (decl
) = 0;
9113 /* At top level, either `static' or no s.c. makes a definition
9114 (perhaps tentative), and absence of `static' makes it public. */
9115 else if (toplevel_bindings_p ())
9117 TREE_PUBLIC (decl
) = (RIDBIT_NOTSETP (RID_STATIC
, specbits
)
9118 && (DECL_THIS_EXTERN (decl
) || ! constp
));
9119 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
9121 /* Not at top level, only `static' makes a static definition. */
9124 TREE_STATIC (decl
) = !! RIDBIT_SETP (RID_STATIC
, specbits
);
9125 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
9128 if (TREE_PUBLIC (decl
))
9130 /* [basic.link]: A name with no linkage (notably, the name of a class
9131 or enumeration declared in a local scope) shall not be used to
9132 declare an entity with linkage.
9134 Only check this for public decls for now. */
9135 tree t
= no_linkage_check (TREE_TYPE (decl
));
9138 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
9139 /* Ignore for now; `enum { foo } e' is pretty common. */;
9141 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
9149 /* Create and return a canonical pointer to member function type, for
9150 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9153 build_ptrmemfunc_type (type
)
9159 tree unqualified_variant
= NULL_TREE
;
9161 /* If a canonical type already exists for this type, use it. We use
9162 this method instead of type_hash_canon, because it only does a
9163 simple equality check on the list of field members. */
9165 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
9168 /* Make sure that we always have the unqualified pointer-to-member
9170 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9172 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
9174 t
= make_aggr_type (RECORD_TYPE
);
9175 /* Let the front-end know this is a pointer to member function... */
9176 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
9177 /* ... and not really an aggregate. */
9178 SET_IS_AGGR_TYPE (t
, 0);
9182 u
= make_aggr_type (UNION_TYPE
);
9183 SET_IS_AGGR_TYPE (u
, 0);
9184 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9185 fields
[1] = build_decl (FIELD_DECL
, delta2_identifier
,
9187 finish_builtin_type (u
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9188 TYPE_NAME (u
) = NULL_TREE
;
9190 fields
[0] = build_decl (FIELD_DECL
, delta_identifier
,
9192 fields
[1] = build_decl (FIELD_DECL
, index_identifier
,
9194 fields
[2] = build_decl (FIELD_DECL
, pfn_or_delta2_identifier
, u
);
9195 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 2, ptr_type_node
);
9199 fields
[0] = build_decl (FIELD_DECL
, pfn_identifier
, type
);
9200 fields
[1] = build_decl (FIELD_DECL
, delta_identifier
,
9202 finish_builtin_type (t
, "__ptrmemfunc_type", fields
, 1, ptr_type_node
);
9205 /* Zap out the name so that the back-end will give us the debugging
9206 information for this anonymous RECORD_TYPE. */
9207 TYPE_NAME (t
) = NULL_TREE
;
9209 /* If this is not the unqualified form of this pointer-to-member
9210 type, set the TYPE_MAIN_VARIANT for this type to be the
9211 unqualified type. Since they are actually RECORD_TYPEs that are
9212 not variants of each other, we must do this manually. */
9213 if (CP_TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
9215 t
= build_qualified_type (t
, CP_TYPE_QUALS (type
));
9216 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
9217 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
9218 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
9221 /* Cache this pointer-to-member type so that we can find it again
9223 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
9225 /* Seems to be wanted. */
9226 CLASSTYPE_GOT_SEMICOLON (t
) = 1;
9231 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9232 Check to see that the definition is valid. Issue appropriate error
9233 messages. Return 1 if the definition is particularly bad, or 0
9237 check_static_variable_definition (decl
, type
)
9241 /* Motion 10 at San Diego: If a static const integral data member is
9242 initialized with an integral constant expression, the initializer
9243 may appear either in the declaration (within the class), or in
9244 the definition, but not both. If it appears in the class, the
9245 member is a member constant. The file-scope definition is always
9247 if (CLASS_TYPE_P (type
) || TREE_CODE (type
) == REFERENCE_TYPE
)
9249 cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9251 /* If we just return the declaration, crashes will sometimes
9252 occur. We therefore return void_type_node, as if this was a
9253 friend declaration, to cause callers to completely ignore
9254 this declaration. */
9257 else if (!CP_TYPE_CONST_P (type
))
9258 cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9260 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
9261 cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
9266 /* Given the SIZE (i.e., number of elements) in an array, compute an
9267 appropriate index type for the array. If non-NULL, NAME is the
9268 name of the thing being declared. */
9271 compute_array_index_type (name
, size
)
9277 /* The size might be the result of a cast. */
9278 STRIP_TYPE_NOPS (size
);
9280 /* It might be a const variable or enumeration constant. */
9281 size
= decl_constant_value (size
);
9283 /* If this involves a template parameter, it will be a constant at
9284 instantiation time, but we don't know what the value is yet.
9285 Even if no template parameters are involved, we may an expression
9286 that is not a constant; we don't even simplify `1 + 2' when
9287 processing a template. */
9288 if (processing_template_decl
)
9290 /* Resolve a qualified reference to an enumerator or static
9291 const data member of ours. */
9292 if (TREE_CODE (size
) == SCOPE_REF
9293 && TREE_OPERAND (size
, 0) == current_class_type
)
9295 tree t
= lookup_field (current_class_type
,
9296 TREE_OPERAND (size
, 1), 0, 0);
9301 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
9302 size
, integer_one_node
));
9305 /* The array bound must be an integer type. */
9306 if (TREE_CODE (TREE_TYPE (size
)) != INTEGER_TYPE
9307 && TREE_CODE (TREE_TYPE (size
)) != ENUMERAL_TYPE
9308 && TREE_CODE (TREE_TYPE (size
)) != BOOLEAN_TYPE
)
9311 cp_error ("size of array `%D' has non-integer type", name
);
9313 cp_error ("size of array has non-integer type");
9314 size
= integer_one_node
;
9317 /* Normally, the array-bound will be a constant. */
9318 if (TREE_CODE (size
) == INTEGER_CST
)
9320 /* Check to see if the array bound overflowed. Make that an
9321 error, no matter how generous we're being. */
9322 int old_flag_pedantic_errors
= flag_pedantic_errors
;
9323 int old_pedantic
= pedantic
;
9324 pedantic
= flag_pedantic_errors
= 1;
9325 constant_expression_warning (size
);
9326 pedantic
= old_pedantic
;
9327 flag_pedantic_errors
= old_flag_pedantic_errors
;
9329 /* An array must have a positive number of elements. */
9330 if (INT_CST_LT (size
, integer_zero_node
))
9333 cp_error ("size of array `%D' is negative", name
);
9335 cp_error ("size of array is negative");
9336 size
= integer_one_node
;
9338 /* Except that an extension we allow zero-sized arrays. We
9339 always allow them in system headers because glibc uses
9341 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
9344 cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name
);
9346 cp_pedwarn ("ISO C++ forbids zero-size array");
9349 else if (TREE_CONSTANT (size
))
9351 /* `(int) &fn' is not a valid array bound. */
9353 cp_error ("size of array `%D' is not an integral constant-expression",
9356 cp_error ("size of array is not an integral constant-expression");
9359 /* Compute the index of the largest element in the array. It is
9360 one less than the number of elements in the array. */
9362 = fold (cp_build_binary_op (MINUS_EXPR
,
9363 cp_convert (ssizetype
, size
),
9364 cp_convert (ssizetype
,
9365 integer_one_node
)));
9367 /* Check for variable-sized arrays. We allow such things as an
9368 extension, even though they are not allowed in ANSI/ISO C++. */
9369 if (!TREE_CONSTANT (itype
))
9374 cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9377 cp_pedwarn ("ISO C++ forbids variable-size array");
9380 /* Create a variable-sized array index type. */
9381 itype
= variable_size (itype
);
9383 /* Make sure that there was no overflow when creating to a signed
9384 index type. (For example, on a 32-bit machine, an array with
9385 size 2^32 - 1 is too big.) */
9386 else if (TREE_OVERFLOW (itype
))
9388 error ("overflow in array dimension");
9389 TREE_OVERFLOW (itype
) = 0;
9392 /* Create and return the appropriate index type. */
9393 return build_index_type (itype
);
9396 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9397 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9401 create_array_type_for_decl (name
, type
, size
)
9406 tree itype
= NULL_TREE
;
9407 const char* error_msg
;
9409 /* If things have already gone awry, bail now. */
9410 if (type
== error_mark_node
|| size
== error_mark_node
)
9411 return error_mark_node
;
9413 /* Assume that everything will go OK. */
9416 /* There are some types which cannot be array elements. */
9417 switch (TREE_CODE (type
))
9420 error_msg
= "array of void";
9424 error_msg
= "array of functions";
9427 case REFERENCE_TYPE
:
9428 error_msg
= "array of references";
9432 error_msg
= "array of data members";
9436 error_msg
= "array of function members";
9443 /* If something went wrong, issue an error-message and return. */
9447 cp_error ("declaration of `%D' as %s", name
, error_msg
);
9449 cp_error ("creating %s", error_msg
);
9451 return error_mark_node
;
9456 The constant expressions that specify the bounds of the arrays
9457 can be omitted only for the first member of the sequence. */
9458 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9460 cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9463 return error_mark_node
;
9466 /* Figure out the index type for the array. */
9468 itype
= compute_array_index_type (name
, size
);
9470 return build_cplus_array_type (type
, itype
);
9473 /* Check that it's OK to declare a function with the indicated TYPE.
9474 SFK indicates the kind of special function (if any) that this
9475 function is. CTYPE is the class of which this function is a
9476 member. OPTYPE is the type given in a conversion operator
9477 declaration. Returns the actual return type of the function; that
9478 may be different than TYPE if an error occurs, or for certain
9479 special functions. */
9482 check_special_function_return_type (sfk
, type
, ctype
, optype
)
9483 special_function_kind sfk
;
9490 case sfk_constructor
:
9492 cp_error ("return type specification for constructor invalid");
9494 /* In the old ABI, we return `this'; in the new ABI we don't
9496 type
= flag_new_abi
? void_type_node
: build_pointer_type (ctype
);
9499 case sfk_destructor
:
9501 cp_error ("return type specification for destructor invalid");
9502 type
= void_type_node
;
9505 case sfk_conversion
:
9506 if (type
&& !same_type_p (type
, optype
))
9507 cp_error ("operator `%T' declared to return `%T'", optype
, type
);
9509 cp_pedwarn ("return type specified for `operator %T'", optype
);
9514 my_friendly_abort (20000408);
9521 /* Given declspecs and a declarator,
9522 determine the name and type of the object declared
9523 and construct a ..._DECL node for it.
9524 (In one case we can return a ..._TYPE node instead.
9525 For invalid input we sometimes return 0.)
9527 DECLSPECS is a chain of tree_list nodes whose value fields
9528 are the storage classes and type specifiers.
9530 DECL_CONTEXT says which syntactic context this declaration is in:
9531 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9532 FUNCDEF for a function definition. Like NORMAL but a few different
9533 error messages in each case. Return value may be zero meaning
9534 this definition is too screwy to try to parse.
9535 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9536 handle member functions (which have FIELD context).
9537 Return value may be zero meaning this definition is too screwy to
9539 PARM for a parameter declaration (either within a function prototype
9540 or before a function body). Make a PARM_DECL, or return void_type_node.
9541 CATCHPARM for a parameter declaration before a catch clause.
9542 TYPENAME if for a typename (in a cast or sizeof).
9543 Don't make a DECL node; just return the ..._TYPE node.
9544 FIELD for a struct or union field; make a FIELD_DECL.
9545 BITFIELD for a field with specified width.
9546 INITIALIZED is 1 if the decl has an initializer.
9548 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9549 normal attributes in TREE_PURPOSE, or NULL_TREE.
9551 In the TYPENAME case, DECLARATOR is really an abstract declarator.
9552 It may also be so in the PARM case, for a prototype where the
9553 argument type is specified but not the name.
9555 This function is where the complicated C meanings of `static'
9556 and `extern' are interpreted.
9558 For C++, if there is any monkey business to do, the function which
9559 calls this one must do it, i.e., prepending instance variables,
9560 renaming overloaded function names, etc.
9562 Note that for this C++, it is an error to define a method within a class
9563 which does not belong to that class.
9565 Except in the case where SCOPE_REFs are implicitly known (such as
9566 methods within a class being redundantly qualified),
9567 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9568 (class_name::decl_name). The caller must also deal with this.
9570 If a constructor or destructor is seen, and the context is FIELD,
9571 then the type gains the attribute TREE_HAS_x. If such a declaration
9572 is erroneous, NULL_TREE is returned.
9574 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9575 function, these are the qualifiers to give to the `this' pointer. We
9576 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9578 May return void_type_node if the declarator turned out to be a friend.
9579 See grokfield for details. */
9582 grokdeclarator (declarator
, declspecs
, decl_context
, initialized
, attrlist
)
9585 enum decl_context decl_context
;
9589 RID_BIT_TYPE specbits
;
9592 tree type
= NULL_TREE
;
9598 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9599 int explicit_int
= 0;
9600 int explicit_char
= 0;
9601 int defaulted_int
= 0;
9602 tree typedef_decl
= NULL_TREE
;
9604 tree typedef_type
= NULL_TREE
;
9605 int funcdef_flag
= 0;
9606 enum tree_code innermost_code
= ERROR_MARK
;
9609 /* See the code below that used this. */
9610 tree decl_machine_attr
= NULL_TREE
;
9612 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9613 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9614 tree init
= NULL_TREE
;
9616 /* Keep track of what sort of function is being processed
9617 so that we can warn about default return values, or explicit
9618 return values which do not match prescribed defaults. */
9619 special_function_kind sfk
= sfk_none
;
9621 tree dname
= NULL_TREE
;
9622 tree ctype
= current_class_type
;
9623 tree ctor_return_type
= NULL_TREE
;
9624 enum overload_flags flags
= NO_SPECIAL
;
9625 tree quals
= NULL_TREE
;
9626 tree raises
= NULL_TREE
;
9627 int template_count
= 0;
9628 tree in_namespace
= NULL_TREE
;
9632 RIDBIT_RESET_ALL (specbits
);
9633 if (decl_context
== FUNCDEF
)
9634 funcdef_flag
= 1, decl_context
= NORMAL
;
9635 else if (decl_context
== MEMFUNCDEF
)
9636 funcdef_flag
= -1, decl_context
= FIELD
;
9637 else if (decl_context
== BITFIELD
)
9638 bitfield
= 1, decl_context
= FIELD
;
9640 /* Look inside a declarator for the name being declared
9641 and get it as a string, for an error message. */
9643 tree
*next
= &declarator
;
9647 while (next
&& *next
)
9650 switch (TREE_CODE (decl
))
9653 /* For attributes. */
9654 next
= &TREE_VALUE (decl
);
9659 next
= &TREE_OPERAND (decl
, 0);
9662 case BIT_NOT_EXPR
: /* For C++ destructors! */
9664 tree name
= TREE_OPERAND (decl
, 0);
9665 tree rename
= NULL_TREE
;
9667 my_friendly_assert (flags
== NO_SPECIAL
, 152);
9669 sfk
= sfk_destructor
;
9670 if (TREE_CODE (name
) == TYPE_DECL
)
9671 TREE_OPERAND (decl
, 0) = name
= constructor_name (name
);
9672 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 153);
9673 if (ctype
== NULL_TREE
)
9675 if (current_class_type
== NULL_TREE
)
9677 error ("destructors must be member functions");
9682 tree t
= constructor_name (current_class_name
);
9689 tree t
= constructor_name (ctype
);
9696 cp_error ("destructor `%T' must match class name `%T'",
9698 TREE_OPERAND (decl
, 0) = rename
;
9704 case ADDR_EXPR
: /* C++ reference declaration */
9709 innermost_code
= TREE_CODE (decl
);
9710 next
= &TREE_OPERAND (decl
, 0);
9714 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl
)))
9716 /* This is actually a variable declaration using
9717 constructor syntax. We need to call start_decl and
9718 cp_finish_decl so we can get the variable
9721 tree attributes
, prefix_attributes
;
9723 *next
= TREE_OPERAND (decl
, 0);
9724 init
= CALL_DECLARATOR_PARMS (decl
);
9728 attributes
= TREE_PURPOSE (attrlist
);
9729 prefix_attributes
= TREE_VALUE (attrlist
);
9733 attributes
= NULL_TREE
;
9734 prefix_attributes
= NULL_TREE
;
9737 decl
= start_decl (declarator
, declspecs
, 1,
9738 attributes
, prefix_attributes
);
9739 decl_type_access_control (decl
);
9742 /* Look for __unused__ attribute */
9743 if (TREE_USED (TREE_TYPE (decl
)))
9744 TREE_USED (decl
) = 1;
9745 finish_decl (decl
, init
, NULL_TREE
);
9748 cp_error ("invalid declarator");
9751 innermost_code
= TREE_CODE (decl
);
9752 if (decl_context
== FIELD
&& ctype
== NULL_TREE
)
9753 ctype
= current_class_type
;
9755 && TREE_OPERAND (decl
, 0)
9756 && (TREE_CODE (TREE_OPERAND (decl
, 0)) == TYPE_DECL
9757 && ((DECL_NAME (TREE_OPERAND (decl
, 0))
9758 == constructor_name_full (ctype
))
9759 || (DECL_NAME (TREE_OPERAND (decl
, 0))
9760 == constructor_name (ctype
)))))
9761 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9762 next
= &TREE_OPERAND (decl
, 0);
9764 if (ctype
!= NULL_TREE
9765 && decl
!= NULL_TREE
&& flags
!= DTOR_FLAG
9766 && decl
== constructor_name (ctype
))
9768 sfk
= sfk_constructor
;
9769 ctor_return_type
= ctype
;
9774 case TEMPLATE_ID_EXPR
:
9776 tree fns
= TREE_OPERAND (decl
, 0);
9778 if (TREE_CODE (fns
) == LOOKUP_EXPR
)
9779 fns
= TREE_OPERAND (fns
, 0);
9782 if (TREE_CODE (dname
) == COMPONENT_REF
)
9783 dname
= TREE_OPERAND (dname
, 1);
9784 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
9786 my_friendly_assert (is_overloaded_fn (dname
),
9788 dname
= DECL_NAME (get_first_fn (dname
));
9793 case IDENTIFIER_NODE
:
9794 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
9799 if (C_IS_RESERVED_WORD (dname
))
9801 cp_error ("declarator-id missing; using reserved word `%D'",
9803 name
= IDENTIFIER_POINTER (dname
);
9805 else if (!IDENTIFIER_TYPENAME_P (dname
))
9806 name
= IDENTIFIER_POINTER (dname
);
9809 my_friendly_assert (flags
== NO_SPECIAL
, 154);
9810 flags
= TYPENAME_FLAG
;
9811 ctor_return_type
= TREE_TYPE (dname
);
9812 sfk
= sfk_conversion
;
9813 if (IDENTIFIER_GLOBAL_VALUE (dname
)
9814 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname
))
9816 name
= IDENTIFIER_POINTER (dname
);
9818 name
= "<invalid operator>";
9825 /* Perform error checking, and decide on a ctype. */
9826 tree cname
= TREE_OPERAND (decl
, 0);
9827 if (cname
== NULL_TREE
)
9829 else if (TREE_CODE (cname
) == NAMESPACE_DECL
)
9832 in_namespace
= TREE_OPERAND (decl
, 0);
9833 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9835 else if (! is_aggr_type (cname
, 1))
9836 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9837 /* Must test TREE_OPERAND (decl, 1), in case user gives
9838 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9839 else if (TREE_OPERAND (decl
, 1)
9840 && TREE_CODE (TREE_OPERAND (decl
, 1)) == INDIRECT_REF
)
9842 else if (TREE_CODE (cname
) == TEMPLATE_TYPE_PARM
9843 || TREE_CODE (cname
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
9845 cp_error ("`%T::%D' is not a valid declarator", cname
,
9846 TREE_OPERAND (decl
, 1));
9847 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9848 cname
, TREE_OPERAND (decl
, 1));
9849 return void_type_node
;
9851 else if (ctype
== NULL_TREE
)
9853 else if (TREE_COMPLEXITY (decl
) == current_class_depth
)
9854 TREE_OPERAND (decl
, 0) = ctype
;
9857 if (! UNIQUELY_DERIVED_FROM_P (cname
, ctype
))
9859 cp_error ("type `%T' is not derived from type `%T'",
9861 TREE_OPERAND (decl
, 0) = NULL_TREE
;
9867 if (ctype
&& TREE_CODE (TREE_OPERAND (decl
, 1)) == TYPE_DECL
9868 && ((DECL_NAME (TREE_OPERAND (decl
, 1))
9869 == constructor_name_full (ctype
))
9870 || (DECL_NAME (TREE_OPERAND (decl
, 1))
9871 == constructor_name (ctype
))))
9872 TREE_OPERAND (decl
, 1) = constructor_name (ctype
);
9873 next
= &TREE_OPERAND (decl
, 1);
9877 if (TREE_CODE (decl
) == IDENTIFIER_NODE
9878 && constructor_name (ctype
) == decl
)
9880 sfk
= sfk_constructor
;
9881 ctor_return_type
= ctype
;
9883 else if (TREE_CODE (decl
) == BIT_NOT_EXPR
9884 && TREE_CODE (TREE_OPERAND (decl
, 0)) == IDENTIFIER_NODE
9885 && (constructor_name (ctype
) == TREE_OPERAND (decl
, 0)
9886 || constructor_name_full (ctype
) == TREE_OPERAND (decl
, 0)))
9888 sfk
= sfk_destructor
;
9889 ctor_return_type
= ctype
;
9891 TREE_OPERAND (decl
, 0) = constructor_name (ctype
);
9892 next
= &TREE_OPERAND (decl
, 0);
9903 /* Parse error puts this typespec where
9904 a declarator should go. */
9905 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl
));
9906 if (TREE_TYPE (decl
) == current_class_type
)
9907 cp_error (" perhaps you want `%T' for a constructor",
9908 current_class_name
);
9909 dname
= DECL_NAME (decl
);
9910 name
= IDENTIFIER_POINTER (dname
);
9912 /* Avoid giving two errors for this. */
9913 IDENTIFIER_CLASS_VALUE (dname
) = NULL_TREE
;
9915 declspecs
= tree_cons (NULL_TREE
, integer_type_node
, declspecs
);
9921 cp_compiler_error ("`%D' as declarator", decl
);
9922 return 0; /* We used to do a 155 abort here. */
9927 /* A function definition's declarator must have the form of
9928 a function declarator. */
9930 if (funcdef_flag
&& innermost_code
!= CALL_EXPR
)
9933 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
9934 && innermost_code
!= CALL_EXPR
9935 && ! (ctype
&& declspecs
== NULL_TREE
))
9937 cp_error ("declaration of `%D' as non-function", dname
);
9938 return void_type_node
;
9941 /* Anything declared one level down from the top level
9942 must be one of the parameters of a function
9943 (because the body is at least two levels down). */
9945 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9946 by not allowing C++ class definitions to specify their parameters
9947 with xdecls (must be spec.d in the parmlist).
9949 Since we now wait to push a class scope until we are sure that
9950 we are in a legitimate method context, we must set oldcname
9951 explicitly (since current_class_name is not yet alive).
9953 We also want to avoid calling this a PARM if it is in a namespace. */
9955 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9957 struct binding_level
*b
= current_binding_level
;
9958 current_binding_level
= b
->level_chain
;
9959 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9960 decl_context
= PARM
;
9961 current_binding_level
= b
;
9965 name
= decl_context
== PARM
? "parameter" : "type name";
9967 /* Look through the decl specs and record which ones appear.
9968 Some typespecs are defined as built-in typenames.
9969 Others, the ones that are modifiers of other types,
9970 are represented by bits in SPECBITS: set the bits for
9971 the modifiers that appear. Storage class keywords are also in SPECBITS.
9973 If there is a typedef name or a type, store the type in TYPE.
9974 This includes builtin typedefs such as `int'.
9976 Set EXPLICIT_INT if the type is `int' or `char' and did not
9977 come from a user typedef.
9979 Set LONGLONG if `long' is mentioned twice.
9981 For C++, constructors and destructors have their own fast treatment. */
9983 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
9988 /* Certain parse errors slip through. For example,
9989 `int class;' is not caught by the parser. Try
9990 weakly to recover here. */
9991 if (TREE_CODE (spec
) != TREE_LIST
)
9994 id
= TREE_VALUE (spec
);
9996 if (TREE_CODE (id
) == IDENTIFIER_NODE
)
9998 if (id
== ridpointers
[(int) RID_INT
]
9999 || id
== ridpointers
[(int) RID_CHAR
]
10000 || id
== ridpointers
[(int) RID_BOOL
]
10001 || id
== ridpointers
[(int) RID_WCHAR
])
10005 if (id
== ridpointers
[(int) RID_BOOL
])
10006 error ("`bool' is now a keyword");
10008 cp_error ("extraneous `%T' ignored", id
);
10012 if (id
== ridpointers
[(int) RID_INT
])
10014 else if (id
== ridpointers
[(int) RID_CHAR
])
10016 type
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id
));
10020 /* C++ aggregate types. */
10021 if (IDENTIFIER_HAS_TYPE_VALUE (id
))
10024 cp_error ("multiple declarations `%T' and `%T'", type
, id
);
10026 type
= IDENTIFIER_TYPE_VALUE (id
);
10030 for (i
= (int) RID_FIRST_MODIFIER
; i
<= (int) RID_LAST_MODIFIER
; i
++)
10032 if (ridpointers
[i
] == id
)
10034 if (i
== (int) RID_LONG
&& RIDBIT_SETP (i
, specbits
))
10036 if (pedantic
&& ! in_system_header
&& warn_long_long
)
10037 pedwarn ("ISO C++ does not support `long long'");
10039 error ("`long long long' is too long for GCC");
10043 else if (RIDBIT_SETP (i
, specbits
))
10044 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id
));
10045 RIDBIT_SET (i
, specbits
);
10050 /* C++ aggregate types. */
10051 else if (TREE_CODE (id
) == TYPE_DECL
)
10054 cp_error ("multiple declarations `%T' and `%T'", type
,
10058 type
= TREE_TYPE (id
);
10059 TREE_VALUE (spec
) = type
;
10064 error ("two or more data types in declaration of `%s'", name
);
10065 else if (TREE_CODE (id
) == IDENTIFIER_NODE
)
10067 register tree t
= lookup_name (id
, 1);
10068 if (!t
|| TREE_CODE (t
) != TYPE_DECL
)
10069 error ("`%s' fails to be a typedef or built in type",
10070 IDENTIFIER_POINTER (id
));
10073 type
= TREE_TYPE (t
);
10075 /* See the code below that used this. */
10076 decl_machine_attr
= DECL_MACHINE_ATTRIBUTES (id
);
10081 else if (id
!= error_mark_node
)
10082 /* Can't change CLASS nodes into RECORD nodes here! */
10088 typedef_type
= type
;
10090 /* No type at all: default to `int', and set DEFAULTED_INT
10091 because it was not a user-defined typedef. */
10093 if (type
== NULL_TREE
10094 && (RIDBIT_SETP (RID_SIGNED
, specbits
)
10095 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10096 || RIDBIT_SETP (RID_LONG
, specbits
)
10097 || RIDBIT_SETP (RID_SHORT
, specbits
)))
10099 /* These imply 'int'. */
10100 type
= integer_type_node
;
10104 if (sfk
!= sfk_none
)
10105 type
= check_special_function_return_type (sfk
, type
,
10108 else if (type
== NULL_TREE
)
10114 /* We handle `main' specially here, because 'main () { }' is so
10115 common. With no options, it is allowed. With -Wreturn-type,
10116 it is a warning. It is only an error with -pedantic-errors. */
10117 is_main
= (funcdef_flag
10118 && MAIN_NAME_P (dname
)
10119 && ctype
== NULL_TREE
10120 && in_namespace
== NULL_TREE
10121 && current_namespace
== global_namespace
);
10123 if (in_system_header
|| flag_ms_extensions
)
10124 /* Allow it, sigh. */;
10125 else if (pedantic
|| ! is_main
)
10126 cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10128 else if (warn_return_type
)
10129 cp_warning ("ISO C++ forbids declaration of `%s' with no type",
10132 type
= integer_type_node
;
10137 /* Now process the modifiers that were specified
10138 and check for invalid combinations. */
10140 /* Long double is a special combination. */
10142 if (RIDBIT_SETP (RID_LONG
, specbits
)
10143 && TYPE_MAIN_VARIANT (type
) == double_type_node
)
10145 RIDBIT_RESET (RID_LONG
, specbits
);
10146 type
= build_qualified_type (long_double_type_node
,
10147 CP_TYPE_QUALS (type
));
10150 /* Check all other uses of type modifiers. */
10152 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10153 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10154 || RIDBIT_SETP (RID_LONG
, specbits
)
10155 || RIDBIT_SETP (RID_SHORT
, specbits
))
10159 if (TREE_CODE (type
) == REAL_TYPE
)
10160 error ("short, signed or unsigned invalid for `%s'", name
);
10161 else if (TREE_CODE (type
) != INTEGER_TYPE
)
10162 error ("long, short, signed or unsigned invalid for `%s'", name
);
10163 else if (RIDBIT_SETP (RID_LONG
, specbits
)
10164 && RIDBIT_SETP (RID_SHORT
, specbits
))
10165 error ("long and short specified together for `%s'", name
);
10166 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10167 || RIDBIT_SETP (RID_SHORT
, specbits
))
10169 error ("long or short specified with char for `%s'", name
);
10170 else if ((RIDBIT_SETP (RID_LONG
, specbits
)
10171 || RIDBIT_SETP (RID_SHORT
, specbits
))
10172 && TREE_CODE (type
) == REAL_TYPE
)
10173 error ("long or short specified with floating type for `%s'", name
);
10174 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10175 && RIDBIT_SETP (RID_UNSIGNED
, specbits
))
10176 error ("signed and unsigned given together for `%s'", name
);
10180 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
10182 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10184 if (flag_pedantic_errors
)
10189 /* Discard the type modifiers if they are invalid. */
10192 RIDBIT_RESET (RID_UNSIGNED
, specbits
);
10193 RIDBIT_RESET (RID_SIGNED
, specbits
);
10194 RIDBIT_RESET (RID_LONG
, specbits
);
10195 RIDBIT_RESET (RID_SHORT
, specbits
);
10200 if (RIDBIT_SETP (RID_COMPLEX
, specbits
)
10201 && TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
10203 error ("complex invalid for `%s'", name
);
10204 RIDBIT_RESET (RID_COMPLEX
, specbits
);
10207 /* Decide whether an integer type is signed or not.
10208 Optionally treat bitfields as signed by default. */
10209 if (RIDBIT_SETP (RID_UNSIGNED
, specbits
)
10212 It is implementation-defined whether a plain (neither
10213 explicitly signed or unsigned) char, short, int, or long
10214 bit-field is signed or unsigned.
10216 Naturally, we extend this to long long as well. Note that
10217 this does not include wchar_t. */
10218 || (bitfield
&& !flag_signed_bitfields
10219 && RIDBIT_NOTSETP (RID_SIGNED
, specbits
)
10220 /* A typedef for plain `int' without `signed' can be
10221 controlled just like plain `int', but a typedef for
10222 `signed int' cannot be so controlled. */
10224 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
10225 && (TREE_CODE (type
) == INTEGER_TYPE
10226 || TREE_CODE (type
) == CHAR_TYPE
)
10227 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
10230 type
= long_long_unsigned_type_node
;
10231 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10232 type
= long_unsigned_type_node
;
10233 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10234 type
= short_unsigned_type_node
;
10235 else if (type
== char_type_node
)
10236 type
= unsigned_char_type_node
;
10237 else if (typedef_decl
)
10238 type
= unsigned_type (type
);
10240 type
= unsigned_type_node
;
10242 else if (RIDBIT_SETP (RID_SIGNED
, specbits
)
10243 && type
== char_type_node
)
10244 type
= signed_char_type_node
;
10246 type
= long_long_integer_type_node
;
10247 else if (RIDBIT_SETP (RID_LONG
, specbits
))
10248 type
= long_integer_type_node
;
10249 else if (RIDBIT_SETP (RID_SHORT
, specbits
))
10250 type
= short_integer_type_node
;
10252 if (RIDBIT_SETP (RID_COMPLEX
, specbits
))
10254 /* If we just have "complex", it is equivalent to
10255 "complex double", but if any modifiers at all are specified it is
10256 the complex form of TYPE. E.g, "complex short" is
10257 "complex short int". */
10259 if (defaulted_int
&& ! longlong
10260 && ! (RIDBIT_SETP (RID_LONG
, specbits
)
10261 || RIDBIT_SETP (RID_SHORT
, specbits
)
10262 || RIDBIT_SETP (RID_SIGNED
, specbits
)
10263 || RIDBIT_SETP (RID_UNSIGNED
, specbits
)))
10264 type
= complex_double_type_node
;
10265 else if (type
== integer_type_node
)
10266 type
= complex_integer_type_node
;
10267 else if (type
== float_type_node
)
10268 type
= complex_float_type_node
;
10269 else if (type
== double_type_node
)
10270 type
= complex_double_type_node
;
10271 else if (type
== long_double_type_node
)
10272 type
= complex_long_double_type_node
;
10274 type
= build_complex_type (type
);
10277 if (sfk
== sfk_conversion
10278 && (RIDBIT_SETP (RID_CONST
, specbits
)
10279 || RIDBIT_SETP (RID_VOLATILE
, specbits
)
10280 || RIDBIT_SETP (RID_RESTRICT
, specbits
)))
10281 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10284 /* Set CONSTP if this declaration is `const', whether by
10285 explicit specification or via a typedef.
10286 Likewise for VOLATILEP. */
10288 constp
= !! RIDBIT_SETP (RID_CONST
, specbits
) + CP_TYPE_CONST_P (type
);
10290 !! RIDBIT_SETP (RID_RESTRICT
, specbits
) + CP_TYPE_RESTRICT_P (type
);
10292 !! RIDBIT_SETP (RID_VOLATILE
, specbits
) + CP_TYPE_VOLATILE_P (type
);
10293 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10294 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10295 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10296 type
= cp_build_qualified_type (type
, type_quals
);
10298 inlinep
= !! RIDBIT_SETP (RID_INLINE
, specbits
);
10299 virtualp
= RIDBIT_SETP (RID_VIRTUAL
, specbits
);
10300 RIDBIT_RESET (RID_VIRTUAL
, specbits
);
10301 explicitp
= RIDBIT_SETP (RID_EXPLICIT
, specbits
) != 0;
10302 RIDBIT_RESET (RID_EXPLICIT
, specbits
);
10304 if (RIDBIT_SETP (RID_STATIC
, specbits
))
10305 staticp
= 1 + (decl_context
== FIELD
);
10307 if (virtualp
&& staticp
== 2)
10309 cp_error ("member `%D' cannot be declared both virtual and static",
10313 friendp
= RIDBIT_SETP (RID_FRIEND
, specbits
);
10314 RIDBIT_RESET (RID_FRIEND
, specbits
);
10316 /* Warn if two storage classes are given. Default to `auto'. */
10318 if (RIDBIT_ANY_SET (specbits
))
10320 if (RIDBIT_SETP (RID_STATIC
, specbits
)) nclasses
++;
10321 if (RIDBIT_SETP (RID_EXTERN
, specbits
)) nclasses
++;
10322 if (decl_context
== PARM
&& nclasses
> 0)
10323 error ("storage class specifiers invalid in parameter declarations");
10324 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10326 if (decl_context
== PARM
)
10327 error ("typedef declaration invalid in parameter declaration");
10330 if (RIDBIT_SETP (RID_AUTO
, specbits
)) nclasses
++;
10331 if (RIDBIT_SETP (RID_REGISTER
, specbits
)) nclasses
++;
10334 /* Give error if `virtual' is used outside of class declaration. */
10336 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
10338 error ("virtual outside class declaration");
10342 /* Static anonymous unions are dealt with here. */
10343 if (staticp
&& decl_context
== TYPENAME
10344 && TREE_CODE (declspecs
) == TREE_LIST
10345 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs
)))
10346 decl_context
= FIELD
;
10348 /* Warn about storage classes that are invalid for certain
10349 kinds of declarations (parameters, typenames, etc.). */
10352 error ("multiple storage classes in declaration of `%s'", name
);
10353 else if (decl_context
!= NORMAL
&& nclasses
> 0)
10355 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
10356 && (RIDBIT_SETP (RID_REGISTER
, specbits
)
10357 || RIDBIT_SETP (RID_AUTO
, specbits
)))
10359 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10361 else if (decl_context
== FIELD
10362 /* C++ allows static class elements */
10363 && RIDBIT_SETP (RID_STATIC
, specbits
))
10364 /* C++ also allows inlines and signed and unsigned elements,
10365 but in those cases we don't come in here. */
10369 if (decl_context
== FIELD
)
10371 tree tmp
= NULL_TREE
;
10372 register int op
= 0;
10376 /* Avoid trying to get an operand off an identifier node. */
10377 if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
10380 tmp
= TREE_OPERAND (declarator
, 0);
10381 op
= IDENTIFIER_OPNAME_P (tmp
);
10382 if (IDENTIFIER_TYPENAME_P (tmp
))
10384 if (IDENTIFIER_GLOBAL_VALUE (tmp
)
10385 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp
))
10387 name
= IDENTIFIER_POINTER (tmp
);
10389 name
= "<invalid operator>";
10392 error ("storage class specified for %s `%s'",
10393 op
? "member operator" : "field",
10398 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10399 error ("storage class specified for parameter `%s'", name
);
10401 error ("storage class specified for typename");
10403 RIDBIT_RESET (RID_REGISTER
, specbits
);
10404 RIDBIT_RESET (RID_AUTO
, specbits
);
10405 RIDBIT_RESET (RID_EXTERN
, specbits
);
10408 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && initialized
&& !funcdef_flag
)
10410 if (toplevel_bindings_p ())
10412 /* It's common practice (and completely valid) to have a const
10413 be initialized and declared extern. */
10414 if (!(type_quals
& TYPE_QUAL_CONST
))
10415 warning ("`%s' initialized and declared `extern'", name
);
10418 error ("`%s' has both `extern' and initializer", name
);
10420 else if (RIDBIT_SETP (RID_EXTERN
, specbits
) && funcdef_flag
10421 && ! toplevel_bindings_p ())
10422 error ("nested function `%s' declared `extern'", name
);
10423 else if (toplevel_bindings_p ())
10425 if (RIDBIT_SETP (RID_AUTO
, specbits
))
10426 error ("top-level declaration of `%s' specifies `auto'", name
);
10429 if (nclasses
> 0 && friendp
)
10430 error ("storage class specifiers invalid in friend function declarations");
10432 /* Now figure out the structure of the declarator proper.
10433 Descend through it, creating more complex types, until we reach
10434 the declared identifier (or NULL_TREE, in an absolute declarator). */
10436 inner_attrs
= NULL_TREE
;
10439 while (declarator
&& TREE_CODE (declarator
) != IDENTIFIER_NODE
10440 && TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
)
10442 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10443 an INDIRECT_REF (for *...),
10444 a CALL_EXPR (for ...(...)),
10445 an identifier (for the name being declared)
10446 or a null pointer (for the place in an absolute declarator
10447 where the name was omitted).
10448 For the last two cases, we have just exited the loop.
10450 For C++ it could also be
10451 a SCOPE_REF (for class :: ...). In this case, we have converted
10452 sensible names to types, and those are the values we use to
10453 qualify the member name.
10454 an ADDR_EXPR (for &...),
10455 a BIT_NOT_EXPR (for destructors)
10457 At this point, TYPE is the type of elements of an array,
10458 or for a function to return, or for a pointer to point to.
10459 After this sequence of ifs, TYPE is the type of the
10460 array or function or pointer, and DECLARATOR has had its
10461 outermost layer removed. */
10463 if (type
== error_mark_node
)
10465 if (TREE_CODE (declarator
) == SCOPE_REF
)
10466 declarator
= TREE_OPERAND (declarator
, 1);
10468 declarator
= TREE_OPERAND (declarator
, 0);
10471 if (quals
!= NULL_TREE
10472 && (declarator
== NULL_TREE
10473 || TREE_CODE (declarator
) != SCOPE_REF
))
10475 if (ctype
== NULL_TREE
&& TREE_CODE (type
) == METHOD_TYPE
)
10476 ctype
= TYPE_METHOD_BASETYPE (type
);
10477 if (ctype
!= NULL_TREE
)
10479 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
10480 grok_method_quals (ctype
, dummy
, quals
);
10481 type
= TREE_TYPE (dummy
);
10482 ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type
)));
10487 /* See the comment for the TREE_LIST case, below. */
10490 else if (inner_attrs
)
10492 decl_attributes (type
, inner_attrs
, NULL_TREE
);
10493 inner_attrs
= NULL_TREE
;
10496 switch (TREE_CODE (declarator
))
10500 /* We encode a declarator with embedded attributes using
10501 a TREE_LIST. The attributes apply to the declarator
10502 directly inside them, so we have to skip an iteration
10503 before applying them to the type. If the declarator just
10504 inside is the declarator-id, we apply the attrs to the
10506 inner_attrs
= TREE_PURPOSE (declarator
);
10508 declarator
= TREE_VALUE (declarator
);
10514 register tree size
;
10516 size
= TREE_OPERAND (declarator
, 1);
10518 /* VC++ spells a zero-sized array with []. */
10519 if (size
== NULL_TREE
&& decl_context
== FIELD
&& ! staticp
10520 && ! RIDBIT_SETP (RID_TYPEDEF
, specbits
))
10521 size
= integer_zero_node
;
10523 declarator
= TREE_OPERAND (declarator
, 0);
10525 type
= create_array_type_for_decl (dname
, type
, size
);
10527 /* VLAs never work as fields. */
10528 if (decl_context
== FIELD
&& !processing_template_decl
10529 && TREE_CODE (type
) == ARRAY_TYPE
10530 && TYPE_DOMAIN (type
) != NULL_TREE
10531 && !TREE_CONSTANT (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
10533 cp_error ("size of member `%D' is not constant", dname
);
10534 /* Proceed with arbitrary constant size, so that offset
10535 computations don't get confused. */
10536 type
= create_array_type_for_decl (dname
, TREE_TYPE (type
),
10548 tree inner_parms
= CALL_DECLARATOR_PARMS (declarator
);
10549 tree inner_decl
= TREE_OPERAND (declarator
, 0);
10551 /* Declaring a function type.
10552 Make sure we have a valid type for the function to return. */
10554 /* We now know that the TYPE_QUALS don't apply to the
10555 decl, but to its return type. */
10556 type_quals
= TYPE_UNQUALIFIED
;
10558 /* Warn about some types functions can't return. */
10560 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10562 error ("`%s' declared as function returning a function", name
);
10563 type
= integer_type_node
;
10565 if (TREE_CODE (type
) == ARRAY_TYPE
)
10567 error ("`%s' declared as function returning an array", name
);
10568 type
= integer_type_node
;
10571 if (inner_decl
&& TREE_CODE (inner_decl
) == SCOPE_REF
)
10572 inner_decl
= TREE_OPERAND (inner_decl
, 1);
10574 if (inner_decl
&& TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
)
10575 inner_decl
= dname
;
10577 /* Pick up type qualifiers which should be applied to `this'. */
10578 quals
= CALL_DECLARATOR_QUALS (declarator
);
10580 /* Pick up the exception specifications. */
10581 raises
= CALL_DECLARATOR_EXCEPTION_SPEC (declarator
);
10583 /* Say it's a definition only for the CALL_EXPR
10584 closest to the identifier. */
10587 && (TREE_CODE (inner_decl
) == IDENTIFIER_NODE
10588 || TREE_CODE (inner_decl
) == TEMPLATE_ID_EXPR
10589 || TREE_CODE (inner_decl
) == BIT_NOT_EXPR
);
10591 if (ctype
== NULL_TREE
10592 && decl_context
== FIELD
10594 && (friendp
== 0 || dname
== current_class_name
))
10595 ctype
= current_class_type
;
10597 if (ctype
&& sfk
== sfk_conversion
)
10598 TYPE_HAS_CONVERSION (ctype
) = 1;
10599 if (ctype
&& constructor_name (ctype
) == dname
)
10601 /* We are within a class's scope. If our declarator name
10602 is the same as the class name, and we are defining
10603 a function, then it is a constructor/destructor, and
10604 therefore returns a void type. */
10606 if (flags
== DTOR_FLAG
)
10608 /* ISO C++ 12.4/2. A destructor may not be
10609 declared const or volatile. A destructor may
10612 error ("destructor cannot be static member function");
10615 cp_error ("destructors may not be `%s'",
10616 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10619 if (decl_context
== FIELD
)
10621 if (! member_function_or_else (ctype
,
10622 current_class_type
,
10624 return void_type_node
;
10627 else /* It's a constructor. */
10629 if (explicitp
== 1)
10631 /* ISO C++ 12.1. A constructor may not be
10632 declared const or volatile. A constructor may
10633 not be virtual. A constructor may not be
10636 error ("constructor cannot be static member function");
10639 pedwarn ("constructors cannot be declared virtual");
10644 cp_error ("constructors may not be `%s'",
10645 IDENTIFIER_POINTER (TREE_VALUE (quals
)));
10649 RID_BIT_TYPE tmp_bits
;
10650 bcopy ((void*)&specbits
, (void*)&tmp_bits
, sizeof (RID_BIT_TYPE
));
10651 RIDBIT_RESET (RID_INLINE
, tmp_bits
);
10652 RIDBIT_RESET (RID_STATIC
, tmp_bits
);
10653 if (RIDBIT_ANY_SET (tmp_bits
))
10654 error ("return value type specifier for constructor ignored");
10656 if (decl_context
== FIELD
)
10658 if (! member_function_or_else (ctype
,
10659 current_class_type
,
10661 return void_type_node
;
10662 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
10663 if (sfk
!= sfk_constructor
)
10667 if (decl_context
== FIELD
)
10673 error ("can't initialize friend function `%s'", name
);
10676 /* Cannot be both friend and virtual. */
10677 error ("virtual functions cannot be friends");
10678 RIDBIT_RESET (RID_FRIEND
, specbits
);
10681 if (decl_context
== NORMAL
)
10682 error ("friend declaration not in class definition");
10683 if (current_function_decl
&& funcdef_flag
)
10684 cp_error ("can't define friend function `%s' in a local class definition",
10688 /* Construct the function type and go to the next
10689 inner layer of declarator. */
10691 declarator
= TREE_OPERAND (declarator
, 0);
10693 /* FIXME: This is where default args should be fully
10696 arg_types
= grokparms (inner_parms
, funcdecl_p
? funcdef_flag
: 0);
10698 if (declarator
&& flags
== DTOR_FLAG
)
10700 /* A destructor declared in the body of a class will
10701 be represented as a BIT_NOT_EXPR. But, we just
10702 want the underlying IDENTIFIER. */
10703 if (TREE_CODE (declarator
) == BIT_NOT_EXPR
)
10704 declarator
= TREE_OPERAND (declarator
, 0);
10706 if (arg_types
!= void_list_node
)
10708 cp_error ("destructors may not have parameters");
10709 arg_types
= void_list_node
;
10710 last_function_parms
= NULL_TREE
;
10714 /* ANSI says that `const int foo ();'
10715 does not make the function foo const. */
10716 type
= build_function_type (type
, arg_types
);
10720 for (t
= arg_types
; t
; t
= TREE_CHAIN (t
))
10721 if (TREE_PURPOSE (t
)
10722 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
10724 add_defarg_fn (type
);
10733 /* Filter out pointers-to-references and references-to-references.
10734 We can get these if a TYPE_DECL is used. */
10736 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10738 error ("cannot declare %s to references",
10739 TREE_CODE (declarator
) == ADDR_EXPR
10740 ? "references" : "pointers");
10741 declarator
= TREE_OPERAND (declarator
, 0);
10745 if (TREE_CODE (type
) == OFFSET_TYPE
10746 && (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
10747 || TREE_CODE (TREE_TYPE (type
)) == REFERENCE_TYPE
))
10749 cp_error ("cannot declare pointer to `%#T' member",
10751 type
= TREE_TYPE (type
);
10754 /* Merge any constancy or volatility into the target type
10755 for the pointer. */
10757 /* We now know that the TYPE_QUALS don't apply to the decl,
10758 but to the target of the pointer. */
10759 type_quals
= TYPE_UNQUALIFIED
;
10761 if (TREE_CODE (declarator
) == ADDR_EXPR
)
10763 if (TREE_CODE (type
) == VOID_TYPE
)
10764 error ("invalid type: `void &'");
10766 type
= build_reference_type (type
);
10768 else if (TREE_CODE (type
) == METHOD_TYPE
)
10769 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10771 type
= build_pointer_type (type
);
10773 /* Process a list of type modifier keywords (such as
10774 const or volatile) that were given inside the `*' or `&'. */
10776 if (TREE_TYPE (declarator
))
10778 register tree typemodlist
;
10784 for (typemodlist
= TREE_TYPE (declarator
); typemodlist
;
10785 typemodlist
= TREE_CHAIN (typemodlist
))
10787 tree qualifier
= TREE_VALUE (typemodlist
);
10789 if (qualifier
== ridpointers
[(int) RID_CONST
])
10791 else if (qualifier
== ridpointers
[(int) RID_VOLATILE
])
10793 else if (qualifier
== ridpointers
[(int) RID_RESTRICT
])
10798 error ("invalid type modifier within pointer declarator");
10802 pedwarn ("duplicate `const'");
10804 pedwarn ("duplicate `volatile'");
10806 pedwarn ("duplicate `restrict'");
10808 type_quals
= ((constp
? TYPE_QUAL_CONST
: 0)
10809 | (restrictp
? TYPE_QUAL_RESTRICT
: 0)
10810 | (volatilep
? TYPE_QUAL_VOLATILE
: 0));
10811 if (TREE_CODE (declarator
) == ADDR_EXPR
10812 && (constp
|| volatilep
))
10815 pedwarn ("discarding `const' applied to a reference");
10817 pedwarn ("discarding `volatile' applied to a reference");
10818 type_quals
&= ~(TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
);
10820 type
= cp_build_qualified_type (type
, type_quals
);
10822 declarator
= TREE_OPERAND (declarator
, 0);
10828 /* We have converted type names to NULL_TREE if the
10829 name was bogus, or to a _TYPE node, if not.
10831 The variable CTYPE holds the type we will ultimately
10832 resolve to. The code here just needs to build
10833 up appropriate member types. */
10834 tree sname
= TREE_OPERAND (declarator
, 1);
10837 /* Destructors can have their visibilities changed as well. */
10838 if (TREE_CODE (sname
) == BIT_NOT_EXPR
)
10839 sname
= TREE_OPERAND (sname
, 0);
10841 if (TREE_COMPLEXITY (declarator
) == 0)
10842 /* This needs to be here, in case we are called
10843 multiple times. */ ;
10844 else if (TREE_COMPLEXITY (declarator
) == -1)
10845 /* Namespace member. */
10846 pop_decl_namespace ();
10847 else if (friendp
&& (TREE_COMPLEXITY (declarator
) < 2))
10848 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10849 else if (! IS_AGGR_TYPE_CODE
10850 (TREE_CODE (TREE_OPERAND (declarator
, 0))))
10852 else if (TREE_COMPLEXITY (declarator
) == current_class_depth
)
10854 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10855 that refer to ctype. They couldn't be resolved earlier
10856 because we hadn't pushed into the class yet.
10857 Example: resolve 'B<T>::type' in
10858 'B<typename B<T>::type> B<T>::f () { }'. */
10859 if (current_template_parms
10860 && uses_template_parms (type
)
10861 && uses_template_parms (current_class_type
))
10863 tree args
= current_template_args ();
10864 type
= tsubst (type
, args
, /*complain=*/1, NULL_TREE
);
10867 /* This pop_nested_class corresponds to the
10868 push_nested_class used to push into class scope for
10869 parsing the argument list of a function decl, in
10871 pop_nested_class ();
10872 TREE_COMPLEXITY (declarator
) = current_class_depth
;
10875 my_friendly_abort (16);
10877 if (TREE_OPERAND (declarator
, 0) == NULL_TREE
)
10879 /* We had a reference to a global decl, or
10880 perhaps we were given a non-aggregate typedef,
10881 in which case we cleared this out, and should just
10882 keep going as though it wasn't there. */
10883 declarator
= sname
;
10886 ctype
= TREE_OPERAND (declarator
, 0);
10889 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
10891 /* You're supposed to have one `template <...>'
10892 for every template class, but you don't need one
10893 for a full specialization. For example:
10895 template <class T> struct S{};
10896 template <> struct S<int> { void f(); };
10897 void S<int>::f () {}
10899 is correct; there shouldn't be a `template <>' for
10900 the definition of `S<int>::f'. */
10901 if (CLASSTYPE_TEMPLATE_INFO (t
)
10902 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
10903 || uses_template_parms (CLASSTYPE_TI_ARGS (t
))))
10904 template_count
+= 1;
10906 t
= TYPE_MAIN_DECL (t
);
10907 if (DECL_LANG_SPECIFIC (t
))
10908 t
= DECL_CONTEXT (t
);
10913 if (sname
== NULL_TREE
)
10916 if (TREE_CODE (sname
) == IDENTIFIER_NODE
)
10918 /* This is the `standard' use of the scoping operator:
10919 basetype :: member . */
10921 if (ctype
== current_class_type
)
10927 Is this ill-formed? */
10930 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10933 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10935 if (current_class_type
== NULL_TREE
10937 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10938 TYPE_ARG_TYPES (type
));
10941 cp_error ("cannot declare member function `%T::%s' within `%T'",
10942 ctype
, name
, current_class_type
);
10943 return void_type_node
;
10946 else if (RIDBIT_SETP (RID_TYPEDEF
, specbits
)
10947 || COMPLETE_TYPE_P (complete_type (ctype
)))
10949 /* Have to move this code elsewhere in this function.
10950 this code is used for i.e., typedef int A::M; M *pm;
10952 It is? How? jason 10/2/94 */
10954 if (current_class_type
)
10956 cp_error ("cannot declare member `%T::%s' within `%T'",
10957 ctype
, name
, current_class_type
);
10958 return void_type_node
;
10960 type
= build_offset_type (ctype
, type
);
10962 else if (uses_template_parms (ctype
))
10964 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10966 = build_cplus_method_type (ctype
, TREE_TYPE (type
),
10967 TYPE_ARG_TYPES (type
));
10971 cp_error ("structure `%T' not yet defined", ctype
);
10972 return error_mark_node
;
10975 declarator
= sname
;
10977 else if (TREE_CODE (sname
) == SCOPE_REF
)
10978 my_friendly_abort (17);
10982 declarator
= TREE_OPERAND (declarator
, 1);
10983 if (declarator
&& TREE_CODE (declarator
) == CALL_EXPR
)
10984 /* In this case, we will deal with it later. */
10988 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10989 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
10990 TYPE_ARG_TYPES (type
));
10992 type
= build_offset_type (ctype
, type
);
10999 declarator
= TREE_OPERAND (declarator
, 0);
11004 case ENUMERAL_TYPE
:
11005 declarator
= NULL_TREE
;
11009 declarator
= NULL_TREE
;
11013 my_friendly_abort (158);
11017 /* See the comment for the TREE_LIST case, above. */
11020 if (! ignore_attrs
)
11021 decl_attributes (type
, inner_attrs
, NULL_TREE
);
11023 TREE_VALUE (attrlist
) = chainon (inner_attrs
, TREE_VALUE (attrlist
));
11025 attrlist
= build_decl_list (NULL_TREE
, inner_attrs
);
11028 /* Now TYPE has the actual type. */
11030 if (explicitp
== 1 || (explicitp
&& friendp
))
11032 /* [dcl.fct.spec] The explicit specifier shall only be used in
11033 declarations of constructors within a class definition. */
11034 error ("only declarations of constructors can be `explicit'");
11038 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11040 if (current_class_name
== NULL_TREE
|| decl_context
== PARM
|| friendp
)
11042 error ("non-member `%s' cannot be declared `mutable'", name
);
11043 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11045 else if (decl_context
== TYPENAME
|| RIDBIT_SETP (RID_TYPEDEF
, specbits
))
11047 error ("non-object member `%s' cannot be declared `mutable'", name
);
11048 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11050 else if (TREE_CODE (type
) == FUNCTION_TYPE
11051 || TREE_CODE (type
) == METHOD_TYPE
)
11053 error ("function `%s' cannot be declared `mutable'", name
);
11054 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11058 error ("static `%s' cannot be declared `mutable'", name
);
11059 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11061 else if (type_quals
& TYPE_QUAL_CONST
)
11063 error ("const `%s' cannot be declared `mutable'", name
);
11064 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11068 if (declarator
== NULL_TREE
11069 || TREE_CODE (declarator
) == IDENTIFIER_NODE
11070 || (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
11071 && (TREE_CODE (type
) == FUNCTION_TYPE
11072 || TREE_CODE (type
) == METHOD_TYPE
)))
11074 else if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11076 cp_error ("template-id `%D' used as a declarator", declarator
);
11077 declarator
= dname
;
11080 /* Unexpected declarator format. */
11081 my_friendly_abort (990210);
11083 /* If this is declaring a typedef name, return a TYPE_DECL. */
11085 if (RIDBIT_SETP (RID_TYPEDEF
, specbits
) && decl_context
!= TYPENAME
)
11089 /* Note that the grammar rejects storage classes
11090 in typenames, fields or parameters. */
11091 if (current_lang_name
== lang_name_java
)
11092 TYPE_FOR_JAVA (type
) = 1;
11094 if (decl_context
== FIELD
)
11096 if (declarator
== constructor_name (current_class_type
))
11097 cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11099 decl
= build_lang_decl (TYPE_DECL
, declarator
, type
);
11102 decl
= build_decl (TYPE_DECL
, declarator
, type
);
11104 /* If the user declares "typedef struct {...} foo" then the
11105 struct will have an anonymous name. Fill that name in now.
11106 Nothing can refer to it, so nothing needs know about the name
11108 if (type
!= error_mark_node
11110 && TYPE_NAME (type
)
11111 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11112 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
))
11113 && CP_TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
11115 tree oldname
= TYPE_NAME (type
);
11118 /* Replace the anonymous name with the real name everywhere. */
11119 lookup_tag_reverse (type
, declarator
);
11120 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
11121 if (TYPE_NAME (t
) == oldname
)
11122 TYPE_NAME (t
) = decl
;
11124 if (TYPE_LANG_SPECIFIC (type
))
11125 TYPE_WAS_ANONYMOUS (type
) = 1;
11127 /* If this is a typedef within a template class, the nested
11128 type is a (non-primary) template. The name for the
11129 template needs updating as well. */
11130 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
11131 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
11132 = TYPE_IDENTIFIER (type
);
11135 DECL_ASSEMBLER_NAME (decl
) = mangle_type (type
);
11138 /* XXX Temporarily set the scope.
11139 When returning, start_decl expects it as NULL_TREE,
11140 and will then then set it using pushdecl. */
11141 my_friendly_assert (DECL_CONTEXT (decl
) == NULL_TREE
, 980404);
11142 if (current_class_type
)
11143 DECL_CONTEXT (decl
) = current_class_type
;
11145 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
11147 DECL_ASSEMBLER_NAME (decl
) = DECL_NAME (decl
);
11148 DECL_ASSEMBLER_NAME (decl
)
11149 = get_identifier (build_overload_name (type
, 1, 1));
11150 DECL_CONTEXT (decl
) = NULL_TREE
;
11153 /* FIXME remangle member functions; member functions of a
11154 type with external linkage have external linkage. */
11157 if (TREE_CODE (type
) == OFFSET_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11159 cp_error_at ("typedef name may not be class-qualified", decl
);
11164 if (ctype
== NULL_TREE
)
11166 if (TREE_CODE (type
) != METHOD_TYPE
)
11167 cp_error_at ("invalid type qualifier for non-member function type", decl
);
11169 ctype
= TYPE_METHOD_BASETYPE (type
);
11171 if (ctype
!= NULL_TREE
)
11172 grok_method_quals (ctype
, decl
, quals
);
11175 if (RIDBIT_SETP (RID_SIGNED
, specbits
)
11176 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
11177 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
11179 bad_specifiers (decl
, "type", virtualp
, quals
!= NULL_TREE
,
11180 inlinep
, friendp
, raises
!= NULL_TREE
);
11183 error ("typedef declaration includes an initializer");
11188 /* Detect the case of an array type of unspecified size
11189 which came, as such, direct from a typedef name.
11190 We must copy the type, so that each identifier gets
11191 a distinct type, so that each identifier's size can be
11192 controlled separately by its own initializer. */
11194 if (type
== typedef_type
&& TREE_CODE (type
) == ARRAY_TYPE
11195 && TYPE_DOMAIN (type
) == NULL_TREE
)
11197 type
= build_cplus_array_type (TREE_TYPE (type
), TYPE_DOMAIN (type
));
11200 /* If this is a type name (such as, in a cast or sizeof),
11201 compute the type and return it now. */
11203 if (decl_context
== TYPENAME
)
11205 /* Note that the grammar rejects storage classes
11206 in typenames, fields or parameters. */
11207 if (type_quals
!= TYPE_UNQUALIFIED
)
11208 type_quals
= TYPE_UNQUALIFIED
;
11210 /* Special case: "friend class foo" looks like a TYPENAME context. */
11213 if (type_quals
!= TYPE_UNQUALIFIED
)
11215 cp_error ("type qualifiers specified for friend class declaration");
11216 type_quals
= TYPE_UNQUALIFIED
;
11220 cp_error ("`inline' specified for friend class declaration");
11224 /* Until core issue 180 is resolved, allow 'friend typename A::B'.
11225 But don't allow implicit typenames. */
11226 if (!current_aggr
&& (TREE_CODE (type
) != TYPENAME_TYPE
11227 || IMPLICIT_TYPENAME_P (type
)))
11229 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11230 cp_pedwarn ("template parameters cannot be friends");
11231 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
11233 friend declaration requires class-key, i.e. `friend class %T::%T'",
11234 constructor_name (current_class_type
),
11235 TYPE_IDENTIFIER (type
));
11238 friend declaration requires class-key, i.e. `friend %#T'",
11242 /* Only try to do this stuff if we didn't already give up. */
11243 if (type
!= integer_type_node
)
11245 /* A friendly class? */
11246 if (current_class_type
)
11247 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
));
11249 cp_error ("trying to make class `%T' a friend of global scope",
11251 type
= void_type_node
;
11256 if (ctype
== NULL_TREE
)
11258 if (TREE_CODE (type
) != METHOD_TYPE
)
11259 cp_error ("invalid qualifiers on non-member function type");
11261 ctype
= TYPE_METHOD_BASETYPE (type
);
11265 tree dummy
= build_decl (TYPE_DECL
, declarator
, type
);
11266 grok_method_quals (ctype
, dummy
, quals
);
11267 type
= TREE_TYPE (dummy
);
11273 else if (declarator
== NULL_TREE
&& decl_context
!= PARM
11274 && decl_context
!= CATCHPARM
11275 && TREE_CODE (type
) != UNION_TYPE
11278 cp_error ("abstract declarator `%T' used as declaration", type
);
11279 declarator
= make_anon_name ();
11282 /* `void' at top level (not within pointer)
11283 is allowed only in typedefs or type names.
11284 We don't complain about parms either, but that is because
11285 a better error message can be made later. */
11287 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
11290 error ("unnamed variable or field declared void");
11291 else if (TREE_CODE (declarator
) == IDENTIFIER_NODE
)
11293 if (IDENTIFIER_OPNAME_P (declarator
))
11294 my_friendly_abort (356);
11296 error ("variable or field `%s' declared void", name
);
11299 error ("variable or field declared void");
11300 type
= integer_type_node
;
11303 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11304 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11306 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
11308 if (ctype
|| in_namespace
)
11309 error ("cannot use `::' in parameter declaration");
11311 /* A parameter declared as an array of T is really a pointer to T.
11312 One declared as a function is really a pointer to a function.
11313 One declared as a member is really a pointer to member. */
11315 if (TREE_CODE (type
) == ARRAY_TYPE
)
11317 /* Transfer const-ness of array into that of type pointed to. */
11318 type
= build_pointer_type (TREE_TYPE (type
));
11319 type_quals
= TYPE_UNQUALIFIED
;
11321 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11322 type
= build_pointer_type (type
);
11323 else if (TREE_CODE (type
) == OFFSET_TYPE
)
11324 type
= build_pointer_type (type
);
11325 else if (TREE_CODE (type
) == VOID_TYPE
&& declarator
)
11327 error ("declaration of `%s' as void", name
);
11333 register tree decl
;
11335 if (decl_context
== PARM
)
11337 decl
= build_decl (PARM_DECL
, declarator
, type
);
11339 bad_specifiers (decl
, "parameter", virtualp
, quals
!= NULL_TREE
,
11340 inlinep
, friendp
, raises
!= NULL_TREE
);
11342 /* Compute the type actually passed in the parmlist,
11343 for the case where there is no prototype.
11344 (For example, shorts and chars are passed as ints.)
11345 When there is a prototype, this is overridden later. */
11347 DECL_ARG_TYPE (decl
) = type_promotes_to (type
);
11349 else if (decl_context
== FIELD
)
11351 if (type
== error_mark_node
)
11353 /* Happens when declaring arrays of sizes which
11354 are error_mark_node, for example. */
11357 else if (in_namespace
&& !friendp
)
11359 /* Something like struct S { int N::j; }; */
11360 cp_error ("invalid use of `::'");
11363 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11366 tree function_context
;
11368 /* We catch the others as conflicts with the builtin
11370 if (friendp
&& declarator
== ridpointers
[(int) RID_SIGNED
])
11372 cp_error ("function `%D' cannot be declared friend",
11379 if (ctype
== NULL_TREE
)
11380 ctype
= current_class_type
;
11382 if (ctype
== NULL_TREE
)
11384 cp_error ("can't make `%D' into a method -- not in a class",
11386 return void_type_node
;
11389 /* ``A union may [ ... ] not [ have ] virtual functions.''
11391 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11393 cp_error ("function `%D' declared virtual inside a union",
11395 return void_type_node
;
11398 if (declarator
== ansi_opname (NEW_EXPR
)
11399 || declarator
== ansi_opname (VEC_NEW_EXPR
)
11400 || declarator
== ansi_opname (DELETE_EXPR
)
11401 || declarator
== ansi_opname (VEC_DELETE_EXPR
))
11405 cp_error ("`%D' cannot be declared virtual, since it is always static",
11410 else if (staticp
< 2)
11411 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11412 TYPE_ARG_TYPES (type
));
11415 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11416 function_context
= (ctype
!= NULL_TREE
) ?
11417 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11418 publicp
= (! friendp
|| ! staticp
)
11419 && function_context
== NULL_TREE
;
11420 decl
= grokfndecl (ctype
, type
,
11421 TREE_CODE (declarator
) != TEMPLATE_ID_EXPR
11422 ? declarator
: dname
,
11424 virtualp
, flags
, quals
, raises
,
11425 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
11426 funcdef_flag
, template_count
, in_namespace
);
11427 if (decl
== NULL_TREE
)
11430 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11431 /* The decl and setting of decl_machine_attr is also turned off. */
11432 decl
= build_decl_attribute_variant (decl
, decl_machine_attr
);
11435 /* [class.conv.ctor]
11437 A constructor declared without the function-specifier
11438 explicit that can be called with a single parameter
11439 specifies a conversion from the type of its first
11440 parameter to the type of its class. Such a constructor
11441 is called a converting constructor. */
11442 if (explicitp
== 2)
11443 DECL_NONCONVERTING_P (decl
) = 1;
11444 else if (DECL_CONSTRUCTOR_P (decl
))
11446 /* The constructor can be called with exactly one
11447 parameter if there is at least one parameter, and
11448 any subsequent parameters have default arguments.
11449 We don't look at the first parameter, which is
11450 really just the `this' parameter for the new
11453 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
11455 /* Skip the `in_chrg' argument too, if present. */
11456 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
11457 arg_types
= TREE_CHAIN (arg_types
);
11459 if (arg_types
== void_list_node
11461 && TREE_CHAIN (arg_types
)
11462 && TREE_CHAIN (arg_types
) != void_list_node
11463 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
11464 DECL_NONCONVERTING_P (decl
) = 1;
11467 else if (TREE_CODE (type
) == METHOD_TYPE
)
11469 /* We only get here for friend declarations of
11470 members of other classes. */
11471 /* All method decls are public, so tell grokfndecl to set
11472 TREE_PUBLIC, also. */
11473 decl
= grokfndecl (ctype
, type
, declarator
, declarator
,
11474 virtualp
, flags
, quals
, raises
,
11475 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
11476 template_count
, in_namespace
);
11477 if (decl
== NULL_TREE
)
11480 else if (!staticp
&& ! processing_template_decl
11481 && !COMPLETE_TYPE_P (complete_type (type
))
11482 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
11485 cp_error ("field `%D' has incomplete type", declarator
);
11487 cp_error ("name `%T' has incomplete type", type
);
11489 /* If we're instantiating a template, tell them which
11490 instantiation made the field's type be incomplete. */
11491 if (current_class_type
11492 && TYPE_NAME (current_class_type
)
11493 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
11494 && declspecs
&& TREE_VALUE (declspecs
)
11495 && TREE_TYPE (TREE_VALUE (declspecs
)) == type
)
11496 cp_error (" in instantiation of template `%T'",
11497 current_class_type
);
11499 type
= error_mark_node
;
11506 error ("`%s' is neither function nor member function; cannot be declared friend",
11507 IDENTIFIER_POINTER (declarator
));
11515 /* Friends are treated specially. */
11516 if (ctype
== current_class_type
)
11517 warning ("member functions are implicitly friends of their class");
11520 tree t
= NULL_TREE
;
11521 if (decl
&& DECL_NAME (decl
))
11523 if (template_class_depth (current_class_type
) == 0)
11526 = check_explicit_specialization
11528 template_count
, 2 * (funcdef_flag
!= 0) + 4);
11529 if (decl
== error_mark_node
)
11530 return error_mark_node
;
11533 t
= do_friend (ctype
, declarator
, decl
,
11534 last_function_parms
, attrlist
, flags
, quals
,
11537 if (t
&& funcdef_flag
)
11540 return void_type_node
;
11544 /* Structure field. It may not be a function, except for C++ */
11546 if (decl
== NULL_TREE
)
11552 /* An attempt is being made to initialize a non-static
11553 member. But, from [class.mem]:
11555 4 A member-declarator can contain a
11556 constant-initializer only if it declares a static
11557 member (_class.static_) of integral or enumeration
11558 type, see _class.static.data_.
11560 This used to be relatively common practice, but
11561 the rest of the compiler does not correctly
11562 handle the initialization unless the member is
11563 static so we make it static below. */
11564 cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11566 cp_pedwarn ("making `%D' static", declarator
);
11570 if (uses_template_parms (type
))
11571 /* We'll check at instantiation time. */
11573 else if (check_static_variable_definition (declarator
,
11575 /* If we just return the declaration, crashes
11576 will sometimes occur. We therefore return
11577 void_type_node, as if this was a friend
11578 declaration, to cause callers to completely
11579 ignore this declaration. */
11580 return void_type_node
;
11583 /* 9.2p13 [class.mem] */
11584 if (declarator
== constructor_name (current_class_type
)
11585 /* The standard does not allow non-static data members
11586 here either, but we agreed at the 10/99 meeting
11587 to change that in TC 1 so that they are allowed in
11588 classes with no user-defined constructors. */
11590 cp_pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11595 /* C++ allows static class members. All other work
11596 for this is done by grokfield. */
11597 decl
= build_lang_decl (VAR_DECL
, declarator
, type
);
11598 TREE_STATIC (decl
) = 1;
11599 /* In class context, 'static' means public access. */
11600 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
) = 1;
11604 decl
= build_decl (FIELD_DECL
, declarator
, type
);
11605 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11606 if (RIDBIT_SETP (RID_MUTABLE
, specbits
))
11608 DECL_MUTABLE_P (decl
) = 1;
11609 RIDBIT_RESET (RID_MUTABLE
, specbits
);
11613 bad_specifiers (decl
, "field", virtualp
, quals
!= NULL_TREE
,
11614 inlinep
, friendp
, raises
!= NULL_TREE
);
11617 else if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
11619 tree original_name
;
11625 if (TREE_CODE (declarator
) == TEMPLATE_ID_EXPR
)
11626 original_name
= dname
;
11628 original_name
= declarator
;
11630 if (RIDBIT_SETP (RID_AUTO
, specbits
))
11631 error ("storage class `auto' invalid for function `%s'", name
);
11632 else if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11633 error ("storage class `register' invalid for function `%s'", name
);
11635 /* Function declaration not at top level.
11636 Storage classes other than `extern' are not allowed
11637 and `extern' makes no difference. */
11638 if (! toplevel_bindings_p ()
11639 && (RIDBIT_SETP (RID_STATIC
, specbits
)
11640 || RIDBIT_SETP (RID_INLINE
, specbits
))
11643 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11644 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name
);
11646 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name
);
11649 if (ctype
== NULL_TREE
)
11653 error ("virtual non-class function `%s'", name
);
11657 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2)
11658 type
= build_cplus_method_type (ctype
, TREE_TYPE (type
),
11659 TYPE_ARG_TYPES (type
));
11661 /* Record presence of `static'. */
11662 publicp
= (ctype
!= NULL_TREE
11663 || RIDBIT_SETP (RID_EXTERN
, specbits
)
11664 || !RIDBIT_SETP (RID_STATIC
, specbits
));
11666 decl
= grokfndecl (ctype
, type
, original_name
, declarator
,
11667 virtualp
, flags
, quals
, raises
,
11669 publicp
, inlinep
, funcdef_flag
,
11670 template_count
, in_namespace
);
11671 if (decl
== NULL_TREE
)
11676 int illegal_static
= 0;
11678 /* Don't allow a static member function in a class, and forbid
11679 declaring main to be static. */
11680 if (TREE_CODE (type
) == METHOD_TYPE
)
11682 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
11683 illegal_static
= 1;
11685 else if (current_function_decl
)
11687 /* FIXME need arm citation */
11688 error ("cannot declare static function inside another function");
11689 illegal_static
= 1;
11692 if (illegal_static
)
11695 RIDBIT_RESET (RID_STATIC
, specbits
);
11701 /* It's a variable. */
11703 /* An uninitialized decl with `extern' is a reference. */
11704 decl
= grokvardecl (type
, declarator
, &specbits
,
11706 (type_quals
& TYPE_QUAL_CONST
) != 0,
11708 bad_specifiers (decl
, "variable", virtualp
, quals
!= NULL_TREE
,
11709 inlinep
, friendp
, raises
!= NULL_TREE
);
11713 DECL_CONTEXT (decl
) = ctype
;
11716 cp_pedwarn ("static member `%D' re-declared as static", decl
);
11718 RIDBIT_RESET (RID_STATIC
, specbits
);
11720 if (RIDBIT_SETP (RID_REGISTER
, specbits
) && TREE_STATIC (decl
))
11722 cp_error ("static member `%D' declared `register'", decl
);
11723 RIDBIT_RESET (RID_REGISTER
, specbits
);
11725 if (RIDBIT_SETP (RID_EXTERN
, specbits
) && pedantic
)
11727 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11729 RIDBIT_RESET (RID_EXTERN
, specbits
);
11734 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE
, specbits
), 19990927);
11736 /* Record `register' declaration for warnings on &
11737 and in case doing stupid register allocation. */
11739 if (RIDBIT_SETP (RID_REGISTER
, specbits
))
11740 DECL_REGISTER (decl
) = 1;
11742 if (RIDBIT_SETP (RID_EXTERN
, specbits
))
11743 DECL_THIS_EXTERN (decl
) = 1;
11745 if (RIDBIT_SETP (RID_STATIC
, specbits
))
11746 DECL_THIS_STATIC (decl
) = 1;
11748 /* Record constancy and volatility. There's no need to do this
11749 when processing a template; we'll do this for the instantiated
11750 declaration based on the type of DECL. */
11751 if (!processing_template_decl
)
11752 c_apply_type_quals_to_decl (type_quals
, decl
);
11758 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11759 An empty exprlist is a parmlist. An exprlist which
11760 contains only identifiers at the global level
11761 is a parmlist. Otherwise, it is an exprlist. */
11764 parmlist_is_exprlist (exprs
)
11767 if (exprs
== NULL_TREE
|| TREE_PARMLIST (exprs
))
11770 if (toplevel_bindings_p ())
11772 /* At the global level, if these are all identifiers,
11773 then it is a parmlist. */
11776 if (TREE_CODE (TREE_VALUE (exprs
)) != IDENTIFIER_NODE
)
11778 exprs
= TREE_CHAIN (exprs
);
11785 /* Subroutine of start_function. Ensure that each of the parameter
11786 types (as listed in PARMS) is complete, as is required for a
11787 function definition. */
11790 require_complete_types_for_parms (parms
)
11793 for (; parms
; parms
= TREE_CHAIN (parms
))
11795 tree type
= TREE_TYPE (parms
);
11797 /* Try to complete the TYPE. */
11798 type
= complete_type (type
);
11800 if (type
== error_mark_node
)
11803 if (!COMPLETE_TYPE_P (type
))
11805 if (DECL_NAME (parms
))
11806 error ("parameter `%s' has incomplete type",
11807 IDENTIFIER_POINTER (DECL_NAME (parms
)));
11809 error ("parameter has incomplete type");
11810 TREE_TYPE (parms
) = error_mark_node
;
11813 layout_decl (parms
, 0);
11817 /* Returns non-zero if T is a local variable. */
11820 local_variable_p (t
)
11823 if ((TREE_CODE (t
) == VAR_DECL
11824 /* A VAR_DECL with a context that is a _TYPE is a static data
11826 && !TYPE_P (CP_DECL_CONTEXT (t
))
11827 /* Any other non-local variable must be at namespace scope. */
11828 && !DECL_NAMESPACE_SCOPE_P (t
))
11829 || (TREE_CODE (t
) == PARM_DECL
))
11835 /* Returns non-zero if T is an automatic local variable or a label.
11836 (These are the declarations that need to be remapped when the code
11837 containing them is duplicated.) */
11840 nonstatic_local_decl_p (t
)
11843 return ((local_variable_p (t
) && !TREE_STATIC (t
))
11844 || TREE_CODE (t
) == LABEL_DECL
11845 || TREE_CODE (t
) == RESULT_DECL
);
11848 /* Like local_variable_p, but suitable for use as a tree-walking
11852 local_variable_p_walkfn (tp
, walk_subtrees
, data
)
11854 int *walk_subtrees ATTRIBUTE_UNUSED
;
11855 void *data ATTRIBUTE_UNUSED
;
11857 return ((local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
11858 ? *tp
: NULL_TREE
);
11861 /* Check that ARG, which is a default-argument expression for a
11862 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11863 something goes wrong. DECL may also be a _TYPE node, rather than a
11864 DECL, if there is no DECL available. */
11867 check_default_argument (decl
, arg
)
11874 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11875 /* We get a DEFAULT_ARG when looking at an in-class declaration
11876 with a default argument. Ignore the argument for now; we'll
11877 deal with it after the class is complete. */
11880 if (processing_template_decl
|| uses_template_parms (arg
))
11881 /* We don't do anything checking until instantiation-time. Note
11882 that there may be uninstantiated arguments even for an
11883 instantiated function, since default arguments are not
11884 instantiated until they are needed. */
11893 decl_type
= TREE_TYPE (decl
);
11895 if (arg
== error_mark_node
11896 || decl
== error_mark_node
11897 || TREE_TYPE (arg
) == error_mark_node
11898 || decl_type
== error_mark_node
)
11899 /* Something already went wrong. There's no need to check
11901 return error_mark_node
;
11903 /* [dcl.fct.default]
11905 A default argument expression is implicitly converted to the
11907 if (!TREE_TYPE (arg
)
11908 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
11911 cp_error ("default argument for `%#D' has type `%T'",
11912 decl
, TREE_TYPE (arg
));
11914 cp_error ("default argument for parameter of type `%T' has type `%T'",
11915 decl_type
, TREE_TYPE (arg
));
11917 return error_mark_node
;
11920 /* [dcl.fct.default]
11922 Local variables shall not be used in default argument
11925 The keyword `this' shall not be used in a default argument of a
11926 member function. */
11927 var
= walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
,
11931 cp_error ("default argument `%E' uses local variable `%D'",
11933 return error_mark_node
;
11940 /* Decode the list of parameter types for a function type.
11941 Given the list of things declared inside the parens,
11942 return a list of types.
11944 The list we receive can have three kinds of elements:
11945 an IDENTIFIER_NODE for names given without types,
11946 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11947 or void_type_node, to mark the end of an argument list
11948 when additional arguments are not permitted (... was not used).
11950 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11951 a mere declaration. A nonempty identifier-list gets an error message
11952 when FUNCDEF_FLAG is zero.
11953 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11954 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11956 If all elements of the input list contain types,
11957 we return a list of the types.
11958 If all elements contain no type (except perhaps a void_type_node
11959 at the end), we return a null list.
11960 If some have types and some do not, it is an error, and we
11961 return a null list.
11963 Also set last_function_parms to either
11964 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11965 A list of names is converted to a chain of PARM_DECLs
11966 by store_parm_decls so that ultimately it is always a chain of decls.
11968 Note that in C++, parameters can take default values. These default
11969 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11970 an error to specify default values which are followed by parameters
11971 that have no default values, or an ELLIPSES. For simplicities sake,
11972 only parameters which are specified with their types can take on
11976 grokparms (first_parm
, funcdef_flag
)
11980 tree result
= NULL_TREE
;
11981 tree decls
= NULL_TREE
;
11983 if (first_parm
!= NULL_TREE
11984 && TREE_CODE (TREE_VALUE (first_parm
)) == IDENTIFIER_NODE
)
11986 if (! funcdef_flag
)
11987 pedwarn ("parameter names (without types) in function declaration");
11988 last_function_parms
= first_parm
;
11991 else if (first_parm
!= NULL_TREE
11992 && TREE_CODE (TREE_VALUE (first_parm
)) != TREE_LIST
11993 && TREE_CODE (TREE_VALUE (first_parm
)) != VOID_TYPE
)
11994 my_friendly_abort (145);
11997 /* Types were specified. This is a list of declarators
11998 each represented as a TREE_LIST node. */
11999 register tree parm
, chain
;
12000 int any_init
= 0, any_error
= 0;
12002 if (first_parm
!= NULL_TREE
)
12004 tree last_result
= NULL_TREE
;
12005 tree last_decl
= NULL_TREE
;
12007 for (parm
= first_parm
; parm
!= NULL_TREE
; parm
= chain
)
12009 tree type
= NULL_TREE
, list_node
= parm
;
12010 register tree decl
= TREE_VALUE (parm
);
12011 tree init
= TREE_PURPOSE (parm
);
12013 chain
= TREE_CHAIN (parm
);
12014 /* @@ weak defense against parse errors. */
12015 if (TREE_CODE (decl
) != VOID_TYPE
12016 && TREE_CODE (decl
) != TREE_LIST
)
12018 /* Give various messages as the need arises. */
12019 if (TREE_CODE (decl
) == STRING_CST
)
12020 cp_error ("invalid string constant `%E'", decl
);
12021 else if (TREE_CODE (decl
) == INTEGER_CST
)
12022 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12026 if (TREE_CODE (decl
) != VOID_TYPE
)
12028 decl
= grokdeclarator (TREE_VALUE (decl
),
12029 TREE_PURPOSE (decl
),
12030 PARM
, init
!= NULL_TREE
,
12032 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
12035 /* Top-level qualifiers on the parameters are
12036 ignored for function types. */
12037 type
= TYPE_MAIN_VARIANT (TREE_TYPE (decl
));
12039 if (TREE_CODE (type
) == VOID_TYPE
)
12040 decl
= void_type_node
;
12041 else if (TREE_CODE (type
) == METHOD_TYPE
)
12043 if (DECL_NAME (decl
))
12044 /* Cannot use the decl here because
12045 we don't have DECL_CONTEXT set up yet. */
12046 cp_error ("parameter `%D' invalidly declared method type",
12049 error ("parameter invalidly declared method type");
12050 type
= build_pointer_type (type
);
12051 TREE_TYPE (decl
) = type
;
12053 else if (TREE_CODE (type
) == OFFSET_TYPE
)
12055 if (DECL_NAME (decl
))
12056 cp_error ("parameter `%D' invalidly declared offset type",
12059 error ("parameter invalidly declared offset type");
12060 type
= build_pointer_type (type
);
12061 TREE_TYPE (decl
) = type
;
12063 else if (abstract_virtuals_error (decl
, type
))
12064 any_error
= 1; /* Seems like a good idea. */
12065 else if (POINTER_TYPE_P (type
))
12068 while (POINTER_TYPE_P (t
)
12069 || (TREE_CODE (t
) == ARRAY_TYPE
12070 && TYPE_DOMAIN (t
) != NULL_TREE
))
12072 if (TREE_CODE (t
) == ARRAY_TYPE
)
12073 cp_error ("parameter type `%T' includes %s to array of unknown bound",
12075 TYPE_PTR_P (type
) ? "pointer" : "reference");
12079 if (TREE_CODE (decl
) == VOID_TYPE
)
12081 if (result
== NULL_TREE
)
12083 result
= void_list_node
;
12084 last_result
= result
;
12088 TREE_CHAIN (last_result
) = void_list_node
;
12089 last_result
= void_list_node
;
12092 && (chain
!= void_list_node
|| TREE_CHAIN (chain
)))
12093 error ("`void' in parameter list must be entire list");
12097 /* Since there is a prototype, args are passed in their own types. */
12098 DECL_ARG_TYPE (decl
) = TREE_TYPE (decl
);
12099 if (PROMOTE_PROTOTYPES
12100 && (TREE_CODE (type
) == INTEGER_TYPE
12101 || TREE_CODE (type
) == ENUMERAL_TYPE
)
12102 && TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
12103 DECL_ARG_TYPE (decl
) = integer_type_node
;
12104 if (!any_error
&& init
)
12107 init
= check_default_argument (decl
, init
);
12112 if (decls
== NULL_TREE
)
12119 TREE_CHAIN (last_decl
) = decl
;
12122 list_node
= tree_cons (init
, type
, NULL_TREE
);
12123 if (result
== NULL_TREE
)
12125 result
= list_node
;
12126 last_result
= result
;
12130 TREE_CHAIN (last_result
) = list_node
;
12131 last_result
= list_node
;
12135 TREE_CHAIN (last_result
) = NULL_TREE
;
12136 /* If there are no parameters, and the function does not end
12137 with `...', then last_decl will be NULL_TREE. */
12138 if (last_decl
!= NULL_TREE
)
12139 TREE_CHAIN (last_decl
) = NULL_TREE
;
12143 last_function_parms
= decls
;
12148 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
12149 FUNCTION_TYPE with the newly parsed version of its default argument, which
12150 was previously digested as text. See snarf_defarg et al in lex.c. */
12153 replace_defarg (arg
, init
)
12156 if (! processing_template_decl
12157 && ! can_convert_arg (TREE_VALUE (arg
), TREE_TYPE (init
), init
))
12158 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
12159 TREE_TYPE (init
), TREE_VALUE (arg
));
12160 TREE_PURPOSE (arg
) = init
;
12163 /* D is a constructor or overloaded `operator='. Returns non-zero if
12164 D's arguments allow it to be a copy constructor, or copy assignment
12173 if (!DECL_FUNCTION_MEMBER_P (d
))
12176 t
= FUNCTION_ARG_CHAIN (d
);
12177 if (DECL_CONSTRUCTOR_P (d
) && DECL_HAS_IN_CHARGE_PARM_P (d
))
12178 t
= TREE_CHAIN (t
);
12179 if (t
&& TREE_CODE (TREE_VALUE (t
)) == REFERENCE_TYPE
12180 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t
)))
12181 == DECL_CONTEXT (d
))
12182 && (TREE_CHAIN (t
) == NULL_TREE
12183 || TREE_CHAIN (t
) == void_list_node
12184 || TREE_PURPOSE (TREE_CHAIN (t
))))
12189 /* These memoizing functions keep track of special properties which
12190 a class may have. `grok_ctor_properties' notices whether a class
12191 has a constructor of the form X(X&), and also complains
12192 if the class has a constructor of the form X(X).
12193 `grok_op_properties' takes notice of the various forms of
12194 operator= which are defined, as well as what sorts of type conversion
12195 may apply. Both functions take a FUNCTION_DECL as an argument. */
12198 grok_ctor_properties (ctype
, decl
)
12201 tree parmtypes
= FUNCTION_ARG_CHAIN (decl
);
12202 tree parmtype
= parmtypes
? TREE_VALUE (parmtypes
) : void_type_node
;
12204 /* When a type has virtual baseclasses, a magical first int argument is
12205 added to any ctor so we can tell if the class has been initialized
12206 yet. This could screw things up in this function, so we deliberately
12207 ignore the leading int if we're in that situation. */
12208 if (DECL_HAS_IN_CHARGE_PARM_P (decl
))
12210 my_friendly_assert (parmtypes
12211 && TREE_VALUE (parmtypes
) == integer_type_node
,
12213 parmtypes
= TREE_CHAIN (parmtypes
);
12214 parmtype
= TREE_VALUE (parmtypes
);
12219 A non-template constructor for class X is a copy constructor if
12220 its first parameter is of type X&, const X&, volatile X& or const
12221 volatile X&, and either there are no other parameters or else all
12222 other parameters have default arguments. */
12223 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
12224 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype
)) == ctype
12225 && (TREE_CHAIN (parmtypes
) == NULL_TREE
12226 || TREE_CHAIN (parmtypes
) == void_list_node
12227 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
12228 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12229 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12231 TYPE_HAS_INIT_REF (ctype
) = 1;
12232 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12233 TYPE_HAS_CONST_INIT_REF (ctype
) = 1;
12237 A declaration of a constructor for a class X is ill-formed if its
12238 first parameter is of type (optionally cv-qualified) X and either
12239 there are no other parameters or else all other parameters have
12242 We *don't* complain about member template instantiations that
12243 have this form, though; they can occur as we try to decide what
12244 constructor to use during overload resolution. Since overload
12245 resolution will never prefer such a constructor to the
12246 non-template copy constructor (which is either explicitly or
12247 implicitly defined), there's no need to worry about their
12248 existence. Theoretically, they should never even be
12249 instantiated, but that's hard to forestall. */
12250 else if (TYPE_MAIN_VARIANT (parmtype
) == ctype
12251 && (TREE_CHAIN (parmtypes
) == NULL_TREE
12252 || TREE_CHAIN (parmtypes
) == void_list_node
12253 || TREE_PURPOSE (TREE_CHAIN (parmtypes
)))
12254 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12255 && is_member_template (DECL_TI_TEMPLATE (decl
))))
12257 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12259 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl
), ctype
);
12262 else if (TREE_CODE (parmtype
) == VOID_TYPE
12263 || TREE_PURPOSE (parmtypes
) != NULL_TREE
)
12264 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype
) = 1;
12269 /* An operator with this code is unary, but can also be binary. */
12273 enum tree_code code
;
12275 return (code
== INDIRECT_REF
12276 || code
== ADDR_EXPR
12277 || code
== CONVERT_EXPR
12278 || code
== NEGATE_EXPR
12279 || code
== PREINCREMENT_EXPR
12280 || code
== PREDECREMENT_EXPR
);
12283 /* An operator with this name can only be unary. */
12287 enum tree_code code
;
12289 return (code
== TRUTH_NOT_EXPR
12290 || code
== BIT_NOT_EXPR
12291 || code
== COMPONENT_REF
12292 || code
== TYPE_EXPR
);
12295 /* Do a little sanity-checking on how they declared their operator. */
12298 grok_op_properties (decl
, virtualp
, friendp
)
12300 int virtualp
, friendp
;
12302 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12304 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12305 tree name
= DECL_NAME (decl
);
12306 enum tree_code operator_code
;
12309 /* Count the number of arguments. */
12310 for (argtype
= argtypes
, arity
= 0;
12311 argtype
&& argtype
!= void_list_node
;
12312 argtype
= TREE_CHAIN (argtype
))
12315 if (current_class_type
== NULL_TREE
)
12318 if (DECL_CONV_FN_P (decl
))
12319 operator_code
= TYPE_EXPR
;
12323 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGING, ARITY, ASSN_P) \
12324 if (ansi_opname (CODE) == name) \
12326 operator_code = CODE; \
12329 else if (ansi_assopname (CODE) == name) \
12331 operator_code = CODE; \
12332 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12336 #include "operators.def"
12337 #undef DEF_OPERATOR
12339 my_friendly_abort (20000527);
12342 my_friendly_assert (operator_code
!= LAST_CPLUS_TREE_CODE
, 20000526);
12343 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12347 switch (operator_code
)
12350 TYPE_OVERLOADS_CALL_EXPR (current_class_type
) = 1;
12354 TYPE_OVERLOADS_ARRAY_REF (current_class_type
) = 1;
12357 case COMPONENT_REF
:
12359 TYPE_OVERLOADS_ARROW (current_class_type
) = 1;
12363 TYPE_HAS_NEW_OPERATOR (current_class_type
) = 1;
12367 TYPE_GETS_DELETE (current_class_type
) |= 1;
12371 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type
) = 1;
12374 case VEC_DELETE_EXPR
:
12375 TYPE_GETS_DELETE (current_class_type
) |= 2;
12383 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12385 /* When the compiler encounters the definition of A::operator new, it
12386 doesn't look at the class declaration to find out if it's static. */
12388 revert_static_member_fn (decl
);
12390 /* Take care of function decl if we had syntax errors. */
12391 if (argtypes
== NULL_TREE
)
12393 = build_function_type (ptr_type_node
,
12394 hash_tree_chain (integer_type_node
,
12397 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12399 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12402 revert_static_member_fn (decl
);
12404 if (argtypes
== NULL_TREE
)
12406 = build_function_type (void_type_node
,
12407 hash_tree_chain (ptr_type_node
,
12410 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12414 /* An operator function must either be a non-static member function
12415 or have at least one parameter of a class, a reference to a class,
12416 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12417 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12419 if (operator_code
== TYPE_EXPR
12420 || operator_code
== CALL_EXPR
12421 || operator_code
== COMPONENT_REF
12422 || operator_code
== ARRAY_REF
12423 || operator_code
== NOP_EXPR
)
12424 cp_error ("`%D' must be a nonstatic member function", decl
);
12429 if (DECL_STATIC_FUNCTION_P (decl
))
12430 cp_error ("`%D' must be either a non-static member function or a non-member function", decl
);
12433 for (; TREE_CODE (TREE_VALUE (p
)) != VOID_TYPE
; p
= TREE_CHAIN (p
))
12435 tree arg
= TREE_VALUE (p
);
12436 if (TREE_CODE (arg
) == REFERENCE_TYPE
)
12437 arg
= TREE_TYPE (arg
);
12439 /* This lets bad template code slip through. */
12440 if (IS_AGGR_TYPE (arg
)
12441 || TREE_CODE (arg
) == ENUMERAL_TYPE
12442 || TREE_CODE (arg
) == TEMPLATE_TYPE_PARM
12443 || TREE_CODE (arg
) == BOUND_TEMPLATE_TEMPLATE_PARM
)
12447 ("`%D' must have an argument of class or enumerated type",
12454 if (operator_code
== CALL_EXPR
)
12455 return; /* No restrictions on args. */
12457 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
12459 tree t
= TREE_TYPE (name
);
12462 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12463 const char *what
= 0;
12466 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12468 if (TREE_CODE (t
) == VOID_TYPE
)
12470 else if (t
== current_class_type
)
12471 what
= "the same type";
12472 /* Don't force t to be complete here. */
12473 else if (IS_AGGR_TYPE (t
)
12474 && COMPLETE_TYPE_P (t
)
12475 && DERIVED_FROM_P (t
, current_class_type
))
12476 what
= "a base class";
12479 warning ("conversion to %s%s will never use a type conversion operator",
12480 ref
? "a reference to " : "", what
);
12484 if (DECL_ASSIGNMENT_OPERATOR_P (decl
)
12485 && operator_code
== NOP_EXPR
)
12489 if (arity
!= 2 && methodp
)
12491 cp_error ("`%D' must take exactly one argument", decl
);
12494 parmtype
= TREE_VALUE (TREE_CHAIN (argtypes
));
12498 A user-declared copy assignment operator X::operator= is
12499 a non-static non-template member function of class X with
12500 exactly one parameter of type X, X&, const X&, volatile
12501 X& or const volatile X&. */
12502 if (copy_assignment_arg_p (parmtype
, virtualp
)
12503 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
12504 && is_member_template (DECL_TI_TEMPLATE (decl
)))
12507 TYPE_HAS_ASSIGN_REF (current_class_type
) = 1;
12508 if (TREE_CODE (parmtype
) != REFERENCE_TYPE
12509 || CP_TYPE_CONST_P (TREE_TYPE (parmtype
)))
12510 TYPE_HAS_CONST_ASSIGN_REF (current_class_type
) = 1;
12513 else if (operator_code
== COND_EXPR
)
12516 cp_error ("ISO C++ prohibits overloading operator ?:");
12518 else if (ambi_op_p (operator_code
))
12521 /* We pick the one-argument operator codes by default, so
12522 we don't have to change anything. */
12524 else if (arity
== 2)
12526 /* If we thought this was a unary operator, we now know
12527 it to be a binary operator. */
12528 switch (operator_code
)
12531 operator_code
= MULT_EXPR
;
12535 operator_code
= BIT_AND_EXPR
;
12539 operator_code
= PLUS_EXPR
;
12543 operator_code
= MINUS_EXPR
;
12546 case PREINCREMENT_EXPR
:
12547 operator_code
= POSTINCREMENT_EXPR
;
12550 case PREDECREMENT_EXPR
:
12551 operator_code
= POSTDECREMENT_EXPR
;
12555 my_friendly_abort (20000527);
12558 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12560 if ((operator_code
== POSTINCREMENT_EXPR
12561 || operator_code
== POSTDECREMENT_EXPR
)
12562 && ! processing_template_decl
12563 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12566 cp_error ("postfix `%D' must take `int' as its argument",
12570 ("postfix `%D' must take `int' as its second argument",
12577 cp_error ("`%D' must take either zero or one argument", decl
);
12579 cp_error ("`%D' must take either one or two arguments", decl
);
12582 /* More Effective C++ rule 6. */
12584 && (operator_code
== POSTINCREMENT_EXPR
12585 || operator_code
== POSTDECREMENT_EXPR
12586 || operator_code
== PREINCREMENT_EXPR
12587 || operator_code
== PREDECREMENT_EXPR
))
12589 tree arg
= TREE_VALUE (argtypes
);
12590 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12591 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12592 arg
= TREE_TYPE (arg
);
12593 arg
= TYPE_MAIN_VARIANT (arg
);
12594 if (operator_code
== PREINCREMENT_EXPR
12595 || operator_code
== PREDECREMENT_EXPR
)
12597 if (TREE_CODE (ret
) != REFERENCE_TYPE
12598 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12600 cp_warning ("prefix `%D' should return `%T'", decl
,
12601 build_reference_type (arg
));
12605 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12606 cp_warning ("postfix `%D' should return `%T'", decl
, arg
);
12610 else if (unary_op_p (operator_code
))
12615 cp_error ("`%D' must take `void'", decl
);
12617 cp_error ("`%D' must take exactly one argument", decl
);
12620 else /* if (binary_op_p (operator_code)) */
12625 cp_error ("`%D' must take exactly one argument", decl
);
12627 cp_error ("`%D' must take exactly two arguments", decl
);
12630 /* More Effective C++ rule 7. */
12632 && (operator_code
== TRUTH_ANDIF_EXPR
12633 || operator_code
== TRUTH_ORIF_EXPR
12634 || operator_code
== COMPOUND_EXPR
))
12635 cp_warning ("user-defined `%D' always evaluates both arguments",
12639 /* Effective C++ rule 23. */
12642 && (operator_code
== PLUS_EXPR
12643 || operator_code
== MINUS_EXPR
12644 || operator_code
== TRUNC_DIV_EXPR
12645 || operator_code
== MULT_EXPR
)
12646 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12647 cp_warning ("`%D' should return by value", decl
);
12650 for (; argtypes
&& argtypes
!= void_list_node
;
12651 argtypes
= TREE_CHAIN (argtypes
))
12652 if (TREE_PURPOSE (argtypes
))
12654 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12655 if (operator_code
== POSTINCREMENT_EXPR
12656 || operator_code
== POSTDECREMENT_EXPR
)
12659 cp_pedwarn ("`%D' cannot have default arguments", decl
);
12662 cp_error ("`%D' cannot have default arguments", decl
);
12668 static const char *
12670 enum tag_types code
;
12683 my_friendly_abort (981122);
12687 /* Get the struct, enum or union (CODE says which) with tag NAME.
12688 Define the tag as a forward-reference if it is not defined.
12690 C++: If a class derivation is given, process it here, and report
12691 an error if multiple derivation declarations are not identical.
12693 If this is a definition, come in through xref_tag and only look in
12694 the current frame for the name (since C++ allows new names in any
12698 xref_tag (code_type_node
, name
, globalize
)
12699 tree code_type_node
;
12703 enum tag_types tag_code
;
12704 enum tree_code code
;
12705 register tree ref
, t
;
12706 struct binding_level
*b
= current_binding_level
;
12708 tree attributes
= NULL_TREE
;
12709 tree context
= NULL_TREE
;
12711 /* If we are called from the parser, code_type_node will sometimes be a
12712 TREE_LIST. This indicates that the user wrote
12713 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12715 if (TREE_CODE (code_type_node
) == TREE_LIST
)
12717 attributes
= TREE_PURPOSE (code_type_node
);
12718 code_type_node
= TREE_VALUE (code_type_node
);
12721 tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12726 code
= RECORD_TYPE
;
12732 code
= ENUMERAL_TYPE
;
12735 my_friendly_abort (18);
12738 /* If a cross reference is requested, look up the type
12739 already defined for this tag and return it. */
12743 name
= TYPE_IDENTIFIER (t
);
12747 t
= IDENTIFIER_TYPE_VALUE (name
);
12749 /* Warn about 'friend struct Inherited;' doing the wrong thing. */
12750 if (t
&& globalize
&& TREE_CODE (t
) == TYPENAME_TYPE
)
12752 static int explained
;
12754 cp_warning ("`%s %T' declares a new type at namespace scope;\n\
12755 to refer to the inherited type, say `%s %T::%T'%s",
12756 tag_name (tag_code
), name
, tag_name (tag_code
),
12757 constructor_name (current_class_type
), TYPE_IDENTIFIER (t
),
12759 (names from dependent base classes are not visible to unqualified name lookup)"
12765 if (t
&& TREE_CODE (t
) != code
&& TREE_CODE (t
) != TEMPLATE_TYPE_PARM
12766 && TREE_CODE (t
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
12771 /* If we know we are defining this tag, only look it up in
12772 this scope and don't try to find it as a type. */
12773 ref
= lookup_tag (code
, name
, b
, 1);
12779 /* [dcl.type.elab] If the identifier resolves to a
12780 typedef-name or a template type-parameter, the
12781 elaborated-type-specifier is ill-formed. */
12782 if (t
!= TYPE_MAIN_VARIANT (t
)
12783 || (CLASS_TYPE_P (t
) && TYPE_WAS_ANONYMOUS (t
)))
12784 cp_pedwarn ("using typedef-name `%D' after `%s'",
12785 TYPE_NAME (t
), tag_name (tag_code
));
12786 else if (TREE_CODE (t
) == TEMPLATE_TYPE_PARM
)
12787 cp_error ("using template type parameter `%T' after `%s'",
12788 t
, tag_name (tag_code
));
12793 ref
= lookup_tag (code
, name
, b
, 0);
12797 /* Try finding it as a type declaration. If that wins,
12799 ref
= lookup_name (name
, 1);
12801 if (ref
!= NULL_TREE
12802 && processing_template_decl
12803 && DECL_CLASS_TEMPLATE_P (ref
)
12804 && template_class_depth (current_class_type
) == 0)
12805 /* Since GLOBALIZE is true, we're declaring a global
12806 template, so we want this type. */
12807 ref
= DECL_TEMPLATE_RESULT (ref
);
12809 if (ref
&& TREE_CODE (ref
) == TYPE_DECL
12810 && TREE_CODE (TREE_TYPE (ref
)) == code
)
12811 ref
= TREE_TYPE (ref
);
12816 if (ref
&& current_class_type
12817 && template_class_depth (current_class_type
)
12818 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12820 /* Since GLOBALIZE is non-zero, we are not looking at a
12821 definition of this tag. Since, in addition, we are currently
12822 processing a (member) template declaration of a template
12823 class, we must be very careful; consider:
12830 { template <class V>
12831 friend struct S1; };
12833 Here, the S2::S1 declaration should not be confused with the
12834 outer declaration. In particular, the inner version should
12835 have a template parameter of level 2, not level 1. This
12836 would be particularly important if the member declaration
12839 template <class V = U> friend struct S1;
12841 say, when we should tsubst into `U' when instantiating
12842 S2. On the other hand, when presented with:
12852 we must find the inner binding eventually. We
12853 accomplish this by making sure that the new type we
12854 create to represent this declaration has the right
12856 context
= TYPE_CONTEXT (ref
);
12863 /* If no such tag is yet defined, create a forward-reference node
12864 and record it as the "definition".
12865 When a real declaration of this type is found,
12866 the forward-reference will be altered into a real type. */
12867 if (code
== ENUMERAL_TYPE
)
12869 cp_error ("use of enum `%#D' without previous declaration", name
);
12871 ref
= make_node (ENUMERAL_TYPE
);
12873 /* Give the type a default layout like unsigned int
12874 to avoid crashing if it does not get defined. */
12875 TYPE_MODE (ref
) = TYPE_MODE (unsigned_type_node
);
12876 TYPE_ALIGN (ref
) = TYPE_ALIGN (unsigned_type_node
);
12877 TYPE_USER_ALIGN (ref
) = 0;
12878 TREE_UNSIGNED (ref
) = 1;
12879 TYPE_PRECISION (ref
) = TYPE_PRECISION (unsigned_type_node
);
12880 TYPE_MIN_VALUE (ref
) = TYPE_MIN_VALUE (unsigned_type_node
);
12881 TYPE_MAX_VALUE (ref
) = TYPE_MAX_VALUE (unsigned_type_node
);
12883 /* Enable us to recognize when a type is created in class context.
12884 To do nested classes correctly, this should probably be cleared
12885 out when we leave this classes scope. Currently this in only
12886 done in `start_enum'. */
12888 pushtag (name
, ref
, globalize
);
12892 struct binding_level
*old_b
= class_binding_level
;
12894 ref
= make_aggr_type (code
);
12895 TYPE_CONTEXT (ref
) = context
;
12897 #ifdef NONNESTED_CLASSES
12898 /* Class types don't nest the way enums do. */
12899 class_binding_level
= (struct binding_level
*)0;
12901 pushtag (name
, ref
, globalize
);
12902 class_binding_level
= old_b
;
12907 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (ref
))
12908 redeclare_class_template (ref
, current_template_parms
);
12911 /* Until the type is defined, tentatively accept whatever
12912 structure tag the user hands us. */
12913 if (!COMPLETE_TYPE_P (ref
)
12914 && ref
!= current_class_type
12915 /* Have to check this, in case we have contradictory tag info. */
12916 && IS_AGGR_TYPE_CODE (TREE_CODE (ref
)))
12918 if (tag_code
== class_type
)
12919 CLASSTYPE_DECLARED_CLASS (ref
) = 1;
12920 else if (tag_code
== record_type
)
12921 CLASSTYPE_DECLARED_CLASS (ref
) = 0;
12924 TREE_TYPE (ref
) = attributes
;
12930 xref_tag_from_type (old
, id
, globalize
)
12934 tree code_type_node
;
12936 if (TREE_CODE (old
) == RECORD_TYPE
)
12937 code_type_node
= (CLASSTYPE_DECLARED_CLASS (old
)
12938 ? class_type_node
: record_type_node
);
12940 code_type_node
= union_type_node
;
12942 if (id
== NULL_TREE
)
12943 id
= TYPE_IDENTIFIER (old
);
12945 return xref_tag (code_type_node
, id
, globalize
);
12948 /* REF is a type (named NAME), for which we have just seen some
12949 baseclasses. BINFO is a list of those baseclasses; the
12950 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12951 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12952 struct, or union. */
12955 xref_basetypes (code_type_node
, name
, ref
, binfo
)
12956 tree code_type_node
;
12960 /* In the declaration `A : X, Y, ... Z' we mark all the types
12961 (A, X, Y, ..., Z) so we can check for duplicates. */
12966 enum tag_types tag_code
= (enum tag_types
) tree_low_cst (code_type_node
, 1);
12968 if (tag_code
== union_type
)
12970 cp_error ("derived union `%T' invalid", ref
);
12974 len
= list_length (binfo
);
12976 /* First, make sure that any templates in base-classes are
12977 instantiated. This ensures that if we call ourselves recursively
12978 we do not get confused about which classes are marked and which
12980 for (base
= binfo
; base
; base
= TREE_CHAIN (base
))
12981 complete_type (TREE_VALUE (base
));
12983 SET_CLASSTYPE_MARKED (ref
);
12984 BINFO_BASETYPES (TYPE_BINFO (ref
)) = binfos
= make_tree_vec (len
);
12986 for (i
= 0; binfo
; binfo
= TREE_CHAIN (binfo
))
12988 /* The base of a derived struct is public by default. */
12990 = (TREE_PURPOSE (binfo
) == access_public_node
12991 || TREE_PURPOSE (binfo
) == access_public_virtual_node
12992 || (tag_code
!= class_type
12993 && (TREE_PURPOSE (binfo
) == access_default_node
12994 || TREE_PURPOSE (binfo
) == access_default_virtual_node
)));
12996 = (TREE_PURPOSE (binfo
) == access_protected_node
12997 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
);
12999 = (TREE_PURPOSE (binfo
) == access_private_virtual_node
13000 || TREE_PURPOSE (binfo
) == access_protected_virtual_node
13001 || TREE_PURPOSE (binfo
) == access_public_virtual_node
13002 || TREE_PURPOSE (binfo
) == access_default_virtual_node
);
13003 tree basetype
= TREE_VALUE (binfo
);
13006 if (basetype
&& TREE_CODE (basetype
) == TYPE_DECL
)
13007 basetype
= TREE_TYPE (basetype
);
13009 || (TREE_CODE (basetype
) != RECORD_TYPE
13010 && TREE_CODE (basetype
) != TYPENAME_TYPE
13011 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
13012 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
))
13014 cp_error ("base type `%T' fails to be a struct or class type",
13015 TREE_VALUE (binfo
));
13019 GNU_xref_hier (name
, basetype
, via_public
, via_virtual
, 0);
13021 /* This code replaces similar code in layout_basetypes.
13022 We put the complete_type first for implicit `typename'. */
13023 if (!COMPLETE_TYPE_P (basetype
)
13024 && ! (current_template_parms
&& uses_template_parms (basetype
)))
13026 cp_error ("base class `%T' has incomplete type", basetype
);
13031 if (CLASSTYPE_MARKED (basetype
))
13033 if (basetype
== ref
)
13034 cp_error ("recursive type `%T' undefined", basetype
);
13036 cp_error ("duplicate base type `%T' invalid", basetype
);
13040 if (TYPE_FOR_JAVA (basetype
)
13041 && (current_lang_stack
13042 == &VARRAY_TREE (current_lang_base
, 0)))
13043 TYPE_FOR_JAVA (ref
) = 1;
13045 /* Note that the BINFO records which describe individual
13046 inheritances are *not* shared in the lattice! They
13047 cannot be shared because a given baseclass may be
13048 inherited with different `accessibility' by different
13049 derived classes. (Each BINFO record describing an
13050 individual inheritance contains flags which say what
13051 the `accessibility' of that particular inheritance is.) */
13054 = make_binfo (size_zero_node
, basetype
,
13055 CLASS_TYPE_P (basetype
)
13056 ? TYPE_BINFO_VTABLE (basetype
) : NULL_TREE
,
13057 CLASS_TYPE_P (basetype
)
13058 ? TYPE_BINFO_VIRTUALS (basetype
) : NULL_TREE
);
13060 TREE_VEC_ELT (binfos
, i
) = base_binfo
;
13061 TREE_VIA_PUBLIC (base_binfo
) = via_public
;
13062 TREE_VIA_PROTECTED (base_binfo
) = via_protected
;
13063 TREE_VIA_VIRTUAL (base_binfo
) = via_virtual
;
13064 BINFO_INHERITANCE_CHAIN (base_binfo
) = TYPE_BINFO (ref
);
13066 /* We need to unshare the binfos now so that lookups during class
13067 definition work. */
13068 unshare_base_binfos (base_binfo
);
13070 SET_CLASSTYPE_MARKED (basetype
);
13072 /* We are free to modify these bits because they are meaningless
13073 at top level, and BASETYPE is a top-level type. */
13074 if (via_virtual
|| TYPE_USES_VIRTUAL_BASECLASSES (basetype
))
13076 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
13077 /* Converting to a virtual base class requires looking
13078 up the offset of the virtual base. */
13079 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
13082 if (CLASS_TYPE_P (basetype
))
13084 TYPE_HAS_NEW_OPERATOR (ref
)
13085 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13086 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13087 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13088 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13089 /* If the base-class uses multiple inheritance, so do we. */
13090 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
13091 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
13092 /* Likewise, if converting to a base of the base may require
13093 code, then we may need to generate code to convert to a
13095 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
)
13096 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
);
13103 TREE_VEC_LENGTH (binfos
) = i
;
13105 BINFO_BASETYPES (TYPE_BINFO (ref
)) = NULL_TREE
;
13109 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
13110 /* If there is more than one non-empty they cannot be at the same
13112 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
13115 /* Unmark all the types. */
13117 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos
, i
)));
13118 CLEAR_CLASSTYPE_MARKED (ref
);
13120 /* Now that we know all the base-classes, set up the list of virtual
13122 get_vbase_types (ref
);
13126 /* Begin compiling the definition of an enumeration type.
13127 NAME is its name (or null if anonymous).
13128 Returns the type object, as yet incomplete.
13129 Also records info about it so that build_enumerator
13130 may be used to declare the individual values as they are read. */
13136 register tree enumtype
= NULL_TREE
;
13137 struct binding_level
*b
= current_binding_level
;
13139 /* If this is the real definition for a previous forward reference,
13140 fill in the contents in the same object that used to be the
13141 forward reference. */
13143 if (name
!= NULL_TREE
)
13144 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
13146 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13148 cp_error ("multiple definition of `%#T'", enumtype
);
13149 cp_error_at ("previous definition here", enumtype
);
13150 /* Clear out TYPE_VALUES, and start again. */
13151 TYPE_VALUES (enumtype
) = NULL_TREE
;
13155 enumtype
= make_node (ENUMERAL_TYPE
);
13156 pushtag (name
, enumtype
, 0);
13159 if (current_class_type
)
13160 TREE_ADDRESSABLE (b
->tags
) = 1;
13162 GNU_xref_decl (current_function_decl
, enumtype
);
13166 /* After processing and defining all the values of an enumeration type,
13167 install their decls in the enumeration type and finish it off.
13168 ENUMTYPE is the type object and VALUES a list of name-value pairs.
13169 Returns ENUMTYPE. */
13172 finish_enum (enumtype
)
13175 register tree minnode
= NULL_TREE
, maxnode
= NULL_TREE
;
13176 /* Calculate the maximum value of any enumerator in this type. */
13178 tree values
= TYPE_VALUES (enumtype
);
13183 for (pair
= values
; pair
; pair
= TREE_CHAIN (pair
))
13188 /* The TREE_VALUE is a CONST_DECL for this enumeration
13190 decl
= TREE_VALUE (pair
);
13194 Following the closing brace of an enum-specifier, each
13195 enumerator has the type of its enumeration. Prior to the
13196 closing brace, the type of each enumerator is the type of
13197 its initializing value. */
13198 TREE_TYPE (decl
) = enumtype
;
13200 /* The DECL_INITIAL will be NULL if we are processing a
13201 template declaration and this enumeration constant had no
13202 explicit initializer. */
13203 value
= DECL_INITIAL (decl
);
13204 if (value
&& !processing_template_decl
)
13206 /* Set the TREE_TYPE for the VALUE as well. That's so
13207 that when we call decl_constant_value we get an
13208 entity of the right type (but with the constant
13209 value). Since we shouldn't ever call
13210 decl_constant_value on a template type, there's no
13211 reason to do that when processing_template_decl.
13212 And, if the expression is something like a
13213 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
13214 wreak havoc on the intended type of the expression.
13216 Of course, there's also no point in trying to compute
13217 minimum or maximum values if we're in a template. */
13218 TREE_TYPE (value
) = enumtype
;
13221 minnode
= maxnode
= value
;
13222 else if (tree_int_cst_lt (maxnode
, value
))
13224 else if (tree_int_cst_lt (value
, minnode
))
13228 if (processing_template_decl
)
13229 /* If this is just a template, leave the CONST_DECL
13230 alone. That way tsubst_copy will find CONST_DECLs for
13231 CONST_DECLs, and not INTEGER_CSTs. */
13234 /* In the list we're building up, we want the enumeration
13235 values, not the CONST_DECLs. */
13236 TREE_VALUE (pair
) = value
;
13240 maxnode
= minnode
= integer_zero_node
;
13242 TYPE_VALUES (enumtype
) = nreverse (values
);
13244 if (processing_template_decl
)
13246 tree scope
= current_scope ();
13247 if (scope
&& TREE_CODE (scope
) == FUNCTION_DECL
)
13248 add_stmt (build_min (TAG_DEFN
, enumtype
));
13252 int unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
13253 int lowprec
= min_precision (minnode
, unsignedp
);
13254 int highprec
= min_precision (maxnode
, unsignedp
);
13255 int precision
= MAX (lowprec
, highprec
);
13258 TYPE_SIZE (enumtype
) = NULL_TREE
;
13260 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
13262 TYPE_PRECISION (enumtype
) = precision
;
13264 fixup_unsigned_type (enumtype
);
13266 fixup_signed_type (enumtype
);
13268 if (flag_short_enums
|| (precision
> TYPE_PRECISION (integer_type_node
)))
13269 /* Use the width of the narrowest normal C type which is wide
13271 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (type_for_size
13274 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (integer_type_node
);
13276 TYPE_SIZE (enumtype
) = 0;
13277 layout_type (enumtype
);
13279 /* Fix up all variant types of this enum type. */
13280 for (tem
= TYPE_MAIN_VARIANT (enumtype
); tem
;
13281 tem
= TYPE_NEXT_VARIANT (tem
))
13283 TYPE_VALUES (tem
) = TYPE_VALUES (enumtype
);
13284 TYPE_MIN_VALUE (tem
) = TYPE_MIN_VALUE (enumtype
);
13285 TYPE_MAX_VALUE (tem
) = TYPE_MAX_VALUE (enumtype
);
13286 TYPE_SIZE (tem
) = TYPE_SIZE (enumtype
);
13287 TYPE_SIZE_UNIT (tem
) = TYPE_SIZE_UNIT (enumtype
);
13288 TYPE_MODE (tem
) = TYPE_MODE (enumtype
);
13289 TYPE_PRECISION (tem
) = TYPE_PRECISION (enumtype
);
13290 TYPE_ALIGN (tem
) = TYPE_ALIGN (enumtype
);
13291 TYPE_USER_ALIGN (tem
) = TYPE_USER_ALIGN (enumtype
);
13292 TREE_UNSIGNED (tem
) = TREE_UNSIGNED (enumtype
);
13295 /* Finish debugging output for this type. */
13296 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13302 /* Build and install a CONST_DECL for an enumeration constant of the
13303 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13304 Assignment of sequential values by default is handled here. */
13307 build_enumerator (name
, value
, enumtype
)
13317 /* Remove no-op casts from the value. */
13319 STRIP_TYPE_NOPS (value
);
13321 if (! processing_template_decl
)
13323 /* Validate and default VALUE. */
13324 if (value
!= NULL_TREE
)
13326 value
= decl_constant_value (value
);
13328 if (TREE_CODE (value
) == INTEGER_CST
)
13330 value
= default_conversion (value
);
13331 constant_expression_warning (value
);
13335 cp_error ("enumerator value for `%D' not integer constant", name
);
13340 /* Default based on previous value. */
13341 if (value
== NULL_TREE
&& ! processing_template_decl
)
13345 if (TYPE_VALUES (enumtype
))
13347 /* The next value is the previous value ... */
13348 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13349 /* ... plus one. */
13350 value
= cp_build_binary_op (PLUS_EXPR
,
13354 if (tree_int_cst_lt (value
, prev_value
))
13355 cp_error ("overflow in enumeration values at `%D'", name
);
13358 value
= integer_zero_node
;
13361 /* Remove no-op casts from the value. */
13363 STRIP_TYPE_NOPS (value
);
13365 /* To fix MAX_VAL enum consts. (bkoz) */
13366 TREE_TYPE (value
) = integer_type_node
;
13370 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13371 Even in other cases, we will later (in finish_enum) be setting
13372 the type of VALUE. But, we don't need to make a copy if this
13373 VALUE is one of the enumeration constants for this same
13374 enumeration type. */
13375 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13376 if (TREE_VALUE (values
) == value
)
13378 /* If we didn't break out of the loop, then we do need a copy. */
13379 if (!values
&& value
)
13380 value
= copy_node (value
);
13382 /* C++ associates enums with global, function, or class declarations. */
13383 context
= current_scope ();
13385 /* Build the actual enumeration constant. Note that the enumeration
13386 constants have the type of their initializers until the
13387 enumeration is complete:
13391 Following the closing brace of an enum-specifier, each enumer-
13392 ator has the type of its enumeration. Prior to the closing
13393 brace, the type of each enumerator is the type of its
13394 initializing value.
13396 In finish_enum we will reset the type. Of course, if we're
13397 processing a template, there may be no value. */
13398 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13400 if (context
&& context
== current_class_type
)
13401 /* This enum declaration is local to the class. We need the full
13402 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13403 decl
= build_lang_decl (CONST_DECL
, name
, type
);
13405 /* It's a global enum, or it's local to a function. (Note local to
13406 a function could mean local to a class method. */
13407 decl
= build_decl (CONST_DECL
, name
, type
);
13409 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
13410 DECL_INITIAL (decl
) = value
;
13411 TREE_READONLY (decl
) = 1;
13413 if (context
&& context
== current_class_type
)
13414 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13415 on the TYPE_FIELDS list for `S'. (That's so that you can say
13416 things like `S::i' later.) */
13417 finish_member_declaration (decl
);
13421 GNU_xref_decl (current_function_decl
, decl
);
13424 /* Add this enumeration constant to the list for this type. */
13425 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13429 /* We're defining DECL. Make sure that it's type is OK. */
13432 check_function_type (decl
, current_function_parms
)
13434 tree current_function_parms
;
13436 tree fntype
= TREE_TYPE (decl
);
13437 tree return_type
= complete_type (TREE_TYPE (fntype
));
13439 /* In a function definition, arg types must be complete. */
13440 require_complete_types_for_parms (current_function_parms
);
13442 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13444 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
13446 /* Make it return void instead, but don't change the
13447 type of the DECL_RESULT, in case we have a named return value. */
13448 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13450 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
13452 = build_cplus_method_type (ctype
,
13454 FUNCTION_ARG_CHAIN (decl
));
13458 = build_function_type (void_type_node
,
13459 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
13461 = build_exception_variant (fntype
,
13462 TYPE_RAISES_EXCEPTIONS (fntype
));
13465 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13468 /* Create the FUNCTION_DECL for a function definition.
13469 DECLSPECS and DECLARATOR are the parts of the declaration;
13470 they describe the function's name and the type it returns,
13471 but twisted together in a fashion that parallels the syntax of C.
13473 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13474 DECLARATOR is really the DECL for the function we are about to
13475 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13476 indicating that the function is an inline defined in-class.
13478 This function creates a binding context for the function body
13479 as well as setting up the FUNCTION_DECL in current_function_decl.
13481 Returns 1 on success. If the DECLARATOR is not suitable for a function
13482 (it defines a datum instead), we return 0, which tells
13483 yyparse to report a parse error.
13485 For C++, we must first check whether that datum makes any sense.
13486 For example, "class A local_a(1,2);" means that variable local_a
13487 is an aggregate of type A, which should have a constructor
13488 applied to it with the argument list [1, 2]. */
13491 start_function (declspecs
, declarator
, attrs
, flags
)
13492 tree declspecs
, declarator
, attrs
;
13496 tree ctype
= NULL_TREE
;
13499 extern int have_extern_spec
;
13500 extern int used_extern_spec
;
13501 int doing_friend
= 0;
13502 struct binding_level
*bl
;
13503 tree current_function_parms
;
13505 /* Sanity check. */
13506 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
13507 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
13509 /* This should only be done once on the top most decl. */
13510 if (have_extern_spec
&& !used_extern_spec
)
13512 declspecs
= decl_tree_cons (NULL_TREE
, get_identifier ("extern"), declspecs
);
13513 used_extern_spec
= 1;
13516 if (flags
& SF_PRE_PARSED
)
13518 decl1
= declarator
;
13520 fntype
= TREE_TYPE (decl1
);
13521 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13522 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13524 /* ISO C++ 11.4/5. A friend function defined in a class is in
13525 the (lexical) scope of the class in which it is defined. */
13526 if (!ctype
&& DECL_FRIEND_P (decl1
))
13528 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13530 /* CTYPE could be null here if we're dealing with a template;
13531 for example, `inline friend float foo()' inside a template
13532 will have no CTYPE set. */
13533 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13539 last_function_parms
= DECL_ARGUMENTS (decl1
);
13540 last_function_parm_tags
= NULL_TREE
;
13544 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, NULL_TREE
);
13545 /* If the declarator is not suitable for a function definition,
13546 cause a syntax error. */
13547 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
) return 0;
13549 fntype
= TREE_TYPE (decl1
);
13551 restype
= TREE_TYPE (fntype
);
13552 if (CLASS_TYPE_P (restype
) && !CLASSTYPE_GOT_SEMICOLON (restype
))
13554 cp_error ("semicolon missing after declaration of `%#T'", restype
);
13555 shadow_tag (build_tree_list (NULL_TREE
, restype
));
13556 CLASSTYPE_GOT_SEMICOLON (restype
) = 1;
13557 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
13558 fntype
= build_function_type (integer_type_node
,
13559 TYPE_ARG_TYPES (fntype
));
13561 fntype
= build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype
), TREE_READONLY (decl1
), TREE_SIDE_EFFECTS (decl1
)),
13563 TYPE_ARG_TYPES (fntype
));
13564 TREE_TYPE (decl1
) = fntype
;
13567 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13568 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13569 else if (DECL_MAIN_P (decl1
))
13571 /* If this doesn't return integer_type, complain. */
13572 if (TREE_TYPE (TREE_TYPE (decl1
)) != integer_type_node
)
13574 if (pedantic
|| warn_return_type
)
13575 pedwarn ("return type for `main' changed to `int'");
13576 TREE_TYPE (decl1
) = fntype
= default_function_type
;
13581 /* Sometimes we don't notice that a function is a static member, and
13582 build a METHOD_TYPE for it. Fix that up now. */
13583 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13584 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
13586 revert_static_member_fn (decl1
);
13587 last_function_parms
= TREE_CHAIN (last_function_parms
);
13591 /* Warn if function was previously implicitly declared
13592 (but not if we warned then). */
13593 if (! warn_implicit
13594 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)) != NULL_TREE
)
13595 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1
)));
13597 /* Set up current_class_type, and enter the scope of the class, if
13600 push_nested_class (ctype
, 1);
13601 else if (DECL_STATIC_FUNCTION_P (decl1
))
13602 push_nested_class (DECL_CONTEXT (decl1
), 2);
13604 /* Now that we have entered the scope of the class, we must restore
13605 the bindings for any template parameters surrounding DECL1, if it
13606 is an inline member template. (Order is important; consider the
13607 case where a template parameter has the same name as a field of
13608 the class.) It is not until after this point that
13609 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13610 if (flags
& SF_INCLASS_INLINE
)
13611 maybe_begin_member_template_processing (decl1
);
13613 /* Effective C++ rule 15. */
13615 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13616 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13617 cp_warning ("`operator=' should return a reference to `*this'");
13619 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13620 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13621 if (!DECL_INITIAL (decl1
))
13622 DECL_INITIAL (decl1
) = error_mark_node
;
13624 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13625 SET_DEFAULT_DECL_ATTRIBUTES (decl1
, attrs
);
13628 /* This function exists in static storage.
13629 (This does not mean `static' in the C sense!) */
13630 TREE_STATIC (decl1
) = 1;
13632 /* We must call push_template_decl after current_class_type is set
13633 up. (If we are processing inline definitions after exiting a
13634 class scope, current_class_type will be NULL_TREE until set above
13635 by push_nested_class.) */
13636 if (processing_template_decl
)
13637 decl1
= push_template_decl (decl1
);
13639 /* We are now in the scope of the function being defined. */
13640 current_function_decl
= decl1
;
13642 /* Save the parm names or decls from this function's declarator
13643 where store_parm_decls will find them. */
13644 current_function_parms
= last_function_parms
;
13645 current_function_parm_tags
= last_function_parm_tags
;
13647 /* Make sure the parameter and return types are reasonable. When
13648 you declare a function, these types can be incomplete, but they
13649 must be complete when you define the function. */
13650 if (! processing_template_decl
)
13651 check_function_type (decl1
, current_function_parms
);
13653 /* Build the return declaration for the function. */
13654 restype
= TREE_TYPE (fntype
);
13655 if (!processing_template_decl
)
13657 if (!DECL_RESULT (decl1
))
13659 DECL_RESULT (decl1
)
13660 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13661 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype
),
13662 DECL_RESULT (decl1
));
13666 /* Just use `void'. Nobody will ever look at this anyhow. */
13667 DECL_RESULT (decl1
) = build_decl (RESULT_DECL
, 0, void_type_node
);
13669 /* Initialize RTL machinery. We cannot do this until
13670 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13671 even when processing a template; this is how we get
13672 CFUN set up, and our per-function variables initialized. */
13673 bl
= current_binding_level
;
13674 init_function_start (decl1
, input_filename
, lineno
);
13675 current_binding_level
= bl
;
13677 /* Even though we're inside a function body, we still don't want to
13678 call expand_expr to calculate the size of a variable-sized array.
13679 We haven't necessarily assigned RTL to all variables yet, so it's
13680 not safe to try to expand expressions involving them. */
13681 immediate_size_expand
= 0;
13682 cfun
->x_dont_save_pending_sizes_p
= 1;
13684 /* Start the statement-tree, start the tree now. */
13685 begin_stmt_tree (&DECL_SAVED_TREE (decl1
));
13687 /* Let the user know we're compiling this function. */
13688 announce_function (decl1
);
13690 /* Record the decl so that the function name is defined.
13691 If we already have a decl for this name, and it is a FUNCTION_DECL,
13692 use the old decl. */
13693 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13695 /* A specialization is not used to guide overload resolution. */
13696 if (!DECL_TEMPLATE_SPECIALIZATION (decl1
)
13697 && ! DECL_FUNCTION_MEMBER_P (decl1
))
13698 decl1
= pushdecl (decl1
);
13701 /* We need to set the DECL_CONTEXT. */
13702 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13703 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13704 /* And make sure we have enough default args. */
13705 check_default_args (decl1
);
13707 fntype
= TREE_TYPE (decl1
);
13710 /* Reset these in case the call to pushdecl changed them. */
13711 current_function_decl
= decl1
;
13712 cfun
->decl
= decl1
;
13714 my_friendly_assert ((DECL_PENDING_INLINE_P (decl1
)
13715 || !DECL_SAVED_FUNCTION_DATA (decl1
)),
13718 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13720 /* We know that this was set up by `grokclassfn'. We do not
13721 wait until `store_parm_decls', since evil parse errors may
13722 never get us to that point. Here we keep the consistency
13723 between `current_class_type' and `current_class_ptr'. */
13724 tree t
= DECL_ARGUMENTS (decl1
);
13726 my_friendly_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
,
13728 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
13731 cp_function_chain
->x_current_class_ref
13732 = build_indirect_ref (t
, NULL_PTR
);
13733 cp_function_chain
->x_current_class_ptr
= t
;
13735 /* Constructors and destructors need to know whether they're "in
13736 charge" of initializing virtual base classes. */
13737 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13738 current_in_charge_parm
= TREE_CHAIN (t
);
13741 if (DECL_INTERFACE_KNOWN (decl1
))
13743 tree ctx
= decl_function_context (decl1
);
13745 if (DECL_NOT_REALLY_EXTERN (decl1
))
13746 DECL_EXTERNAL (decl1
) = 0;
13748 if (ctx
!= NULL_TREE
&& DECL_THIS_INLINE (ctx
)
13749 && TREE_PUBLIC (ctx
))
13750 /* This is a function in a local class in an extern inline
13752 comdat_linkage (decl1
);
13754 /* If this function belongs to an interface, it is public.
13755 If it belongs to someone else's interface, it is also external.
13756 This only affects inlines and template instantiations. */
13757 else if (interface_unknown
== 0
13758 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13759 || flag_alt_external_templates
))
13761 if (DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
)
13762 || processing_template_decl
)
13764 DECL_EXTERNAL (decl1
)
13766 || (DECL_THIS_INLINE (decl1
) && ! flag_implement_inlines
13767 && !DECL_VINDEX (decl1
)));
13769 /* For WIN32 we also want to put these in linkonce sections. */
13770 maybe_make_one_only (decl1
);
13773 DECL_EXTERNAL (decl1
) = 0;
13774 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13775 DECL_INTERFACE_KNOWN (decl1
) = 1;
13777 else if (interface_unknown
&& interface_only
13778 && (! DECL_TEMPLATE_INSTANTIATION (decl1
)
13779 || flag_alt_external_templates
))
13781 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13782 interface, we will have interface_only set but not
13783 interface_known. In that case, we don't want to use the normal
13784 heuristics because someone will supply a #pragma implementation
13785 elsewhere, and deducing it here would produce a conflict. */
13786 comdat_linkage (decl1
);
13787 DECL_EXTERNAL (decl1
) = 0;
13788 DECL_INTERFACE_KNOWN (decl1
) = 1;
13789 DECL_DEFER_OUTPUT (decl1
) = 1;
13793 /* This is a definition, not a reference.
13794 So clear DECL_EXTERNAL. */
13795 DECL_EXTERNAL (decl1
) = 0;
13797 if ((DECL_THIS_INLINE (decl1
) || DECL_TEMPLATE_INSTANTIATION (decl1
))
13798 && ! DECL_INTERFACE_KNOWN (decl1
)
13799 /* Don't try to defer nested functions for now. */
13800 && ! decl_function_context (decl1
))
13801 DECL_DEFER_OUTPUT (decl1
) = 1;
13803 DECL_INTERFACE_KNOWN (decl1
) = 1;
13807 current_binding_level
->parm_flag
= 1;
13810 cplus_decl_attributes (decl1
, NULL_TREE
, attrs
);
13812 /* We need to do this even if we aren't expanding yet so that
13813 assemble_external works. */
13814 make_function_rtl (decl1
);
13816 /* Promote the value to int before returning it. */
13817 if (C_PROMOTING_INTEGER_TYPE_P (restype
))
13818 restype
= type_promotes_to (restype
);
13820 /* If this fcn was already referenced via a block-scope `extern' decl
13821 (or an implicit decl), propagate certain information about the usage. */
13822 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1
)))
13823 TREE_ADDRESSABLE (decl1
) = 1;
13825 if (DECL_RESULT (decl1
) == NULL_TREE
)
13827 DECL_RESULT (decl1
)
13828 = build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
13829 TREE_READONLY (DECL_RESULT (decl1
)) = CP_TYPE_CONST_P (restype
);
13830 TREE_THIS_VOLATILE (DECL_RESULT (decl1
)) = CP_TYPE_VOLATILE_P (restype
);
13835 if (DECL_DESTRUCTOR_P (decl1
))
13837 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13838 DECL_CONTEXT (dtor_label
) = current_function_decl
;
13840 /* Under the old ABI we return `this' from constructors, so we make
13841 ordinary `return' statements in constructors jump to CTOR_LABEL;
13842 from there we return `this'. Under the new ABI, we don't bother
13843 with any of this. By not setting CTOR_LABEL the remainder of the
13844 machinery is automatically disabled. */
13845 else if (!flag_new_abi
&& DECL_CONSTRUCTOR_P (decl1
))
13847 ctor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13848 DECL_CONTEXT (ctor_label
) = current_function_decl
;
13851 store_parm_decls (current_function_parms
);
13856 /* Store the parameter declarations into the current function declaration.
13857 This is called after parsing the parameter declarations, before
13858 digesting the body of the function.
13860 Also install to binding contour return value identifier, if any. */
13863 store_parm_decls (current_function_parms
)
13864 tree current_function_parms
;
13866 register tree fndecl
= current_function_decl
;
13867 register tree parm
;
13868 int parms_have_cleanups
= 0;
13869 tree cleanups
= NULL_TREE
;
13871 /* This is a list of types declared among parms in a prototype. */
13872 tree parmtags
= current_function_parm_tags
;
13874 /* This is a chain of any other decls that came in among the parm
13875 declarations. If a parm is declared with enum {foo, bar} x;
13876 then CONST_DECLs for foo and bar are put here. */
13877 tree nonparms
= NULL_TREE
;
13879 if (current_function_parms
)
13881 /* This case is when the function was defined with an ANSI prototype.
13882 The parms already have decls, so we need not do anything here
13883 except record them as in effect
13884 and complain if any redundant old-style parm decls were written. */
13886 tree specparms
= current_function_parms
;
13889 /* Must clear this because it might contain TYPE_DECLs declared
13891 storedecls (NULL_TREE
);
13893 /* If we're doing semantic analysis, then we'll call pushdecl
13894 for each of these. We must do them in reverse order so that
13895 they end in the correct forward order. */
13896 specparms
= nreverse (specparms
);
13898 for (parm
= specparms
; parm
; parm
= next
)
13900 next
= TREE_CHAIN (parm
);
13901 if (TREE_CODE (parm
) == PARM_DECL
)
13905 if (DECL_NAME (parm
) == NULL_TREE
13906 || TREE_CODE (parm
) != VOID_TYPE
)
13909 cp_error ("parameter `%D' declared void", parm
);
13911 cleanup
= (processing_template_decl
13913 : maybe_build_cleanup (parm
));
13916 cleanups
= tree_cons (parm
, cleanup
, cleanups
);
13920 /* If we find an enum constant or a type tag,
13921 put it aside for the moment. */
13922 TREE_CHAIN (parm
) = NULL_TREE
;
13923 nonparms
= chainon (nonparms
, parm
);
13927 /* Get the decls in their original chain order and record in the
13928 function. This is all and only the PARM_DECLs that were
13929 pushed into scope by the loop above. */
13930 DECL_ARGUMENTS (fndecl
) = getdecls ();
13931 storetags (chainon (parmtags
, gettags ()));
13934 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13936 /* Now store the final chain of decls for the arguments
13937 as the decl-chain of the current lexical scope.
13938 Put the enumerators in as well, at the front so that
13939 DECL_ARGUMENTS is not modified. */
13940 storedecls (chainon (nonparms
, DECL_ARGUMENTS (fndecl
)));
13942 /* Now that we have initialized the parms, we can start their
13943 cleanups. We cannot do this before, since expand_decl_cleanup
13944 should not be called before the parm can be used. */
13947 finish_decl_cleanup (TREE_PURPOSE (cleanups
),
13948 TREE_VALUE (cleanups
));
13949 cleanups
= TREE_CHAIN (cleanups
);
13952 /* Create a binding contour which can be used to catch
13953 cleanup-generated temporaries. */
13954 if (parms_have_cleanups
)
13957 /* Do the starting of the exception specifications, if we have any. */
13958 if (flag_exceptions
&& !processing_template_decl
13959 && flag_enforce_eh_specs
13960 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
13961 current_eh_spec_try_block
= expand_start_eh_spec ();
13965 /* We have finished doing semantic analysis on DECL, but have not yet
13966 generated RTL for its body. Save away our current state, so that
13967 when we want to generate RTL later we know what to do. */
13970 save_function_data (decl
)
13973 struct cp_language_function
*f
;
13975 /* Save the language-specific per-function data so that we can
13976 get it back when we really expand this function. */
13977 my_friendly_assert (!DECL_PENDING_INLINE_P (decl
),
13981 f
= ((struct cp_language_function
*)
13982 xmalloc (sizeof (struct cp_language_function
)));
13983 bcopy ((char *) cp_function_chain
, (char *) f
,
13984 sizeof (struct cp_language_function
));
13985 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13987 /* Clear out the bits we don't need. */
13988 f
->base
.x_stmt_tree
.x_last_stmt
= NULL_TREE
;
13989 f
->base
.x_stmt_tree
.x_last_expr_type
= NULL_TREE
;
13990 f
->x_result_rtx
= NULL_RTX
;
13991 f
->x_named_label_uses
= NULL
;
13992 f
->bindings
= NULL
;
13994 /* When we get back here again, we will be expanding. */
13995 f
->x_expanding_p
= 1;
13997 /* If we've already decided that we cannot inline this function, we
13998 must remember that fact when we actually go to expand the
14000 f
->cannot_inline
= current_function_cannot_inline
;
14003 /* At the end of every constructor we generate to code to return
14004 `this'. Do that now. */
14007 finish_constructor_body ()
14009 /* Any return from a constructor will end up here. */
14011 add_stmt (build_stmt (LABEL_STMT
, ctor_label
));
14013 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
14014 generate the return, rather than a goto to CTOR_LABEL. */
14015 ctor_label
= NULL_TREE
;
14016 /* In check_return_expr we translate an empty return from a
14017 constructor to a return of `this'. */
14018 finish_return_stmt (NULL_TREE
);
14019 /* Mark the end of the constructor. */
14020 add_stmt (build_stmt (CTOR_STMT
));
14023 /* At the end of every destructor we generate code to restore virtual
14024 function tables to the values desired by base classes and to call
14025 to base class destructors. Do that now. */
14028 finish_destructor_body ()
14030 tree compound_stmt
;
14035 /* Create a block to contain all the extra code. */
14036 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
14038 /* Any return from a destructor will end up here. */
14039 add_stmt (build_stmt (LABEL_STMT
, dtor_label
));
14041 /* Generate the code to call destructor on base class. If this
14042 destructor belongs to a class with virtual functions, then set
14043 the virtual function table pointer to represent the type of our
14046 /* This side-effect makes call to `build_delete' generate the code
14047 we have to have at the end of this destructor. `build_delete'
14048 will set the flag again. */
14049 TYPE_HAS_DESTRUCTOR (current_class_type
) = 0;
14051 exprstmt
= build_delete (current_class_type
,
14053 sfk_base_destructor
,
14054 LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
|LOOKUP_NORMAL
,
14057 if (exprstmt
!= error_mark_node
14058 && (TREE_CODE (exprstmt
) != NOP_EXPR
14059 || TREE_OPERAND (exprstmt
, 0) != integer_zero_node
14060 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
)))
14062 if (exprstmt
!= void_zero_node
)
14063 /* Don't call `expand_expr_stmt' if we're not going to do
14064 anything, since -Wall will give a diagnostic. */
14065 finish_expr_stmt (exprstmt
);
14067 /* Run destructors for all virtual baseclasses. */
14068 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type
))
14073 if_stmt
= begin_if_stmt ();
14074 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
14075 current_in_charge_parm
,
14079 vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
14080 /* The CLASSTYPE_VBASECLASSES list is in initialization
14081 order, so we have to march through it in reverse order. */
14082 for (vbases
= nreverse (copy_list (vbases
));
14084 vbases
= TREE_CHAIN (vbases
))
14086 tree vbase
= TREE_VALUE (vbases
);
14088 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbase
)))
14090 tree vb
= get_vbase
14091 (BINFO_TYPE (vbase
),
14092 TYPE_BINFO (current_class_type
));
14094 (build_scoped_method_call
14095 (current_class_ref
, vb
, base_dtor_identifier
,
14100 finish_then_clause (if_stmt
);
14105 virtual_size
= c_sizeof (current_class_type
);
14107 /* At the end, call delete if that's what's requested. */
14109 /* FDIS sez: At the point of definition of a virtual destructor
14110 (including an implicit definition), non-placement operator delete
14111 shall be looked up in the scope of the destructor's class and if
14112 found shall be accessible and unambiguous.
14114 This is somewhat unclear, but I take it to mean that if the class
14115 only defines placement deletes we don't do anything here. So we
14116 pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
14117 they ever try to delete one of these. */
14118 exprstmt
= build_op_delete_call
14119 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
14120 LOOKUP_NORMAL
| LOOKUP_SPECULATIVELY
, NULL_TREE
);
14122 if_stmt
= begin_if_stmt ();
14123 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
14124 current_in_charge_parm
,
14127 finish_expr_stmt (exprstmt
);
14128 finish_then_clause (if_stmt
);
14131 /* Close the block we started above. */
14132 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
14135 /* Finish up a function declaration and compile that function
14136 all the way to assembler language output. The free the storage
14137 for the function definition.
14139 FLAGS is a bitwise or of the following values:
14141 An extra call to poplevel (and expand_end_bindings) must be
14142 made to take care of the binding contour for the base
14143 initializers. This is only relevant for constructors.
14145 We just finished processing the body of an in-class inline
14146 function definition. (This processing will have taken place
14147 after the class definition is complete.) */
14150 finish_function (flags
)
14153 register tree fndecl
= current_function_decl
;
14154 tree fntype
, ctype
= NULL_TREE
;
14155 int call_poplevel
= (flags
& 1) != 0;
14156 int inclass_inline
= (flags
& 2) != 0;
14159 /* When we get some parse errors, we can end up without a
14160 current_function_decl, so cope. */
14161 if (fndecl
== NULL_TREE
)
14162 return error_mark_node
;
14164 nested
= function_depth
> 1;
14165 fntype
= TREE_TYPE (fndecl
);
14167 /* TREE_READONLY (fndecl) = 1;
14168 This caused &foo to be of type ptr-to-const-function
14169 which then got a warning when stored in a ptr-to-function variable. */
14171 my_friendly_assert (building_stmt_tree (), 20000911);
14173 /* For a cloned function, we've already got all the code we need;
14174 there's no need to add any extra bits. */
14175 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14177 if (DECL_CONSTRUCTOR_P (fndecl
))
14179 finish_constructor_body ();
14183 else if (DECL_DESTRUCTOR_P (fndecl
) && !processing_template_decl
)
14184 finish_destructor_body ();
14185 else if (DECL_MAIN_P (fndecl
))
14187 /* Make it so that `main' always returns 0 by default. */
14189 finish_return_stmt (integer_one_node
);
14191 finish_return_stmt (integer_zero_node
);
14195 /* Finish dealing with exception specifiers. */
14196 if (flag_exceptions
&& !processing_template_decl
14197 && flag_enforce_eh_specs
14198 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
14199 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
14200 (TREE_TYPE (current_function_decl
)),
14201 current_eh_spec_try_block
);
14204 /* If we're saving up tree structure, tie off the function now. */
14205 finish_stmt_tree (&DECL_SAVED_TREE (fndecl
));
14207 /* This must come after expand_function_end because cleanups might
14208 have declarations (from inline functions) that need to go into
14209 this function's blocks. */
14210 if (current_binding_level
->parm_flag
!= 1)
14211 my_friendly_abort (122);
14212 poplevel (1, 0, 1);
14214 /* Remember that we were in class scope. */
14215 if (current_class_name
)
14216 ctype
= current_class_type
;
14218 /* Must mark the RESULT_DECL as being in this function. */
14219 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14221 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14222 to the FUNCTION_DECL node itself. */
14223 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14225 /* Save away current state, if appropriate. */
14226 if (!processing_template_decl
)
14227 save_function_data (fndecl
);
14229 /* If this function calls `setjmp' it cannot be inlined. When
14230 `longjmp' is called it is not guaranteed to restore the value of
14231 local variables that have been modified since the call to
14232 `setjmp'. So, if were to inline this function into some caller
14233 `c', then when we `longjmp', we might not restore all variables
14234 in `c'. (It might seem, at first blush, that there's no way for
14235 this function to modify local variables in `c', but their
14236 addresses may have been stored somewhere accessible to this
14238 if (!processing_template_decl
&& calls_setjmp_p (fndecl
))
14239 DECL_UNINLINABLE (fndecl
) = 1;
14241 /* Clear out memory we no longer need. */
14242 free_after_parsing (cfun
);
14243 /* Since we never call rest_of_compilation, we never clear
14244 CFUN. Do so explicitly. */
14245 free_after_compilation (cfun
);
14248 /* If this is a in-class inline definition, we may have to pop the
14249 bindings for the template parameters that we added in
14250 maybe_begin_member_template_processing when start_function was
14252 if (inclass_inline
)
14253 maybe_end_member_template_processing ();
14255 /* Leave the scope of the class. */
14257 pop_nested_class ();
14264 /* Let the error reporting routines know that we're outside a
14265 function. For a nested function, this value is used in
14266 pop_cp_function_context and then reset via pop_function_context. */
14267 current_function_decl
= NULL_TREE
;
14268 /* We don't really care about obstacks, but the middle-end
14269 sometimes cares on what obstck things are located. */
14270 permanent_allocation (1);
14276 /* Create the FUNCTION_DECL for a function definition.
14277 DECLSPECS and DECLARATOR are the parts of the declaration;
14278 they describe the return type and the name of the function,
14279 but twisted together in a fashion that parallels the syntax of C.
14281 This function creates a binding context for the function body
14282 as well as setting up the FUNCTION_DECL in current_function_decl.
14284 Returns a FUNCTION_DECL on success.
14286 If the DECLARATOR is not suitable for a function (it defines a datum
14287 instead), we return 0, which tells yyparse to report a parse error.
14289 May return void_type_node indicating that this method is actually
14290 a friend. See grokfield for more details.
14292 Came here with a `.pushlevel' .
14294 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14295 CHANGES TO CODE IN `grokfield'. */
14298 start_method (declspecs
, declarator
, attrlist
)
14299 tree declarator
, declspecs
, attrlist
;
14301 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14304 /* Something too ugly to handle. */
14305 if (fndecl
== NULL_TREE
)
14308 /* Pass friends other than inline friend functions back. */
14309 if (fndecl
== void_type_node
)
14312 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
14313 /* Not a function, tell parser to report parse error. */
14316 if (DECL_IN_AGGR_P (fndecl
))
14318 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl
)) != current_class_type
)
14320 if (DECL_CONTEXT (fndecl
)
14321 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
14322 cp_error ("`%D' is already defined in class `%T'", fndecl
,
14323 DECL_CONTEXT (fndecl
));
14325 return void_type_node
;
14328 check_template_shadow (fndecl
);
14330 DECL_THIS_INLINE (fndecl
) = 1;
14332 if (flag_default_inline
)
14333 DECL_INLINE (fndecl
) = 1;
14335 /* We process method specializations in finish_struct_1. */
14336 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14337 fndecl
= push_template_decl (fndecl
);
14339 if (! DECL_FRIEND_P (fndecl
))
14341 if (TREE_CHAIN (fndecl
))
14343 fndecl
= copy_node (fndecl
);
14344 TREE_CHAIN (fndecl
) = NULL_TREE
;
14347 if (DECL_CONSTRUCTOR_P (fndecl
))
14349 if (! grok_ctor_properties (current_class_type
, fndecl
))
14350 return void_type_node
;
14352 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl
)))
14353 grok_op_properties (fndecl
, DECL_VIRTUAL_P (fndecl
), 0);
14356 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
14358 /* Make a place for the parms */
14360 current_binding_level
->parm_flag
= 1;
14362 DECL_IN_AGGR_P (fndecl
) = 1;
14366 /* Go through the motions of finishing a function definition.
14367 We don't compile this method until after the whole class has
14370 FINISH_METHOD must return something that looks as though it
14371 came from GROKFIELD (since we are defining a method, after all).
14373 This is called after parsing the body of the function definition.
14374 STMTS is the chain of statements that makes up the function body.
14376 DECL is the ..._DECL that `start_method' provided. */
14379 finish_method (decl
)
14382 register tree fndecl
= decl
;
14385 register tree link
;
14387 if (decl
== void_type_node
)
14390 old_initial
= DECL_INITIAL (fndecl
);
14392 /* Undo the level for the parms (from start_method).
14393 This is like poplevel, but it causes nothing to be
14394 saved. Saving information here confuses symbol-table
14395 output routines. Besides, this information will
14396 be correctly output when this method is actually
14399 /* Clear out the meanings of the local variables of this level;
14400 also record in each decl which block it belongs to. */
14402 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
14404 if (DECL_NAME (link
) != NULL_TREE
)
14405 pop_binding (DECL_NAME (link
), link
);
14406 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
14407 DECL_CONTEXT (link
) = NULL_TREE
;
14410 GNU_xref_end_scope ((HOST_WIDE_INT
) current_binding_level
,
14411 (HOST_WIDE_INT
) current_binding_level
->level_chain
,
14412 current_binding_level
->parm_flag
,
14413 current_binding_level
->keep
);
14415 poplevel (0, 0, 0);
14417 DECL_INITIAL (fndecl
) = old_initial
;
14419 /* We used to check if the context of FNDECL was different from
14420 current_class_type as another way to get inside here. This didn't work
14421 for String.cc in libg++. */
14422 if (DECL_FRIEND_P (fndecl
))
14424 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
14425 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
14426 decl
= void_type_node
;
14432 /* Called when a new struct TYPE is defined.
14433 If this structure or union completes the type of any previous
14434 variable declaration, lay it out and output its rtl. */
14437 hack_incomplete_structures (type
)
14441 struct binding_level
*level
;
14443 if (!type
) /* Don't do this for class templates. */
14446 if (namespace_bindings_p ())
14449 list
= &namespace_scope_incomplete
;
14453 level
= innermost_nonclass_level ();
14454 list
= &level
->incomplete
;
14461 tree decl
= TREE_VALUE (*list
);
14462 if ((decl
&& TREE_TYPE (decl
) == type
)
14463 || (TREE_TYPE (decl
)
14464 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14465 && TREE_TYPE (TREE_TYPE (decl
)) == type
))
14467 int toplevel
= toplevel_bindings_p ();
14468 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
14469 && TREE_TYPE (TREE_TYPE (decl
)) == type
)
14470 layout_type (TREE_TYPE (decl
));
14471 layout_decl (decl
, 0);
14472 rest_of_decl_compilation (decl
, NULL_PTR
, toplevel
, 0);
14476 expand_decl (decl
);
14477 cleanup
= maybe_build_cleanup (decl
);
14478 expand_decl_init (decl
);
14479 if (! expand_decl_cleanup (decl
, cleanup
))
14480 cp_error ("parser lost in parsing declaration of `%D'",
14483 *list
= TREE_CHAIN (*list
);
14486 list
= &TREE_CHAIN (*list
);
14489 /* Keep looking through artificial binding levels generated
14490 for local variables. */
14491 if (level
&& level
->keep
== 2)
14493 level
= level
->level_chain
;
14494 list
= &level
->incomplete
;
14501 /* If DECL is of a type which needs a cleanup, build that cleanup
14505 maybe_build_cleanup (decl
)
14508 tree type
= TREE_TYPE (decl
);
14510 if (type
!= error_mark_node
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14512 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14515 if (TREE_CODE (type
) == ARRAY_TYPE
)
14519 mark_addressable (decl
);
14520 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
14523 /* Optimize for space over speed here. */
14524 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
14525 || flag_expensive_optimizations
)
14526 flags
|= LOOKUP_NONVIRTUAL
;
14528 rval
= build_delete (TREE_TYPE (rval
), rval
,
14529 sfk_complete_destructor
, flags
, 0);
14531 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
14532 && ! TYPE_HAS_DESTRUCTOR (type
))
14533 rval
= build_compound_expr (tree_cons (NULL_TREE
, rval
,
14534 build_tree_list (NULL_TREE
, build_vbase_delete (type
, decl
))));
14541 /* When a stmt has been parsed, this function is called. */
14546 /* Always assume this statement was not an expression statement. If
14547 it actually was an expression statement, its our callers
14548 responsibility to fix this up. */
14549 last_expr_type
= NULL_TREE
;
14552 /* DECL was originally constructed as a non-static member function,
14553 but turned out to be static. Update it accordingly. */
14556 revert_static_member_fn (decl
)
14560 tree function
= TREE_TYPE (decl
);
14561 tree args
= TYPE_ARG_TYPES (function
);
14563 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args
)))
14564 != TYPE_UNQUALIFIED
)
14565 cp_error ("static member function `%#D' declared with type qualifiers",
14568 args
= TREE_CHAIN (args
);
14569 tmp
= build_function_type (TREE_TYPE (function
), args
);
14570 tmp
= build_qualified_type (tmp
, CP_TYPE_QUALS (function
));
14571 tmp
= build_exception_variant (tmp
,
14572 TYPE_RAISES_EXCEPTIONS (function
));
14573 TREE_TYPE (decl
) = tmp
;
14574 if (DECL_ARGUMENTS (decl
))
14575 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
14576 DECL_STATIC_FUNCTION_P (decl
) = 1;
14579 /* Initialize the variables used during compilation of a C++
14583 push_cp_function_context (f
)
14584 struct function
*f
;
14586 struct cp_language_function
*p
14587 = ((struct cp_language_function
*)
14588 xcalloc (1, sizeof (struct cp_language_function
)));
14589 f
->language
= (struct language_function
*) p
;
14591 /* It takes an explicit call to expand_body to generate RTL for a
14595 /* Whenever we start a new function, we destroy temporaries in the
14597 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14600 /* Free the language-specific parts of F, now that we've finished
14601 compiling the function. */
14604 pop_cp_function_context (f
)
14605 struct function
*f
;
14608 free (f
->language
);
14612 /* Mark P for GC. */
14615 mark_lang_function (p
)
14616 struct cp_language_function
*p
;
14621 mark_c_language_function (&p
->base
);
14623 ggc_mark_tree (p
->x_ctor_label
);
14624 ggc_mark_tree (p
->x_dtor_label
);
14625 ggc_mark_tree (p
->x_current_class_ptr
);
14626 ggc_mark_tree (p
->x_current_class_ref
);
14627 ggc_mark_tree (p
->x_eh_spec_try_block
);
14629 ggc_mark_rtx (p
->x_result_rtx
);
14631 mark_named_label_lists (&p
->x_named_labels
, &p
->x_named_label_uses
);
14632 mark_binding_level (&p
->bindings
);
14635 /* Mark the language-specific data in F for GC. */
14638 mark_cp_function_context (f
)
14639 struct function
*f
;
14641 mark_lang_function ((struct cp_language_function
*) f
->language
);
14645 lang_mark_false_label_stack (l
)
14646 struct label_node
*l
;
14648 /* C++ doesn't use false_label_stack. It better be NULL. */
14649 my_friendly_assert (l
== NULL
, 19990904);
14656 enum tree_code code
= TREE_CODE (t
);
14657 if (code
== IDENTIFIER_NODE
)
14659 struct lang_identifier
*li
= (struct lang_identifier
*) t
;
14660 struct lang_id2
*li2
= li
->x
;
14661 ggc_mark_tree (li
->namespace_bindings
);
14662 ggc_mark_tree (li
->bindings
);
14663 ggc_mark_tree (li
->class_value
);
14664 ggc_mark_tree (li
->class_template_info
);
14668 ggc_mark_tree (li2
->label_value
);
14669 ggc_mark_tree (li2
->implicit_decl
);
14670 ggc_mark_tree (li2
->error_locus
);
14673 else if (code
== CPLUS_BINDING
)
14675 if (BINDING_HAS_LEVEL_P (t
))
14676 mark_binding_level (&BINDING_LEVEL (t
));
14678 ggc_mark_tree (BINDING_SCOPE (t
));
14679 ggc_mark_tree (BINDING_VALUE (t
));
14681 else if (code
== OVERLOAD
)
14682 ggc_mark_tree (OVL_FUNCTION (t
));
14683 else if (code
== TEMPLATE_PARM_INDEX
)
14684 ggc_mark_tree (TEMPLATE_PARM_DECL (t
));
14685 else if (TREE_CODE_CLASS (code
) == 'd')
14687 struct lang_decl
*ld
= DECL_LANG_SPECIFIC (t
);
14692 c_mark_lang_decl (&ld
->decl_flags
.base
);
14693 if (!DECL_GLOBAL_CTOR_P (t
)
14694 && !DECL_GLOBAL_DTOR_P (t
)
14695 && !DECL_THUNK_P (t
))
14696 ggc_mark_tree (ld
->decl_flags
.u2
.access
);
14697 else if (DECL_THUNK_P (t
))
14698 ggc_mark_tree (ld
->decl_flags
.u2
.vcall_offset
);
14699 if (TREE_CODE (t
) != NAMESPACE_DECL
)
14700 ggc_mark_tree (ld
->decl_flags
.u
.template_info
);
14702 mark_binding_level (&NAMESPACE_LEVEL (t
));
14703 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
14705 ggc_mark_tree (ld
->befriending_classes
);
14706 ggc_mark_tree (ld
->context
);
14707 ggc_mark_tree (ld
->cloned_function
);
14708 if (!DECL_OVERLOADED_OPERATOR_P (t
))
14709 ggc_mark_tree (ld
->u2
.vtt_parm
);
14710 if (TREE_CODE (t
) == TYPE_DECL
)
14711 ggc_mark_tree (ld
->u
.sorted_fields
);
14712 else if (TREE_CODE (t
) == FUNCTION_DECL
14713 && !DECL_PENDING_INLINE_P (t
))
14714 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t
));
14718 else if (TREE_CODE_CLASS (code
) == 't')
14720 struct lang_type
*lt
= TYPE_LANG_SPECIFIC (t
);
14722 if (lt
&& !(TREE_CODE (t
) == POINTER_TYPE
14723 && TREE_CODE (TREE_TYPE (t
)) == METHOD_TYPE
))
14726 ggc_mark_tree (lt
->primary_base
);
14727 ggc_mark_tree (lt
->vfields
);
14728 ggc_mark_tree (lt
->vbases
);
14729 ggc_mark_tree (lt
->tags
);
14730 ggc_mark_tree (lt
->size
);
14731 ggc_mark_tree (lt
->pure_virtuals
);
14732 ggc_mark_tree (lt
->friend_classes
);
14733 ggc_mark_tree (lt
->rtti
);
14734 ggc_mark_tree (lt
->methods
);
14735 ggc_mark_tree (lt
->template_info
);
14736 ggc_mark_tree (lt
->befriending_classes
);
14739 /* In the case of pointer-to-member function types, the
14740 TYPE_LANG_SPECIFIC is really just a tree. */
14741 ggc_mark_tree ((tree
) lt
);