1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 92-98, 1999, 2000 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Process declarations and symbol lookup for C front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
51 extern struct obstack permanent_obstack;
53 extern int current_class_depth;
55 extern tree static_ctors, static_dtors;
57 extern tree global_namespace;
59 extern int (*valid_lang_attribute) PROTO ((tree, tree, tree, tree));
61 /* Use garbage collection. */
65 #ifndef WCHAR_UNSIGNED
66 #define WCHAR_UNSIGNED 0
69 #ifndef CHAR_TYPE_SIZE
70 #define CHAR_TYPE_SIZE BITS_PER_UNIT
73 #ifndef BOOL_TYPE_SIZE
74 #ifdef SLOW_BYTE_ACCESS
75 /* In the new ABI, `bool' has size and alignment `1', on all
77 #define BOOL_TYPE_SIZE \
78 ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
80 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
84 /* We let tm.h override the types used here, to handle trivial differences
85 such as the choice of unsigned int or long unsigned int for size_t.
86 When machines start needing nontrivial differences in the size type,
87 it would be best to do something here to figure out automatically
88 from other information what type to use. */
91 #define SIZE_TYPE "long unsigned int"
95 #define PTRDIFF_TYPE "long int"
99 #define WCHAR_TYPE "int"
102 static tree grokparms PROTO((tree, int));
103 static const char *redeclaration_error_message PROTO((tree, tree));
105 static void push_binding_level PROTO((struct binding_level *, int,
107 static void pop_binding_level PROTO((void));
108 static void suspend_binding_level PROTO((void));
109 static void resume_binding_level PROTO((struct binding_level *));
110 static struct binding_level *make_binding_level PROTO((void));
111 static void declare_namespace_level PROTO((void));
112 static void signal_catch PROTO((int)) ATTRIBUTE_NORETURN;
113 static void storedecls PROTO((tree));
114 static void require_complete_types_for_parms PROTO((tree));
115 static void push_overloaded_decl_1 PROTO((tree));
116 static int ambi_op_p PROTO((tree));
117 static int unary_op_p PROTO((tree));
118 static tree store_bindings PROTO((tree, tree));
119 static tree lookup_tag_reverse PROTO((tree, tree));
120 static tree obscure_complex_init PROTO((tree, tree));
121 static tree maybe_build_cleanup_1 PROTO((tree, tree));
122 static tree lookup_name_real PROTO((tree, int, int, int));
123 static void warn_extern_redeclared_static PROTO((tree, tree));
124 static void grok_reference_init PROTO((tree, tree, tree));
125 static tree grokfndecl PROTO((tree, tree, tree, tree, int,
126 enum overload_flags, tree,
127 tree, int, int, int, int, int, int, tree));
128 static tree grokvardecl PROTO((tree, tree, RID_BIT_TYPE *, int, int, tree));
129 static tree lookup_tag PROTO((enum tree_code, tree,
130 struct binding_level *, int));
131 static void set_identifier_type_value_with_scope
132 PROTO((tree, tree, struct binding_level *));
133 static void record_builtin_type PROTO((enum rid, const char *, tree));
134 static void record_unknown_type PROTO((tree, const char *));
135 static int member_function_or_else PROTO((tree, tree, const char *));
136 static void bad_specifiers PROTO((tree, const char *, int, int, int, int,
138 static void lang_print_error_function PROTO((const char *));
139 static tree maybe_process_template_type_declaration PROTO((tree, int, struct binding_level*));
140 static void check_for_uninitialized_const_var PROTO((tree));
141 static unsigned long typename_hash PROTO((hash_table_key));
142 static boolean typename_compare PROTO((hash_table_key, hash_table_key));
143 static void push_binding PROTO((tree, tree, struct binding_level*));
144 static int add_binding PROTO((tree, tree));
145 static void pop_binding PROTO((tree, tree));
146 static tree local_variable_p_walkfn PROTO((tree *, int *, void *));
147 static tree find_binding PROTO((tree, tree));
148 static tree select_decl PROTO((tree, int));
149 static int lookup_flags PROTO((int, int));
150 static tree qualify_lookup PROTO((tree, int));
151 static tree record_builtin_java_type PROTO((const char *, int));
152 static const char *tag_name PROTO((enum tag_types code));
153 static void find_class_binding_level PROTO((void));
154 static struct binding_level *innermost_nonclass_level PROTO((void));
155 static void warn_about_implicit_typename_lookup PROTO((tree, tree));
156 static int walk_namespaces_r PROTO((tree, walk_namespaces_fn, void *));
157 static int walk_globals_r PROTO((tree, void *));
158 static void add_decl_to_level PROTO((tree, struct binding_level *));
159 static tree make_label_decl PROTO((tree, int));
160 static void pop_label PROTO((tree));
161 static void pop_labels PROTO((tree));
162 static void maybe_deduce_size_from_array_init PROTO((tree, tree));
163 static void layout_var_decl PROTO((tree));
164 static void maybe_commonize_var PROTO((tree));
165 static tree check_initializer PROTO((tree, tree));
166 static void make_rtl_for_nonlocal_decl PROTO((tree, tree, const char *));
167 static void push_cp_function_context PROTO((struct function *));
168 static void pop_cp_function_context PROTO((struct function *));
169 static void mark_binding_level PROTO((void *));
170 static void mark_cp_function_context PROTO((struct function *));
171 static void mark_saved_scope PROTO((void *));
172 static void mark_lang_function PROTO((struct language_function *));
173 static void mark_stmt_tree PROTO((struct stmt_tree *));
174 static void save_function_data PROTO((tree));
175 static void check_function_type PROTO((tree));
176 static void destroy_local_static PROTO((tree));
177 static void destroy_local_var PROTO((tree));
178 static void finish_constructor_body PROTO((void));
179 static void finish_destructor_body PROTO((void));
180 static tree create_array_type_for_decl PROTO((tree, tree, tree));
181 static tree get_atexit_node PROTO((void));
182 static tree get_dso_handle_node PROTO((void));
183 static tree start_cleanup_fn PROTO((void));
184 static void end_cleanup_fn PROTO((void));
186 #if defined (DEBUG_CP_BINDING_LEVELS)
187 static void indent PROTO((void));
190 /* Erroneous argument lists can use this *IFF* they do not modify it. */
191 tree error_mark_list;
193 /* The following symbols are subsumed in the cp_global_trees array, and
194 listed here individually for documentation purposes.
197 tree wchar_decl_node;
200 tree vtable_entry_type;
201 tree delta_type_node;
204 tree __baselist_desc_type_node;
205 tree __i_desc_type_node, __m_desc_type_node;
206 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
208 tree __t_desc_type_node;
210 tree __tp_desc_type_node;
212 tree __access_mode_type_node;
213 tree __bltn_desc_type_node, __user_desc_type_node, __class_desc_type_node;
214 tree __ptr_desc_type_node, __attr_desc_type_node, __func_desc_type_node;
215 tree __ptmf_desc_type_node, __ptmd_desc_type_node;
217 Not needed yet? May be needed one day?
218 tree __bltn_desc_array_type, __user_desc_array_type, __class_desc_array_type;
219 tree __ptr_desc_array_type, __attr_dec_array_type, __func_desc_array_type;
220 tree __ptmf_desc_array_type, __ptmd_desc_array_type;
223 tree class_star_type_node;
224 tree class_type_node, record_type_node, union_type_node, enum_type_node;
225 tree unknown_type_node;
227 Array type `vtable_entry_type[]'
230 tree vtbl_ptr_type_node;
236 A FUNCTION_DECL which can call `abort'. Not necessarily the
237 one that the user will declare, but sufficient to be called
238 by routines that want to abort the program.
242 The FUNCTION_DECL for the default `::operator delete'.
244 tree global_delete_fndecl;
247 tree type_info_type_node, tinfo_fn_id, tinfo_fn_type;
251 tree cp_global_trees[CPTI_MAX];
253 /* Indicates that there is a type value in some namespace, although
254 that is not necessarily in scope at the moment. */
256 static tree global_type_node;
261 /* Expect only namespace names now. */
262 static int only_namespace_names;
264 /* If original DECL_RESULT of current function was a register,
265 but due to being an addressable named return value, would up
266 on the stack, this variable holds the named return value's
267 original location. */
269 #define original_result_rtx cp_function_chain->x_result_rtx
271 struct named_label_list
273 struct binding_level *binding_level;
276 const char *filename_o_goto;
278 struct named_label_list *next;
281 /* Used only for jumps to as-yet undefined labels, since jumps to
282 defined labels can have their validity checked by stmt.c. */
284 #define named_label_uses cp_function_chain->x_named_label_uses
286 /* A list of objects which have constructors or destructors
287 which reside in the global scope. The decl is stored in
288 the TREE_VALUE slot and the initializer is stored
289 in the TREE_PURPOSE slot. */
290 tree static_aggregates;
294 /* A node for the integer constants 2, and 3. */
296 tree integer_two_node, integer_three_node;
298 /* Parsing a function declarator leaves here a chain of structure
299 and enum types declared in the parmlist. */
301 static tree last_function_parm_tags;
303 /* Similar, for last_function_parm_tags. */
304 tree last_function_parms;
305 static tree current_function_parm_tags;
307 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
308 that have names. Here so we can clear out their names' definitions
309 at the end of the function. The TREE_VALUE is a LABEL_DECL; the
310 TREE_PURPOSE is the previous binding of the label. */
312 #define named_labels cp_function_chain->x_named_labels
314 /* The FUNCTION_DECL for the function currently being compiled,
315 or 0 if between functions. */
316 tree current_function_decl;
318 /* Set to 0 at beginning of a function definition, and whenever
319 a label (case or named) is defined. Set to value of expression
320 returned from function when that value can be transformed into
321 a named return value. */
323 tree current_function_return_value;
325 /* Nonzero means use the ISO C9x dialect of C. */
329 /* Nonzero means give `double' the same size as `float'. */
331 extern int flag_short_double;
333 /* Nonzero means don't recognize any builtin functions. */
335 extern int flag_no_builtin;
337 /* Nonzero means don't recognize the non-ANSI builtin functions.
340 extern int flag_no_nonansi_builtin;
342 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
344 extern int flag_huge_objects;
346 /* Nonzero if we want to conserve space in the .o files. We do this
347 by putting uninitialized data and runtime initialized data into
348 .common instead of .data at the expense of not flagging multiple
350 extern int flag_conserve_space;
352 /* C and C++ flags are in decl2.c. */
354 /* Flag used when debugging spew.c */
356 extern int spew_debug;
358 /* A expression of value 0 with the same precision as a sizetype
360 tree signed_size_zero_node;
362 /* The name of the anonymous namespace, throughout this translation
364 tree anonymous_namespace_name;
367 /* For each binding contour we allocate a binding_level structure
368 which records the names defined in that contour.
371 1) one for each function definition,
372 where internal declarations of the parameters appear.
373 2) one for each compound statement,
374 to record its declarations.
376 The current meaning of a name can be found by searching the levels
377 from the current one out to the global one.
379 Off to the side, may be the class_binding_level. This exists only
380 to catch class-local declarations. It is otherwise nonexistent.
382 Also there may be binding levels that catch cleanups that must be
383 run when exceptions occur. Thus, to see whether a name is bound in
384 the current scope, it is not enough to look in the
385 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
388 /* Note that the information in the `names' component of the global contour
389 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
393 /* A chain of _DECL nodes for all variables, constants, functions,
394 and typedef types. These are in the reverse of the order
395 supplied. There may be OVERLOADs on this list, too, but they
396 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
399 /* A list of structure, union and enum definitions, for looking up
401 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
402 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
403 or ENUMERAL_TYPE node.
405 C++: the TREE_VALUE nodes can be simple types for
406 component_bindings. */
409 /* A list of USING_DECL nodes. */
412 /* A list of used namespaces. PURPOSE is the namespace,
413 VALUE the common ancestor with this binding_level's namespace. */
414 tree using_directives;
416 /* If this binding level is the binding level for a class, then
417 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
418 is the name of an entity bound in the class; the TREE_VALUE is
419 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
420 when leaving class scope, we can restore the
421 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
422 the DECL bound by this name in the class. */
425 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
426 is used for all binding levels. */
429 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
430 label in this scope. The TREE_PURPOSE is the previous value of
431 the IDENTIFIER_LABEL VALUE. */
432 tree shadowed_labels;
434 /* For each level (except not the global one),
435 a chain of BLOCK nodes for all the levels
436 that were entered and exited one level down. */
439 /* The BLOCK node for this level, if one has been preallocated.
440 If 0, the BLOCK is allocated (if needed) when the level is popped. */
443 /* The binding level which this one is contained in (inherits from). */
444 struct binding_level *level_chain;
446 /* List of decls in `names' that have incomplete
447 structure or union types. */
450 /* List of VAR_DECLS saved from a previous for statement.
451 These would be dead in ANSI-conforming code, but might
452 be referenced in ARM-era code. These are stored in a
453 TREE_LIST; the TREE_VALUE is the actual declaration. */
454 tree dead_vars_from_for;
456 /* 1 for the level that holds the parameters of a function.
457 2 for the level that holds a class declaration.
458 3 for levels that hold parameter declarations. */
459 unsigned parm_flag : 4;
461 /* 1 means make a BLOCK for this level regardless of all else.
462 2 for temporary binding contours created by the compiler. */
465 /* Nonzero if this level "doesn't exist" for tags. */
466 unsigned tag_transparent : 1;
468 /* Nonzero if this level can safely have additional
469 cleanup-needing variables added to it. */
470 unsigned more_cleanups_ok : 1;
471 unsigned have_cleanups : 1;
473 /* Nonzero if this level is for storing the decls for template
474 parameters and generic decls; these decls will be discarded and
475 replaced with a TEMPLATE_DECL. */
476 unsigned pseudo_global : 1;
478 /* This is set for a namespace binding level. */
479 unsigned namespace_p : 1;
481 /* True if this level is that of a for-statement where we need to
482 worry about ambiguous (ARM or ANSI) scope rules. */
483 unsigned is_for_scope : 1;
485 /* True if this level corresponds to an EH region, as for a try block. */
486 unsigned eh_region : 1;
488 /* One bit left for this word. */
490 #if defined(DEBUG_CP_BINDING_LEVELS)
491 /* Binding depth at which this level began. */
492 unsigned binding_depth;
493 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
496 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
498 /* The binding level currently in effect. */
500 #define current_binding_level \
502 ? cp_function_chain->bindings \
503 : scope_chain->bindings)
505 /* The binding level of the current class, if any. */
507 #define class_binding_level scope_chain->class_bindings
509 /* A chain of binding_level structures awaiting reuse. */
511 static struct binding_level *free_binding_level;
513 /* The outermost binding level, for names of file scope.
514 This is created when the compiler is started and exists
515 through the entire run. */
517 static struct binding_level *global_binding_level;
519 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
521 static int keep_next_level_flag;
523 #if defined(DEBUG_CP_BINDING_LEVELS)
524 static int binding_depth = 0;
525 static int is_class_level = 0;
532 for (i = 0; i < binding_depth*2; i++)
535 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
537 static tree pushdecl_with_scope PROTO((tree, struct binding_level *));
540 push_binding_level (newlevel, tag_transparent, keep)
541 struct binding_level *newlevel;
542 int tag_transparent, keep;
544 /* Add this level to the front of the chain (stack) of levels that
546 bzero ((char*) newlevel, sizeof (struct binding_level));
547 newlevel->level_chain = current_binding_level;
548 current_binding_level = newlevel;
549 newlevel->tag_transparent = tag_transparent;
550 newlevel->more_cleanups_ok = 1;
552 /* We are called before expand_start_bindings, but after
553 expand_eh_region_start for a try block; so we check this now,
554 before the EH block is covered up. */
555 newlevel->eh_region = is_eh_region ();
557 newlevel->keep = keep;
558 #if defined(DEBUG_CP_BINDING_LEVELS)
559 newlevel->binding_depth = binding_depth;
561 fprintf (stderr, "push %s level 0x%08x line %d\n",
562 (is_class_level) ? "class" : "block", newlevel, lineno);
565 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
568 /* Find the innermost enclosing class scope, and reset
569 CLASS_BINDING_LEVEL appropriately. */
572 find_class_binding_level ()
574 struct binding_level *level = current_binding_level;
576 while (level && level->parm_flag != 2)
577 level = level->level_chain;
578 if (level && level->parm_flag == 2)
579 class_binding_level = level;
581 class_binding_level = 0;
587 if (global_binding_level)
589 /* Cannot pop a level, if there are none left to pop. */
590 if (current_binding_level == global_binding_level)
591 my_friendly_abort (123);
593 /* Pop the current level, and free the structure for reuse. */
594 #if defined(DEBUG_CP_BINDING_LEVELS)
597 fprintf (stderr, "pop %s level 0x%08x line %d\n",
598 (is_class_level) ? "class" : "block",
599 current_binding_level, lineno);
600 if (is_class_level != (current_binding_level == class_binding_level))
603 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
606 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
608 register struct binding_level *level = current_binding_level;
609 current_binding_level = current_binding_level->level_chain;
610 level->level_chain = free_binding_level;
611 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
612 if (level->binding_depth != binding_depth)
614 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
615 free_binding_level = level;
616 find_class_binding_level ();
621 suspend_binding_level ()
623 if (class_binding_level)
624 current_binding_level = class_binding_level;
626 if (global_binding_level)
628 /* Cannot suspend a level, if there are none left to suspend. */
629 if (current_binding_level == global_binding_level)
630 my_friendly_abort (123);
632 /* Suspend the current level. */
633 #if defined(DEBUG_CP_BINDING_LEVELS)
636 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
637 (is_class_level) ? "class" : "block",
638 current_binding_level, lineno);
639 if (is_class_level != (current_binding_level == class_binding_level))
642 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
645 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
646 current_binding_level = current_binding_level->level_chain;
647 find_class_binding_level ();
651 resume_binding_level (b)
652 struct binding_level *b;
654 /* Resuming binding levels is meant only for namespaces,
655 and those cannot nest into classes. */
656 my_friendly_assert(!class_binding_level, 386);
657 /* Also, resuming a non-directly nested namespace is a no-no. */
658 my_friendly_assert(b->level_chain == current_binding_level, 386);
659 current_binding_level = b;
660 #if defined(DEBUG_CP_BINDING_LEVELS)
661 b->binding_depth = binding_depth;
663 fprintf (stderr, "resume %s level 0x%08x line %d\n",
664 (is_class_level) ? "class" : "block", b, lineno);
667 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
670 /* Create a new `struct binding_level'. */
673 struct binding_level *
674 make_binding_level ()
677 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
680 /* Nonzero if we are currently in the global binding level. */
685 return current_binding_level == global_binding_level;
688 /* Return the innermost binding level that is not for a class scope. */
690 static struct binding_level *
691 innermost_nonclass_level ()
693 struct binding_level *b;
695 b = current_binding_level;
696 while (b->parm_flag == 2)
702 /* Nonzero if we are currently in a toplevel binding level. This
703 means either the global binding level or a namespace in a toplevel
704 binding level. Since there are no non-toplevel namespace levels,
705 this really means any namespace or pseudo-global level. We also
706 include a class whose context is toplevel. */
709 toplevel_bindings_p ()
711 struct binding_level *b = innermost_nonclass_level ();
713 return b->namespace_p || b->pseudo_global;
716 /* Nonzero if this is a namespace scope, or if we are defining a class
717 which is itself at namespace scope, or whose enclosing class is
718 such a class, etc. */
721 namespace_bindings_p ()
723 struct binding_level *b = innermost_nonclass_level ();
725 return b->namespace_p;
728 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
729 unconditionally. Otherwise, use the normal logic to decide whether
730 or not to create a BLOCK. */
733 keep_next_level (keep)
736 keep_next_level_flag = keep;
739 /* Nonzero if the current level needs to have a BLOCK made. */
744 return (current_binding_level->blocks != NULL_TREE
745 || current_binding_level->keep
746 || current_binding_level->names != NULL_TREE
747 || (current_binding_level->tags != NULL_TREE
748 && !current_binding_level->tag_transparent));
752 declare_pseudo_global_level ()
754 current_binding_level->pseudo_global = 1;
758 declare_namespace_level ()
760 current_binding_level->namespace_p = 1;
764 pseudo_global_level_p ()
766 return current_binding_level->pseudo_global;
770 set_class_shadows (shadows)
773 class_binding_level->class_shadowed = shadows;
776 /* Enter a new binding level.
777 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
778 not for that of tags. */
781 pushlevel (tag_transparent)
784 struct binding_level *newlevel;
786 if (cfun && !doing_semantic_analysis_p ())
789 /* Reuse or create a struct for this binding level. */
790 #if defined(DEBUG_CP_BINDING_LEVELS)
792 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
793 if (free_binding_level)
794 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
796 newlevel = free_binding_level;
797 free_binding_level = free_binding_level->level_chain;
800 newlevel = make_binding_level ();
802 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
803 GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
804 keep_next_level_flag = 0;
808 note_level_for_for ()
810 current_binding_level->is_for_scope = 1;
813 /* For a binding between a name and an entity at a block scope,
814 this is the `struct binding_level' for the block. */
815 #define BINDING_LEVEL(NODE) \
816 (((struct tree_binding*)NODE)->scope.level)
818 /* Make DECL the innermost binding for ID. The LEVEL is the binding
819 level at which this declaration is being bound. */
822 push_binding (id, decl, level)
825 struct binding_level* level;
829 binding = make_node (CPLUS_BINDING);
831 /* Now, fill in the binding information. */
832 BINDING_VALUE (binding) = decl;
833 BINDING_TYPE (binding) = NULL_TREE;
834 BINDING_LEVEL (binding) = level;
835 INHERITED_VALUE_BINDING_P (binding) = 0;
836 LOCAL_BINDING_P (binding) = (level != class_binding_level);
837 BINDING_HAS_LEVEL_P (binding) = 1;
839 /* And put it on the front of the list of bindings for ID. */
840 TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
841 IDENTIFIER_BINDING (id) = binding;
844 /* ID is already bound in the current scope. But, DECL is an
845 additional binding for ID in the same scope. This is the `struct
846 stat' hack whereby a non-typedef class-name or enum-name can be
847 bound at the same level as some other kind of entity. It's the
848 responsibility of the caller to check that inserting this name is
849 legal here. Returns nonzero if the new binding was successful. */
851 add_binding (id, decl)
855 tree binding = IDENTIFIER_BINDING (id);
858 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
859 /* The new name is the type name. */
860 BINDING_TYPE (binding) = decl;
861 else if (!BINDING_VALUE (binding))
862 /* This situation arises when push_class_level_binding moves an
863 inherited type-binding out of the way to make room for a new
865 BINDING_VALUE (binding) = decl;
866 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
867 && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
869 /* The old binding was a type name. It was placed in
870 BINDING_VALUE because it was thought, at the point it was
871 declared, to be the only entity with such a name. Move the
872 type name into the type slot; it is now hidden by the new
874 BINDING_TYPE (binding) = BINDING_VALUE (binding);
875 BINDING_VALUE (binding) = decl;
876 INHERITED_VALUE_BINDING_P (binding) = 0;
878 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
879 && TREE_CODE (decl) == TYPE_DECL
880 && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
881 && same_type_p (TREE_TYPE (decl),
882 TREE_TYPE (BINDING_VALUE (binding))))
883 /* We have two typedef-names, both naming the same type to have
884 the same name. This is OK because of:
888 In a given scope, a typedef specifier can be used to redefine
889 the name of any type declared in that scope to refer to the
890 type to which it already refers. */
894 cp_error ("declaration of `%#D'", decl);
895 cp_error_at ("conflicts with previous declaration `%#D'",
896 BINDING_VALUE (binding));
903 /* Add DECL to the list of things declared in B. */
906 add_decl_to_level (decl, b)
908 struct binding_level *b;
910 /* We build up the list in reverse order, and reverse it later if
912 TREE_CHAIN (decl) = b->names;
916 /* Bind DECL to ID in the current_binding_level, assumed to be a local
917 binding level. If PUSH_USING is set in FLAGS, we know that DECL
918 doesn't really belong to this binding level, that it got here
919 through a using-declaration. */
922 push_local_binding (id, decl, flags)
927 struct binding_level *b;
929 /* Skip over any local classes. This makes sense if we call
930 push_local_binding with a friend decl of a local class. */
931 b = current_binding_level;
932 while (b->parm_flag == 2)
935 if (lookup_name_current_level (id))
937 /* Supplement the existing binding. */
938 if (!add_binding (id, decl))
939 /* It didn't work. Something else must be bound at this
940 level. Do not add DECL to the list of things to pop
945 /* Create a new binding. */
946 push_binding (id, decl, b);
948 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
949 /* We must put the OVERLOAD into a TREE_LIST since the
950 TREE_CHAIN of an OVERLOAD is already used. Similarly for
951 decls that got here through a using-declaration. */
952 decl = build_tree_list (NULL_TREE, decl);
954 /* And put DECL on the list of things declared by the current
956 add_decl_to_level (decl, b);
959 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
960 binding was successful. */
963 push_class_binding (id, decl)
968 tree binding = IDENTIFIER_BINDING (id);
971 /* Note that we declared this value so that we can issue an error if
972 this an illegal redeclaration of a name already used for some
974 note_name_declared_in_class (id, decl);
976 if (binding && BINDING_LEVEL (binding) == class_binding_level)
977 /* Supplement the existing binding. */
978 result = add_binding (id, decl);
980 /* Create a new binding. */
981 push_binding (id, decl, class_binding_level);
983 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
984 class-level declaration. Note that we do not use DECL here
985 because of the possibility of the `struct stat' hack; if DECL is
986 a class-name or enum-name we might prefer a field-name, or some
988 IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
990 /* If this is a binding from a base class, mark it as such. */
991 binding = IDENTIFIER_BINDING (id);
992 if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
994 /* Any implicit typename must be from a base-class. The
995 context for an implicit typename declaration is always
996 the derived class in which the lookup was done, so the checks
997 based on the context of DECL below will not trigger. */
998 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
999 INHERITED_VALUE_BINDING_P (binding) = 1;
1002 if (TREE_CODE (decl) == OVERLOAD)
1003 context = DECL_REAL_CONTEXT (OVL_CURRENT (decl));
1006 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd',
1008 context = DECL_REAL_CONTEXT (decl);
1011 if (is_properly_derived_from (current_class_type, context))
1012 INHERITED_VALUE_BINDING_P (binding) = 1;
1014 INHERITED_VALUE_BINDING_P (binding) = 0;
1017 else if (BINDING_VALUE (binding) == decl)
1018 /* We only encounter a TREE_LIST when push_class_decls detects an
1019 ambiguity. Such an ambiguity can be overridden by a definition
1021 INHERITED_VALUE_BINDING_P (binding) = 1;
1026 /* Remove the binding for DECL which should be the innermost binding
1030 pop_binding (id, decl)
1036 if (id == NULL_TREE)
1037 /* It's easiest to write the loops that call this function without
1038 checking whether or not the entities involved have names. We
1039 get here for such an entity. */
1042 /* Get the innermost binding for ID. */
1043 binding = IDENTIFIER_BINDING (id);
1045 /* The name should be bound. */
1046 my_friendly_assert (binding != NULL_TREE, 0);
1048 /* The DECL will be either the ordinary binding or the type
1049 binding for this identifier. Remove that binding. */
1050 if (BINDING_VALUE (binding) == decl)
1051 BINDING_VALUE (binding) = NULL_TREE;
1052 else if (BINDING_TYPE (binding) == decl)
1053 BINDING_TYPE (binding) = NULL_TREE;
1055 my_friendly_abort (0);
1057 if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1058 /* We're completely done with the innermost binding for this
1059 identifier. Unhook it from the list of bindings. */
1060 IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1063 /* When a label goes out of scope, check to see if that label was used
1064 in a valid manner, and issue any appropriate warnings or errors. */
1070 tree label = TREE_VALUE (link);
1072 if (!processing_template_decl && doing_semantic_analysis_p ())
1074 if (DECL_INITIAL (label) == NULL_TREE)
1076 cp_error_at ("label `%D' used but not defined", label);
1077 /* Avoid crashing later. */
1078 define_label (input_filename, 1, DECL_NAME (label));
1080 else if (warn_unused && !TREE_USED (label))
1081 cp_warning_at ("label `%D' defined but not used", label);
1084 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1087 /* At the end of a function, all labels declared within the fucntion
1088 go out of scope. BLOCK is the top-level block for the
1097 /* Clear out the definitions of all label names, since their scopes
1099 for (link = named_labels; link; link = TREE_CHAIN (link))
1102 /* Put the labels into the "variables" of the top-level block,
1103 so debugger can see them. */
1104 TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1105 BLOCK_VARS (block) = TREE_VALUE (link);
1108 named_labels = NULL_TREE;
1111 /* Exit a binding level.
1112 Pop the level off, and restore the state of the identifier-decl mappings
1113 that were in effect when this level was entered.
1115 If KEEP == 1, this level had explicit declarations, so
1116 and create a "block" (a BLOCK node) for the level
1117 to record its declarations and subblocks for symbol table output.
1119 If FUNCTIONBODY is nonzero, this level is the body of a function,
1120 so create a block as if KEEP were set and also clear out all
1123 If REVERSE is nonzero, reverse the order of decls before putting
1124 them into the BLOCK. */
1127 poplevel (keep, reverse, functionbody)
1133 /* The chain of decls was accumulated in reverse order.
1134 Put it into forward order, just for cleanliness. */
1136 int tmp = functionbody;
1137 int real_functionbody;
1140 tree block = NULL_TREE;
1142 int block_previously_created;
1143 int leaving_for_scope;
1145 if (cfun && !doing_semantic_analysis_p ())
1148 my_friendly_assert (current_binding_level->parm_flag != 2,
1151 real_functionbody = (current_binding_level->keep == 2
1152 ? ((functionbody = 0), tmp) : functionbody);
1153 tags = functionbody >= 0 ? current_binding_level->tags : 0;
1154 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1156 my_friendly_assert (!current_binding_level->class_shadowed,
1159 /* We used to use KEEP == 2 to indicate that the new block should go
1160 at the beginning of the list of blocks at this binding level,
1161 rather than the end. This hack is no longer used. */
1162 my_friendly_assert (keep == 0 || keep == 1, 0);
1164 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1165 (HOST_WIDE_INT) current_binding_level->level_chain,
1166 current_binding_level->parm_flag,
1167 current_binding_level->keep);
1169 if (current_binding_level->keep == 1)
1172 /* Get the decls in the order they were written.
1173 Usually current_binding_level->names is in reverse order.
1174 But parameter decls were previously put in forward order. */
1177 current_binding_level->names
1178 = decls = nreverse (current_binding_level->names);
1180 decls = current_binding_level->names;
1182 /* Output any nested inline functions within this block
1183 if they weren't already output. */
1184 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1185 if (TREE_CODE (decl) == FUNCTION_DECL
1186 && ! TREE_ASM_WRITTEN (decl)
1187 && DECL_INITIAL (decl) != NULL_TREE
1188 && TREE_ADDRESSABLE (decl)
1189 && decl_function_context (decl) == current_function_decl)
1191 /* If this decl was copied from a file-scope decl
1192 on account of a block-scope extern decl,
1193 propagate TREE_ADDRESSABLE to the file-scope decl. */
1194 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1195 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1198 push_function_context ();
1199 output_inline_function (decl);
1200 pop_function_context ();
1204 /* When not in function-at-a-time mode, expand_end_bindings will
1205 warn about unused variables. But, in function-at-a-time mode
1206 expand_end_bindings is not passed the list of variables in the
1207 current scope, and therefore no warning is emitted. So, we
1208 explicitly warn here. */
1209 if (!processing_template_decl)
1210 warn_about_unused_variables (getdecls ());
1212 /* If there were any declarations or structure tags in that level,
1213 or if this level is a function body,
1214 create a BLOCK to record them for the life of this function. */
1216 block_previously_created = (current_binding_level->this_block != NULL_TREE);
1217 if (block_previously_created)
1218 block = current_binding_level->this_block;
1219 else if (keep == 1 || functionbody)
1220 block = make_node (BLOCK);
1221 if (block != NULL_TREE)
1223 if (block_previously_created)
1225 if (decls || tags || subblocks)
1227 if (BLOCK_VARS (block))
1228 warning ("internal compiler error: debugging info corrupted");
1230 BLOCK_VARS (block) = decls;
1232 /* We can have previous subblocks and new subblocks when
1233 doing fixup_gotos with complex cleanups. We chain the new
1234 subblocks onto the end of any pre-existing subblocks. */
1235 BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1241 BLOCK_VARS (block) = decls;
1242 BLOCK_SUBBLOCKS (block) = subblocks;
1246 /* In each subblock, record that this is its superior. */
1248 for (link = subblocks; link; link = TREE_CHAIN (link))
1249 BLOCK_SUPERCONTEXT (link) = block;
1251 /* We still support the old for-scope rules, whereby the variables
1252 in a for-init statement were in scope after the for-statement
1253 ended. We only use the new rules in flag_new_for_scope is
1256 = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1258 /* Remove declarations for all the DECLs in this level. */
1259 for (link = decls; link; link = TREE_CHAIN (link))
1261 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1264 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1268 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1270 ns_binding = NULL_TREE;
1273 && (BINDING_LEVEL (outer_binding)
1274 == current_binding_level->level_chain))
1275 /* We have something like:
1280 and we are leaving the `for' scope. There's no reason to
1281 keep the binding of the inner `i' in this case. */
1282 pop_binding (DECL_NAME (link), link);
1283 else if ((outer_binding
1284 && (TREE_CODE (BINDING_VALUE (outer_binding))
1287 && TREE_CODE (ns_binding) == TYPE_DECL))
1288 /* Here, we have something like:
1296 We must pop the for-scope binding so we know what's a
1297 type and what isn't. */
1298 pop_binding (DECL_NAME (link), link);
1301 /* Mark this VAR_DECL as dead so that we can tell we left it
1302 there only for backward compatibility. */
1303 DECL_DEAD_FOR_LOCAL (link) = 1;
1305 /* Keep track of what should of have happenned when we
1306 popped the binding. */
1307 if (outer_binding && BINDING_VALUE (outer_binding))
1308 DECL_SHADOWED_FOR_VAR (link)
1309 = BINDING_VALUE (outer_binding);
1311 /* Add it to the list of dead variables in the next
1312 outermost binding to that we can remove these when we
1313 leave that binding. */
1314 current_binding_level->level_chain->dead_vars_from_for
1315 = tree_cons (NULL_TREE, link,
1316 current_binding_level->level_chain->
1317 dead_vars_from_for);
1319 /* Although we don't pop the CPLUS_BINDING, we do clear
1320 its BINDING_LEVEL since the level is going away now. */
1321 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1327 /* Remove the binding. */
1329 if (TREE_CODE (decl) == TREE_LIST)
1330 decl = TREE_VALUE (decl);
1331 if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd')
1332 pop_binding (DECL_NAME (decl), decl);
1333 else if (TREE_CODE (decl) == OVERLOAD)
1334 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1336 my_friendly_abort (0);
1340 /* Remove declarations for any `for' variables from inner scopes
1341 that we kept around. */
1342 for (link = current_binding_level->dead_vars_from_for;
1343 link; link = TREE_CHAIN (link))
1344 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1346 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1347 for (link = current_binding_level->type_shadowed;
1348 link; link = TREE_CHAIN (link))
1349 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1351 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1352 for (link = current_binding_level->shadowed_labels;
1354 link = TREE_CHAIN (link))
1357 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1358 list if a `using' declaration put them there. The debugging
1359 back-ends won't understand OVERLOAD, so we remove them here.
1360 Because the BLOCK_VARS are (temporarily) shared with
1361 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1362 popped all the bindings. */
1367 for (d = &BLOCK_VARS (block); *d; )
1369 if (TREE_CODE (*d) == TREE_LIST)
1370 *d = TREE_CHAIN (*d);
1372 d = &TREE_CHAIN (*d);
1376 /* If the level being exited is the top level of a function,
1377 check over all the labels. */
1380 /* Since this is the top level block of a function, the vars are
1381 the function's parameters. Don't leave them in the BLOCK
1382 because they are found in the FUNCTION_DECL instead. */
1383 BLOCK_VARS (block) = 0;
1387 /* Any uses of undefined labels now operate under constraints
1388 of next binding contour. */
1391 struct binding_level *level_chain;
1392 level_chain = current_binding_level->level_chain;
1395 struct named_label_list *labels;
1396 for (labels = named_label_uses; labels; labels = labels->next)
1397 if (labels->binding_level == current_binding_level)
1399 labels->binding_level = level_chain;
1400 labels->names_in_scope = level_chain->names;
1405 tmp = current_binding_level->keep;
1407 pop_binding_level ();
1409 DECL_INITIAL (current_function_decl) = block;
1412 if (!block_previously_created)
1413 current_binding_level->blocks
1414 = chainon (current_binding_level->blocks, block);
1416 /* If we did not make a block for the level just exited,
1417 any blocks made for inner levels
1418 (since they cannot be recorded as subblocks in that level)
1419 must be carried forward so they will later become subblocks
1420 of something else. */
1422 current_binding_level->blocks
1423 = chainon (current_binding_level->blocks, subblocks);
1425 /* Each and every BLOCK node created here in `poplevel' is important
1426 (e.g. for proper debugging information) so if we created one
1427 earlier, mark it as "used". */
1429 TREE_USED (block) = 1;
1431 /* Take care of compiler's internal binding structures. */
1437 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1440 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1441 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1444 block = poplevel (keep, reverse, functionbody);
1450 /* Delete the node BLOCK from the current binding level.
1451 This is used for the block inside a stmt expr ({...})
1452 so that the block can be reinserted where appropriate. */
1455 delete_block (block)
1459 if (current_binding_level->blocks == block)
1460 current_binding_level->blocks = TREE_CHAIN (block);
1461 for (t = current_binding_level->blocks; t;)
1463 if (TREE_CHAIN (t) == block)
1464 TREE_CHAIN (t) = TREE_CHAIN (block);
1468 TREE_CHAIN (block) = NULL_TREE;
1469 /* Clear TREE_USED which is always set by poplevel.
1470 The flag is set again if insert_block is called. */
1471 TREE_USED (block) = 0;
1474 /* Insert BLOCK at the end of the list of subblocks of the
1475 current binding level. This is used when a BIND_EXPR is expanded,
1476 to handle the BLOCK node inside the BIND_EXPR. */
1479 insert_block (block)
1482 TREE_USED (block) = 1;
1483 current_binding_level->blocks
1484 = chainon (current_binding_level->blocks, block);
1487 /* Set the BLOCK node for the innermost scope
1488 (the one we are currently in). */
1492 register tree block;
1494 current_binding_level->this_block = block;
1497 /* Do a pushlevel for class declarations. */
1502 register struct binding_level *newlevel;
1504 /* Reuse or create a struct for this binding level. */
1505 #if defined(DEBUG_CP_BINDING_LEVELS)
1507 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1508 if (free_binding_level)
1509 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1511 newlevel = free_binding_level;
1512 free_binding_level = free_binding_level->level_chain;
1515 newlevel = make_binding_level ();
1517 #if defined(DEBUG_CP_BINDING_LEVELS)
1519 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1521 push_binding_level (newlevel, 0, 0);
1523 class_binding_level = current_binding_level;
1524 class_binding_level->parm_flag = 2;
1527 /* ...and a poplevel for class declarations. */
1532 register struct binding_level *level = class_binding_level;
1535 my_friendly_assert (level != 0, 354);
1537 /* If we're leaving a toplevel class, don't bother to do the setting
1538 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1539 shouldn't even be used when current_class_type isn't set, and second,
1540 if we don't touch it here, we're able to use the cache effect if the
1541 next time we're entering a class scope, it is the same class. */
1542 if (current_class_depth != 1)
1544 struct binding_level* b;
1546 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1547 for (shadowed = level->class_shadowed;
1549 shadowed = TREE_CHAIN (shadowed))
1550 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1552 /* Find the next enclosing class, and recreate
1553 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1554 b = level->level_chain;
1555 while (b && b->parm_flag != 2)
1559 for (shadowed = b->class_shadowed;
1561 shadowed = TREE_CHAIN (shadowed))
1565 t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1566 while (t && BINDING_LEVEL (t) != b)
1570 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1571 = BINDING_VALUE (t);
1575 /* Remember to save what IDENTIFIER's were bound in this scope so we
1576 can recover from cache misses. */
1578 previous_class_type = current_class_type;
1579 previous_class_values = class_binding_level->class_shadowed;
1581 for (shadowed = level->type_shadowed;
1583 shadowed = TREE_CHAIN (shadowed))
1584 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1586 /* Remove the bindings for all of the class-level declarations. */
1587 for (shadowed = level->class_shadowed;
1589 shadowed = TREE_CHAIN (shadowed))
1590 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1592 GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1593 (HOST_WIDE_INT) class_binding_level->level_chain,
1594 class_binding_level->parm_flag,
1595 class_binding_level->keep);
1597 /* Now, pop out of the binding level which we created up in the
1598 `pushlevel_class' routine. */
1599 #if defined(DEBUG_CP_BINDING_LEVELS)
1601 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1603 pop_binding_level ();
1606 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1607 for any names in enclosing classes. */
1610 clear_identifier_class_values ()
1614 if (!class_binding_level)
1617 for (t = class_binding_level->class_shadowed;
1620 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1623 /* Returns non-zero if T is a virtual function table. */
1626 vtable_decl_p (t, data)
1628 void *data ATTRIBUTE_UNUSED;
1630 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1633 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1637 vtype_decl_p (t, data)
1639 void *data ATTRIBUTE_UNUSED;
1641 return (TREE_CODE (t) == TYPE_DECL
1642 && TREE_TYPE (t) != error_mark_node
1643 && TYPE_LANG_SPECIFIC (TREE_TYPE (t))
1644 && CLASSTYPE_VSIZE (TREE_TYPE (t)));
1647 /* Return the declarations that are members of the namespace NS. */
1650 cp_namespace_decls (ns)
1653 return NAMESPACE_LEVEL (ns)->names;
1656 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1657 itself, calling F for each. The DATA is passed to F as well. */
1660 walk_namespaces_r (namespace, f, data)
1662 walk_namespaces_fn f;
1668 result |= (*f) (namespace, data);
1670 for (current = cp_namespace_decls (namespace);
1672 current = TREE_CHAIN (current))
1674 if (TREE_CODE (current) != NAMESPACE_DECL
1675 || DECL_NAMESPACE_ALIAS (current))
1677 if (!DECL_LANG_SPECIFIC (current))
1680 my_friendly_assert (current == std_node, 393);
1684 /* We found a namespace. */
1685 result |= walk_namespaces_r (current, f, data);
1691 /* Walk all the namespaces, calling F for each. The DATA is passed to
1695 walk_namespaces (f, data)
1696 walk_namespaces_fn f;
1699 return walk_namespaces_r (global_namespace, f, data);
1702 struct walk_globals_data {
1703 walk_globals_pred p;
1708 /* Walk the global declarations in NAMESPACE. Whenever one is found
1709 for which P returns non-zero, call F with its address. If any call
1710 to F returns a non-zero value, return a non-zero value. */
1713 walk_globals_r (namespace, data)
1717 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1718 walk_globals_pred p = wgd->p;
1719 walk_globals_fn f = wgd->f;
1720 void *d = wgd->data;
1724 t = &NAMESPACE_LEVEL (namespace)->names;
1731 result |= (*f) (t, d);
1733 /* If F changed *T, then *T still points at the next item to
1736 t = &TREE_CHAIN (*t);
1742 /* Walk the global declarations. Whenever one is found for which P
1743 returns non-zero, call F with its address. If any call to F
1744 returns a non-zero value, return a non-zero value. */
1747 walk_globals (p, f, data)
1748 walk_globals_pred p;
1752 struct walk_globals_data wgd;
1757 return walk_namespaces (walk_globals_r, &wgd);
1760 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1761 DATA is non-NULL, this is the last time we will call
1762 wrapup_global_declarations for this NAMESPACE. */
1765 wrapup_globals_for_namespace (namespace, data)
1769 tree globals = cp_namespace_decls (namespace);
1770 int len = list_length (globals);
1771 tree *vec = (tree *) alloca (sizeof (tree) * len);
1775 int last_time = (data != 0);
1777 if (last_time && namespace == global_namespace)
1778 /* Let compile_file handle the global namespace. */
1781 /* Process the decls in reverse order--earliest first.
1782 Put them into VEC from back to front, then take out from front. */
1784 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1785 vec[len - i - 1] = decl;
1789 check_global_declarations (vec, len);
1793 /* Temporarily mark vtables as external. That prevents
1794 wrapup_global_declarations from writing them out; we must process
1795 them ourselves in finish_vtable_vardecl. */
1796 for (i = 0; i < len; ++i)
1797 if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1799 DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1800 DECL_EXTERNAL (vec[i]) = 1;
1803 /* Write out any globals that need to be output. */
1804 result = wrapup_global_declarations (vec, len);
1806 /* Undo the hack to DECL_EXTERNAL above. */
1807 for (i = 0; i < len; ++i)
1808 if (vtable_decl_p (vec[i], /*data=*/0)
1809 && DECL_NOT_REALLY_EXTERN (vec[i]))
1811 DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1812 DECL_EXTERNAL (vec[i]) = 0;
1819 /* Mark ARG (which is really a struct binding_level **) for GC. */
1822 mark_binding_level (arg)
1825 struct binding_level *lvl = *(struct binding_level **)arg;
1829 ggc_mark_tree (lvl->names);
1830 ggc_mark_tree (lvl->tags);
1831 ggc_mark_tree (lvl->usings);
1832 ggc_mark_tree (lvl->using_directives);
1833 ggc_mark_tree (lvl->class_shadowed);
1834 ggc_mark_tree (lvl->type_shadowed);
1835 ggc_mark_tree (lvl->shadowed_labels);
1836 ggc_mark_tree (lvl->blocks);
1837 ggc_mark_tree (lvl->this_block);
1838 ggc_mark_tree (lvl->incomplete);
1839 ggc_mark_tree (lvl->dead_vars_from_for);
1841 lvl = lvl->level_chain;
1845 /* For debugging. */
1846 static int no_print_functions = 0;
1847 static int no_print_builtins = 0;
1850 print_binding_level (lvl)
1851 struct binding_level *lvl;
1855 fprintf (stderr, " blocks=");
1856 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1857 fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1858 list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1859 if (lvl->tag_transparent)
1860 fprintf (stderr, " tag-transparent");
1861 if (lvl->more_cleanups_ok)
1862 fprintf (stderr, " more-cleanups-ok");
1863 if (lvl->have_cleanups)
1864 fprintf (stderr, " have-cleanups");
1865 fprintf (stderr, "\n");
1868 fprintf (stderr, " names:\t");
1869 /* We can probably fit 3 names to a line? */
1870 for (t = lvl->names; t; t = TREE_CHAIN (t))
1872 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1874 if (no_print_builtins
1875 && (TREE_CODE (t) == TYPE_DECL)
1876 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1879 /* Function decls tend to have longer names. */
1880 if (TREE_CODE (t) == FUNCTION_DECL)
1887 fprintf (stderr, "\n\t");
1890 print_node_brief (stderr, "", t, 0);
1891 if (t == error_mark_node)
1895 fprintf (stderr, "\n");
1899 fprintf (stderr, " tags:\t");
1901 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1903 if (TREE_PURPOSE (t) == NULL_TREE)
1905 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1912 fprintf (stderr, "\n\t");
1915 if (TREE_PURPOSE (t) == NULL_TREE)
1917 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1918 fprintf (stderr, ">");
1920 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1921 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1924 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1925 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1926 fprintf (stderr, ">");
1930 fprintf (stderr, "\n");
1932 if (lvl->class_shadowed)
1934 fprintf (stderr, " class-shadowed:");
1935 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1937 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1939 fprintf (stderr, "\n");
1941 if (lvl->type_shadowed)
1943 fprintf (stderr, " type-shadowed:");
1944 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1946 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1948 fprintf (stderr, "\n");
1953 print_other_binding_stack (stack)
1954 struct binding_level *stack;
1956 struct binding_level *level;
1957 for (level = stack; level != global_binding_level; level = level->level_chain)
1959 fprintf (stderr, "binding level ");
1960 fprintf (stderr, HOST_PTR_PRINTF, level);
1961 fprintf (stderr, "\n");
1962 print_binding_level (level);
1967 print_binding_stack ()
1969 struct binding_level *b;
1970 fprintf (stderr, "current_binding_level=");
1971 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
1972 fprintf (stderr, "\nclass_binding_level=");
1973 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
1974 fprintf (stderr, "\nglobal_binding_level=");
1975 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
1976 fprintf (stderr, "\n");
1977 if (class_binding_level)
1979 for (b = class_binding_level; b; b = b->level_chain)
1980 if (b == current_binding_level)
1983 b = class_binding_level;
1985 b = current_binding_level;
1988 b = current_binding_level;
1989 print_other_binding_stack (b);
1990 fprintf (stderr, "global:\n");
1991 print_binding_level (global_binding_level);
1994 /* Namespace binding access routines: The namespace_bindings field of
1995 the identifier is polymorphic, with three possible values:
1996 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
1997 indicating the BINDING_VALUE of global_namespace. */
1999 /* Check whether the a binding for the name to scope is known.
2000 Assumes that the bindings of the name are already a list
2001 of bindings. Returns the binding found, or NULL_TREE. */
2004 find_binding (name, scope)
2008 tree iter, prev = NULL_TREE;
2010 scope = ORIGINAL_NAMESPACE (scope);
2012 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2013 iter = TREE_CHAIN (iter))
2015 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2016 if (BINDING_SCOPE (iter) == scope)
2018 /* Move binding found to the front of the list, so
2019 subsequent lookups will find it faster. */
2022 TREE_CHAIN (prev) = TREE_CHAIN (iter);
2023 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2024 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2033 /* Always returns a binding for name in scope. If the
2034 namespace_bindings is not a list, convert it to one first.
2035 If no binding is found, make a new one. */
2038 binding_for_name (name, scope)
2042 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2045 scope = ORIGINAL_NAMESPACE (scope);
2047 if (b && TREE_CODE (b) != CPLUS_BINDING)
2049 /* Get rid of optimization for global scope. */
2050 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2051 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2052 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2054 if (b && (result = find_binding (name, scope)))
2056 /* Not found, make a new one. */
2057 result = make_node (CPLUS_BINDING);
2058 TREE_CHAIN (result) = b;
2059 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2060 BINDING_SCOPE (result) = scope;
2061 BINDING_TYPE (result) = NULL_TREE;
2062 BINDING_VALUE (result) = NULL_TREE;
2066 /* Return the binding value for name in scope, considering that
2067 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2070 namespace_binding (name, scope)
2074 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2077 if (scope == NULL_TREE)
2078 scope = global_namespace;
2079 if (TREE_CODE (b) != CPLUS_BINDING)
2080 return (scope == global_namespace) ? b : NULL_TREE;
2081 name = find_binding (name,scope);
2082 if (name == NULL_TREE)
2084 return BINDING_VALUE (name);
2087 /* Set the binding value for name in scope. If modifying the binding
2088 of global_namespace is attempted, try to optimize it. */
2091 set_namespace_binding (name, scope, val)
2098 if (scope == NULL_TREE)
2099 scope = global_namespace;
2101 if (scope == global_namespace)
2103 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2104 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2106 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2110 b = binding_for_name (name, scope);
2111 BINDING_VALUE (b) = val;
2114 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2115 select a name that is unique to this compilation unit. */
2118 push_namespace (name)
2123 int implicit_use = 0;
2125 if (!global_namespace)
2127 /* This must be ::. */
2128 my_friendly_assert (name == get_identifier ("::"), 377);
2133 /* The name of anonymous namespace is unique for the translation
2135 if (!anonymous_namespace_name)
2136 anonymous_namespace_name = get_file_function_name ('N');
2137 name = anonymous_namespace_name;
2138 d = IDENTIFIER_NAMESPACE_VALUE (name);
2140 /* Reopening anonymous namespace. */
2144 else if (current_namespace == global_namespace
2145 && name == DECL_NAME (std_node))
2152 /* Check whether this is an extended namespace definition. */
2153 d = IDENTIFIER_NAMESPACE_VALUE (name);
2154 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2157 if (DECL_NAMESPACE_ALIAS (d))
2159 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2160 d, DECL_NAMESPACE_ALIAS (d));
2161 d = DECL_NAMESPACE_ALIAS (d);
2168 /* Make a new namespace, binding the name to it. */
2169 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2170 /* The global namespace is not pushed, and the global binding
2171 level is set elsewhere. */
2176 declare_namespace_level ();
2177 NAMESPACE_LEVEL (d) = current_binding_level;
2181 resume_binding_level (NAMESPACE_LEVEL (d));
2184 do_using_directive (d);
2185 /* Enter the name space. */
2186 current_namespace = d;
2189 /* Pop from the scope of the current namespace. */
2194 if (current_namespace == global_namespace)
2196 my_friendly_assert (in_std>0, 980421);
2200 current_namespace = CP_DECL_CONTEXT (current_namespace);
2201 /* The binding level is not popped, as it might be re-opened later. */
2202 suspend_binding_level ();
2205 /* Push into the scope of the namespace NS, even if it is deeply
2206 nested within another namespace. */
2209 push_nested_namespace (ns)
2212 if (ns == global_namespace)
2213 push_to_top_level ();
2216 push_nested_namespace (CP_DECL_CONTEXT (ns));
2217 push_namespace (DECL_NAME (ns));
2221 /* Pop back from the scope of the namespace NS, which was previously
2222 entered with push_nested_namespace. */
2225 pop_nested_namespace (ns)
2228 while (ns != global_namespace)
2231 ns = CP_DECL_CONTEXT (ns);
2234 pop_from_top_level ();
2238 /* Subroutines for reverting temporarily to top-level for instantiation
2239 of templates and such. We actually need to clear out the class- and
2240 local-value slots of all identifiers, so that only the global values
2241 are at all visible. Simply setting current_binding_level to the global
2242 scope isn't enough, because more binding levels may be pushed. */
2243 struct saved_scope *scope_chain;
2245 /* Mark ST for GC. */
2249 struct stmt_tree *st;
2251 ggc_mark_tree (st->x_last_stmt);
2252 ggc_mark_tree (st->x_last_expr_type);
2255 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2258 mark_saved_scope (arg)
2261 struct saved_scope *t = *(struct saved_scope **)arg;
2264 mark_binding_level (&t->class_bindings);
2265 ggc_mark_tree (t->old_bindings);
2266 ggc_mark_tree (t->old_namespace);
2267 ggc_mark_tree (t->class_name);
2268 ggc_mark_tree (t->class_type);
2269 ggc_mark_tree (t->access_specifier);
2270 ggc_mark_tree (t->function_decl);
2272 ggc_mark_tree_varray (t->lang_base);
2273 ggc_mark_tree (t->lang_name);
2274 ggc_mark_tree (t->x_function_parms);
2275 ggc_mark_tree (t->template_parms);
2276 ggc_mark_tree (t->x_previous_class_type);
2277 ggc_mark_tree (t->x_previous_class_values);
2278 ggc_mark_tree (t->x_saved_tree);
2280 mark_stmt_tree (&t->x_stmt_tree);
2281 mark_binding_level (&t->bindings);
2287 store_bindings (names, old_bindings)
2288 tree names, old_bindings;
2291 for (t = names; t; t = TREE_CHAIN (t))
2293 tree binding, t1, id;
2295 if (TREE_CODE (t) == TREE_LIST)
2296 id = TREE_PURPOSE (t);
2301 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2302 we have no IDENTIFIER_BINDING if we have left the class
2303 scope, but cached the class-level declarations. */
2304 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2307 for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2308 if (TREE_VEC_ELT (t1, 0) == id)
2311 binding = make_tree_vec (4);
2315 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2316 TREE_VEC_ELT (binding, 0) = id;
2317 TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2318 TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2319 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2320 IDENTIFIER_BINDING (id) = NULL_TREE;
2321 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2323 TREE_CHAIN (binding) = old_bindings;
2324 old_bindings = binding;
2328 return old_bindings;
2332 maybe_push_to_top_level (pseudo)
2335 struct saved_scope *s;
2336 struct binding_level *b;
2340 s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2342 b = scope_chain ? current_binding_level : 0;
2344 /* If we're in the middle of some function, save our state. */
2348 push_function_context_to (NULL_TREE);
2353 old_bindings = NULL_TREE;
2354 if (scope_chain && previous_class_type)
2355 old_bindings = store_bindings (previous_class_values, old_bindings);
2357 /* Have to include global_binding_level, because class-level decls
2358 aren't listed anywhere useful. */
2359 for (; b; b = b->level_chain)
2363 /* Template IDs are inserted into the global level. If they were
2364 inserted into namespace level, finish_file wouldn't find them
2365 when doing pending instantiations. Therefore, don't stop at
2366 namespace level, but continue until :: . */
2367 if (b == global_binding_level || (pseudo && b->pseudo_global))
2370 old_bindings = store_bindings (b->names, old_bindings);
2371 /* We also need to check class_shadowed to save class-level type
2372 bindings, since pushclass doesn't fill in b->names. */
2373 if (b->parm_flag == 2)
2374 old_bindings = store_bindings (b->class_shadowed, old_bindings);
2376 /* Unwind type-value slots back to top level. */
2377 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2378 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2380 s->prev = scope_chain;
2381 s->old_bindings = old_bindings;
2383 s->need_pop_function_context = need_pop;
2384 s->function_decl = current_function_decl;
2387 current_function_decl = NULL_TREE;
2388 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2389 current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2390 current_lang_name = lang_name_cplusplus;
2391 strict_prototype = strict_prototypes_lang_cplusplus;
2392 current_namespace = global_namespace;
2396 push_to_top_level ()
2398 maybe_push_to_top_level (0);
2402 pop_from_top_level ()
2404 struct saved_scope *s = scope_chain;
2407 /* Clear out class-level bindings cache. */
2408 if (previous_class_type)
2409 invalidate_class_lookup_cache ();
2411 VARRAY_FREE (current_lang_base);
2413 scope_chain = s->prev;
2414 for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2416 tree id = TREE_VEC_ELT (t, 0);
2419 SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2420 IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2421 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2425 if (current_lang_name == lang_name_cplusplus)
2426 strict_prototype = strict_prototypes_lang_cplusplus;
2427 else if (current_lang_name == lang_name_c)
2428 strict_prototype = strict_prototypes_lang_c;
2430 /* If we were in the middle of compiling a function, restore our
2432 if (s->need_pop_function_context)
2433 pop_function_context_from (NULL_TREE);
2434 current_function_decl = s->function_decl;
2439 /* Push a definition of struct, union or enum tag "name".
2440 into binding_level "b". "type" should be the type node,
2441 We assume that the tag "name" is not already defined.
2443 Note that the definition may really be just a forward reference.
2444 In that case, the TYPE_SIZE will be a NULL_TREE.
2446 C++ gratuitously puts all these tags in the name space. */
2448 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2449 record the shadowed value for this binding contour. TYPE is
2450 the type that ID maps to. */
2453 set_identifier_type_value_with_scope (id, type, b)
2456 struct binding_level *b;
2458 if (!b->namespace_p)
2460 /* Shadow the marker, not the real thing, so that the marker
2461 gets restored later. */
2462 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2464 = tree_cons (id, old_type_value, b->type_shadowed);
2468 tree binding = binding_for_name (id, current_namespace);
2469 BINDING_TYPE (binding) = type;
2470 /* Store marker instead of real type. */
2471 type = global_type_node;
2473 SET_IDENTIFIER_TYPE_VALUE (id, type);
2476 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2479 set_identifier_type_value (id, type)
2483 set_identifier_type_value_with_scope (id, type, current_binding_level);
2486 /* Return the type associated with id. */
2489 identifier_type_value (id)
2492 /* There is no type with that name, anywhere. */
2493 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2495 /* This is not the type marker, but the real thing. */
2496 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2497 return REAL_IDENTIFIER_TYPE_VALUE (id);
2498 /* Have to search for it. It must be on the global level, now.
2499 Ask lookup_name not to return non-types. */
2500 id = lookup_name_real (id, 2, 1, 0);
2502 return TREE_TYPE (id);
2506 /* Pop off extraneous binding levels left over due to syntax errors.
2508 We don't pop past namespaces, as they might be valid. */
2513 #ifdef DEBUG_CP_BINDING_LEVELS
2514 fprintf (stderr, "XXX entering pop_everything ()\n");
2516 while (!toplevel_bindings_p ())
2518 if (current_binding_level->parm_flag == 2)
2519 pop_nested_class ();
2523 #ifdef DEBUG_CP_BINDING_LEVELS
2524 fprintf (stderr, "XXX leaving pop_everything ()\n");
2528 /* The type TYPE is being declared. If it is a class template, or a
2529 specialization of a class template, do any processing required and
2530 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2531 being declared a friend. B is the binding level at which this TYPE
2534 Returns the TYPE_DECL for TYPE, which may have been altered by this
2538 maybe_process_template_type_declaration (type, globalize, b)
2541 struct binding_level* b;
2543 tree decl = TYPE_NAME (type);
2545 if (processing_template_parmlist)
2546 /* You can't declare a new template type in a template parameter
2547 list. But, you can declare a non-template type:
2549 template <class A*> struct S;
2551 is a forward-declaration of `A'. */
2555 maybe_check_template_type (type);
2557 my_friendly_assert (IS_AGGR_TYPE (type)
2558 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2561 if (processing_template_decl)
2563 /* This may change after the call to
2564 push_template_decl_real, but we want the original value. */
2565 tree name = DECL_NAME (decl);
2567 decl = push_template_decl_real (decl, globalize);
2568 /* If the current binding level is the binding level for the
2569 template parameters (see the comment in
2570 begin_template_parm_list) and the enclosing level is a class
2571 scope, and we're not looking at a friend, push the
2572 declaration of the member class into the class scope. In the
2573 friend case, push_template_decl will already have put the
2574 friend into global scope, if appropriate. */
2575 if (TREE_CODE (type) != ENUMERAL_TYPE
2576 && !globalize && b->pseudo_global
2577 && b->level_chain->parm_flag == 2)
2579 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2580 /* Put this tag on the list of tags for the class, since
2581 that won't happen below because B is not the class
2582 binding level, but is instead the pseudo-global level. */
2583 b->level_chain->tags =
2584 tree_cons (name, type, b->level_chain->tags);
2585 if (TYPE_SIZE (current_class_type) == NULL_TREE)
2586 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2594 /* In C++, you don't have to write `struct S' to refer to `S'; you
2595 can just use `S'. We accomplish this by creating a TYPE_DECL as
2596 if the user had written `typedef struct S S'. Create and return
2597 the TYPE_DECL for TYPE. */
2600 create_implicit_typedef (name, type)
2606 decl = build_decl (TYPE_DECL, name, type);
2607 SET_DECL_ARTIFICIAL (decl);
2608 /* There are other implicit type declarations, like the one *within*
2609 a class that allows you to write `S::S'. We must distinguish
2611 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2612 TYPE_NAME (type) = decl;
2617 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2618 Normally put it into the inner-most non-tag-transparent scope,
2619 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2620 The latter is needed for implicit declarations. */
2623 pushtag (name, type, globalize)
2627 register struct binding_level *b;
2629 b = current_binding_level;
2630 while (b->tag_transparent
2631 || (globalize && b->parm_flag == 2))
2634 b->tags = tree_cons (name, type, b->tags);
2638 /* Do C++ gratuitous typedefing. */
2639 if (IDENTIFIER_TYPE_VALUE (name) != type)
2641 register tree d = NULL_TREE;
2643 tree context = TYPE_CONTEXT (type);
2647 tree cs = current_scope ();
2651 else if (cs != NULL_TREE
2652 && TREE_CODE_CLASS (TREE_CODE (cs)) == 't')
2653 /* When declaring a friend class of a local class, we want
2654 to inject the newly named class into the scope
2655 containing the local class, not the namespace scope. */
2656 context = hack_decl_function_context (get_type_decl (cs));
2659 context = current_namespace;
2661 if ((b->pseudo_global && b->level_chain->parm_flag == 2)
2662 || b->parm_flag == 2)
2665 if (current_lang_name == lang_name_java)
2666 TYPE_FOR_JAVA (type) = 1;
2668 d = create_implicit_typedef (name, type);
2669 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2671 set_identifier_type_value_with_scope (name, type, b);
2673 d = maybe_process_template_type_declaration (type,
2676 if (b->parm_flag == 2)
2678 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2679 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2680 class. But if it's a member template class, we
2681 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2683 finish_member_declaration (d);
2685 pushdecl_class_level (d);
2688 d = pushdecl_with_scope (d, b);
2690 if (ANON_AGGRNAME_P (name))
2691 DECL_IGNORED_P (d) = 1;
2693 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2694 DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2695 if (!uses_template_parms (type))
2696 DECL_ASSEMBLER_NAME (d)
2697 = get_identifier (build_overload_name (type, 1, 1));
2699 if (b->parm_flag == 2)
2701 if (TYPE_SIZE (current_class_type) == NULL_TREE)
2702 CLASSTYPE_TAGS (current_class_type) = b->tags;
2706 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2707 /* Use the canonical TYPE_DECL for this node. */
2708 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2711 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2712 will be the tagged type we just added to the current
2713 binding level. This fake NULL-named TYPE_DECL node helps
2714 dwarfout.c to know when it needs to output a
2715 representation of a tagged type, and it also gives us a
2716 convenient place to record the "scope start" address for
2719 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2720 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2724 /* Counter used to create anonymous type names. */
2726 static int anon_cnt = 0;
2728 /* Return an IDENTIFIER which can be used as a name for
2729 anonymous structs and unions. */
2736 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2737 return get_identifier (buf);
2740 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2741 This keeps dbxout from getting confused. */
2746 register struct binding_level *b;
2748 static int last_cnt = 0;
2750 /* Fast out if no new anon names were declared. */
2751 if (last_cnt == anon_cnt)
2754 b = current_binding_level;
2755 while (b->tag_transparent)
2760 /* A NULL purpose means we have already processed all tags
2761 from here to the end of the list. */
2762 if (TREE_PURPOSE (tags) == NULL_TREE)
2764 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2765 TREE_PURPOSE (tags) = NULL_TREE;
2766 tags = TREE_CHAIN (tags);
2768 last_cnt = anon_cnt;
2771 /* Subroutine of duplicate_decls: return truthvalue of whether
2772 or not types of these decls match.
2774 For C++, we must compare the parameter list so that `int' can match
2775 `int&' in a parameter position, but `int&' is not confused with
2779 decls_match (newdecl, olddecl)
2780 tree newdecl, olddecl;
2784 if (newdecl == olddecl)
2787 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2788 /* If the two DECLs are not even the same kind of thing, we're not
2789 interested in their types. */
2792 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2794 tree f1 = TREE_TYPE (newdecl);
2795 tree f2 = TREE_TYPE (olddecl);
2796 tree p1 = TYPE_ARG_TYPES (f1);
2797 tree p2 = TYPE_ARG_TYPES (f2);
2799 if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl)
2800 && ! (DECL_LANGUAGE (newdecl) == lang_c
2801 && DECL_LANGUAGE (olddecl) == lang_c))
2804 /* When we parse a static member function definition,
2805 we put together a FUNCTION_DECL which thinks its type
2806 is METHOD_TYPE. Change that to FUNCTION_TYPE, and
2808 if (TREE_CODE (f1) == METHOD_TYPE && DECL_STATIC_FUNCTION_P (olddecl))
2809 revert_static_member_fn (&newdecl, &f1, &p1);
2810 else if (TREE_CODE (f2) == METHOD_TYPE
2811 && DECL_STATIC_FUNCTION_P (newdecl))
2812 revert_static_member_fn (&olddecl, &f2, &p2);
2814 /* Here we must take care of the case where new default
2815 parameters are specified. Also, warn if an old
2816 declaration becomes ambiguous because default
2817 parameters may cause the two to be ambiguous. */
2818 if (TREE_CODE (f1) != TREE_CODE (f2))
2820 if (TREE_CODE (f1) == OFFSET_TYPE)
2821 cp_compiler_error ("`%D' redeclared as member function", newdecl);
2823 cp_compiler_error ("`%D' redeclared as non-member function", newdecl);
2827 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2829 if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2832 types_match = self_promoting_args_p (p1);
2833 if (p1 == void_list_node)
2834 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2836 else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2837 && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2839 types_match = self_promoting_args_p (p2);
2840 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2843 types_match = compparms (p1, p2);
2848 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2850 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2851 DECL_TEMPLATE_PARMS (olddecl)))
2854 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2857 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2858 DECL_TEMPLATE_RESULT (newdecl));
2862 if (TREE_TYPE (newdecl) == error_mark_node)
2863 types_match = TREE_TYPE (olddecl) == error_mark_node;
2864 else if (TREE_TYPE (olddecl) == NULL_TREE)
2865 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2866 else if (TREE_TYPE (newdecl) == NULL_TREE)
2869 types_match = comptypes (TREE_TYPE (newdecl),
2870 TREE_TYPE (olddecl),
2871 COMPARE_REDECLARATION);
2877 /* If NEWDECL is `static' and an `extern' was seen previously,
2878 warn about it. OLDDECL is the previous declaration.
2880 Note that this does not apply to the C++ case of declaring
2881 a variable `extern const' and then later `const'.
2883 Don't complain about built-in functions, since they are beyond
2884 the user's control. */
2887 warn_extern_redeclared_static (newdecl, olddecl)
2888 tree newdecl, olddecl;
2890 static const char *explicit_extern_static_warning
2891 = "`%D' was declared `extern' and later `static'";
2892 static const char *implicit_extern_static_warning
2893 = "`%D' was declared implicitly `extern' and later `static'";
2897 if (TREE_CODE (newdecl) == TYPE_DECL
2898 || TREE_CODE (newdecl) == TEMPLATE_DECL)
2901 /* Don't get confused by static member functions; that's a different
2903 if (TREE_CODE (newdecl) == FUNCTION_DECL
2904 && DECL_STATIC_FUNCTION_P (newdecl))
2907 /* If the old declaration was `static', or the new one isn't, then
2908 then everything is OK. */
2909 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2912 /* It's OK to declare a builtin function as `static'. */
2913 if (TREE_CODE (olddecl) == FUNCTION_DECL
2914 && DECL_ARTIFICIAL (olddecl))
2917 name = DECL_ASSEMBLER_NAME (newdecl);
2918 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2919 ? implicit_extern_static_warning
2920 : explicit_extern_static_warning, newdecl);
2921 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2924 /* Handle when a new declaration NEWDECL has the same name as an old
2925 one OLDDECL in the same binding contour. Prints an error message
2928 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2929 Otherwise, return 0. */
2932 duplicate_decls (newdecl, olddecl)
2933 tree newdecl, olddecl;
2935 unsigned olddecl_uid = DECL_UID (olddecl);
2936 int olddecl_friend = 0, types_match = 0;
2937 int new_defines_function = 0;
2939 if (newdecl == olddecl)
2942 types_match = decls_match (newdecl, olddecl);
2944 /* If either the type of the new decl or the type of the old decl is an
2945 error_mark_node, then that implies that we have already issued an
2946 error (earlier) for some bogus type specification, and in that case,
2947 it is rather pointless to harass the user with yet more error message
2948 about the same declaration, so just pretend the types match here. */
2949 if (TREE_TYPE (newdecl) == error_mark_node
2950 || TREE_TYPE (olddecl) == error_mark_node)
2953 /* Check for redeclaration and other discrepancies. */
2954 if (TREE_CODE (olddecl) == FUNCTION_DECL
2955 && DECL_ARTIFICIAL (olddecl))
2957 if (TREE_CODE (newdecl) != FUNCTION_DECL)
2959 /* If you declare a built-in or predefined function name as static,
2960 the old definition is overridden, but optionally warn this was a
2961 bad choice of name. */
2962 if (! TREE_PUBLIC (newdecl))
2965 cp_warning ("shadowing %s function `%#D'",
2966 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2968 /* Discard the old built-in function. */
2971 /* If the built-in is not ansi, then programs can override
2972 it even globally without an error. */
2973 else if (! DECL_BUILT_IN (olddecl))
2974 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
2978 cp_error ("declaration of `%#D'", newdecl);
2979 cp_error ("conflicts with built-in declaration `%#D'",
2984 else if (!types_match)
2986 if ((DECL_LANGUAGE (newdecl) == lang_c
2987 && DECL_LANGUAGE (olddecl) == lang_c)
2988 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
2989 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
2991 /* A near match; override the builtin. */
2993 if (TREE_PUBLIC (newdecl))
2995 cp_warning ("new declaration `%#D'", newdecl);
2996 cp_warning ("ambiguates built-in declaration `%#D'",
2999 else if (warn_shadow)
3000 cp_warning ("shadowing %s function `%#D'",
3001 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3005 /* Discard the old built-in function. */
3009 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3011 /* If a builtin function is redeclared as `static', merge
3012 the declarations, but make the original one static. */
3013 DECL_THIS_STATIC (olddecl) = 1;
3014 TREE_PUBLIC (olddecl) = 0;
3016 /* Make the olddeclaration consistent with the new one so that
3017 all remnants of the builtin-ness of this function will be
3019 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3020 DECL_RTL (olddecl) = DECL_RTL (newdecl);
3021 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3022 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3026 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3028 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3029 && TREE_CODE (newdecl) != TYPE_DECL
3030 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3031 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3032 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3033 && TREE_CODE (olddecl) != TYPE_DECL
3034 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3035 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3038 /* We do nothing special here, because C++ does such nasty
3039 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3040 get shadowed, and know that if we need to find a TYPE_DECL
3041 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3042 slot of the identifier. */
3046 if ((TREE_CODE (newdecl) == FUNCTION_DECL
3047 && DECL_FUNCTION_TEMPLATE_P (olddecl))
3048 || (TREE_CODE (olddecl) == FUNCTION_DECL
3049 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3052 cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3053 if (TREE_CODE (olddecl) == TREE_LIST)
3054 olddecl = TREE_VALUE (olddecl);
3055 cp_error_at ("previous declaration of `%#D'", olddecl);
3057 /* New decl is completely inconsistent with the old one =>
3058 tell caller to replace the old one. */
3062 else if (!types_match)
3064 if (DECL_REAL_CONTEXT (newdecl) != DECL_REAL_CONTEXT (olddecl))
3065 /* These are certainly not duplicate declarations; they're
3066 from different scopes. */
3069 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3071 /* The name of a class template may not be declared to refer to
3072 any other template, class, function, object, namespace, value,
3073 or type in the same scope. */
3074 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3075 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3077 cp_error ("declaration of template `%#D'", newdecl);
3078 cp_error_at ("conflicts with previous declaration `%#D'",
3081 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3082 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3083 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3084 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3085 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3086 DECL_TEMPLATE_PARMS (olddecl)))
3088 cp_error ("new declaration `%#D'", newdecl);
3089 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3093 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3095 if (DECL_LANGUAGE (newdecl) == lang_c
3096 && DECL_LANGUAGE (olddecl) == lang_c)
3098 cp_error ("declaration of C function `%#D' conflicts with",
3100 cp_error_at ("previous declaration `%#D' here", olddecl);
3102 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3103 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3105 cp_error ("new declaration `%#D'", newdecl);
3106 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3112 /* Already complained about this, so don't do so again. */
3113 else if (current_class_type == NULL_TREE
3114 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3116 cp_error ("conflicting types for `%#D'", newdecl);
3117 cp_error_at ("previous declaration as `%#D'", olddecl);
3120 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3121 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3122 && (!DECL_TEMPLATE_INFO (newdecl)
3123 || (DECL_TI_TEMPLATE (newdecl)
3124 != DECL_TI_TEMPLATE (olddecl))))
3125 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3126 && (!DECL_TEMPLATE_INFO (olddecl)
3127 || (DECL_TI_TEMPLATE (olddecl)
3128 != DECL_TI_TEMPLATE (newdecl))))))
3129 /* It's OK to have a template specialization and a non-template
3130 with the same type, or to have specializations of two
3131 different templates with the same type. Note that if one is a
3132 specialization, and the other is an instantiation of the same
3133 template, that we do not exit at this point. That situation
3134 can occur if we instantiate a template class, and then
3135 specialize one of its methods. This situation is legal, but
3136 the declarations must be merged in the usual way. */
3138 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3139 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3140 && !DECL_USE_TEMPLATE (newdecl))
3141 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3142 && !DECL_USE_TEMPLATE (olddecl))))
3143 /* One of the declarations is a template instantiation, and the
3144 other is not a template at all. That's OK. */
3146 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3147 && DECL_NAMESPACE_ALIAS (newdecl)
3148 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3149 /* Redeclaration of namespace alias, ignore it. */
3153 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3156 cp_error (errmsg, newdecl);
3157 if (DECL_NAME (olddecl) != NULL_TREE)
3158 cp_error_at ((DECL_INITIAL (olddecl)
3159 && namespace_bindings_p ())
3160 ? "`%#D' previously defined here"
3161 : "`%#D' previously declared here", olddecl);
3163 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3164 && DECL_INITIAL (olddecl) != NULL_TREE
3165 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3166 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3168 /* Prototype decl follows defn w/o prototype. */
3169 cp_warning_at ("prototype for `%#D'", newdecl);
3170 cp_warning_at ("follows non-prototype definition here", olddecl);
3172 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3173 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3175 /* extern "C" int foo ();
3176 int foo () { bar (); }
3178 if (current_lang_stack
3179 == &VARRAY_TREE (current_lang_base, 0))
3180 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3183 cp_error_at ("previous declaration of `%#D' with %L linkage",
3184 olddecl, DECL_LANGUAGE (olddecl));
3185 cp_error ("conflicts with new declaration with %L linkage",
3186 DECL_LANGUAGE (newdecl));
3190 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3192 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3194 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3195 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3198 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3199 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3201 for (; t1 && t1 != void_list_node;
3202 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3203 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3205 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3210 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3212 cp_pedwarn_at ("after previous specification in `%#D'",
3218 cp_error ("default argument given for parameter %d of `%#D'",
3220 cp_error_at ("after previous specification in `%#D'",
3225 if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3226 && TREE_ADDRESSABLE (olddecl) && warn_inline)
3228 cp_warning ("`%#D' was used before it was declared inline",
3230 cp_warning_at ("previous non-inline declaration here",
3236 /* If new decl is `static' and an `extern' was seen previously,
3238 warn_extern_redeclared_static (newdecl, olddecl);
3240 /* We have committed to returning 1 at this point. */
3241 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3243 /* Now that functions must hold information normally held
3244 by field decls, there is extra work to do so that
3245 declaration information does not get destroyed during
3247 if (DECL_VINDEX (olddecl))
3248 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3249 if (DECL_CONTEXT (olddecl))
3250 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3251 if (DECL_CLASS_CONTEXT (olddecl))
3252 DECL_CLASS_CONTEXT (newdecl) = DECL_CLASS_CONTEXT (olddecl);
3253 if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3254 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3255 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3256 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3257 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3258 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3259 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3260 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3261 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3263 /* Optionally warn about more than one declaration for the same
3264 name, but don't warn about a function declaration followed by a
3266 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3267 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3268 /* Don't warn about extern decl followed by definition. */
3269 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3270 /* Don't warn about friends, let add_friend take care of it. */
3271 && ! DECL_FRIEND_P (newdecl))
3273 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3274 cp_warning_at ("previous declaration of `%D'", olddecl);
3278 /* Deal with C++: must preserve virtual function table size. */
3279 if (TREE_CODE (olddecl) == TYPE_DECL)
3281 register tree newtype = TREE_TYPE (newdecl);
3282 register tree oldtype = TREE_TYPE (olddecl);
3284 if (newtype != error_mark_node && oldtype != error_mark_node
3285 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3287 CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3288 CLASSTYPE_FRIEND_CLASSES (newtype)
3289 = CLASSTYPE_FRIEND_CLASSES (oldtype);
3293 /* Copy all the DECL_... slots specified in the new decl
3294 except for any that we copy here from the old type. */
3295 DECL_MACHINE_ATTRIBUTES (newdecl)
3296 = merge_machine_decl_attributes (olddecl, newdecl);
3298 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3300 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3301 DECL_TEMPLATE_RESULT (olddecl)))
3302 cp_error ("invalid redeclaration of %D", newdecl);
3303 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3304 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3305 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3306 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3313 /* Automatically handles default parameters. */
3314 tree oldtype = TREE_TYPE (olddecl);
3317 /* Merge the data types specified in the two decls. */
3318 newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3320 if (TREE_CODE (newdecl) == VAR_DECL)
3321 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3322 /* Do this after calling `common_type' so that default
3323 parameters don't confuse us. */
3324 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3325 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3326 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3328 TREE_TYPE (newdecl) = build_exception_variant (newtype,
3329 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3330 TREE_TYPE (olddecl) = build_exception_variant (newtype,
3331 TYPE_RAISES_EXCEPTIONS (oldtype));
3333 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3334 && DECL_SOURCE_LINE (olddecl) != 0
3336 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3337 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3339 cp_error ("declaration of `%F' throws different exceptions",
3341 cp_error_at ("than previous declaration `%F'", olddecl);
3344 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3346 /* Lay the type out, unless already done. */
3347 if (! same_type_p (newtype, oldtype)
3348 && TREE_TYPE (newdecl) != error_mark_node
3349 && !(processing_template_decl && uses_template_parms (newdecl)))
3350 layout_type (TREE_TYPE (newdecl));
3352 if ((TREE_CODE (newdecl) == VAR_DECL
3353 || TREE_CODE (newdecl) == PARM_DECL
3354 || TREE_CODE (newdecl) == RESULT_DECL
3355 || TREE_CODE (newdecl) == FIELD_DECL
3356 || TREE_CODE (newdecl) == TYPE_DECL)
3357 && !(processing_template_decl && uses_template_parms (newdecl)))
3358 layout_decl (newdecl, 0);
3360 /* Merge the type qualifiers. */
3361 if (TREE_READONLY (newdecl))
3362 TREE_READONLY (olddecl) = 1;
3363 if (TREE_THIS_VOLATILE (newdecl))
3364 TREE_THIS_VOLATILE (olddecl) = 1;
3366 /* Merge the initialization information. */
3367 if (DECL_INITIAL (newdecl) == NULL_TREE
3368 && DECL_INITIAL (olddecl) != NULL_TREE)
3370 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3371 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3372 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3373 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3374 && DECL_LANG_SPECIFIC (newdecl)
3375 && DECL_LANG_SPECIFIC (olddecl))
3376 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3379 /* Merge the section attribute.
3380 We want to issue an error if the sections conflict but that must be
3381 done later in decl_attributes since we are called before attributes
3383 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3384 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3386 /* Keep the old rtl since we can safely use it. */
3387 DECL_RTL (newdecl) = DECL_RTL (olddecl);
3389 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3391 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3392 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3393 DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3394 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3395 DECL_NO_LIMIT_STACK (newdecl)
3396 |= DECL_NO_LIMIT_STACK (olddecl);
3399 /* If cannot merge, then use the new type and qualifiers,
3400 and don't preserve the old rtl. */
3403 /* Clean out any memory we had of the old declaration. */
3404 tree oldstatic = value_member (olddecl, static_aggregates);
3406 TREE_VALUE (oldstatic) = error_mark_node;
3408 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3409 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3410 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3411 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3414 /* Merge the storage class information. */
3415 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3416 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3417 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3418 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3419 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3420 if (! DECL_EXTERNAL (olddecl))
3421 DECL_EXTERNAL (newdecl) = 0;
3423 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3425 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3426 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3427 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3428 DECL_TEMPLATE_INSTANTIATED (newdecl)
3429 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3430 /* Don't really know how much of the language-specific
3431 values we should copy from old to new. */
3432 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3433 DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3434 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3435 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3436 olddecl_friend = DECL_FRIEND_P (olddecl);
3438 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3439 if (TREE_CODE (newdecl) == FUNCTION_DECL
3440 || DECL_FUNCTION_TEMPLATE_P (newdecl))
3441 DECL_BEFRIENDING_CLASSES (newdecl)
3442 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3443 DECL_BEFRIENDING_CLASSES (olddecl));
3446 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3448 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3449 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3451 /* If newdecl is not a specialization, then it is not a
3452 template-related function at all. And that means that we
3453 shoud have exited above, returning 0. */
3454 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3457 if (TREE_USED (olddecl))
3458 /* From [temp.expl.spec]:
3460 If a template, a member template or the member of a class
3461 template is explicitly specialized then that
3462 specialization shall be declared before the first use of
3463 that specialization that would cause an implicit
3464 instantiation to take place, in every translation unit in
3465 which such a use occurs. */
3466 cp_error ("explicit specialization of %D after first use",
3469 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3471 DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3473 /* If either decl says `inline', this fn is inline, unless its
3474 definition was passed already. */
3475 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3476 DECL_INLINE (olddecl) = 1;
3477 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3481 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3482 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3483 DECL_RTL (olddecl) = DECL_RTL (newdecl);
3485 if (! types_match || new_defines_function)
3487 /* These need to be copied so that the names are available.
3488 Note that if the types do match, we'll preserve inline
3489 info and other bits, but if not, we won't. */
3490 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3491 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3493 if (new_defines_function)
3494 /* If defining a function declared with other language
3495 linkage, use the previously declared language linkage. */
3496 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3497 else if (types_match)
3499 /* If redeclaring a builtin function, and not a definition,
3500 it stays built in. */
3501 if (DECL_BUILT_IN (olddecl))
3503 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3504 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3505 /* If we're keeping the built-in definition, keep the rtl,
3506 regardless of declaration matches. */
3507 DECL_RTL (newdecl) = DECL_RTL (olddecl);
3510 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3512 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3513 if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3514 /* Previously saved insns go together with
3515 the function's previous definition. */
3516 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3517 /* Don't clear out the arguments if we're redefining a function. */
3518 if (DECL_ARGUMENTS (olddecl))
3519 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3521 if (DECL_LANG_SPECIFIC (olddecl))
3522 DECL_MAIN_VARIANT (newdecl) = DECL_MAIN_VARIANT (olddecl);
3525 if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3527 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3530 /* Now preserve various other info from the definition. */
3531 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3532 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3533 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3534 DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3536 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3540 function_size = sizeof (struct tree_decl);
3542 bcopy ((char *) newdecl + sizeof (struct tree_common),
3543 (char *) olddecl + sizeof (struct tree_common),
3544 function_size - sizeof (struct tree_common));
3546 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3548 /* If newdecl is a template instantiation, it is possible that
3549 the following sequence of events has occurred:
3551 o A friend function was declared in a class template. The
3552 class template was instantiated.
3554 o The instantiation of the friend declaration was
3555 recorded on the instantiation list, and is newdecl.
3557 o Later, however, instantiate_class_template called pushdecl
3558 on the newdecl to perform name injection. But, pushdecl in
3559 turn called duplicate_decls when it discovered that another
3560 declaration of a global function with the same name already
3563 o Here, in duplicate_decls, we decided to clobber newdecl.
3565 If we're going to do that, we'd better make sure that
3566 olddecl, and not newdecl, is on the list of
3567 instantiations so that if we try to do the instantiation
3568 again we won't get the clobbered declaration. */
3570 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3571 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3573 for (; decls; decls = TREE_CHAIN (decls))
3574 if (TREE_VALUE (decls) == newdecl)
3575 TREE_VALUE (decls) = olddecl;
3580 bcopy ((char *) newdecl + sizeof (struct tree_common),
3581 (char *) olddecl + sizeof (struct tree_common),
3582 sizeof (struct tree_decl) - sizeof (struct tree_common)
3583 + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3586 DECL_UID (olddecl) = olddecl_uid;
3588 DECL_FRIEND_P (olddecl) = 1;
3590 /* NEWDECL contains the merged attribute lists.
3591 Update OLDDECL to be the same. */
3592 DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3597 /* Record a decl-node X as belonging to the current lexical scope.
3598 Check for errors (such as an incompatible declaration for the same
3599 name already seen in the same scope).
3601 Returns either X or an old decl for the same name.
3602 If an old decl is returned, it may have been smashed
3603 to agree with what X says. */
3611 int need_new_binding;
3613 /* We shouldn't be calling pushdecl when we're generating RTL for a
3614 function that we already did semantic analysis on previously. */
3615 my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3618 name = DECL_ASSEMBLER_NAME (x);
3619 need_new_binding = 1;
3621 if (DECL_TEMPLATE_PARM_P (x))
3622 /* Template parameters have no context; they are not X::T even
3623 when declared within a class or namespace. */
3627 if (current_function_decl && x != current_function_decl
3628 /* A local declaration for a function doesn't constitute
3630 && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3631 /* A local declaration for an `extern' variable is in the
3632 scoped of the current namespace, not the current
3634 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3635 /* Don't change DECL_CONTEXT of virtual methods. */
3636 && (TREE_CODE (x) != FUNCTION_DECL || !DECL_VIRTUAL_P (x))
3637 && !DECL_CONTEXT (x))
3638 DECL_CONTEXT (x) = current_function_decl;
3639 if (!DECL_CONTEXT (x))
3640 DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3642 /* If this is the declaration for a namespace-scope function,
3643 but the declaration itself is in a local scope, mark the
3645 if (TREE_CODE (x) == FUNCTION_DECL
3646 && DECL_NAMESPACE_SCOPE_P (x)
3647 && current_function_decl
3648 && x != current_function_decl)
3649 DECL_LOCAL_FUNCTION_P (x) = 1;
3652 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3653 compiler wants to use. */
3654 if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3655 || TREE_CODE (x) == NAMESPACE_DECL)
3656 name = DECL_NAME (x);
3661 /* Not needed...see below. */
3665 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3666 name = TREE_OPERAND (name, 0);
3668 /* Namespace-scoped variables are not found in the current level. */
3669 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3670 t = namespace_binding (name, DECL_CONTEXT (x));
3672 t = lookup_name_current_level (name);
3673 if (t == error_mark_node)
3675 /* error_mark_node is 0 for a while during initialization! */
3677 cp_error_at ("`%#D' used prior to declaration", x);
3680 else if (t != NULL_TREE)
3683 /* This is turned off until I have time to do it right (bpk). */
3684 /* With the code below that uses it... */
3685 file = DECL_SOURCE_FILE (t);
3686 line = DECL_SOURCE_LINE (t);
3688 if (TREE_CODE (t) == PARM_DECL)
3690 if (DECL_CONTEXT (t) == NULL_TREE)
3691 fatal ("parse errors have confused me too much");
3693 /* Check for duplicate params. */
3694 if (duplicate_decls (x, t))
3697 else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3698 || DECL_FUNCTION_TEMPLATE_P (x))
3699 && is_overloaded_fn (t))
3700 /* Don't do anything just yet. */;
3701 else if (t == wchar_decl_node)
3703 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3704 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3706 /* Throw away the redeclaration. */
3709 else if (TREE_CODE (t) != TREE_CODE (x))
3711 if (duplicate_decls (x, t))
3714 else if (duplicate_decls (x, t))
3717 /* This is turned off until I have time to do it right (bpk). */
3719 /* Also warn if they did a prototype with `static' on it, but
3720 then later left the `static' off. */
3721 if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3723 if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3728 cp_warning ("`static' missing from declaration of `%D'",
3730 warning_with_file_and_line (file, line,
3731 "previous declaration of `%s'",
3732 decl_as_string (t, 0));
3735 /* Now fix things so it'll do what they expect. */
3736 if (current_function_decl)
3737 TREE_PUBLIC (current_function_decl) = 0;
3739 /* Due to interference in memory reclamation (X may be
3740 obstack-deallocated at this point), we must guard against
3741 one really special case. [jason: This should be handled
3742 by start_function] */
3743 if (current_function_decl == x)
3744 current_function_decl = t;
3746 if (TREE_CODE (t) == TYPE_DECL)
3747 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3748 else if (TREE_CODE (t) == FUNCTION_DECL)
3749 check_default_args (t);
3753 else if (DECL_MAIN_P (x))
3755 /* A redeclaration of main, but not a duplicate of the
3760 This function shall not be overloaded. */
3761 cp_error_at ("invalid redeclaration of `%D'", t);
3762 cp_error ("as `%D'", x);
3763 /* We don't try to push this declaration since that
3769 check_template_shadow (x);
3771 /* If this is a function conjured up by the backend, massage it
3772 so it looks friendly. */
3773 if (TREE_CODE (x) == FUNCTION_DECL
3774 && ! DECL_LANG_SPECIFIC (x))
3776 retrofit_lang_decl (x);
3777 DECL_LANGUAGE (x) = lang_c;
3780 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3782 t = push_overloaded_decl (x, PUSH_LOCAL);
3785 if (!namespace_bindings_p ())
3786 /* We do not need to create a binding for this name;
3787 push_overloaded_decl will have already done so if
3789 need_new_binding = 0;
3791 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3793 t = push_overloaded_decl (x, PUSH_GLOBAL);
3795 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3799 /* If declaring a type as a typedef, copy the type (unless we're
3800 at line 0), and install this TYPE_DECL as the new type's typedef
3801 name. See the extensive comment in ../c-decl.c (pushdecl). */
3802 if (TREE_CODE (x) == TYPE_DECL)
3804 tree type = TREE_TYPE (x);
3805 if (DECL_SOURCE_LINE (x) == 0)
3807 if (TYPE_NAME (type) == 0)
3808 TYPE_NAME (type) = x;
3810 else if (type != error_mark_node && TYPE_NAME (type) != x
3811 /* We don't want to copy the type when all we're
3812 doing is making a TYPE_DECL for the purposes of
3814 && (!TYPE_NAME (type)
3815 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3817 DECL_ORIGINAL_TYPE (x) = type;
3818 type = build_type_copy (type);
3819 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3820 TYPE_NAME (type) = x;
3821 TREE_TYPE (x) = type;
3824 if (type != error_mark_node
3826 && TYPE_IDENTIFIER (type))
3827 set_identifier_type_value_with_scope (DECL_NAME (x), type,
3828 current_binding_level);
3832 /* Multiple external decls of the same identifier ought to match.
3834 We get warnings about inline functions where they are defined.
3835 We get warnings about other functions from push_overloaded_decl.
3837 Avoid duplicate warnings where they are used. */
3838 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3842 if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3843 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3844 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3845 decl = IDENTIFIER_NAMESPACE_VALUE (name);
3850 /* If different sort of thing, we already gave an error. */
3851 && TREE_CODE (decl) == TREE_CODE (x)
3852 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3854 cp_pedwarn ("type mismatch with previous external decl", x);
3855 cp_pedwarn_at ("previous external decl of `%#D'", decl);
3859 /* This name is new in its binding level.
3860 Install the new declaration and return it. */
3861 if (namespace_bindings_p ())
3863 /* Install a global value. */
3865 /* If the first global decl has external linkage,
3866 warn if we later see static one. */
3867 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3868 TREE_PUBLIC (name) = 1;
3870 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3872 /* For an ordinary function, we create a binding from
3873 the mangled name (i.e., NAME) to the DECL. But, for
3874 an `extern "C"' function, the mangled name and the
3875 ordinary name are the same so we need not do this. */
3876 && !(TREE_CODE (x) == FUNCTION_DECL &&
3877 DECL_LANGUAGE (x) == lang_c))
3879 if (TREE_CODE (x) == FUNCTION_DECL)
3881 ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3882 || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3883 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3886 /* Don't forget if the function was used via an implicit decl. */
3887 if (IDENTIFIER_IMPLICIT_DECL (name)
3888 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3891 /* Don't forget if its address was taken in that way. */
3892 if (IDENTIFIER_IMPLICIT_DECL (name)
3893 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3894 TREE_ADDRESSABLE (x) = 1;
3896 /* Warn about mismatches against previous implicit decl. */
3897 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3898 /* If this real decl matches the implicit, don't complain. */
3899 && ! (TREE_CODE (x) == FUNCTION_DECL
3900 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3902 ("`%D' was previously implicitly declared to return `int'", x);
3904 /* If new decl is `static' and an `extern' was seen previously,
3906 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3907 warn_extern_redeclared_static (x, t);
3911 /* Here to install a non-global value. */
3912 tree oldlocal = IDENTIFIER_VALUE (name);
3913 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3915 if (need_new_binding)
3917 push_local_binding (name, x, 0);
3918 /* Because push_local_binding will hook X on to the
3919 current_binding_level's name list, we don't want to
3920 do that again below. */
3921 need_new_binding = 0;
3924 /* If this is a TYPE_DECL, push it into the type value slot. */
3925 if (TREE_CODE (x) == TYPE_DECL)
3926 set_identifier_type_value_with_scope (name, TREE_TYPE (x),
3927 current_binding_level);
3929 /* Clear out any TYPE_DECL shadowed by a namespace so that
3930 we won't think this is a type. The C struct hack doesn't
3931 go through namespaces. */
3932 if (TREE_CODE (x) == NAMESPACE_DECL)
3933 set_identifier_type_value_with_scope (name, NULL_TREE,
3934 current_binding_level);
3936 /* If this is an extern function declaration, see if we
3937 have a global definition or declaration for the function. */
3938 if (oldlocal == NULL_TREE
3939 && DECL_EXTERNAL (x)
3940 && oldglobal != NULL_TREE
3941 && TREE_CODE (x) == FUNCTION_DECL
3942 && TREE_CODE (oldglobal) == FUNCTION_DECL)
3944 /* We have one. Their types must agree. */
3945 if (decls_match (x, oldglobal))
3949 cp_warning ("extern declaration of `%#D' doesn't match", x);
3950 cp_warning_at ("global declaration `%#D'", oldglobal);
3953 /* If we have a local external declaration,
3954 and no file-scope declaration has yet been seen,
3955 then if we later have a file-scope decl it must not be static. */
3956 if (oldlocal == NULL_TREE
3957 && oldglobal == NULL_TREE
3958 && DECL_EXTERNAL (x)
3960 TREE_PUBLIC (name) = 1;
3962 if (DECL_FROM_INLINE (x))
3963 /* Inline decls shadow nothing. */;
3965 /* Warn if shadowing an argument at the top level of the body. */
3966 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
3967 && TREE_CODE (oldlocal) == PARM_DECL
3968 /* Don't complain if it's from an enclosing function. */
3969 && DECL_CONTEXT (oldlocal) == current_function_decl
3970 && TREE_CODE (x) != PARM_DECL)
3972 /* Go to where the parms should be and see if we
3974 struct binding_level *b = current_binding_level->level_chain;
3980 if (b->parm_flag == 1)
3981 cp_error ("declaration of `%#D' shadows a parameter", name);
3983 else if (warn_shadow && oldlocal != NULL_TREE
3984 && current_binding_level->is_for_scope
3985 && !DECL_DEAD_FOR_LOCAL (oldlocal))
3987 warning ("variable `%s' shadows local",
3988 IDENTIFIER_POINTER (name));
3989 cp_warning_at (" this is the shadowed declaration", oldlocal);
3991 /* Maybe warn if shadowing something else. */
3992 else if (warn_shadow && !DECL_EXTERNAL (x)
3993 /* No shadow warnings for internally generated vars. */
3994 && ! DECL_ARTIFICIAL (x)
3995 /* No shadow warnings for vars made for inlining. */
3996 && ! DECL_FROM_INLINE (x))
3998 if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
3999 warning ("declaration of `%s' shadows a parameter",
4000 IDENTIFIER_POINTER (name));
4001 else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4002 && current_class_ptr
4003 && !TREE_STATIC (name))
4004 warning ("declaration of `%s' shadows a member of `this'",
4005 IDENTIFIER_POINTER (name));
4006 else if (oldlocal != NULL_TREE)
4007 warning ("declaration of `%s' shadows previous local",
4008 IDENTIFIER_POINTER (name));
4009 else if (oldglobal != NULL_TREE)
4010 /* XXX shadow warnings in outer-more namespaces */
4011 warning ("declaration of `%s' shadows global declaration",
4012 IDENTIFIER_POINTER (name));
4016 if (TREE_CODE (x) == FUNCTION_DECL)
4017 check_default_args (x);
4019 /* Keep count of variables in this level with incomplete type. */
4020 if (TREE_CODE (x) == VAR_DECL
4021 && TREE_TYPE (x) != error_mark_node
4022 && ((TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
4023 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4024 /* RTTI TD entries are created while defining the type_info. */
4025 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4026 && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4027 current_binding_level->incomplete
4028 = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4031 if (need_new_binding)
4032 add_decl_to_level (x,
4033 DECL_NAMESPACE_SCOPE_P (x)
4034 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4035 : current_binding_level);
4040 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4041 caller to set DECL_CONTEXT properly. */
4044 pushdecl_with_scope (x, level)
4046 struct binding_level *level;
4048 register struct binding_level *b;
4049 tree function_decl = current_function_decl;
4051 current_function_decl = NULL_TREE;
4052 if (level->parm_flag == 2)
4054 b = class_binding_level;
4055 class_binding_level = level;
4056 pushdecl_class_level (x);
4057 class_binding_level = b;
4061 b = current_binding_level;
4062 current_binding_level = level;
4064 current_binding_level = b;
4066 current_function_decl = function_decl;
4070 /* Like pushdecl, only it places X in the current namespace,
4074 pushdecl_namespace_level (x)
4077 register struct binding_level *b = current_binding_level;
4080 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4082 /* Now, the type_shadowed stack may screw us. Munge it so it does
4084 if (TREE_CODE (x) == TYPE_DECL)
4086 tree name = DECL_NAME (x);
4088 tree *ptr = (tree *)0;
4089 for (; b != global_binding_level; b = b->level_chain)
4091 tree shadowed = b->type_shadowed;
4092 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4093 if (TREE_PURPOSE (shadowed) == name)
4095 ptr = &TREE_VALUE (shadowed);
4096 /* Can't break out of the loop here because sometimes
4097 a binding level will have duplicate bindings for
4098 PT names. It's gross, but I haven't time to fix it. */
4101 newval = TREE_TYPE (x);
4102 if (ptr == (tree *)0)
4104 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4105 up here if this is changed to an assertion. --KR */
4106 SET_IDENTIFIER_TYPE_VALUE (name, newval);
4116 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4120 pushdecl_top_level (x)
4123 push_to_top_level ();
4124 x = pushdecl_namespace_level (x);
4125 pop_from_top_level ();
4129 /* Make the declaration of X appear in CLASS scope. */
4132 pushdecl_class_level (x)
4135 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4136 scope looks for the pre-mangled name. */
4139 if (TREE_CODE (x) == OVERLOAD)
4140 x = OVL_CURRENT (x);
4141 name = DECL_NAME (x);
4145 push_class_level_binding (name, x);
4146 if (TREE_CODE (x) == TYPE_DECL)
4147 set_identifier_type_value (name, TREE_TYPE (x));
4149 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4153 for (f = TYPE_FIELDS (TREE_TYPE (x));
4156 pushdecl_class_level (f);
4160 /* Enter DECL into the symbol table, if that's appropriate. Returns
4161 DECL, or a modified version thereof. */
4164 maybe_push_decl (decl)
4167 tree type = TREE_TYPE (decl);
4169 /* Add this decl to the current binding level, but not if it comes
4170 from another scope, e.g. a static member variable. TEM may equal
4171 DECL or it may be a previous decl of the same name. */
4172 if (decl == error_mark_node
4173 || (TREE_CODE (decl) != PARM_DECL
4174 && DECL_CONTEXT (decl) != NULL_TREE
4175 /* Definitions of namespace members outside their namespace are
4177 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4178 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4179 || TREE_CODE (type) == UNKNOWN_TYPE
4180 /* The declaration of a template specialization does not affect
4181 the functions available for overload resolution, so we do not
4183 || (TREE_CODE (decl) == FUNCTION_DECL
4184 && DECL_TEMPLATE_SPECIALIZATION (decl)))
4187 return pushdecl (decl);
4191 /* This function is used to push the mangled decls for nested types into
4192 the appropriate scope. Previously pushdecl_top_level was used, but that
4193 is incorrect for members of local classes. */
4196 pushdecl_nonclass_level (x)
4199 struct binding_level *b = current_binding_level;
4201 my_friendly_assert (b->parm_flag != 2, 180);
4204 /* Get out of template binding levels */
4205 while (b->pseudo_global)
4209 pushdecl_with_scope (x, b);
4213 /* Make the declaration(s) of X appear in CLASS scope
4214 under the name NAME. */
4217 push_class_level_binding (name, x)
4222 /* The class_binding_level will be NULL if x is a template
4223 parameter name in a member template. */
4224 if (!class_binding_level)
4227 /* Make sure that this new member does not have the same name
4228 as a template parameter. */
4229 if (TYPE_BEING_DEFINED (current_class_type))
4230 check_template_shadow (x);
4232 /* If this declaration shadows a declaration from an enclosing
4233 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4234 we leave this class. Record the shadowed declaration here. */
4235 binding = IDENTIFIER_BINDING (name);
4237 && ((TREE_CODE (x) == OVERLOAD
4238 && BINDING_VALUE (binding)
4239 && is_overloaded_fn (BINDING_VALUE (binding)))
4240 || INHERITED_VALUE_BINDING_P (binding)))
4245 /* If the old binding was from a base class, and was for a tag
4246 name, slide it over to make room for the new binding. The
4247 old binding is still visible if explicitly qualified with a
4249 if (INHERITED_VALUE_BINDING_P (binding)
4250 && BINDING_VALUE (binding)
4251 && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4252 && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4253 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4255 old_decl = BINDING_TYPE (binding);
4256 BINDING_TYPE (binding) = BINDING_VALUE (binding);
4257 BINDING_VALUE (binding) = NULL_TREE;
4258 INHERITED_VALUE_BINDING_P (binding) = 0;
4261 old_decl = BINDING_VALUE (binding);
4263 /* There was already a binding for X containing fewer
4264 functions than are named in X. Find the previous
4265 declaration of X on the class-shadowed list, and update it. */
4266 for (shadow = class_binding_level->class_shadowed;
4268 shadow = TREE_CHAIN (shadow))
4269 if (TREE_PURPOSE (shadow) == name
4270 && TREE_TYPE (shadow) == old_decl)
4272 BINDING_VALUE (binding) = x;
4273 INHERITED_VALUE_BINDING_P (binding) = 0;
4274 TREE_TYPE (shadow) = x;
4279 /* If we didn't replace an existing binding, put the binding on the
4280 stack of bindings for the identifier, and update
4281 IDENTIFIER_CLASS_VALUE. */
4282 if (push_class_binding (name, x))
4284 class_binding_level->class_shadowed
4285 = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4286 class_binding_level->class_shadowed);
4287 /* Record the value we are binding NAME to so that we can know
4288 what to pop later. */
4289 TREE_TYPE (class_binding_level->class_shadowed) = x;
4293 /* Insert another USING_DECL into the current binding level,
4294 returning this declaration. If this is a redeclaration,
4295 do nothing and return NULL_TREE. */
4298 push_using_decl (scope, name)
4304 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4305 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4306 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4307 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4311 decl = build_lang_decl (USING_DECL, name, void_type_node);
4312 DECL_INITIAL (decl) = scope;
4313 TREE_CHAIN (decl) = current_binding_level->usings;
4314 current_binding_level->usings = decl;
4318 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4319 changed (i.e. there was already a directive), or the fresh
4320 TREE_LIST otherwise. */
4323 push_using_directive (used)
4326 tree ud = current_binding_level->using_directives;
4327 tree iter, ancestor;
4329 /* Check if we already have this. */
4330 if (purpose_member (used, ud) != NULL_TREE)
4333 /* Recursively add all namespaces used. */
4334 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4335 push_using_directive (TREE_PURPOSE (iter));
4337 ancestor = namespace_ancestor (current_decl_namespace (), used);
4338 ud = current_binding_level->using_directives;
4339 ud = tree_cons (used, ancestor, ud);
4340 current_binding_level->using_directives = ud;
4344 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4345 other definitions already in place. We get around this by making
4346 the value of the identifier point to a list of all the things that
4347 want to be referenced by that name. It is then up to the users of
4348 that name to decide what to do with that list.
4350 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its DECL_RESULT
4351 slot. It is dealt with the same way.
4353 FLAGS is a bitwise-or of the following values:
4354 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4356 PUSH_USING: DECL is being pushed as the result of a using
4359 The value returned may be a previous declaration if we guessed wrong
4360 about what language DECL should belong to (C or C++). Otherwise,
4361 it's always DECL (and never something that's not a _DECL). */
4364 push_overloaded_decl (decl, flags)
4368 tree name = DECL_NAME (decl);
4371 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4374 old = namespace_binding (name, DECL_CONTEXT (decl));
4376 old = lookup_name_current_level (name);
4380 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4382 tree t = TREE_TYPE (old);
4383 if (IS_AGGR_TYPE (t) && warn_shadow
4384 && (! DECL_IN_SYSTEM_HEADER (decl)
4385 || ! DECL_IN_SYSTEM_HEADER (old)))
4386 cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4389 else if (is_overloaded_fn (old))
4393 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4395 tree fn = OVL_CURRENT (tmp);
4397 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4398 && !(flags & PUSH_USING)
4399 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4400 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4401 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4404 if (duplicate_decls (decl, fn))
4410 cp_error_at ("previous non-function declaration `%#D'", old);
4411 cp_error ("conflicts with function declaration `%#D'", decl);
4416 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4418 if (old && TREE_CODE (old) != OVERLOAD)
4419 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4421 new_binding = ovl_cons (decl, old);
4422 if (flags & PUSH_USING)
4423 OVL_USED (new_binding) = 1;
4426 /* NAME is not ambiguous. */
4430 set_namespace_binding (name, current_namespace, new_binding);
4433 /* We only create an OVERLOAD if there was a previous binding at
4434 this level, or if decl is a template. In the former case, we
4435 need to remove the old binding and replace it with the new
4436 binding. We must also run through the NAMES on the binding
4437 level where the name was bound to update the chain. */
4439 if (TREE_CODE (new_binding) == OVERLOAD && old)
4443 for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4445 d = &TREE_CHAIN (*d))
4447 || (TREE_CODE (*d) == TREE_LIST
4448 && TREE_VALUE (*d) == old))
4450 if (TREE_CODE (*d) == TREE_LIST)
4451 /* Just replace the old binding with the new. */
4452 TREE_VALUE (*d) = new_binding;
4454 /* Build a TREE_LIST to wrap the OVERLOAD. */
4455 *d = tree_cons (NULL_TREE, new_binding,
4458 /* And update the CPLUS_BINDING node. */
4459 BINDING_VALUE (IDENTIFIER_BINDING (name))
4464 /* We should always find a previous binding in this case. */
4465 my_friendly_abort (0);
4468 /* Install the new binding. */
4469 push_local_binding (name, new_binding, flags);
4475 /* Generate an implicit declaration for identifier FUNCTIONID
4476 as a function of type int (). Print a warning if appropriate. */
4479 implicitly_declare (functionid)
4484 /* We used to reuse an old implicit decl here,
4485 but this loses with inline functions because it can clobber
4486 the saved decl chains. */
4487 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4489 DECL_EXTERNAL (decl) = 1;
4490 TREE_PUBLIC (decl) = 1;
4492 /* ANSI standard says implicit declarations are in the innermost block.
4493 So we record the decl in the standard fashion. */
4495 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4498 /* Only one warning per identifier. */
4499 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4501 cp_pedwarn ("implicit declaration of function `%#D'", decl);
4504 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4509 /* Return zero if the declaration NEWDECL is valid
4510 when the declaration OLDDECL (assumed to be for the same name)
4511 has already been seen.
4512 Otherwise return an error message format string with a %s
4513 where the identifier should go. */
4516 redeclaration_error_message (newdecl, olddecl)
4517 tree newdecl, olddecl;
4519 if (TREE_CODE (newdecl) == TYPE_DECL)
4521 /* Because C++ can put things into name space for free,
4522 constructs like "typedef struct foo { ... } foo"
4523 would look like an erroneous redeclaration. */
4524 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4527 return "redefinition of `%#D'";
4529 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4531 /* If this is a pure function, its olddecl will actually be
4532 the original initialization to `0' (which we force to call
4533 abort()). Don't complain about redefinition in this case. */
4534 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4537 /* If both functions come from different namespaces, this is not
4538 a redeclaration - this is a conflict with a used function. */
4539 if (DECL_NAMESPACE_SCOPE_P (olddecl)
4540 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4541 return "`%D' conflicts with used function";
4543 /* We'll complain about linkage mismatches in
4544 warn_extern_redeclared_static. */
4546 /* Defining the same name twice is no good. */
4547 if (DECL_INITIAL (olddecl) != NULL_TREE
4548 && DECL_INITIAL (newdecl) != NULL_TREE)
4550 if (DECL_NAME (olddecl) == NULL_TREE)
4551 return "`%#D' not declared in class";
4553 return "redefinition of `%#D'";
4557 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4559 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4560 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4561 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4562 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4563 && TYPE_SIZE (TREE_TYPE (newdecl))
4564 && TYPE_SIZE (TREE_TYPE (olddecl))))
4565 return "redefinition of `%#D'";
4568 else if (toplevel_bindings_p ())
4570 /* Objects declared at top level: */
4571 /* If at least one is a reference, it's ok. */
4572 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4574 /* Reject two definitions. */
4575 return "redefinition of `%#D'";
4579 /* Objects declared with block scope: */
4580 /* Reject two definitions, and reject a definition
4581 together with an external reference. */
4582 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4583 return "redeclaration of `%#D'";
4588 /* Create a new label, named ID. */
4591 make_label_decl (id, local_p)
4597 decl = build_decl (LABEL_DECL, id, void_type_node);
4599 /* Make sure every label has an rtx. */
4602 DECL_CONTEXT (decl) = current_function_decl;
4603 DECL_MODE (decl) = VOIDmode;
4604 C_DECLARED_LABEL_FLAG (decl) = local_p;
4606 /* Say where one reference is to the label, for the sake of the
4607 error if it is not defined. */
4608 DECL_SOURCE_LINE (decl) = lineno;
4609 DECL_SOURCE_FILE (decl) = input_filename;
4611 /* Record the fact that this identifier is bound to this label. */
4612 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4614 /* Record this label on the list of used labels so that we can check
4615 at the end of the function to see whether or not the label was
4616 actually defined. */
4617 if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4618 && (named_label_uses == NULL
4619 || named_label_uses->names_in_scope != current_binding_level->names
4620 || named_label_uses->label_decl != decl))
4622 struct named_label_list *new_ent;
4624 = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4625 new_ent->label_decl = decl;
4626 new_ent->names_in_scope = current_binding_level->names;
4627 new_ent->binding_level = current_binding_level;
4628 new_ent->lineno_o_goto = lineno;
4629 new_ent->filename_o_goto = input_filename;
4630 new_ent->next = named_label_uses;
4631 named_label_uses = new_ent;
4637 /* Look for a label named ID in the current function. If one cannot
4638 be found, create one. (We keep track of used, but undefined,
4639 labels, and complain about them at the end of a function.) */
4647 /* You can't use labels at global scope. */
4648 if (current_function_decl == NULL_TREE)
4650 error ("label `%s' referenced outside of any function",
4651 IDENTIFIER_POINTER (id));
4655 /* See if we've already got this label. */
4656 decl = IDENTIFIER_LABEL_VALUE (id);
4657 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4660 /* Record this label on the list of labels used in this function.
4661 We do this before calling make_label_decl so that we get the
4662 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4663 named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4665 /* We need a new label. */
4666 decl = make_label_decl (id, /*local_p=*/0);
4667 /* Now fill in the information we didn't have before. */
4668 TREE_VALUE (named_labels) = decl;
4673 /* Declare a local label named ID. */
4676 declare_local_label (id)
4681 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4682 this scope we can restore the old value of
4683 IDENTIFIER_TYPE_VALUE. */
4684 current_binding_level->shadowed_labels
4685 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4686 current_binding_level->shadowed_labels);
4687 /* Look for the label. */
4688 decl = make_label_decl (id, /*local_p=*/1);
4689 /* Now fill in the information we didn't have before. */
4690 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4695 /* Define a label, specifying the location in the source file.
4696 Return the LABEL_DECL node for the label, if the definition is valid.
4697 Otherwise return 0. */
4700 define_label (filename, line, name)
4705 tree decl = lookup_label (name);
4707 /* After labels, make any new cleanups go into their
4708 own new (temporary) binding contour. */
4709 current_binding_level->more_cleanups_ok = 0;
4711 if (name == get_identifier ("wchar_t"))
4712 cp_pedwarn ("label named wchar_t");
4714 if (DECL_INITIAL (decl) != NULL_TREE)
4716 cp_error ("duplicate label `%D'", decl);
4721 struct named_label_list *uses, *prev;
4725 /* Mark label as having been defined. */
4726 DECL_INITIAL (decl) = error_mark_node;
4727 /* Say where in the source. */
4728 DECL_SOURCE_FILE (decl) = filename;
4729 DECL_SOURCE_LINE (decl) = line;
4732 uses = named_label_uses;
4733 while (uses != NULL)
4734 if (uses->label_decl == decl)
4736 struct binding_level *b = current_binding_level;
4739 tree new_decls = b->names;
4740 tree old_decls = (b == uses->binding_level)
4741 ? uses->names_in_scope : NULL_TREE;
4742 while (new_decls != old_decls)
4744 if (TREE_CODE (new_decls) == VAR_DECL
4745 /* Don't complain about crossing initialization
4746 of internal entities. They can't be accessed,
4747 and they should be cleaned up
4748 by the time we get to the label. */
4749 && ! DECL_ARTIFICIAL (new_decls)
4750 && !(DECL_INITIAL (new_decls) == NULL_TREE
4751 && pod_type_p (TREE_TYPE (new_decls))))
4753 /* This is really only important if we're crossing
4754 an initialization. The POD stuff is just
4755 pedantry; why should it matter if the class
4756 contains a field of pointer to member type? */
4757 int problem = (DECL_INITIAL (new_decls)
4758 || (TYPE_NEEDS_CONSTRUCTING
4759 (TREE_TYPE (new_decls))));
4765 cp_error ("jump to label `%D'", decl);
4766 error_with_file_and_line
4767 (uses->filename_o_goto,
4768 uses->lineno_o_goto, " from here");
4772 cp_pedwarn ("jump to label `%D'", decl);
4773 pedwarn_with_file_and_line
4774 (uses->filename_o_goto,
4775 uses->lineno_o_goto, " from here");
4781 cp_error_at (" crosses initialization of `%#D'",
4784 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4787 new_decls = TREE_CHAIN (new_decls);
4789 if (b == uses->binding_level)
4791 if (b->eh_region && ! saw_eh)
4795 cp_error ("jump to label `%D'", decl);
4796 error_with_file_and_line
4797 (uses->filename_o_goto,
4798 uses->lineno_o_goto, " from here");
4801 error (" enters exception handling block");
4808 prev->next = uses->next;
4810 named_label_uses = uses->next;
4819 current_function_return_value = NULL_TREE;
4826 struct binding_level *level;
4827 struct cp_switch *next;
4830 static struct cp_switch *switch_stack;
4836 = (struct cp_switch *) oballoc (sizeof (struct cp_switch));
4837 p->level = current_binding_level;
4838 p->next = switch_stack;
4845 switch_stack = switch_stack->next;
4848 /* Note that we've seen a definition of a case label, and complain if this
4849 is a bad place for one. */
4852 define_case_label ()
4854 tree cleanup = last_cleanup_this_contour ();
4855 struct binding_level *b = current_binding_level;
4859 /* Don't crash; we'll complain in do_case. */
4864 static int explained = 0;
4865 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4866 warning ("where case label appears here");
4869 warning ("(enclose actions of previous case statements requiring");
4870 warning ("destructors in their own binding contours.)");
4875 for (; b && b != switch_stack->level; b = b->level_chain)
4877 tree new_decls = b->names;
4878 for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4880 if (TREE_CODE (new_decls) == VAR_DECL
4881 /* Don't complain about crossing initialization
4882 of internal entities. They can't be accessed,
4883 and they should be cleaned up
4884 by the time we get to the label. */
4885 && ! DECL_ARTIFICIAL (new_decls)
4886 && ((DECL_INITIAL (new_decls) != NULL_TREE
4887 && DECL_INITIAL (new_decls) != error_mark_node)
4888 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4891 error ("jump to case label");
4893 cp_error_at (" crosses initialization of `%#D'",
4899 /* After labels, make any new cleanups go into their
4900 own new (temporary) binding contour. */
4902 current_binding_level->more_cleanups_ok = 0;
4903 current_function_return_value = NULL_TREE;
4906 /* Return the list of declarations of the current level.
4907 Note that this list is in reverse order unless/until
4908 you nreverse it; and when you do nreverse it, you must
4909 store the result back using `storedecls' or you will lose. */
4914 return current_binding_level->names;
4917 /* Return the list of type-tags (for structs, etc) of the current level. */
4922 return current_binding_level->tags;
4925 /* Store the list of declarations of the current level.
4926 This is done for the parameter declarations of a function being defined,
4927 after they are modified in the light of any missing parameters. */
4933 current_binding_level->names = decls;
4936 /* Similarly, store the list of tags of the current level. */
4942 current_binding_level->tags = tags;
4945 /* Given NAME, an IDENTIFIER_NODE,
4946 return the structure (or union or enum) definition for that name.
4947 Searches binding levels from BINDING_LEVEL up to the global level.
4948 If THISLEVEL_ONLY is nonzero, searches only the specified context
4949 (but skips any tag-transparent contexts to find one that is
4950 meaningful for tags).
4951 FORM says which kind of type the caller wants;
4952 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
4953 If the wrong kind of type is found, and it's not a template, an error is
4957 lookup_tag (form, name, binding_level, thislevel_only)
4958 enum tree_code form;
4960 struct binding_level *binding_level;
4963 register struct binding_level *level;
4964 /* Non-zero if, we should look past a pseudo-global level, even if
4966 int allow_pseudo_global = 1;
4968 for (level = binding_level; level; level = level->level_chain)
4971 if (ANON_AGGRNAME_P (name))
4972 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
4974 /* There's no need for error checking here, because
4975 anon names are unique throughout the compilation. */
4976 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
4977 return TREE_VALUE (tail);
4979 else if (level->namespace_p)
4980 /* Do namespace lookup. */
4981 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
4983 tree old = binding_for_name (name, tail);
4985 /* If we just skipped past a pseudo global level, even
4986 though THISLEVEL_ONLY, and we find a template class
4987 declaration, then we use the _TYPE node for the
4988 template. See the example below. */
4989 if (thislevel_only && !allow_pseudo_global
4990 && old && BINDING_VALUE (old)
4991 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
4992 old = TREE_TYPE (BINDING_VALUE (old));
4994 old = BINDING_TYPE (old);
4996 /* If it has an original type, it is a typedef, and we
4997 should not return it. */
4998 if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5000 if (old && TREE_CODE (old) != form
5001 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5003 cp_error ("`%#D' redeclared as %C", old, form);
5008 if (thislevel_only || tail == global_namespace)
5012 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5014 if (TREE_PURPOSE (tail) == name)
5016 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5017 /* Should tighten this up; it'll probably permit
5018 UNION_TYPE and a struct template, for example. */
5020 && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5022 /* Definition isn't the kind we were looking for. */
5023 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5027 return TREE_VALUE (tail);
5030 if (thislevel_only && ! level->tag_transparent)
5032 if (level->pseudo_global && allow_pseudo_global)
5034 /* We must deal with cases like this:
5036 template <class T> struct S;
5037 template <class T> struct S {};
5039 When looking up `S', for the second declaration, we
5040 would like to find the first declaration. But, we
5041 are in the pseudo-global level created for the
5042 template parameters, rather than the (surrounding)
5043 namespace level. Thus, we keep going one more level,
5044 even though THISLEVEL_ONLY is non-zero. */
5045 allow_pseudo_global = 0;
5057 set_current_level_tags_transparency (tags_transparent)
5058 int tags_transparent;
5060 current_binding_level->tag_transparent = tags_transparent;
5064 /* Given a type, find the tag that was defined for it and return the tag name.
5065 Otherwise return 0. However, the value can never be 0
5066 in the cases in which this is used.
5068 C++: If NAME is non-zero, this is the new name to install. This is
5069 done when replacing anonymous tags with real tag names. */
5072 lookup_tag_reverse (type, name)
5076 register struct binding_level *level;
5078 for (level = current_binding_level; level; level = level->level_chain)
5081 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5083 if (TREE_VALUE (tail) == type)
5086 TREE_PURPOSE (tail) = name;
5087 return TREE_PURPOSE (tail);
5094 /* Look up NAME in the NAMESPACE. */
5097 lookup_namespace_name (namespace, name)
5098 tree namespace, name;
5101 tree template_id = NULL_TREE;
5103 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5105 if (TREE_CODE (name) == NAMESPACE_DECL)
5106 /* This happens for A::B<int> when B is a namespace. */
5108 else if (TREE_CODE (name) == TEMPLATE_DECL)
5110 /* This happens for A::B where B is a template, and there are no
5111 template arguments. */
5112 cp_error ("invalid use of `%D'", name);
5113 return error_mark_node;
5116 namespace = ORIGINAL_NAMESPACE (namespace);
5118 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5121 name = TREE_OPERAND (name, 0);
5122 if (TREE_CODE (name) == OVERLOAD)
5123 name = DECL_NAME (OVL_CURRENT (name));
5124 else if (TREE_CODE_CLASS (TREE_CODE (name)) == 'd')
5125 name = DECL_NAME (name);
5128 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5130 val = make_node (CPLUS_BINDING);
5131 if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5132 return error_mark_node;
5134 if (BINDING_VALUE (val))
5136 val = BINDING_VALUE (val);
5140 if (DECL_CLASS_TEMPLATE_P (val))
5141 val = lookup_template_class (val,
5142 TREE_OPERAND (template_id, 1),
5143 /*in_decl=*/NULL_TREE,
5144 /*context=*/NULL_TREE,
5145 /*entering_scope=*/0);
5146 else if (DECL_FUNCTION_TEMPLATE_P (val)
5147 || TREE_CODE (val) == OVERLOAD)
5148 val = lookup_template_function (val,
5149 TREE_OPERAND (template_id, 1));
5152 cp_error ("`%D::%D' is not a template",
5154 return error_mark_node;
5158 /* If we have a single function from a using decl, pull it out. */
5159 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5160 val = OVL_FUNCTION (val);
5164 cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5165 return error_mark_node;
5168 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5170 static unsigned long
5178 hash = (((unsigned long) TYPE_CONTEXT (t))
5179 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5184 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5187 typename_compare (k1, k2)
5198 d1 = TYPE_NAME (t1);
5199 d2 = TYPE_NAME (t2);
5201 return (DECL_NAME (d1) == DECL_NAME (d2)
5202 && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5203 && ((TREE_TYPE (t1) != NULL_TREE)
5204 == (TREE_TYPE (t2) != NULL_TREE))
5205 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5206 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5209 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5210 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5211 is non-NULL, this type is being created by the implicit typename
5212 extension, and BASE_TYPE is a type named `t' in some base class of
5213 `T' which depends on template parameters.
5215 Returns the new TYPENAME_TYPE. */
5218 build_typename_type (context, name, fullname, base_type)
5226 struct hash_entry* e;
5228 static struct hash_table ht;
5232 static struct hash_table *h = &ht;
5233 if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5235 fatal ("virtual memory exhausted");
5236 ggc_add_tree_hash_table_root (&h, 1);
5239 /* Build the TYPENAME_TYPE. */
5240 t = make_aggr_type (TYPENAME_TYPE);
5241 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5242 TYPENAME_TYPE_FULLNAME (t) = fullname;
5243 TREE_TYPE (t) = base_type;
5245 /* Build the corresponding TYPE_DECL. */
5246 d = build_decl (TYPE_DECL, name, t);
5247 TYPE_NAME (TREE_TYPE (d)) = d;
5248 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5249 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5250 DECL_ARTIFICIAL (d) = 1;
5252 /* See if we already have this type. */
5253 e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5257 /* Insert the type into the table. */
5258 hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5263 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5264 unless an error occurs, in which case error_mark_node is returned.
5265 If COMPLAIN zero, don't complain about any errors that occur. */
5268 make_typename_type (context, name, complain)
5274 if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
5276 if (!(TYPE_LANG_SPECIFIC (name)
5277 && (CLASSTYPE_IS_TEMPLATE (name)
5278 || CLASSTYPE_USE_TEMPLATE (name))))
5279 name = TYPE_IDENTIFIER (name);
5281 /* Create a TEMPLATE_ID_EXPR for the type. */
5282 name = build_nt (TEMPLATE_ID_EXPR,
5283 CLASSTYPE_TI_TEMPLATE (name),
5284 CLASSTYPE_TI_ARGS (name));
5286 else if (TREE_CODE (name) == TYPE_DECL)
5287 name = DECL_NAME (name);
5291 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5293 name = TREE_OPERAND (name, 0);
5294 if (TREE_CODE (name) == TEMPLATE_DECL)
5295 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5297 if (TREE_CODE (name) != IDENTIFIER_NODE)
5298 my_friendly_abort (2000);
5300 if (TREE_CODE (context) == NAMESPACE_DECL)
5302 /* We can get here from typename_sub0 in the explicit_template_type
5303 expansion. Just fail. */
5305 cp_error ("no class template named `%#T' in `%#T'",
5307 return error_mark_node;
5310 if (! uses_template_parms (context)
5311 || currently_open_class (context))
5313 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5315 tree tmpl = NULL_TREE;
5316 if (IS_AGGR_TYPE (context))
5317 tmpl = lookup_field (context, name, 0, 0);
5318 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5321 cp_error ("no class template named `%#T' in `%#T'",
5323 return error_mark_node;
5326 return lookup_template_class (tmpl,
5327 TREE_OPERAND (fullname, 1),
5329 /*entering_scope=*/0);
5335 if (!IS_AGGR_TYPE (context))
5338 cp_error ("no type named `%#T' in `%#T'", name, context);
5339 return error_mark_node;
5342 t = lookup_field (context, name, 0, 1);
5344 return TREE_TYPE (t);
5348 /* If the CONTEXT is not a template type, then either the field is
5349 there now or its never going to be. */
5350 if (!uses_template_parms (context))
5353 cp_error ("no type named `%#T' in `%#T'", name, context);
5354 return error_mark_node;
5358 return build_typename_type (context, name, fullname, NULL_TREE);
5361 /* Select the right _DECL from multiple choices. */
5364 select_decl (binding, flags)
5369 val = BINDING_VALUE (binding);
5370 if (LOOKUP_NAMESPACES_ONLY (flags))
5372 /* We are not interested in types. */
5373 if (val && TREE_CODE (val) == NAMESPACE_DECL)
5378 /* If we could have a type and
5379 we have nothing or we need a type and have none. */
5380 if (BINDING_TYPE (binding)
5381 && (!val || ((flags & LOOKUP_PREFER_TYPES)
5382 && TREE_CODE (val) != TYPE_DECL)))
5383 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5384 /* Don't return non-types if we really prefer types. */
5385 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
5386 && (TREE_CODE (val) != TEMPLATE_DECL
5387 || !DECL_CLASS_TEMPLATE_P (val)))
5393 /* Unscoped lookup of a global: iterate over current namespaces,
5394 considering using-directives. If SPACESP is non-NULL, store a list
5395 of the namespaces we've considered in it. */
5398 unqualified_namespace_lookup (name, flags, spacesp)
5403 tree b = make_node (CPLUS_BINDING);
5404 tree initial = current_decl_namespace();
5405 tree scope = initial;
5407 struct binding_level *level;
5408 tree val = NULL_TREE;
5411 *spacesp = NULL_TREE;
5413 for (; !val; scope = CP_DECL_CONTEXT (scope))
5416 *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5417 val = binding_for_name (name, scope);
5419 /* Initialize binding for this context. */
5420 BINDING_VALUE (b) = BINDING_VALUE (val);
5421 BINDING_TYPE (b) = BINDING_TYPE (val);
5423 /* Add all _DECLs seen through local using-directives. */
5424 for (level = current_binding_level;
5425 !level->namespace_p;
5426 level = level->level_chain)
5427 if (!lookup_using_namespace (name, b, level->using_directives,
5428 scope, flags, spacesp))
5429 /* Give up because of error. */
5430 return error_mark_node;
5432 /* Add all _DECLs seen through global using-directives. */
5433 /* XXX local and global using lists should work equally. */
5437 if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5438 scope, flags, spacesp))
5439 /* Give up because of error. */
5440 return error_mark_node;
5441 if (siter == scope) break;
5442 siter = CP_DECL_CONTEXT (siter);
5445 val = select_decl (b, flags);
5446 if (scope == global_namespace)
5452 /* Combine prefer_type and namespaces_only into flags. */
5455 lookup_flags (prefer_type, namespaces_only)
5456 int prefer_type, namespaces_only;
5458 if (namespaces_only)
5459 return LOOKUP_PREFER_NAMESPACES;
5460 if (prefer_type > 1)
5461 return LOOKUP_PREFER_TYPES;
5462 if (prefer_type > 0)
5463 return LOOKUP_PREFER_BOTH;
5467 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5468 ignore it or not. Subroutine of lookup_name_real. */
5471 qualify_lookup (val, flags)
5475 if (val == NULL_TREE)
5477 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5479 if ((flags & LOOKUP_PREFER_TYPES)
5480 && (TREE_CODE (val) == TYPE_DECL
5481 || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5482 && DECL_CLASS_TEMPLATE_P (val))))
5484 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5489 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5493 warn_about_implicit_typename_lookup (typename, binding)
5497 tree subtype = TREE_TYPE (TREE_TYPE (typename));
5498 tree name = DECL_NAME (typename);
5500 if (! (TREE_CODE (binding) == TEMPLATE_DECL
5501 && CLASSTYPE_TEMPLATE_INFO (subtype)
5502 && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5503 && ! (TREE_CODE (binding) == TYPE_DECL
5504 && same_type_p (TREE_TYPE (binding), subtype)))
5506 cp_warning ("lookup of `%D' finds `%#D'",
5508 cp_warning (" instead of `%D' from dependent base class",
5510 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5511 constructor_name (current_class_type), name);
5515 /* Look up NAME in the current binding level and its superiors in the
5516 namespace of variables, functions and typedefs. Return a ..._DECL
5517 node of some kind representing its definition if there is only one
5518 such declaration, or return a TREE_LIST with all the overloaded
5519 definitions if there are many, or return 0 if it is undefined.
5521 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5522 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5523 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5524 Otherwise we prefer non-TYPE_DECLs.
5526 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5527 using IDENTIFIER_CLASS_VALUE. */
5530 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5532 int prefer_type, nonclass, namespaces_only;
5535 tree val = NULL_TREE;
5537 tree from_obj = NULL_TREE;
5539 int val_is_implicit_typename = 0;
5541 /* Hack: copy flag set by parser, if set. */
5542 if (only_namespace_names)
5543 namespaces_only = 1;
5545 if (prefer_type == -2)
5547 extern int looking_for_typename;
5548 tree type = NULL_TREE;
5551 prefer_type = looking_for_typename;
5553 flags = lookup_flags (prefer_type, namespaces_only);
5554 /* If the next thing is '<', class templates are types. */
5555 if (looking_for_template)
5556 flags |= LOOKUP_TEMPLATES_EXPECTED;
5558 /* std:: becomes :: for now. */
5559 if (got_scope == std_node)
5560 got_scope = void_type_node;
5564 else if (got_object != error_mark_node)
5569 if (type == error_mark_node)
5570 return error_mark_node;
5571 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5572 type = TREE_TYPE (type);
5575 type = complete_type (type);
5577 if (TREE_CODE (type) == VOID_TYPE)
5578 type = global_namespace;
5579 if (TREE_CODE (type) == NAMESPACE_DECL)
5581 val = make_node (CPLUS_BINDING);
5582 flags |= LOOKUP_COMPLAIN;
5583 if (!qualified_lookup_using_namespace (name, type, val, flags))
5585 val = select_decl (val, flags);
5587 else if (! IS_AGGR_TYPE (type)
5588 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5589 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5590 || TREE_CODE (type) == TYPENAME_TYPE)
5591 /* Someone else will give an error about this if needed. */
5593 else if (type == current_class_type)
5594 val = IDENTIFIER_CLASS_VALUE (name);
5596 val = lookup_member (type, name, 0, prefer_type);
5603 else if (got_object && val)
5608 flags = lookup_flags (prefer_type, namespaces_only);
5609 /* If we're not parsing, we need to complain. */
5610 flags |= LOOKUP_COMPLAIN;
5613 /* First, look in non-namespace scopes. */
5615 if (current_class_type == NULL_TREE)
5618 for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5622 if (!LOCAL_BINDING_P (t) && nonclass)
5623 /* We're not looking for class-scoped bindings, so keep going. */
5626 /* If this is the kind of thing we're looking for, we're done. */
5627 if (qualify_lookup (BINDING_VALUE (t), flags))
5628 binding = BINDING_VALUE (t);
5629 else if ((flags & LOOKUP_PREFER_TYPES)
5630 && qualify_lookup (BINDING_TYPE (t), flags))
5631 binding = BINDING_TYPE (t);
5633 binding = NULL_TREE;
5636 && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5638 if (val_is_implicit_typename && !yylex)
5639 warn_about_implicit_typename_lookup (val, binding);
5641 val_is_implicit_typename
5642 = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5643 if (!val_is_implicit_typename)
5648 /* Now lookup in namespace scopes. */
5649 if (!val || val_is_implicit_typename)
5651 t = unqualified_namespace_lookup (name, flags, 0);
5654 if (val_is_implicit_typename && !yylex)
5655 warn_about_implicit_typename_lookup (val, t);
5663 /* This should only warn about types used in qualified-ids. */
5664 if (from_obj && from_obj != val)
5666 if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5667 && TREE_CODE (val) == TYPE_DECL
5668 && TREE_TYPE (from_obj) != TREE_TYPE (val))
5670 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5671 name, got_object, TREE_TYPE (from_obj));
5672 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5676 /* We don't change val to from_obj if got_object depends on
5677 template parms because that breaks implicit typename for
5678 destructor calls. */
5679 if (! uses_template_parms (got_object))
5683 /* If we have a single function from a using decl, pull it out. */
5684 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5685 val = OVL_FUNCTION (val);
5694 lookup_name_nonclass (name)
5697 return lookup_name_real (name, 0, 1, 0);
5701 lookup_function_nonclass (name, args)
5705 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5709 lookup_name_namespace_only (name)
5712 /* type-or-namespace, nonclass, namespace_only */
5713 return lookup_name_real (name, 1, 1, 1);
5717 lookup_name (name, prefer_type)
5721 return lookup_name_real (name, prefer_type, 0, 0);
5724 /* Similar to `lookup_name' but look only in the innermost non-class
5728 lookup_name_current_level (name)
5731 struct binding_level *b;
5734 b = current_binding_level;
5735 while (b->parm_flag == 2)
5740 t = IDENTIFIER_NAMESPACE_VALUE (name);
5742 /* extern "C" function() */
5743 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5746 else if (IDENTIFIER_BINDING (name)
5747 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5751 if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5752 return IDENTIFIER_VALUE (name);
5764 /* Like lookup_name_current_level, but for types. */
5767 lookup_type_current_level (name)
5770 register tree t = NULL_TREE;
5772 my_friendly_assert (! current_binding_level->namespace_p, 980716);
5774 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5775 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5777 struct binding_level *b = current_binding_level;
5780 if (purpose_member (name, b->type_shadowed))
5781 return REAL_IDENTIFIER_TYPE_VALUE (name);
5793 begin_only_namespace_names ()
5795 only_namespace_names = 1;
5799 end_only_namespace_names ()
5801 only_namespace_names = 0;
5804 /* Arrange for the user to get a source line number, even when the
5805 compiler is going down in flames, so that she at least has a
5806 chance of working around problems in the compiler. We used to
5807 call error(), but that let the segmentation fault continue
5808 through; now, it's much more passive by asking them to send the
5809 maintainers mail about the problem. */
5813 int sig ATTRIBUTE_UNUSED;
5815 signal (SIGSEGV, SIG_DFL);
5817 signal (SIGIOT, SIG_DFL);
5820 signal (SIGILL, SIG_DFL);
5823 signal (SIGABRT, SIG_DFL);
5826 signal (SIGBUS, SIG_DFL);
5828 my_friendly_abort (0);
5831 /* Push the declarations of builtin types into the namespace.
5832 RID_INDEX, if < RID_MAX is the index of the builtin type
5833 in the array RID_POINTERS. NAME is the name used when looking
5834 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5837 record_builtin_type (rid_index, name, type)
5842 tree rname = NULL_TREE, tname = NULL_TREE;
5843 tree tdecl = NULL_TREE;
5845 if ((int) rid_index < (int) RID_MAX)
5846 rname = ridpointers[(int) rid_index];
5848 tname = get_identifier (name);
5850 TYPE_BUILT_IN (type) = 1;
5854 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5855 set_identifier_type_value (tname, NULL_TREE);
5856 if ((int) rid_index < (int) RID_MAX)
5857 /* Built-in types live in the global namespace. */
5858 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5860 if (rname != NULL_TREE)
5862 if (tname != NULL_TREE)
5864 set_identifier_type_value (rname, NULL_TREE);
5865 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5869 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5870 set_identifier_type_value (rname, NULL_TREE);
5875 /* Record one of the standard Java types.
5876 * Declare it as having the given NAME.
5877 * If SIZE > 0, it is the size of one of the integral types;
5878 * otherwise it is the negative of the size of one of the other types. */
5881 record_builtin_java_type (name, size)
5887 type = make_signed_type (size);
5888 else if (size > -32)
5889 { /* "__java_char" or ""__java_boolean". */
5890 type = make_unsigned_type (-size);
5891 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
5894 { /* "__java_float" or ""__java_double". */
5895 type = make_node (REAL_TYPE);
5896 TYPE_PRECISION (type) = - size;
5899 record_builtin_type (RID_MAX, name, type);
5900 decl = TYPE_NAME (type);
5902 /* Suppress generate debug symbol entries for these types,
5903 since for normal C++ they are just clutter.
5904 However, push_lang_context undoes this if extern "Java" is seen. */
5905 DECL_IGNORED_P (decl) = 1;
5907 TYPE_FOR_JAVA (type) = 1;
5911 /* Push a type into the namespace so that the back-ends ignore it. */
5914 record_unknown_type (type, name)
5918 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
5919 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
5920 DECL_IGNORED_P (decl) = 1;
5921 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5922 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
5923 TYPE_ALIGN (type) = 1;
5924 TYPE_MODE (type) = TYPE_MODE (void_type_node);
5927 /* Push overloaded decl, in global scope, with one argument so it
5928 can be used as a callback from define_function. */
5931 push_overloaded_decl_1 (x)
5938 auto_function (name, type)
5941 return define_function
5942 (IDENTIFIER_POINTER (name), type, push_overloaded_decl_1,
5943 IDENTIFIER_POINTER (build_decl_overload (name, TYPE_ARG_TYPES (type),
5947 /* Create the predefined scalar types of C,
5948 and some nodes representing standard constants (0, 1, (void *)0).
5949 Initialize the global binding level.
5950 Make definitions for built-in primitive functions. */
5953 init_decl_processing ()
5956 int wchar_type_size;
5957 tree array_domain_type;
5959 /* Check to see that the user did not specify an invalid combination
5960 of command-line options. */
5961 if (flag_new_abi && !flag_vtable_thunks)
5962 fatal ("the new ABI requires vtable thunks");
5964 /* Have to make these distinct before we try using them. */
5965 lang_name_cplusplus = get_identifier ("C++");
5966 lang_name_c = get_identifier ("C");
5967 lang_name_java = get_identifier ("Java");
5969 /* Let the back-end now how to save and restore language-specific
5970 per-function globals. */
5971 init_lang_status = &push_cp_function_context;
5972 free_lang_status = &pop_cp_function_context;
5973 mark_lang_status = &mark_cp_function_context;
5979 /* Create the global variables. */
5980 push_to_top_level ();
5982 /* Enter the global namespace. */
5983 my_friendly_assert (global_namespace == NULL_TREE, 375);
5984 push_namespace (get_identifier ("::"));
5985 global_namespace = current_namespace;
5986 current_lang_name = NULL_TREE;
5988 /* Adjust various flags based on command-line settings. */
5989 if (flag_strict_prototype == 2)
5990 flag_strict_prototype = pedantic;
5991 if (! flag_permissive && ! pedantic)
5992 flag_pedantic_errors = 1;
5993 if (!flag_no_inline)
5994 flag_inline_trees = 1;
5996 strict_prototypes_lang_c = flag_strict_prototype;
5999 current_lang_name = lang_name_c;
6001 current_function_decl = NULL_TREE;
6002 current_binding_level = NULL_BINDING_LEVEL;
6003 free_binding_level = NULL_BINDING_LEVEL;
6005 /* Because most segmentation signals can be traced back into user
6006 code, catch them and at least give the user a chance of working
6007 around compiler bugs. */
6008 signal (SIGSEGV, signal_catch);
6010 /* We will also catch aborts in the back-end through signal_catch and
6011 give the user a chance to see where the error might be, and to defeat
6012 aborts in the back-end when there have been errors previously in their
6015 signal (SIGIOT, signal_catch);
6018 signal (SIGILL, signal_catch);
6021 signal (SIGABRT, signal_catch);
6024 signal (SIGBUS, signal_catch);
6027 build_common_tree_nodes (flag_signed_char);
6029 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6030 TREE_TYPE (error_mark_list) = error_mark_node;
6032 /* Make the binding_level structure for global names. */
6034 global_binding_level = current_binding_level;
6035 /* The global level is the namespace level of ::. */
6036 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6037 declare_namespace_level ();
6039 this_identifier = get_identifier (THIS_NAME);
6040 in_charge_identifier = get_identifier (IN_CHARGE_NAME);
6041 ctor_identifier = get_identifier (CTOR_NAME);
6042 dtor_identifier = get_identifier (DTOR_NAME);
6043 pfn_identifier = get_identifier (VTABLE_PFN_NAME);
6044 index_identifier = get_identifier (VTABLE_INDEX_NAME);
6045 delta_identifier = get_identifier (VTABLE_DELTA_NAME);
6046 delta2_identifier = get_identifier (VTABLE_DELTA2_NAME);
6047 pfn_or_delta2_identifier = get_identifier ("__pfn_or_delta2");
6049 /* Define `int' and `char' first so that dbx will output them first. */
6050 record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6051 record_builtin_type (RID_CHAR, "char", char_type_node);
6053 /* `signed' is the same as `int' */
6054 record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6055 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6056 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6057 record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6058 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6059 record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6060 record_builtin_type (RID_MAX, "long long unsigned int",
6061 long_long_unsigned_type_node);
6062 record_builtin_type (RID_MAX, "long long unsigned",
6063 long_long_unsigned_type_node);
6064 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6065 record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6066 record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6069 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6071 /* Define both `signed char' and `unsigned char'. */
6072 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6073 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6075 /* `unsigned long' is the standard type for sizeof.
6076 Note that stddef.h uses `unsigned long',
6077 and this must agree, even if long and int are the same size. */
6079 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6081 /* Create the widest literal types. */
6082 widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6083 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6084 widest_integer_literal_type_node));
6086 widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6087 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6088 widest_unsigned_literal_type_node));
6090 /* These are types that type_for_size and type_for_mode use. */
6091 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6092 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6093 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6094 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6095 #if HOST_BITS_PER_WIDE_INT >= 64
6096 pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6098 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6099 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6100 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6101 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6102 #if HOST_BITS_PER_WIDE_INT >= 64
6103 pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6106 build_common_tree_nodes_2 (flag_short_double);
6108 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6109 java_short_type_node = record_builtin_java_type ("__java_short", 16);
6110 java_int_type_node = record_builtin_java_type ("__java_int", 32);
6111 java_long_type_node = record_builtin_java_type ("__java_long", 64);
6112 java_float_type_node = record_builtin_java_type ("__java_float", -32);
6113 java_double_type_node = record_builtin_java_type ("__java_double", -64);
6114 java_char_type_node = record_builtin_java_type ("__java_char", -16);
6115 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6117 integer_two_node = build_int_2 (2, 0);
6118 TREE_TYPE (integer_two_node) = integer_type_node;
6119 integer_three_node = build_int_2 (3, 0);
6120 TREE_TYPE (integer_three_node) = integer_type_node;
6122 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6123 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6124 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6125 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6126 TYPE_PRECISION (boolean_type_node) = 1;
6127 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6128 boolean_false_node = build_int_2 (0, 0);
6129 TREE_TYPE (boolean_false_node) = boolean_type_node;
6130 boolean_true_node = build_int_2 (1, 0);
6131 TREE_TYPE (boolean_true_node) = boolean_type_node;
6133 signed_size_zero_node = build_int_2 (0, 0); record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6134 record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6135 record_builtin_type (RID_MAX, "long double", long_double_type_node);
6137 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6138 complex_integer_type_node));
6139 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6140 complex_float_type_node));
6141 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6142 complex_double_type_node));
6143 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6144 complex_long_double_type_node));
6146 TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6148 record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6149 void_list_node = build_tree_list (NULL_TREE, void_type_node);
6150 TREE_PARMLIST (void_list_node) = 1;
6152 /* Used for expressions that do nothing, but are not errors. */
6153 void_zero_node = build_int_2 (0, 0);
6154 TREE_TYPE (void_zero_node) = void_type_node;
6156 string_type_node = build_pointer_type (char_type_node);
6157 const_string_type_node
6158 = build_pointer_type (build_qualified_type (char_type_node,
6160 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6162 record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6165 /* Make a type to be the domain of a few array types
6166 whose domains don't really matter.
6167 200 is small enough that it always fits in size_t
6168 and large enough that it can hold most function names for the
6169 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
6170 array_domain_type = build_index_type (build_int_2 (200, 0));
6172 /* Make a type for arrays of characters.
6173 With luck nothing will ever really depend on the length of this
6175 char_array_type_node
6176 = build_array_type (char_type_node, array_domain_type);
6177 /* Likewise for arrays of ints. */
6179 = build_array_type (integer_type_node, array_domain_type);
6181 /* This is just some anonymous class type. Nobody should ever
6182 need to look inside this envelope. */
6183 class_star_type_node = build_pointer_type (make_aggr_type (RECORD_TYPE));
6185 if (flag_huge_objects)
6186 delta_type_node = long_integer_type_node;
6188 delta_type_node = short_integer_type_node;
6190 default_function_type
6191 = build_function_type (integer_type_node, NULL_TREE);
6193 ptr_type_node = build_pointer_type (void_type_node);
6195 = build_pointer_type (build_qualified_type (void_type_node,
6197 c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6198 lang_type_promotes_to = convert_type_from_ellipsis;
6201 = build_exception_variant (void_ftype_ptr, empty_except_spec);
6203 /* C++ extensions */
6205 unknown_type_node = make_node (UNKNOWN_TYPE);
6206 record_unknown_type (unknown_type_node, "unknown type");
6208 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6209 TREE_TYPE (unknown_type_node) = unknown_type_node;
6211 TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6213 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6215 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6216 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6218 /* This is special for C++ so functions can be overloaded. */
6219 wchar_type_node = get_identifier (flag_short_wchar
6220 ? "short unsigned int"
6222 wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6223 wchar_type_size = TYPE_PRECISION (wchar_type_node);
6224 signed_wchar_type_node = make_signed_type (wchar_type_size);
6225 unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6227 = TREE_UNSIGNED (wchar_type_node)
6228 ? unsigned_wchar_type_node
6229 : signed_wchar_type_node;
6230 record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6232 /* Artificial declaration of wchar_t -- can be bashed */
6233 wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6235 pushdecl (wchar_decl_node);
6237 /* This is for wide string constants. */
6238 wchar_array_type_node
6239 = build_array_type (wchar_type_node, array_domain_type);
6241 if (flag_vtable_thunks)
6243 /* Make sure we get a unique function type, so we can give
6244 its pointer type a name. (This wins for gdb.) */
6245 tree vfunc_type = make_node (FUNCTION_TYPE);
6246 TREE_TYPE (vfunc_type) = integer_type_node;
6247 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6248 layout_type (vfunc_type);
6250 vtable_entry_type = build_pointer_type (vfunc_type);
6254 vtable_entry_type = make_aggr_type (RECORD_TYPE);
6255 fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6257 fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6259 fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6261 finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6264 /* Make this part of an invisible union. */
6265 fields[3] = copy_node (fields[2]);
6266 TREE_TYPE (fields[3]) = delta_type_node;
6267 DECL_NAME (fields[3]) = delta2_identifier;
6268 DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6269 DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6270 TREE_UNSIGNED (fields[3]) = 0;
6271 TREE_CHAIN (fields[2]) = fields[3];
6272 vtable_entry_type = build_qualified_type (vtable_entry_type,
6275 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6278 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6279 layout_type (vtbl_type_node);
6280 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6281 record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6282 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6283 layout_type (vtbl_ptr_type_node);
6284 record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6286 std_node = build_decl (NAMESPACE_DECL,
6287 get_identifier (flag_honor_std ? "fake std":"std"),
6289 pushdecl (std_node);
6291 global_type_node = make_node (LANG_TYPE);
6292 record_unknown_type (global_type_node, "global type");
6295 current_lang_name = lang_name_cplusplus;
6298 tree bad_alloc_type_node, newtype, deltype;
6300 push_namespace (get_identifier ("std"));
6301 bad_alloc_type_node = xref_tag
6302 (class_type_node, get_identifier ("bad_alloc"), 1);
6305 newtype = build_exception_variant
6306 (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6307 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6308 auto_function (ansi_opname[(int) NEW_EXPR], newtype);
6309 auto_function (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6310 global_delete_fndecl = auto_function (ansi_opname[(int) DELETE_EXPR],
6312 auto_function (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6316 = define_function ("__pure_virtual", void_ftype, 0, 0);
6318 /* Perform other language dependent initializations. */
6319 init_class_processing ();
6320 init_init_processing ();
6321 init_search_processing ();
6322 init_rtti_processing ();
6324 if (flag_exceptions)
6325 init_exception_processing ();
6328 flag_inline_functions = 0;
6331 if (! supports_one_only ())
6334 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6335 declare_function_name ();
6337 /* Prepare to check format strings against argument lists. */
6338 init_function_format_info ();
6340 /* Show we use EH for cleanups. */
6341 using_eh_for_cleanups ();
6343 print_error_function = lang_print_error_function;
6344 lang_get_alias_set = &c_get_alias_set;
6345 valid_lang_attribute = cp_valid_lang_attribute;
6347 /* Maintain consistency. Perhaps we should just complain if they
6348 say -fwritable-strings? */
6349 if (flag_writable_strings)
6350 flag_const_strings = 0;
6352 /* Add GC roots for all of our global variables. */
6353 ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6354 ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6355 ggc_add_tree_root (&integer_three_node, 1);
6356 ggc_add_tree_root (&integer_two_node, 1);
6357 ggc_add_tree_root (&signed_size_zero_node, 1);
6358 ggc_add_tree_root (&size_one_node, 1);
6359 ggc_add_tree_root (&size_zero_node, 1);
6360 ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6361 mark_binding_level);
6362 ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6363 ggc_add_tree_root (&static_ctors, 1);
6364 ggc_add_tree_root (&static_dtors, 1);
6365 ggc_add_tree_root (&lastiddecl, 1);
6367 ggc_add_tree_root (&last_function_parm_tags, 1);
6368 ggc_add_tree_root (¤t_function_return_value, 1);
6369 ggc_add_tree_root (¤t_function_parms, 1);
6370 ggc_add_tree_root (¤t_function_parm_tags, 1);
6371 ggc_add_tree_root (&last_function_parms, 1);
6372 ggc_add_tree_root (&error_mark_list, 1);
6374 ggc_add_tree_root (&global_namespace, 1);
6375 ggc_add_tree_root (&global_type_node, 1);
6376 ggc_add_tree_root (&anonymous_namespace_name, 1);
6378 ggc_add_tree_root (&got_object, 1);
6379 ggc_add_tree_root (&got_scope, 1);
6381 ggc_add_tree_root (¤t_lang_name, 1);
6382 ggc_add_tree_root (&static_aggregates, 1);
6385 /* Function to print any language-specific context for an error message. */
6388 lang_print_error_function (file)
6391 default_print_error_function (file);
6392 maybe_print_template_context ();
6395 /* Make a definition for a builtin function named NAME and whose data type
6396 is TYPE. TYPE should be a function type with argument types.
6398 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6399 the name to be called if we can't opencode the function. */
6402 define_function (name, type, pfn, library_name)
6405 void (*pfn) PROTO((tree));
6406 const char *library_name;
6408 tree decl = build_lang_decl (FUNCTION_DECL, get_identifier (name), type);
6409 DECL_EXTERNAL (decl) = 1;
6410 TREE_PUBLIC (decl) = 1;
6411 DECL_ARTIFICIAL (decl) = 1;
6413 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6414 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6416 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6417 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6418 function in the namespace. */
6419 if (pfn) (*pfn) (decl);
6421 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
6422 make_function_rtl (decl);
6427 /* Wrapper around define_function, for the benefit of
6428 c_common_nodes_and_builtins.
6429 FUNCTION_CODE tells later passes how to compile calls to this function.
6430 See tree.h for its possible values. */
6433 builtin_function (name, type, code, class, libname)
6437 enum built_in_class class;
6438 const char *libname;
6440 tree decl = define_function (name, type, (void (*) PROTO((tree)))pushdecl,
6442 DECL_BUILT_IN_CLASS (decl) = class;
6443 DECL_FUNCTION_CODE (decl) = code;
6447 /* When we call finish_struct for an anonymous union, we create
6448 default copy constructors and such. But, an anonymous union
6449 shouldn't have such things; this function undoes the damage to the
6450 anonymous union type T.
6452 (The reason that we create the synthesized methods is that we don't
6453 distinguish `union { int i; }' from `typedef union { int i; } U'.
6454 The first is an anonymous union; the second is just an ordinary
6458 fixup_anonymous_aggr (t)
6463 /* Wipe out memory of synthesized methods */
6464 TYPE_HAS_CONSTRUCTOR (t) = 0;
6465 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6466 TYPE_HAS_INIT_REF (t) = 0;
6467 TYPE_HAS_CONST_INIT_REF (t) = 0;
6468 TYPE_HAS_ASSIGN_REF (t) = 0;
6469 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6471 /* Splice the implicitly generated functions out of the TYPE_METHODS
6473 q = &TYPE_METHODS (t);
6476 if (DECL_ARTIFICIAL (*q))
6477 *q = TREE_CHAIN (*q);
6479 q = &TREE_CHAIN (*q);
6482 /* ANSI C++ June 5 1992 WP 9.5.3. Anonymous unions may not have
6483 function members. */
6484 if (TYPE_METHODS (t))
6485 error ("an anonymous union cannot have function members");
6488 /* Make sure that a declaration with no declarator is well-formed, i.e.
6489 just defines a tagged type or anonymous union.
6491 Returns the type defined, if any. */
6494 check_tag_decl (declspecs)
6498 tree ob_modifier = NULL_TREE;
6500 register tree t = NULL_TREE;
6502 for (link = declspecs; link; link = TREE_CHAIN (link))
6504 register tree value = TREE_VALUE (link);
6510 if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6512 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6516 else if (value == ridpointers[(int) RID_FRIEND])
6518 if (current_class_type == NULL_TREE
6519 || current_scope () != current_class_type)
6520 ob_modifier = value;
6522 else if (value == ridpointers[(int) RID_STATIC]
6523 || value == ridpointers[(int) RID_EXTERN]
6524 || value == ridpointers[(int) RID_AUTO]
6525 || value == ridpointers[(int) RID_REGISTER]
6526 || value == ridpointers[(int) RID_INLINE]
6527 || value == ridpointers[(int) RID_VIRTUAL]
6528 || value == ridpointers[(int) RID_CONST]
6529 || value == ridpointers[(int) RID_VOLATILE]
6530 || value == ridpointers[(int) RID_EXPLICIT])
6531 ob_modifier = value;
6535 error ("multiple types in one declaration");
6537 /* Inside a class, we might be in a friend or access declaration.
6538 Until we have a good way of detecting the latter, don't warn. */
6539 if (t == NULL_TREE && ! current_class_type)
6540 pedwarn ("declaration does not declare anything");
6542 /* Check for an anonymous union. We're careful
6543 accessing TYPE_IDENTIFIER because some built-in types, like
6544 pointer-to-member types, do not have TYPE_NAME. */
6545 else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6547 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6549 /* Anonymous unions are objects, so they can have specifiers. */;
6550 SET_ANON_AGGR_TYPE_P (t);
6552 if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6553 pedwarn ("ISO C++ prohibits anonymous structs");
6556 else if (ob_modifier)
6558 if (ob_modifier == ridpointers[(int) RID_INLINE]
6559 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6560 cp_error ("`%D' can only be specified for functions", ob_modifier);
6561 else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6562 cp_error ("`%D' can only be specified inside a class", ob_modifier);
6563 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6564 cp_error ("`%D' can only be specified for constructors",
6567 cp_error ("`%D' can only be specified for objects and functions",
6574 /* Called when a declaration is seen that contains no names to declare.
6575 If its type is a reference to a structure, union or enum inherited
6576 from a containing scope, shadow that tag name for the current scope
6577 with a forward reference.
6578 If its type defines a new named structure or union
6579 or defines an enum, it is valid but we need not do anything here.
6580 Otherwise, it is an error.
6582 C++: may have to grok the declspecs to learn about static,
6583 complain for anonymous unions. */
6586 shadow_tag (declspecs)
6589 tree t = check_tag_decl (declspecs);
6592 maybe_process_partial_specialization (t);
6594 /* This is where the variables in an anonymous union are
6595 declared. An anonymous union declaration looks like:
6597 because there is no declarator after the union, the parser
6598 sends that declaration here. */
6599 if (t && ANON_AGGR_TYPE_P (t))
6601 fixup_anonymous_aggr (t);
6603 if (TYPE_FIELDS (t))
6605 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6607 finish_anon_union (decl);
6612 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6615 groktypename (typename)
6618 if (TREE_CODE (typename) != TREE_LIST)
6620 return grokdeclarator (TREE_VALUE (typename),
6621 TREE_PURPOSE (typename),
6622 TYPENAME, 0, NULL_TREE);
6625 /* Decode a declarator in an ordinary declaration or data definition.
6626 This is called as soon as the type information and variable name
6627 have been parsed, before parsing the initializer if any.
6628 Here we create the ..._DECL node, fill in its type,
6629 and put it on the list of decls for the current context.
6630 The ..._DECL node is returned as the value.
6632 Exception: for arrays where the length is not specified,
6633 the type is left null, to be filled in by `cp_finish_decl'.
6635 Function definitions do not come here; they go to start_function
6636 instead. However, external and forward declarations of functions
6637 do go through here. Structure field declarations are done by
6638 grokfield and not through here. */
6640 /* Set this to zero to debug not using the temporary obstack
6641 to parse initializers. */
6642 int debug_temp_inits = 1;
6645 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6646 tree declarator, declspecs;
6648 tree attributes, prefix_attributes;
6651 register tree type, tem;
6653 extern int have_extern_spec;
6654 extern int used_extern_spec;
6658 /* See code below that used this. */
6659 int init_written = initialized;
6662 /* This should only be done once on the top most decl. */
6663 if (have_extern_spec && !used_extern_spec)
6665 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6667 used_extern_spec = 1;
6670 if (attributes || prefix_attributes)
6671 attrlist = build_tree_list (attributes, prefix_attributes);
6673 attrlist = NULL_TREE;
6675 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6678 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6681 type = TREE_TYPE (decl);
6683 if (type == error_mark_node)
6687 = (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
6688 ? DECL_CLASS_CONTEXT (decl)
6689 : DECL_CONTEXT (decl);
6691 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6692 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6694 /* When parsing the initializer, lookup should use the object's
6696 push_decl_namespace (context);
6699 /* We are only interested in class contexts, later. */
6700 if (context && TREE_CODE (context) == NAMESPACE_DECL)
6701 context = NULL_TREE;
6704 /* Is it valid for this decl to have an initializer at all?
6705 If not, set INITIALIZED to zero, which will indirectly
6706 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6707 switch (TREE_CODE (decl))
6710 /* typedef foo = bar means give foo the same type as bar.
6711 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
6712 Any other case of an initialization in a TYPE_DECL is an error. */
6713 if (pedantic || list_length (declspecs) > 1)
6715 cp_error ("typedef `%D' is initialized", decl);
6721 cp_error ("function `%#D' is initialized like a variable", decl);
6731 if (! toplevel_bindings_p ()
6732 && DECL_EXTERNAL (decl))
6733 cp_warning ("declaration of `%#D' has `extern' and is initialized",
6735 DECL_EXTERNAL (decl) = 0;
6736 if (toplevel_bindings_p ())
6737 TREE_STATIC (decl) = 1;
6739 /* Tell `pushdecl' this is an initialized decl
6740 even though we don't yet have the initializer expression.
6741 Also tell `cp_finish_decl' it may store the real initializer. */
6742 DECL_INITIAL (decl) = error_mark_node;
6745 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
6746 SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
6749 /* Set attributes here so if duplicate decl, will have proper attributes. */
6750 cplus_decl_attributes (decl, attributes, prefix_attributes);
6752 if (context && TYPE_SIZE (complete_type (context)) != NULL_TREE)
6754 push_nested_class (context, 2);
6756 if (TREE_CODE (decl) == VAR_DECL)
6758 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
6759 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
6760 cp_error ("`%#D' is not a static member of `%#T'", decl, context);
6763 if (DECL_CONTEXT (field) != context)
6765 cp_pedwarn ("ANSI C++ does not permit `%T::%D' to be defined as `%T::%D'",
6766 DECL_CONTEXT (field), DECL_NAME (decl),
6767 context, DECL_NAME (decl));
6768 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
6770 /* Static data member are tricky; an in-class initialization
6771 still doesn't provide a definition, so the in-class
6772 declaration will have DECL_EXTERNAL set, but will have an
6773 initialization. Thus, duplicate_decls won't warn
6774 about this situation, and so we check here. */
6775 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
6776 cp_error ("duplicate initialization of %D", decl);
6777 if (duplicate_decls (decl, field))
6783 tree field = check_classfn (context, decl);
6784 if (field && duplicate_decls (decl, field))
6788 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6789 DECL_IN_AGGR_P (decl) = 0;
6790 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
6791 || CLASSTYPE_USE_TEMPLATE (context))
6793 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
6794 /* [temp.expl.spec] An explicit specialization of a static data
6795 member of a template is a definition if the declaration
6796 includes an initializer; otherwise, it is a declaration.
6798 We check for processing_specialization so this only applies
6799 to the new specialization syntax. */
6800 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
6801 DECL_EXTERNAL (decl) = 1;
6804 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
6805 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
6809 /* Enter this declaration into the symbol table. */
6810 tem = maybe_push_decl (decl);
6812 if (processing_template_decl)
6813 tem = push_template_decl (tem);
6815 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
6816 /* Tell the back-end to use or not use .common as appropriate. If we say
6817 -fconserve-space, we want this to save .data space, at the expense of
6818 wrong semantics. If we say -fno-conserve-space, we want this to
6819 produce errors about redefs; to do this we force variables into the
6821 DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
6824 if (! processing_template_decl)
6834 tree type = TREE_TYPE (decl);
6835 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
6837 if (type == error_mark_node)
6840 /* If this type of object needs a cleanup, but we're not allowed to
6841 add any more objects with cleanups to the current scope, create a
6842 new binding level. */
6843 if (TYPE_NEEDS_DESTRUCTOR (type)
6844 && current_binding_level->more_cleanups_ok == 0)
6846 keep_next_level (2);
6849 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
6853 /* Is it valid for this decl to have an initializer at all?
6854 If not, set INITIALIZED to zero, which will indirectly
6855 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6857 /* Don't allow initializations for incomplete types except for
6858 arrays which might be completed by the initialization. */
6859 if (TYPE_SIZE (complete_type (type)) != NULL_TREE)
6860 ; /* A complete type is ok. */
6861 else if (TREE_CODE (type) != ARRAY_TYPE)
6863 cp_error ("variable `%#D' has initializer but incomplete type",
6866 type = TREE_TYPE (decl) = error_mark_node;
6868 else if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
6870 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
6871 cp_error ("elements of array `%#D' have incomplete type", decl);
6872 /* else we already gave an error in start_decl. */
6878 && TREE_CODE (decl) != TYPE_DECL
6879 && TREE_CODE (decl) != TEMPLATE_DECL
6880 && type != error_mark_node
6881 && IS_AGGR_TYPE (type)
6882 && ! DECL_EXTERNAL (decl))
6884 if ((! processing_template_decl || ! uses_template_parms (type))
6885 && TYPE_SIZE (complete_type (type)) == NULL_TREE)
6887 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
6889 /* Change the type so that assemble_variable will give
6890 DECL an rtl we can live with: (mem (const_int 0)). */
6891 type = TREE_TYPE (decl) = error_mark_node;
6895 /* If any base type in the hierarchy of TYPE needs a constructor,
6896 then we set initialized to 1. This way any nodes which are
6897 created for the purposes of initializing this aggregate
6898 will live as long as it does. This is necessary for global
6899 aggregates which do not have their initializers processed until
6900 the end of the file. */
6901 initialized = TYPE_NEEDS_CONSTRUCTING (type);
6906 DECL_INITIAL (decl) = NULL_TREE;
6909 /* Handle initialization of references.
6910 These three arguments are from `cp_finish_decl', and have the
6911 same meaning here that they do there.
6913 Quotes on semantics can be found in ARM 8.4.3. */
6916 grok_reference_init (decl, type, init)
6917 tree decl, type, init;
6921 if (init == NULL_TREE)
6923 if ((DECL_LANG_SPECIFIC (decl) == 0
6924 || DECL_IN_AGGR_P (decl) == 0)
6925 && ! DECL_THIS_EXTERN (decl))
6926 cp_error ("`%D' declared as reference but not initialized", decl);
6930 if (init == error_mark_node)
6933 if (TREE_CODE (init) == CONSTRUCTOR)
6935 cp_error ("ANSI C++ forbids use of initializer list to initialize reference `%D'", decl);
6939 if (TREE_CODE (init) == TREE_LIST)
6940 init = build_compound_expr (init);
6942 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
6943 init = convert_from_reference (init);
6945 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
6946 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
6948 /* Note: default conversion is only called in very special cases. */
6949 init = default_conversion (init);
6952 /* Convert INIT to the reference type TYPE. This may involve the
6953 creation of a temporary, whose lifetime must be the same as that
6954 of the reference. If so, a DECL_STMT for the temporary will be
6955 added just after the DECL_STMT for DECL. That's why we don't set
6956 DECL_INITIAL for local references (instead assigning to them
6957 explicitly); we need to allow the temporary to be initialized
6959 tmp = convert_to_reference
6960 (type, init, CONV_IMPLICIT,
6961 LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
6963 if (tmp == error_mark_node)
6965 else if (tmp != NULL_TREE)
6968 tmp = save_expr (tmp);
6969 if (building_stmt_tree ())
6971 /* Initialize the declaration. */
6972 tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
6973 finish_expr_stmt (tmp);
6976 DECL_INITIAL (decl) = tmp;
6980 cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
6984 if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
6986 expand_static_init (decl, DECL_INITIAL (decl));
6987 DECL_INITIAL (decl) = NULL_TREE;
6992 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
6993 mucking with forces it does not comprehend (i.e. initialization with a
6994 constructor). If we are at global scope and won't go into COMMON, fill
6995 it in with a dummy CONSTRUCTOR to force the variable into .data;
6996 otherwise we can use error_mark_node. */
6999 obscure_complex_init (decl, init)
7002 if (! flag_no_inline && TREE_STATIC (decl))
7004 if (extract_init (decl, init))
7008 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7009 if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7010 DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7014 DECL_INITIAL (decl) = error_mark_node;
7019 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7020 array until we finish parsing the initializer. If that's the
7021 situation we're in, update DECL accordingly. */
7024 maybe_deduce_size_from_array_init (decl, init)
7028 tree type = TREE_TYPE (decl);
7030 if (TREE_CODE (type) == ARRAY_TYPE
7031 && TYPE_DOMAIN (type) == NULL_TREE
7032 && TREE_CODE (decl) != TYPE_DECL)
7035 = (TREE_STATIC (decl)
7036 /* Even if pedantic, an external linkage array
7037 may have incomplete type at first. */
7038 ? pedantic && ! DECL_EXTERNAL (decl)
7039 : !DECL_EXTERNAL (decl));
7040 tree initializer = init ? init : DECL_INITIAL (decl);
7041 int failure = complete_array_type (type, initializer, do_default);
7044 cp_error ("initializer fails to determine size of `%D'", decl);
7049 cp_error ("array size missing in `%D'", decl);
7050 /* If a `static' var's size isn't known, make it extern as
7051 well as static, so it does not get allocated. If it's not
7052 `static', then don't mark it extern; finish_incomplete_decl
7053 will give it a default size and it will get allocated. */
7054 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7055 DECL_EXTERNAL (decl) = 1;
7058 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7059 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7061 cp_error ("zero-size array `%D'", decl);
7063 layout_decl (decl, 0);
7067 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7068 any appropriate error messages regarding the layout. */
7071 layout_var_decl (decl)
7074 tree type = TREE_TYPE (decl);
7076 tree ttype = target_type (type);
7079 /* If we haven't already layed out this declaration, do so now.
7080 Note that we must not call complete type for an external object
7081 because it's type might involve templates that we are not
7082 supposed to isntantiate yet. (And it's perfectly legal to say
7083 `extern X x' for some incomplete type `X'.) */
7084 if (!DECL_EXTERNAL (decl))
7085 complete_type (type);
7086 if (!DECL_SIZE (decl)&& TYPE_SIZE (type))
7087 layout_decl (decl, 0);
7089 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7091 /* An automatic variable with an incomplete type: that is an error.
7092 Don't talk about array types here, since we took care of that
7093 message in grokdeclarator. */
7094 cp_error ("storage size of `%D' isn't known", decl);
7095 TREE_TYPE (decl) = error_mark_node;
7098 /* Keep this code around in case we later want to control debug info
7099 based on whether a type is "used". (jason 1999-11-11) */
7101 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7102 /* Let debugger know it should output info for this type. */
7103 note_debug_info_needed (ttype);
7105 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7106 note_debug_info_needed (DECL_CONTEXT (decl));
7109 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7110 && DECL_SIZE (decl) != NULL_TREE
7111 && ! TREE_CONSTANT (DECL_SIZE (decl)))
7113 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7114 constant_expression_warning (DECL_SIZE (decl));
7116 cp_error ("storage size of `%D' isn't constant", decl);
7120 /* If a local static variable is declared in an inline function, or if
7121 we have a weak definition, we must endeavor to create only one
7122 instance of the variable at link-time. */
7125 maybe_commonize_var (decl)
7128 /* Static data in a function with comdat linkage also has comdat
7130 if (TREE_STATIC (decl)
7131 /* Don't mess with __FUNCTION__. */
7132 && ! TREE_ASM_WRITTEN (decl)
7133 && current_function_decl
7134 && DECL_CONTEXT (decl) == current_function_decl
7135 && (DECL_THIS_INLINE (current_function_decl)
7136 || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7137 && TREE_PUBLIC (current_function_decl))
7139 /* Rather than try to get this right with inlining, we suppress
7140 inlining of such functions. */
7141 current_function_cannot_inline
7142 = "function with static variable cannot be inline";
7144 /* If flag_weak, we don't need to mess with this, as we can just
7145 make the function weak, and let it refer to its unique local
7146 copy. This works because we don't allow the function to be
7150 if (DECL_INTERFACE_KNOWN (current_function_decl))
7152 TREE_PUBLIC (decl) = 1;
7153 DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7155 else if (DECL_INITIAL (decl) == NULL_TREE
7156 || DECL_INITIAL (decl) == error_mark_node)
7158 TREE_PUBLIC (decl) = 1;
7159 DECL_COMMON (decl) = 1;
7161 /* else we lose. We can only do this if we can use common,
7162 which we can't if it has been initialized. */
7164 if (TREE_PUBLIC (decl))
7165 DECL_ASSEMBLER_NAME (decl)
7166 = build_static_name (current_function_decl, DECL_NAME (decl));
7167 else if (! DECL_ARTIFICIAL (decl))
7169 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7170 cp_warning_at (" you can work around this by removing the initializer", decl);
7174 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7175 /* Set it up again; we might have set DECL_INITIAL since the last
7177 comdat_linkage (decl);
7180 /* Issue an error message if DECL is an uninitialized const variable. */
7183 check_for_uninitialized_const_var (decl)
7186 tree type = TREE_TYPE (decl);
7188 /* ``Unless explicitly declared extern, a const object does not have
7189 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7191 if (TREE_CODE (decl) == VAR_DECL
7192 && TREE_CODE (type) != REFERENCE_TYPE
7193 && CP_TYPE_CONST_P (type)
7194 && !TYPE_NEEDS_CONSTRUCTING (type)
7195 && !DECL_INITIAL (decl))
7196 cp_error ("uninitialized const `%D'", decl);
7199 /* Verify INIT (the initializer for DECL), and record the
7200 initialization in DECL_INITIAL, if appropriate. Returns a new
7204 check_initializer (decl, init)
7210 if (TREE_CODE (decl) == FIELD_DECL)
7213 type = TREE_TYPE (decl);
7215 /* If `start_decl' didn't like having an initialization, ignore it now. */
7216 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7219 /* Check the initializer. */
7222 /* Things that are going to be initialized need to have complete
7224 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7226 if (type == error_mark_node)
7227 /* We will have already complained. */
7229 else if (TYPE_SIZE (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7231 cp_error ("variable-sized object `%D' may not be initialized", decl);
7234 else if (TREE_CODE (type) == ARRAY_TYPE
7235 && !TYPE_SIZE (TREE_TYPE (type)))
7237 cp_error ("elements of array `%#D' have incomplete type", decl);
7240 else if (!TYPE_SIZE (type))
7242 cp_error ("`%D' has incomplete type", decl);
7243 TREE_TYPE (decl) = error_mark_node;
7248 if (TREE_CODE (decl) == CONST_DECL)
7250 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7252 DECL_INITIAL (decl) = init;
7254 /* This will keep us from needing to worry about our obstacks. */
7255 my_friendly_assert (init != NULL_TREE, 149);
7258 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7260 if (TREE_STATIC (decl))
7261 make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7262 grok_reference_init (decl, type, init);
7267 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7269 if (TREE_CODE (type) == ARRAY_TYPE)
7270 init = digest_init (type, init, (tree *) 0);
7271 else if (TREE_CODE (init) == CONSTRUCTOR
7272 && TREE_HAS_CONSTRUCTOR (init))
7274 if (TYPE_NON_AGGREGATE_CLASS (type))
7276 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7278 init = error_mark_node;
7281 goto dont_use_constructor;
7286 dont_use_constructor:
7287 if (TREE_CODE (init) != TREE_VEC)
7288 init = store_init_value (decl, init);
7292 /* We must hide the initializer so that expand_decl
7293 won't try to do something it does not understand. */
7294 init = obscure_complex_init (decl, init);
7296 else if (DECL_EXTERNAL (decl))
7298 else if (TREE_CODE_CLASS (TREE_CODE (type)) == 't'
7299 && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7301 tree core_type = strip_array_types (type);
7303 if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7305 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7306 cp_error ("structure `%D' with uninitialized const members", decl);
7307 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7308 cp_error ("structure `%D' with uninitialized reference members",
7312 check_for_uninitialized_const_var (decl);
7314 if (TYPE_SIZE (type) != NULL_TREE
7315 && TYPE_NEEDS_CONSTRUCTING (type))
7316 init = obscure_complex_init (decl, NULL_TREE);
7320 check_for_uninitialized_const_var (decl);
7325 /* If DECL is not a local variable, give it RTL. */
7328 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7331 const char *asmspec;
7336 type = TREE_TYPE (decl);
7337 toplev = toplevel_bindings_p ();
7339 /* Handle non-variables up front. */
7340 if (TREE_CODE (decl) != VAR_DECL)
7342 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7346 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7348 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7350 if (DECL_VIRTUAL_P (decl))
7351 make_decl_rtl (decl, NULL_PTR, toplev);
7352 else if (TREE_READONLY (decl)
7353 && DECL_INITIAL (decl) != NULL_TREE
7354 && DECL_INITIAL (decl) != error_mark_node
7355 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7357 DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7359 if (toplev && ! TREE_PUBLIC (decl))
7361 /* If this is a static const, change its apparent linkage
7362 if it belongs to a #pragma interface. */
7363 if (!interface_unknown)
7365 TREE_PUBLIC (decl) = 1;
7366 DECL_EXTERNAL (decl) = interface_only;
7368 make_decl_rtl (decl, asmspec, toplev);
7371 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7373 else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7375 my_friendly_assert (TREE_STATIC (decl), 19990828);
7377 if (init == NULL_TREE
7378 #ifdef DEFAULT_STATIC_DEFS
7379 /* If this code is dead, then users must
7380 explicitly declare static member variables
7381 outside the class def'n as well. */
7382 && TYPE_NEEDS_CONSTRUCTING (type)
7386 DECL_EXTERNAL (decl) = 1;
7387 make_decl_rtl (decl, asmspec, 1);
7390 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7392 else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7393 || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7394 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7397 /* Create RTL for the local static variable DECL. */
7400 make_rtl_for_local_static (decl)
7403 const char *asmspec = NULL;
7405 /* If we inlined this variable, we could see it's declaration
7407 if (DECL_RTL (decl))
7410 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7412 /* The only way this situaton can occur is if the
7413 user specified a name for this DECL using the
7414 `attribute' syntax. */
7415 asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7416 DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7419 rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7422 /* The old ARM scoping rules injected variables declared in the
7423 initialization statement of a for-statement into the surrounding
7424 scope. We support this usage, in order to be backward-compatible.
7425 DECL is a just-declared VAR_DECL; if necessary inject its
7426 declaration into the surrounding scope. */
7429 maybe_inject_for_scope_var (decl)
7432 if (current_binding_level->is_for_scope)
7434 struct binding_level *outer
7435 = current_binding_level->level_chain;
7437 /* Check to see if the same name is already bound at the outer
7438 level, either because it was directly declared, or because a
7439 dead for-decl got preserved. In either case, the code would
7440 not have been valid under the ARM scope rules, so clear
7441 is_for_scope for the current_binding_level.
7443 Otherwise, we need to preserve the temp slot for decl to last
7444 into the outer binding level. */
7447 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7449 if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7450 && (TREE_CODE (BINDING_VALUE (outer_binding))
7452 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7454 BINDING_VALUE (outer_binding)
7455 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7456 current_binding_level->is_for_scope = 0;
7458 else if (DECL_IN_MEMORY_P (decl))
7459 preserve_temp_slots (DECL_RTL (decl));
7463 /* Generate code to initialize DECL (a local variable). */
7466 initialize_local_var (decl, init, flags)
7471 tree type = TREE_TYPE (decl);
7473 /* If the type is bogus, don't bother initializing the variable. */
7474 if (type == error_mark_node)
7477 if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7479 /* If we used it already as memory, it must stay in memory. */
7480 DECL_INITIAL (decl) = NULL_TREE;
7481 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7484 /* Local statics are handled differently from ordinary automatic
7486 if (TREE_STATIC (decl))
7488 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7489 || TYPE_NEEDS_DESTRUCTOR (type))
7490 expand_static_init (decl, init);
7494 if (DECL_SIZE (decl) && type != error_mark_node)
7498 /* Compute and store the initial value. */
7499 already_used = TREE_USED (decl) || TREE_USED (type);
7501 if (init || TYPE_NEEDS_CONSTRUCTING (type))
7503 int saved_stmts_are_full_exprs_p;
7505 emit_line_note (DECL_SOURCE_FILE (decl),
7506 DECL_SOURCE_LINE (decl));
7507 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7508 stmts_are_full_exprs_p = 1;
7509 finish_expr_stmt (build_aggr_init (decl, init, flags));
7510 stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7513 /* Set this to 0 so we can tell whether an aggregate which was
7514 initialized was ever used. Don't do this if it has a
7515 destructor, so we don't complain about the 'resource
7516 allocation is initialization' idiom. Now set
7517 attribute((unused)) on types so decls of that type will be
7518 marked used. (see TREE_USED, above.) */
7519 if (TYPE_NEEDS_CONSTRUCTING (type)
7521 && !TYPE_NEEDS_DESTRUCTOR (type)
7522 && DECL_NAME (decl))
7523 TREE_USED (decl) = 0;
7524 else if (already_used)
7525 TREE_USED (decl) = 1;
7529 /* Generate code to destroy DECL (a local variable). */
7532 destroy_local_var (decl)
7535 tree type = TREE_TYPE (decl);
7538 /* Only variables get cleaned up. */
7539 if (TREE_CODE (decl) != VAR_DECL)
7542 /* And only things with destructors need cleaning up. */
7543 if (!TYPE_NEEDS_DESTRUCTOR (type))
7546 if (TREE_CODE (decl) == VAR_DECL &&
7547 (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7548 /* We don't clean up things that aren't defined in this
7549 translation unit, or that need a static cleanup. The latter
7550 are handled by finish_file. */
7553 /* Compute the cleanup. */
7554 cleanup = maybe_build_cleanup (decl);
7556 /* Record the cleanup required for this declaration. */
7557 if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7559 finish_decl_cleanup (decl, cleanup);
7562 /* Let the back-end know about DECL. */
7565 emit_local_var (decl)
7568 /* Create RTL for this variable. */
7569 if (DECL_RTL (decl))
7570 /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7571 All other local variables are assigned RTL in this function. */
7572 my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7576 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7577 /* The user must have specified an assembler name for this
7578 variable. Set that up now. */
7579 rest_of_decl_compilation
7580 (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7581 /*top_level=*/0, /*at_end=*/0);
7586 /* Actually do the initialization. */
7587 expand_start_target_temps ();
7588 expand_decl_init (decl);
7589 expand_end_target_temps ();
7592 /* Finish processing of a declaration;
7593 install its line number and initial value.
7594 If the length of an array type is not known before,
7595 it must be determined now, from the initial value, or it is an error.
7597 For C++, `cp_finish_decl' must be fairly evasive: it must keep initializers
7598 for aggregates that have constructors alive on the permanent obstack,
7599 so that the global initializing functions can be written at the end.
7601 INIT0 holds the value of an initializer that should be allowed to escape
7604 FLAGS is LOOKUP_ONLYCONVERTING is the = init syntax was used, else 0
7605 if the (init) syntax was used.
7607 For functions that take default parameters, DECL points to its
7608 "maximal" instantiation. `cp_finish_decl' must then also declared its
7609 subsequently lower and lower forms of instantiation, checking for
7610 ambiguity as it goes. This can be sped up later. */
7613 cp_finish_decl (decl, init, asmspec_tree, flags)
7619 tree ttype = NULL_TREE;
7620 const char *asmspec = NULL;
7621 int was_readonly = 0;
7623 /* If this is 0, then we did not change obstacks. */
7627 error ("assignment (not initialization) in declaration");
7631 /* Handling __FUNCTION__ and its ilk in a template-function requires
7632 some special processing because we are called from
7633 language-independent code. */
7634 if (cfun && processing_template_decl
7635 && current_function_name_declared == 2)
7637 /* Since we're in a template function, we need to
7638 push_template_decl. The language-independent code in
7639 declare_hidden_char_array doesn't know to do this. */
7640 retrofit_lang_decl (decl);
7641 decl = push_template_decl (decl);
7643 if (strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
7644 "__PRETTY_FUNCTION__") == 0)
7646 init = build (FUNCTION_NAME, const_string_type_node);
7647 DECL_PRETTY_FUNCTION_P (decl) = 1;
7651 /* If a name was specified, get the string. */
7653 asmspec = TREE_STRING_POINTER (asmspec_tree);
7655 if (init && TREE_CODE (init) == NAMESPACE_DECL)
7657 cp_error ("Cannot initialize `%D' to namespace `%D'",
7662 if (current_class_type
7663 && DECL_REAL_CONTEXT (decl) == current_class_type
7664 && TYPE_BEING_DEFINED (current_class_type)
7665 && (DECL_INITIAL (decl) || init))
7666 DECL_DEFINED_IN_CLASS_P (decl) = 1;
7668 if (TREE_CODE (decl) == VAR_DECL
7669 && DECL_CONTEXT (decl)
7670 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7671 && DECL_CONTEXT (decl) != current_namespace
7674 /* Leave the namespace of the object. */
7675 pop_decl_namespace ();
7678 type = TREE_TYPE (decl);
7680 if (type == error_mark_node)
7683 /* Add this declaration to the statement-tree. */
7684 if (building_stmt_tree () && at_function_scope_p ())
7685 add_decl_stmt (decl);
7687 if (TYPE_HAS_MUTABLE_P (type))
7688 TREE_READONLY (decl) = 0;
7690 if (processing_template_decl)
7692 if (init && DECL_INITIAL (decl))
7693 DECL_INITIAL (decl) = init;
7697 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7698 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7700 /* Take care of TYPE_DECLs up front. */
7701 if (TREE_CODE (decl) == TYPE_DECL)
7703 if (init && DECL_INITIAL (decl))
7705 /* typedef foo = bar; store the type of bar as the type of foo. */
7706 TREE_TYPE (decl) = type = TREE_TYPE (init);
7707 DECL_INITIAL (decl) = init = NULL_TREE;
7709 if (type != error_mark_node
7710 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7712 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7713 cp_warning ("shadowing previous type declaration of `%#D'", decl);
7714 set_identifier_type_value (DECL_NAME (decl), type);
7715 CLASSTYPE_GOT_SEMICOLON (type) = 1;
7717 GNU_xref_decl (current_function_decl, decl);
7719 /* If we have installed this as the canonical typedef for this
7720 type, and that type has not been defined yet, delay emitting
7721 the debug information for it, as we will emit it later. */
7722 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7723 && TYPE_SIZE (TREE_TYPE (decl)) == NULL_TREE)
7724 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7726 rest_of_decl_compilation (decl, NULL_PTR,
7727 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7731 if (TREE_CODE (decl) != FUNCTION_DECL)
7732 ttype = target_type (type);
7734 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7735 && TYPE_NEEDS_CONSTRUCTING (type))
7737 /* Currently, GNU C++ puts constants in text space, making them
7738 impossible to initialize. In the future, one would hope for
7739 an operating system which understood the difference between
7740 initialization and the running of a program. */
7742 TREE_READONLY (decl) = 0;
7745 if (TREE_CODE (decl) == FIELD_DECL && asmspec)
7747 /* This must override the asm specifier which was placed by
7748 grokclassfn. Lay this out fresh. */
7749 DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
7750 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7751 make_decl_rtl (decl, asmspec, 0);
7754 /* Deduce size of array from initialization, if not already known. */
7755 maybe_deduce_size_from_array_init (decl, init);
7756 init = check_initializer (decl, init);
7758 GNU_xref_decl (current_function_decl, decl);
7760 if (TREE_CODE (decl) == VAR_DECL)
7761 layout_var_decl (decl);
7763 /* Output the assembler code and/or RTL code for variables and functions,
7764 unless the type is an undefined structure or union.
7765 If not, it will get done when the type is completed. */
7766 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
7767 || TREE_CODE (decl) == RESULT_DECL)
7769 if (TREE_CODE (decl) == VAR_DECL)
7770 maybe_commonize_var (decl);
7772 make_rtl_for_nonlocal_decl (decl, init, asmspec);
7774 if (TREE_CODE (type) == FUNCTION_TYPE
7775 || TREE_CODE (type) == METHOD_TYPE)
7776 abstract_virtuals_error (decl,
7777 strip_array_types (TREE_TYPE (type)));
7779 abstract_virtuals_error (decl, strip_array_types (type));
7781 if (TREE_CODE (decl) == FUNCTION_DECL)
7783 else if (DECL_EXTERNAL (decl)
7784 && ! (DECL_LANG_SPECIFIC (decl)
7785 && DECL_NOT_REALLY_EXTERN (decl)))
7788 DECL_INITIAL (decl) = init;
7790 else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
7792 /* This is a local declaration. */
7793 if (doing_semantic_analysis_p ())
7794 maybe_inject_for_scope_var (decl);
7795 /* Initialize the local variable. But, if we're building a
7796 statement-tree, we'll do the initialization when we
7798 if (processing_template_decl)
7800 if (init || DECL_INITIAL (decl) == error_mark_node)
7801 DECL_INITIAL (decl) = init;
7805 /* If we're not building RTL, then we need to do so
7807 if (!building_stmt_tree ())
7808 emit_local_var (decl);
7809 /* Initialize the variable. */
7810 initialize_local_var (decl, init, flags);
7811 /* Clean up the variable. */
7812 destroy_local_var (decl);
7815 else if (TREE_STATIC (decl) && type != error_mark_node)
7817 /* Cleanups for static variables are handled by `finish_file'. */
7818 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7819 || TYPE_NEEDS_DESTRUCTOR (type))
7820 expand_static_init (decl, init);
7824 /* Undo call to `pushclass' that was done in `start_decl'
7825 due to initialization of qualified member variable.
7826 I.e., Foo::x = 10; */
7828 tree context = DECL_REAL_CONTEXT (decl);
7830 && TREE_CODE_CLASS (TREE_CODE (context)) == 't'
7831 && (TREE_CODE (decl) == VAR_DECL
7832 /* We also have a pushclass done that we need to undo here
7833 if we're at top level and declare a method. */
7834 || TREE_CODE (decl) == FUNCTION_DECL)
7835 /* If size hasn't been set, we're still defining it,
7836 and therefore inside the class body; don't pop
7837 the binding level.. */
7838 && TYPE_SIZE (context) != NULL_TREE
7839 && context == current_class_type)
7840 pop_nested_class ();
7846 /* If requested, warn about definitions of large data objects. */
7848 if (warn_larger_than
7849 && ! processing_template_decl
7850 && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
7851 && !DECL_EXTERNAL (decl))
7853 register tree decl_size = DECL_SIZE (decl);
7855 if (decl_size && TREE_CODE (decl_size) == INTEGER_CST)
7857 unsigned units = TREE_INT_CST_LOW (decl_size) / BITS_PER_UNIT;
7859 if (units > larger_than_size)
7860 warning_with_decl (decl, "size of `%s' is %u bytes", units);
7865 TREE_READONLY (decl) = 1;
7868 /* This is here for a midend callback from c-common.c */
7871 finish_decl (decl, init, asmspec_tree)
7875 cp_finish_decl (decl, init, asmspec_tree, 0);
7878 /* Returns a declaration for a VAR_DECL as if:
7880 extern "C" TYPE NAME;
7882 had been seen. Used to create compiler-generated global
7886 declare_global_var (name, type)
7892 push_to_top_level ();
7893 decl = build_decl (VAR_DECL, name, type);
7894 TREE_PUBLIC (decl) = 1;
7895 DECL_EXTERNAL (decl) = 1;
7896 DECL_ARTIFICIAL (decl) = 1;
7898 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
7899 pop_from_top_level ();
7904 /* Returns a pointer to the `atexit' function. Note that if
7905 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
7906 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7920 if (flag_use_cxa_atexit)
7922 /* The declaration for `__cxa_atexit' is:
7924 int __cxa_atexit (void (*)(void *), void *, void *)
7926 We build up the argument types and then then function type
7929 /* First, build the pointer-to-function type for the first
7931 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7932 fn_type = build_function_type (void_type_node, arg_types);
7933 fn_ptr_type = build_pointer_type (fn_type);
7934 /* Then, build the rest of the argument types. */
7935 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
7936 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
7937 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
7938 /* And the final __cxa_atexit type. */
7939 fn_type = build_function_type (integer_type_node, arg_types);
7940 fn_ptr_type = build_pointer_type (fn_type);
7941 name = "__cxa_atexit";
7945 /* The declaration for `atexit' is:
7947 int atexit (void (*)());
7949 We build up the argument types and then then function type
7951 fn_type = build_function_type (void_type_node, void_list_node);
7952 fn_ptr_type = build_pointer_type (fn_type);
7953 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
7954 /* Build the final atexit type. */
7955 fn_type = build_function_type (integer_type_node, arg_types);
7959 /* Now, build the function declaration. */
7960 push_lang_context (lang_name_c);
7961 atexit_fndecl = define_function (name, fn_type, /*pfn=*/0, NULL_PTR);
7962 mark_used (atexit_fndecl);
7963 pop_lang_context ();
7964 atexit_node = default_conversion (atexit_fndecl);
7969 /* Returns the __dso_handle VAR_DECL. */
7972 get_dso_handle_node ()
7974 if (dso_handle_node)
7975 return dso_handle_node;
7977 /* Declare the variable. */
7978 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
7981 return dso_handle_node;
7984 /* Begin a new function with internal linkage whose job will be simply
7985 to destroy some particular variable. */
7990 static int counter = 0;
7991 int old_interface_unknown = interface_unknown;
7997 push_to_top_level ();
7999 /* No need to mangle this. */
8000 push_lang_context (lang_name_c);
8002 interface_unknown = 1;
8004 /* Build the parameter-types. */
8005 parmtypes = void_list_node;
8006 /* Functions passed to __cxa_atexit take an additional parameter.
8007 We'll just ignore it. After we implement the new calling
8008 convention for destructors, we can eliminate the use of
8009 additional cleanup functions entirely in the -fnew-abi case. */
8010 if (flag_use_cxa_atexit)
8011 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8012 /* Build the function type itself. */
8013 fntype = build_function_type (void_type_node, parmtypes);
8014 /* Build the name of the function. */
8015 sprintf (name, "__tcf_%d", counter++);
8016 /* Build the function declaration. */
8017 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8018 /* It's a function with internal linkage, generated by the
8020 TREE_PUBLIC (fndecl) = 0;
8021 DECL_ARTIFICIAL (fndecl) = 1;
8022 /* Build the parameter. */
8023 if (flag_use_cxa_atexit)
8027 parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8028 DECL_CONTEXT (parmdecl) = fndecl;
8029 DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8030 TREE_USED (parmdecl) = 1;
8031 DECL_ARGUMENTS (fndecl) = parmdecl;
8035 start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8038 interface_unknown = old_interface_unknown;
8040 pop_lang_context ();
8042 return current_function_decl;
8045 /* Finish the cleanup function begun by start_cleanup_fn. */
8052 expand_body (finish_function (lineno, 0));
8054 pop_from_top_level ();
8057 /* Generate code to handle the destruction of the function-scoped
8058 static variable DECL. */
8061 destroy_local_static (decl)
8069 int saved_flag_access_control;
8071 /* Call build_cleanup before we enter the anonymous function so that
8072 any access checks will be done relative to the current scope,
8073 rather than the scope of the anonymous function. */
8074 build_cleanup (decl);
8076 /* Now start the function. */
8077 cleanup = start_cleanup_fn ();
8079 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8080 to the original function, rather than the anonymous one. That
8081 will make the back-end think that nested functions are in use,
8082 which causes confusion. */
8083 saved_flag_access_control = flag_access_control;
8084 flag_access_control = 0;
8085 fcall = build_cleanup (decl);
8086 flag_access_control = saved_flag_access_control;
8088 /* Create the body of the anonymous function. */
8089 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8090 finish_expr_stmt (fcall);
8091 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8094 /* Call atexit with the cleanup function. */
8095 mark_addressable (cleanup);
8096 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8097 if (flag_use_cxa_atexit)
8099 args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8100 args = tree_cons (NULL_TREE, null_pointer_node, args);
8101 args = tree_cons (NULL_TREE, cleanup, args);
8104 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8105 finish_expr_stmt (build_function_call (get_atexit_node (), args));
8109 expand_static_init (decl, init)
8113 tree oldstatic = value_member (decl, static_aggregates);
8117 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8118 cp_error ("multiple initializations given for `%D'", decl);
8120 else if (! toplevel_bindings_p ())
8122 /* Emit code to perform this initialization but once. */
8129 /* Emit code to perform this initialization but once. This code
8132 static int temp = 0;
8134 // Do initialization.
8136 // Register variable for destruction at end of program.
8139 Note that the `temp' variable is only set to 1 *after* the
8140 initialization is complete. This ensures that an exception,
8141 thrown during the construction, will cause the variable to
8142 reinitialized when we pass through this code again, as per:
8146 If the initialization exits by throwing an exception, the
8147 initialization is not complete, so it will be tried again
8148 the next time control enters the declaration.
8150 In theory, this process should be thread-safe, too; multiple
8151 threads should not be able to initialize the variable more
8152 than once. We don't yet attempt to ensure thread-safety. */
8153 temp = get_temp_name (integer_type_node, 1);
8154 rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8156 /* Begin the conditional initialization. */
8157 if_stmt = begin_if_stmt ();
8158 finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8161 then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8163 /* Do the initialization itself. */
8164 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8165 || (init && TREE_CODE (init) == TREE_LIST))
8166 assignment = build_aggr_init (decl, init, 0);
8168 /* The initialization we're doing here is just a bitwise
8170 assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8172 assignment = NULL_TREE;
8174 /* Once the assignment is complete, set TEMP to 1. Since the
8175 construction of the static object is complete at this point,
8176 we want to make sure TEMP is set to 1 even if a temporary
8177 constructed during the initialization throws an exception
8178 when it is destroyed. So, we combine the initialization and
8179 the assignment to TEMP into a single expression, ensuring
8180 that when we call finish_expr_stmt the cleanups will not be
8181 run until after TEMP is set to 1. */
8182 temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8185 assignment = tree_cons (NULL_TREE, assignment,
8186 build_tree_list (NULL_TREE,
8188 assignment = build_compound_expr (assignment);
8191 assignment = temp_init;
8192 finish_expr_stmt (assignment);
8194 /* Use atexit to register a function for destroying this static
8196 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (decl)))
8197 destroy_local_static (decl);
8199 finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8200 finish_then_clause (if_stmt);
8204 static_aggregates = tree_cons (init, decl, static_aggregates);
8207 /* Finish the declaration of a catch-parameter. */
8210 start_handler_parms (declspecs, declarator)
8217 decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8219 if (decl == NULL_TREE)
8220 error ("invalid catch parameter");
8229 /* Make TYPE a complete type based on INITIAL_VALUE.
8230 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8231 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8234 complete_array_type (type, initial_value, do_default)
8235 tree type, initial_value;
8238 register tree maxindex = NULL_TREE;
8243 /* Note MAXINDEX is really the maximum index,
8244 one less than the size. */
8245 if (TREE_CODE (initial_value) == STRING_CST)
8248 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8249 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8252 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8254 tree elts = CONSTRUCTOR_ELTS (initial_value);
8255 maxindex = size_binop (MINUS_EXPR, integer_zero_node, size_one_node);
8256 for (; elts; elts = TREE_CHAIN (elts))
8258 if (TREE_PURPOSE (elts))
8259 maxindex = TREE_PURPOSE (elts);
8261 maxindex = size_binop (PLUS_EXPR, maxindex, size_one_node);
8263 maxindex = copy_node (maxindex);
8267 /* Make an error message unless that happened already. */
8268 if (initial_value != error_mark_node)
8271 initial_value = NULL_TREE;
8273 /* Prevent further error messages. */
8274 maxindex = build_int_2 (0, 0);
8281 maxindex = build_int_2 (0, 0);
8290 domain = build_index_type (maxindex);
8291 TYPE_DOMAIN (type) = domain;
8293 if (! TREE_TYPE (maxindex))
8294 TREE_TYPE (maxindex) = domain;
8296 itype = TREE_TYPE (initial_value);
8299 if (itype && !TYPE_DOMAIN (itype))
8300 TYPE_DOMAIN (itype) = domain;
8301 /* The type of the main variant should never be used for arrays
8302 of different sizes. It should only ever be completed with the
8303 size of the array. */
8304 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8305 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8308 /* Lay out the type now that we can get the real answer. */
8315 /* Return zero if something is declared to be a member of type
8316 CTYPE when in the context of CUR_TYPE. STRING is the error
8317 message to print in that case. Otherwise, quietly return 1. */
8320 member_function_or_else (ctype, cur_type, string)
8321 tree ctype, cur_type;
8324 if (ctype && ctype != cur_type)
8326 error (string, TYPE_NAME_STRING (ctype));
8332 /* Subroutine of `grokdeclarator'. */
8334 /* Generate errors possibly applicable for a given set of specifiers.
8335 This is for ARM $7.1.2. */
8338 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8341 int virtualp, quals, friendp, raises, inlinep;
8344 cp_error ("`%D' declared as a `virtual' %s", object, type);
8346 cp_error ("`%D' declared as an `inline' %s", object, type);
8348 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8351 cp_error_at ("`%D' declared as a friend", object);
8353 cp_error_at ("`%D' declared with an exception specification", object);
8356 /* CTYPE is class type, or null if non-class.
8357 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8359 DECLARATOR is the function's name.
8360 VIRTUALP is truthvalue of whether the function is virtual or not.
8361 FLAGS are to be passed through to `grokclassfn'.
8362 QUALS are qualifiers indicating whether the function is `const'
8364 RAISES is a list of exceptions that this function can raise.
8365 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8366 not look, and -1 if we should not call `grokclassfn' at all.
8368 Returns `NULL_TREE' if something goes wrong, after issuing
8369 applicable error messages. */
8372 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8373 raises, check, friendp, publicp, inlinep, funcdef_flag,
8374 template_count, in_namespace)
8377 tree orig_declarator;
8379 enum overload_flags flags;
8381 int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8385 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8386 int has_default_arg = 0;
8390 cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8391 ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8397 type = build_exception_variant (type, raises);
8400 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8401 /* Propagate volatile out from type to decl. */
8402 if (TYPE_VOLATILE (type))
8403 TREE_THIS_VOLATILE (decl) = 1;
8405 /* If this decl has namespace scope, set that up. */
8407 set_decl_namespace (decl, in_namespace, friendp);
8408 else if (publicp && ! ctype)
8409 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8411 /* `main' and builtins have implicit 'C' linkage. */
8412 if ((MAIN_NAME_P (declarator)
8413 || (IDENTIFIER_LENGTH (declarator) > 10
8414 && IDENTIFIER_POINTER (declarator)[0] == '_'
8415 && IDENTIFIER_POINTER (declarator)[1] == '_'
8416 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8417 && current_lang_name == lang_name_cplusplus
8418 && ctype == NULL_TREE
8419 /* NULL_TREE means global namespace. */
8420 && DECL_CONTEXT (decl) == NULL_TREE)
8421 DECL_LANGUAGE (decl) = lang_c;
8423 /* Should probably propagate const out from type to decl I bet (mrs). */
8426 DECL_STATIC_FUNCTION_P (decl) = 1;
8427 DECL_CONTEXT (decl) = ctype;
8431 DECL_CLASS_CONTEXT (decl) = ctype;
8433 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8435 if (processing_template_decl)
8436 error ("cannot declare `main' to be a template");
8438 error ("cannot declare `main' to be inline");
8440 error ("cannot declare `main' to be static");
8445 /* Members of anonymous types and local classes have no linkage; make
8447 if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8448 || hack_decl_function_context (TYPE_MAIN_DECL (ctype))))
8453 /* [basic.link]: A name with no linkage (notably, the name of a class
8454 or enumeration declared in a local scope) shall not be used to
8455 declare an entity with linkage.
8457 Only check this for public decls for now. */
8458 t = no_linkage_check (TREE_TYPE (decl));
8461 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8463 if (DECL_LANGUAGE (decl) == lang_c)
8464 /* Allow this; it's pretty common in C. */;
8466 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8470 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8475 TREE_PUBLIC (decl) = publicp;
8478 DECL_INTERFACE_KNOWN (decl) = 1;
8479 DECL_NOT_REALLY_EXTERN (decl) = 1;
8483 DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8485 DECL_EXTERNAL (decl) = 1;
8486 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8488 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8489 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8493 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8494 grok_op_properties (decl, virtualp, check < 0);
8496 if (ctype && hack_decl_function_context (decl))
8497 DECL_NO_STATIC_CHAIN (decl) = 1;
8499 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8500 if (TREE_PURPOSE (t)
8501 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8503 has_default_arg = 1;
8508 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8512 ("defining explicit specialization `%D' in friend declaration",
8516 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8518 /* Something like `template <class T> friend void f<T>()'. */
8519 cp_error ("template-id `%D' in declaration of primary template",
8525 /* A friend declaration of the form friend void f<>(). Record
8526 the information in the TEMPLATE_ID_EXPR. */
8527 SET_DECL_IMPLICIT_INSTANTIATION (decl);
8528 DECL_TEMPLATE_INFO (decl)
8529 = tree_cons (TREE_OPERAND (orig_declarator, 0),
8530 TREE_OPERAND (orig_declarator, 1),
8533 if (has_default_arg)
8535 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8542 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8549 if (has_default_arg)
8550 add_defarg_fn (decl);
8552 /* Plain overloading: will not be grok'd by grokclassfn. */
8553 if (! ctype && ! processing_template_decl
8554 && DECL_LANGUAGE (decl) != lang_c
8555 && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8556 set_mangled_name_for_decl (decl);
8559 /* Make the init_value nonzero so pushdecl knows this is not
8560 tentative. error_mark_node is replaced later with the BLOCK. */
8561 DECL_INITIAL (decl) = error_mark_node;
8563 /* Caller will do the rest of this. */
8567 if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8570 /* Just handle constructors here. We could do this
8571 inside the following if stmt, but I think
8572 that the code is more legible by breaking this
8573 case out. See comments below for what each of
8574 the following calls is supposed to do. */
8575 DECL_CONSTRUCTOR_P (decl) = 1;
8577 grokclassfn (ctype, decl, flags, quals);
8579 decl = check_explicit_specialization (orig_declarator, decl,
8581 2 * (funcdef_flag != 0) +
8582 4 * (friendp != 0));
8583 if (decl == error_mark_node)
8586 if ((! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8589 tmp = check_classfn (ctype, decl);
8591 if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8592 tmp = DECL_TEMPLATE_RESULT(tmp);
8594 if (tmp && DECL_ARTIFICIAL (tmp))
8595 cp_error ("definition of implicitly-declared `%D'", tmp);
8596 if (tmp && duplicate_decls (decl, tmp))
8599 if (! grok_ctor_properties (ctype, decl))
8606 /* Function gets the ugly name, field gets the nice one.
8607 This call may change the type of the function (because
8608 of default parameters)! */
8609 if (ctype != NULL_TREE)
8610 grokclassfn (ctype, decl, flags, quals);
8612 decl = check_explicit_specialization (orig_declarator, decl,
8614 2 * (funcdef_flag != 0) +
8615 4 * (friendp != 0));
8616 if (decl == error_mark_node)
8619 if (ctype != NULL_TREE
8620 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8623 tmp = check_classfn (ctype, decl);
8625 if (tmp && TREE_CODE (tmp) == TEMPLATE_DECL)
8626 tmp = DECL_TEMPLATE_RESULT (tmp);
8628 if (tmp && DECL_STATIC_FUNCTION_P (tmp)
8629 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8631 /* Remove the `this' parm added by grokclassfn.
8632 XXX Isn't this done in start_function, too? */
8633 revert_static_member_fn (&decl, NULL, NULL);
8634 last_function_parms = TREE_CHAIN (last_function_parms);
8636 if (tmp && DECL_ARTIFICIAL (tmp))
8637 cp_error ("definition of implicitly-declared `%D'", tmp);
8640 /* Attempt to merge the declarations. This can fail, in
8641 the case of some illegal specialization declarations. */
8642 if (!duplicate_decls (decl, tmp))
8643 cp_error ("no `%#D' member function declared in class `%T'",
8649 if (ctype == NULL_TREE || check)
8654 DECL_VIRTUAL_P (decl) = 1;
8655 if (DECL_VINDEX (decl) == NULL_TREE)
8656 DECL_VINDEX (decl) = error_mark_node;
8657 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8664 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8667 RID_BIT_TYPE *specbits_in;
8673 RID_BIT_TYPE specbits;
8675 specbits = *specbits_in;
8677 if (TREE_CODE (type) == OFFSET_TYPE)
8679 /* If you declare a static member so that it
8680 can be initialized, the code will reach here. */
8681 tree basetype = TYPE_OFFSET_BASETYPE (type);
8682 type = TREE_TYPE (type);
8683 decl = build_lang_decl (VAR_DECL, declarator, type);
8684 DECL_CONTEXT (decl) = basetype;
8685 DECL_CLASS_CONTEXT (decl) = basetype;
8686 DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8693 context = in_namespace;
8694 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8695 context = current_namespace;
8697 context = NULL_TREE;
8699 if (processing_template_decl)
8700 /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8701 we can call push_template_decl. */
8702 decl = build_lang_decl (VAR_DECL, declarator, type);
8704 decl = build_decl (VAR_DECL, declarator, type);
8707 set_decl_namespace (decl, context, 0);
8709 context = DECL_CONTEXT (decl);
8710 if (declarator && context && current_lang_name != lang_name_c)
8711 DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8715 set_decl_namespace (decl, in_namespace, 0);
8717 if (RIDBIT_SETP (RID_EXTERN, specbits))
8719 DECL_THIS_EXTERN (decl) = 1;
8720 DECL_EXTERNAL (decl) = !initialized;
8723 /* In class context, static means one per class,
8724 public access, and static storage. */
8725 if (DECL_CLASS_SCOPE_P (decl))
8727 TREE_PUBLIC (decl) = 1;
8728 TREE_STATIC (decl) = 1;
8729 DECL_EXTERNAL (decl) = 0;
8731 /* At top level, either `static' or no s.c. makes a definition
8732 (perhaps tentative), and absence of `static' makes it public. */
8733 else if (toplevel_bindings_p ())
8735 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8736 && (DECL_THIS_EXTERN (decl) || ! constp));
8737 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8739 /* Not at top level, only `static' makes a static definition. */
8742 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8743 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8746 if (TREE_PUBLIC (decl))
8748 /* [basic.link]: A name with no linkage (notably, the name of a class
8749 or enumeration declared in a local scope) shall not be used to
8750 declare an entity with linkage.
8752 Only check this for public decls for now. */
8753 tree t = no_linkage_check (TREE_TYPE (decl));
8756 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8757 /* Ignore for now; `enum { foo } e' is pretty common. */;
8759 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8767 /* Create and return a canonical pointer to member function type, for
8768 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8771 build_ptrmemfunc_type (type)
8777 tree unqualified_variant = NULL_TREE;
8779 /* If a canonical type already exists for this type, use it. We use
8780 this method instead of type_hash_canon, because it only does a
8781 simple equality check on the list of field members. */
8783 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8786 /* Make sure that we always have the unqualified pointer-to-member
8788 if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8790 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8792 u = make_aggr_type (UNION_TYPE);
8793 SET_IS_AGGR_TYPE (u, 0);
8794 fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
8795 fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
8797 finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
8798 TYPE_NAME (u) = NULL_TREE;
8800 t = make_aggr_type (RECORD_TYPE);
8802 /* Let the front-end know this is a pointer to member function... */
8803 TYPE_PTRMEMFUNC_FLAG (t) = 1;
8804 /* ... and not really an aggregate. */
8805 SET_IS_AGGR_TYPE (t, 0);
8807 fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
8809 fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
8811 fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
8812 finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
8814 /* Zap out the name so that the back-end will give us the debugging
8815 information for this anonymous RECORD_TYPE. */
8816 TYPE_NAME (t) = NULL_TREE;
8818 /* If this is not the unqualified form of this pointer-to-member
8819 type, set the TYPE_MAIN_VARIANT for this type to be the
8820 unqualified type. Since they are actually RECORD_TYPEs that are
8821 not variants of each other, we must do this manually. */
8822 if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
8824 t = build_qualified_type (t, CP_TYPE_QUALS (type));
8825 TYPE_MAIN_VARIANT (t) = unqualified_variant;
8826 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
8827 TYPE_NEXT_VARIANT (unqualified_variant) = t;
8830 /* Cache this pointer-to-member type so that we can find it again
8832 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8834 /* Seems to be wanted. */
8835 CLASSTYPE_GOT_SEMICOLON (t) = 1;
8840 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8841 Check to see that the definition is valid. Issue appropriate error
8842 messages. Return 1 if the definition is particularly bad, or 0
8846 check_static_variable_definition (decl, type)
8850 /* Motion 10 at San Diego: If a static const integral data member is
8851 initialized with an integral constant expression, the initializer
8852 may appear either in the declaration (within the class), or in
8853 the definition, but not both. If it appears in the class, the
8854 member is a member constant. The file-scope definition is always
8856 if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
8858 cp_error ("in-class initialization of static data member of non-integral type `%T'",
8860 /* If we just return the declaration, crashes will sometimes
8861 occur. We therefore return void_type_node, as if this was a
8862 friend declaration, to cause callers to completely ignore
8863 this declaration. */
8866 else if (!CP_TYPE_CONST_P (type))
8867 cp_error ("ANSI C++ forbids in-class initialization of non-const static member `%D'",
8869 else if (pedantic && !INTEGRAL_TYPE_P (type))
8870 cp_pedwarn ("ANSI C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
8875 /* Given the SIZE (i.e., number of elements) in an array, compute an
8876 appropriate index type for the array. If non-NULL, NAME is the
8877 name of the thing being declared. */
8880 compute_array_index_type (name, size)
8886 /* The size might be the result of a cast. */
8887 STRIP_TYPE_NOPS (size);
8889 /* It might be a const variable or enumeration constant. */
8890 if (TREE_READONLY_DECL_P (size))
8891 size = decl_constant_value (size);
8893 /* If this involves a template parameter, it will be a constant at
8894 instantiation time, but we don't know what the value is yet.
8895 Even if no template parameters are involved, we may an expression
8896 that is not a constant; we don't even simplify `1 + 2' when
8897 processing a template. */
8898 if (processing_template_decl)
8900 /* Resolve a qualified reference to an enumerator or static
8901 const data member of ours. */
8902 if (TREE_CODE (size) == SCOPE_REF
8903 && TREE_OPERAND (size, 0) == current_class_type)
8905 tree t = lookup_field (current_class_type,
8906 TREE_OPERAND (size, 1), 0, 0);
8911 return build_index_type (build_min (MINUS_EXPR, sizetype,
8912 size, integer_one_node));
8915 /* The array bound must be an integer type. */
8916 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
8917 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
8918 && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
8921 cp_error ("size of array `%D' has non-integer type", name);
8923 cp_error ("size of array has non-integer type");
8924 size = integer_one_node;
8927 /* Normally, the array-bound will be a constant. */
8928 if (TREE_CONSTANT (size))
8930 /* Check to see if the array bound overflowed. Make that an
8931 error, no matter how generous we're being. */
8932 int old_flag_pedantic_errors = flag_pedantic_errors;
8933 int old_pedantic = pedantic;
8934 pedantic = flag_pedantic_errors = 1;
8935 constant_expression_warning (size);
8936 pedantic = old_pedantic;
8937 flag_pedantic_errors = old_flag_pedantic_errors;
8939 /* An array must have a positive number of elements. */
8940 if (INT_CST_LT (size, integer_zero_node))
8943 cp_error ("size of array `%D' is negative", name);
8945 cp_error ("size of array is negative");
8946 size = integer_one_node;
8948 /* Except that an extension we allow zero-sized arrays. We
8949 always allow them in system headers because glibc uses
8951 else if (integer_zerop (size) && pedantic && !in_system_header)
8954 cp_pedwarn ("ANSI C++ forbids zero-size array `%D'", name);
8956 cp_pedwarn ("ANSI C++ forbids zero-size array");
8960 /* Compute the index of the largest element in the array. It is
8961 one less than the number of elements in the array. */
8963 = fold (build_binary_op (MINUS_EXPR,
8964 cp_convert (ssizetype, size),
8965 cp_convert (ssizetype,
8966 integer_one_node)));
8968 /* Check for variable-sized arrays. We allow such things as an
8969 extension, even though they are not allowed in ANSI/ISO C++. */
8970 if (!TREE_CONSTANT (itype))
8975 cp_pedwarn ("ANSI C++ forbids variable-size array `%D'",
8978 cp_pedwarn ("ANSI C++ forbids variable-size array");
8981 /* Create a variable-sized array index type. */
8982 itype = variable_size (itype);
8984 /* Make sure that there was no overflow when creating to a signed
8985 index type. (For example, on a 32-bit machine, an array with
8986 size 2^32 - 1 is too big.) */
8987 else if (TREE_OVERFLOW (itype))
8989 error ("overflow in array dimension");
8990 TREE_OVERFLOW (itype) = 0;
8993 /* Create and return the appropriate index type. */
8994 return build_index_type (itype);
8997 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8998 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9002 create_array_type_for_decl (name, type, size)
9007 tree itype = NULL_TREE;
9008 const char* error_msg;
9010 /* If things have already gone awry, bail now. */
9011 if (type == error_mark_node || size == error_mark_node)
9012 return error_mark_node;
9014 /* Assume that everything will go OK. */
9017 /* There are some types which cannot be array elements. */
9018 switch (TREE_CODE (type))
9021 error_msg = "array of void";
9025 error_msg = "array of functions";
9028 case REFERENCE_TYPE:
9029 error_msg = "array of references";
9033 error_msg = "array of data members";
9037 error_msg = "array of function members";
9044 /* If something went wrong, issue an error-message and return. */
9048 cp_error ("declaration of `%D' as %s", name, error_msg);
9050 cp_error ("creating %s", error_msg);
9052 return error_mark_node;
9057 The constant expressions that specify the bounds of the arrays
9058 can be omitted only for the first member of the sequence. */
9059 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9061 cp_error ("declaration of `%D' as multidimensional array",
9063 cp_error ("must have bounds for all dimensions except the first");
9065 return error_mark_node;
9068 /* Figure out the index type for the array. */
9070 itype = compute_array_index_type (name, size);
9072 return build_cplus_array_type (type, itype);
9075 /* Given declspecs and a declarator,
9076 determine the name and type of the object declared
9077 and construct a ..._DECL node for it.
9078 (In one case we can return a ..._TYPE node instead.
9079 For invalid input we sometimes return 0.)
9081 DECLSPECS is a chain of tree_list nodes whose value fields
9082 are the storage classes and type specifiers.
9084 DECL_CONTEXT says which syntactic context this declaration is in:
9085 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9086 FUNCDEF for a function definition. Like NORMAL but a few different
9087 error messages in each case. Return value may be zero meaning
9088 this definition is too screwy to try to parse.
9089 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9090 handle member functions (which have FIELD context).
9091 Return value may be zero meaning this definition is too screwy to
9093 PARM for a parameter declaration (either within a function prototype
9094 or before a function body). Make a PARM_DECL, or return void_type_node.
9095 CATCHPARM for a parameter declaration before a catch clause.
9096 TYPENAME if for a typename (in a cast or sizeof).
9097 Don't make a DECL node; just return the ..._TYPE node.
9098 FIELD for a struct or union field; make a FIELD_DECL.
9099 BITFIELD for a field with specified width.
9100 INITIALIZED is 1 if the decl has an initializer.
9102 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9103 normal attributes in TREE_PURPOSE, or NULL_TREE.
9105 In the TYPENAME case, DECLARATOR is really an absolute declarator.
9106 It may also be so in the PARM case, for a prototype where the
9107 argument type is specified but not the name.
9109 This function is where the complicated C meanings of `static'
9110 and `extern' are interpreted.
9112 For C++, if there is any monkey business to do, the function which
9113 calls this one must do it, i.e., prepending instance variables,
9114 renaming overloaded function names, etc.
9116 Note that for this C++, it is an error to define a method within a class
9117 which does not belong to that class.
9119 Except in the case where SCOPE_REFs are implicitly known (such as
9120 methods within a class being redundantly qualified),
9121 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9122 (class_name::decl_name). The caller must also deal with this.
9124 If a constructor or destructor is seen, and the context is FIELD,
9125 then the type gains the attribute TREE_HAS_x. If such a declaration
9126 is erroneous, NULL_TREE is returned.
9128 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9129 function, these are the qualifiers to give to the `this' pointer. We
9130 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9132 May return void_type_node if the declarator turned out to be a friend.
9133 See grokfield for details. */
9135 enum return_types { return_normal, return_ctor, return_dtor, return_conversion };
9138 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9141 enum decl_context decl_context;
9145 RID_BIT_TYPE specbits;
9148 tree type = NULL_TREE;
9154 int virtualp, explicitp, friendp, inlinep, staticp;
9155 int explicit_int = 0;
9156 int explicit_char = 0;
9157 int defaulted_int = 0;
9158 tree typedef_decl = NULL_TREE;
9160 tree typedef_type = NULL_TREE;
9161 int funcdef_flag = 0;
9162 enum tree_code innermost_code = ERROR_MARK;
9165 /* See the code below that used this. */
9166 tree decl_machine_attr = NULL_TREE;
9168 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9169 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9170 tree init = NULL_TREE;
9172 /* Keep track of what sort of function is being processed
9173 so that we can warn about default return values, or explicit
9174 return values which do not match prescribed defaults. */
9175 enum return_types return_type = return_normal;
9177 tree dname = NULL_TREE;
9178 tree ctype = current_class_type;
9179 tree ctor_return_type = NULL_TREE;
9180 enum overload_flags flags = NO_SPECIAL;
9181 tree quals = NULL_TREE;
9182 tree raises = NULL_TREE;
9183 int template_count = 0;
9184 tree in_namespace = NULL_TREE;
9188 RIDBIT_RESET_ALL (specbits);
9189 if (decl_context == FUNCDEF)
9190 funcdef_flag = 1, decl_context = NORMAL;
9191 else if (decl_context == MEMFUNCDEF)
9192 funcdef_flag = -1, decl_context = FIELD;
9193 else if (decl_context == BITFIELD)
9194 bitfield = 1, decl_context = FIELD;
9196 /* Look inside a declarator for the name being declared
9197 and get it as a string, for an error message. */
9199 tree *next = &declarator;
9203 while (next && *next)
9206 switch (TREE_CODE (decl))
9209 /* For attributes. */
9210 next = &TREE_VALUE (decl);
9215 next = &TREE_OPERAND (decl, 0);
9218 case BIT_NOT_EXPR: /* For C++ destructors! */
9220 tree name = TREE_OPERAND (decl, 0);
9221 tree rename = NULL_TREE;
9223 my_friendly_assert (flags == NO_SPECIAL, 152);
9225 return_type = return_dtor;
9226 if (TREE_CODE (name) == TYPE_DECL)
9227 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9228 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9229 if (ctype == NULL_TREE)
9231 if (current_class_type == NULL_TREE)
9233 error ("destructors must be member functions");
9238 tree t = constructor_name (current_class_name);
9245 tree t = constructor_name (ctype);
9252 cp_error ("destructor `%T' must match class name `%T'",
9254 TREE_OPERAND (decl, 0) = rename;
9260 case ADDR_EXPR: /* C++ reference declaration */
9265 innermost_code = TREE_CODE (decl);
9266 next = &TREE_OPERAND (decl, 0);
9270 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9272 /* This is actually a variable declaration using
9273 constructor syntax. We need to call start_decl and
9274 cp_finish_decl so we can get the variable
9277 tree attributes, prefix_attributes;
9279 *next = TREE_OPERAND (decl, 0);
9280 init = CALL_DECLARATOR_PARMS (decl);
9284 attributes = TREE_PURPOSE (attrlist);
9285 prefix_attributes = TREE_VALUE (attrlist);
9289 attributes = NULL_TREE;
9290 prefix_attributes = NULL_TREE;
9293 decl = start_decl (declarator, declspecs, 1,
9294 attributes, prefix_attributes);
9297 /* Look for __unused__ attribute */
9298 if (TREE_USED (TREE_TYPE (decl)))
9299 TREE_USED (decl) = 1;
9300 finish_decl (decl, init, NULL_TREE);
9303 cp_error ("invalid declarator");
9306 innermost_code = TREE_CODE (decl);
9307 if (decl_context == FIELD && ctype == NULL_TREE)
9308 ctype = current_class_type;
9310 && TREE_OPERAND (decl, 0)
9311 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9312 && ((DECL_NAME (TREE_OPERAND (decl, 0))
9313 == constructor_name_full (ctype))
9314 || (DECL_NAME (TREE_OPERAND (decl, 0))
9315 == constructor_name (ctype)))))
9316 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9317 next = &TREE_OPERAND (decl, 0);
9319 if (ctype != NULL_TREE
9320 && decl != NULL_TREE && flags != DTOR_FLAG
9321 && decl == constructor_name (ctype))
9323 return_type = return_ctor;
9324 ctor_return_type = ctype;
9329 case TEMPLATE_ID_EXPR:
9331 tree fns = TREE_OPERAND (decl, 0);
9333 if (TREE_CODE (fns) == LOOKUP_EXPR)
9334 fns = TREE_OPERAND (fns, 0);
9337 if (TREE_CODE (dname) == COMPONENT_REF)
9338 dname = TREE_OPERAND (dname, 1);
9339 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9341 my_friendly_assert (is_overloaded_fn (dname),
9343 dname = DECL_NAME (get_first_fn (dname));
9348 case IDENTIFIER_NODE:
9349 if (TREE_CODE (decl) == IDENTIFIER_NODE)
9356 cp_error ("declarator-id missing; using reserved word `%D'",
9358 name = IDENTIFIER_POINTER (dname);
9360 if (! IDENTIFIER_OPNAME_P (dname)
9361 /* GNU/Linux headers use '__op'. Arrgh. */
9362 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9363 name = IDENTIFIER_POINTER (dname);
9366 if (IDENTIFIER_TYPENAME_P (dname))
9368 my_friendly_assert (flags == NO_SPECIAL, 154);
9369 flags = TYPENAME_FLAG;
9370 ctor_return_type = TREE_TYPE (dname);
9371 return_type = return_conversion;
9373 name = operator_name_string (dname);
9380 /* Perform error checking, and decide on a ctype. */
9381 tree cname = TREE_OPERAND (decl, 0);
9382 if (cname == NULL_TREE)
9384 else if (TREE_CODE (cname) == NAMESPACE_DECL)
9387 in_namespace = TREE_OPERAND (decl, 0);
9388 TREE_OPERAND (decl, 0) = NULL_TREE;
9390 else if (! is_aggr_type (cname, 1))
9391 TREE_OPERAND (decl, 0) = NULL_TREE;
9392 /* Must test TREE_OPERAND (decl, 1), in case user gives
9393 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9394 else if (TREE_OPERAND (decl, 1)
9395 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9397 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9398 || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9400 cp_error ("`%T::%D' is not a valid declarator", cname,
9401 TREE_OPERAND (decl, 1));
9402 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9403 cname, TREE_OPERAND (decl, 1));
9404 return void_type_node;
9406 else if (ctype == NULL_TREE)
9408 else if (TREE_COMPLEXITY (decl) == current_class_depth)
9409 TREE_OPERAND (decl, 0) = ctype;
9412 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9414 cp_error ("type `%T' is not derived from type `%T'",
9416 TREE_OPERAND (decl, 0) = NULL_TREE;
9422 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9423 && ((DECL_NAME (TREE_OPERAND (decl, 1))
9424 == constructor_name_full (ctype))
9425 || (DECL_NAME (TREE_OPERAND (decl, 1))
9426 == constructor_name (ctype))))
9427 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9428 next = &TREE_OPERAND (decl, 1);
9432 if (TREE_CODE (decl) == IDENTIFIER_NODE
9433 && constructor_name (ctype) == decl)
9435 return_type = return_ctor;
9436 ctor_return_type = ctype;
9438 else if (TREE_CODE (decl) == BIT_NOT_EXPR
9439 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9440 && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9441 || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9443 return_type = return_dtor;
9444 ctor_return_type = ctype;
9446 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9447 next = &TREE_OPERAND (decl, 0);
9458 /* Parse error puts this typespec where
9459 a declarator should go. */
9460 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9461 if (TREE_TYPE (decl) == current_class_type)
9462 cp_error (" perhaps you want `%T' for a constructor",
9463 current_class_name);
9464 dname = DECL_NAME (decl);
9465 name = IDENTIFIER_POINTER (dname);
9467 /* Avoid giving two errors for this. */
9468 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9470 declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9476 cp_compiler_error ("`%D' as declarator", decl);
9477 return 0; /* We used to do a 155 abort here. */
9482 /* A function definition's declarator must have the form of
9483 a function declarator. */
9485 if (funcdef_flag && innermost_code != CALL_EXPR)
9488 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9489 && innermost_code != CALL_EXPR
9490 && ! (ctype && declspecs == NULL_TREE))
9492 cp_error ("declaration of `%D' as non-function", dname);
9493 return void_type_node;
9496 /* Anything declared one level down from the top level
9497 must be one of the parameters of a function
9498 (because the body is at least two levels down). */
9500 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9501 by not allowing C++ class definitions to specify their parameters
9502 with xdecls (must be spec.d in the parmlist).
9504 Since we now wait to push a class scope until we are sure that
9505 we are in a legitimate method context, we must set oldcname
9506 explicitly (since current_class_name is not yet alive).
9508 We also want to avoid calling this a PARM if it is in a namespace. */
9510 if (decl_context == NORMAL && !toplevel_bindings_p ())
9512 struct binding_level *b = current_binding_level;
9513 current_binding_level = b->level_chain;
9514 if (current_binding_level != 0 && toplevel_bindings_p ())
9515 decl_context = PARM;
9516 current_binding_level = b;
9520 name = decl_context == PARM ? "parameter" : "type name";
9522 /* Look through the decl specs and record which ones appear.
9523 Some typespecs are defined as built-in typenames.
9524 Others, the ones that are modifiers of other types,
9525 are represented by bits in SPECBITS: set the bits for
9526 the modifiers that appear. Storage class keywords are also in SPECBITS.
9528 If there is a typedef name or a type, store the type in TYPE.
9529 This includes builtin typedefs such as `int'.
9531 Set EXPLICIT_INT if the type is `int' or `char' and did not
9532 come from a user typedef.
9534 Set LONGLONG if `long' is mentioned twice.
9536 For C++, constructors and destructors have their own fast treatment. */
9538 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9543 /* Certain parse errors slip through. For example,
9544 `int class;' is not caught by the parser. Try
9545 weakly to recover here. */
9546 if (TREE_CODE (spec) != TREE_LIST)
9549 id = TREE_VALUE (spec);
9551 if (TREE_CODE (id) == IDENTIFIER_NODE)
9553 if (id == ridpointers[(int) RID_INT]
9554 || id == ridpointers[(int) RID_CHAR]
9555 || id == ridpointers[(int) RID_BOOL]
9556 || id == ridpointers[(int) RID_WCHAR])
9560 if (id == ridpointers[(int) RID_BOOL])
9561 error ("`bool' is now a keyword");
9563 cp_error ("extraneous `%T' ignored", id);
9567 if (id == ridpointers[(int) RID_INT])
9569 else if (id == ridpointers[(int) RID_CHAR])
9571 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9575 /* C++ aggregate types. */
9576 if (IDENTIFIER_HAS_TYPE_VALUE (id))
9579 cp_error ("multiple declarations `%T' and `%T'", type, id);
9581 type = IDENTIFIER_TYPE_VALUE (id);
9585 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9587 if (ridpointers[i] == id)
9589 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9591 if (pedantic && ! in_system_header && warn_long_long)
9592 pedwarn ("ANSI C++ does not support `long long'");
9594 error ("`long long long' is too long for GCC");
9598 else if (RIDBIT_SETP (i, specbits))
9599 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9600 RIDBIT_SET (i, specbits);
9605 /* C++ aggregate types. */
9606 else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9609 cp_error ("multiple declarations `%T' and `%T'", type,
9613 type = TREE_TYPE (id);
9614 TREE_VALUE (spec) = type;
9619 error ("two or more data types in declaration of `%s'", name);
9620 else if (TREE_CODE (id) == IDENTIFIER_NODE)
9622 register tree t = lookup_name (id, 1);
9623 if (!t || TREE_CODE (t) != TYPE_DECL)
9624 error ("`%s' fails to be a typedef or built in type",
9625 IDENTIFIER_POINTER (id));
9628 type = TREE_TYPE (t);
9630 /* See the code below that used this. */
9631 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9636 else if (id != error_mark_node)
9637 /* Can't change CLASS nodes into RECORD nodes here! */
9643 typedef_type = type;
9645 /* No type at all: default to `int', and set DEFAULTED_INT
9646 because it was not a user-defined typedef. */
9648 if (type == NULL_TREE
9649 && (RIDBIT_SETP (RID_SIGNED, specbits)
9650 || RIDBIT_SETP (RID_UNSIGNED, specbits)
9651 || RIDBIT_SETP (RID_LONG, specbits)
9652 || RIDBIT_SETP (RID_SHORT, specbits)))
9654 /* These imply 'int'. */
9655 type = integer_type_node;
9659 if (type == NULL_TREE)
9662 if (return_type == return_dtor)
9663 type = void_type_node;
9664 else if (return_type == return_ctor)
9665 type = build_pointer_type (ctor_return_type);
9666 else if (return_type == return_conversion)
9667 type = ctor_return_type;
9670 /* We handle `main' specially here, because 'main () { }' is so
9671 common. With no options, it is allowed. With -Wreturn-type,
9672 it is a warning. It is only an error with -pedantic-errors. */
9673 int is_main = (funcdef_flag
9674 && MAIN_NAME_P (dname)
9675 && ctype == NULL_TREE
9676 && in_namespace == NULL_TREE
9677 && current_namespace == global_namespace);
9679 if (in_system_header || flag_ms_extensions)
9680 /* Allow it, sigh. */;
9681 else if (pedantic || ! is_main)
9682 cp_pedwarn ("ANSI C++ forbids declaration of `%s' with no type",
9684 else if (warn_return_type)
9685 cp_warning ("ANSI C++ forbids declaration of `%s' with no type",
9688 type = integer_type_node;
9691 else if (return_type == return_dtor)
9693 error ("return type specification for destructor invalid");
9694 type = void_type_node;
9696 else if (return_type == return_ctor)
9698 error ("return type specification for constructor invalid");
9699 type = build_pointer_type (ctor_return_type);
9701 else if (return_type == return_conversion)
9703 if (!same_type_p (type, ctor_return_type))
9704 cp_error ("operator `%T' declared to return `%T'",
9705 ctor_return_type, type);
9707 cp_pedwarn ("return type specified for `operator %T'",
9710 type = ctor_return_type;
9715 /* Now process the modifiers that were specified
9716 and check for invalid combinations. */
9718 /* Long double is a special combination. */
9720 if (RIDBIT_SETP (RID_LONG, specbits)
9721 && TYPE_MAIN_VARIANT (type) == double_type_node)
9723 RIDBIT_RESET (RID_LONG, specbits);
9724 type = build_qualified_type (long_double_type_node,
9725 CP_TYPE_QUALS (type));
9728 /* Check all other uses of type modifiers. */
9730 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9731 || RIDBIT_SETP (RID_SIGNED, specbits)
9732 || RIDBIT_SETP (RID_LONG, specbits)
9733 || RIDBIT_SETP (RID_SHORT, specbits))
9737 if (TREE_CODE (type) == REAL_TYPE)
9738 error ("short, signed or unsigned invalid for `%s'", name);
9739 else if (TREE_CODE (type) != INTEGER_TYPE)
9740 error ("long, short, signed or unsigned invalid for `%s'", name);
9741 else if (RIDBIT_SETP (RID_LONG, specbits)
9742 && RIDBIT_SETP (RID_SHORT, specbits))
9743 error ("long and short specified together for `%s'", name);
9744 else if ((RIDBIT_SETP (RID_LONG, specbits)
9745 || RIDBIT_SETP (RID_SHORT, specbits))
9747 error ("long or short specified with char for `%s'", name);
9748 else if ((RIDBIT_SETP (RID_LONG, specbits)
9749 || RIDBIT_SETP (RID_SHORT, specbits))
9750 && TREE_CODE (type) == REAL_TYPE)
9751 error ("long or short specified with floating type for `%s'", name);
9752 else if (RIDBIT_SETP (RID_SIGNED, specbits)
9753 && RIDBIT_SETP (RID_UNSIGNED, specbits))
9754 error ("signed and unsigned given together for `%s'", name);
9758 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
9760 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
9762 if (flag_pedantic_errors)
9767 /* Discard the type modifiers if they are invalid. */
9770 RIDBIT_RESET (RID_UNSIGNED, specbits);
9771 RIDBIT_RESET (RID_SIGNED, specbits);
9772 RIDBIT_RESET (RID_LONG, specbits);
9773 RIDBIT_RESET (RID_SHORT, specbits);
9778 if (RIDBIT_SETP (RID_COMPLEX, specbits)
9779 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9781 error ("complex invalid for `%s'", name);
9782 RIDBIT_RESET (RID_COMPLEX, specbits);
9785 /* Decide whether an integer type is signed or not.
9786 Optionally treat bitfields as signed by default. */
9787 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9790 It is implementation-defined whether a plain (neither
9791 explicitly signed or unsigned) char, short, int, or long
9792 bit-field is signed or unsigned.
9794 Naturally, we extend this to long long as well. Note that
9795 this does not include wchar_t. */
9796 || (bitfield && !flag_signed_bitfields
9797 && RIDBIT_NOTSETP (RID_SIGNED, specbits)
9798 /* A typedef for plain `int' without `signed' can be
9799 controlled just like plain `int', but a typedef for
9800 `signed int' cannot be so controlled. */
9802 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9803 && (TREE_CODE (type) == INTEGER_TYPE
9804 || TREE_CODE (type) == CHAR_TYPE)
9805 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9808 type = long_long_unsigned_type_node;
9809 else if (RIDBIT_SETP (RID_LONG, specbits))
9810 type = long_unsigned_type_node;
9811 else if (RIDBIT_SETP (RID_SHORT, specbits))
9812 type = short_unsigned_type_node;
9813 else if (type == char_type_node)
9814 type = unsigned_char_type_node;
9815 else if (typedef_decl)
9816 type = unsigned_type (type);
9818 type = unsigned_type_node;
9820 else if (RIDBIT_SETP (RID_SIGNED, specbits)
9821 && type == char_type_node)
9822 type = signed_char_type_node;
9824 type = long_long_integer_type_node;
9825 else if (RIDBIT_SETP (RID_LONG, specbits))
9826 type = long_integer_type_node;
9827 else if (RIDBIT_SETP (RID_SHORT, specbits))
9828 type = short_integer_type_node;
9830 if (RIDBIT_SETP (RID_COMPLEX, specbits))
9832 /* If we just have "complex", it is equivalent to
9833 "complex double", but if any modifiers at all are specified it is
9834 the complex form of TYPE. E.g, "complex short" is
9835 "complex short int". */
9837 if (defaulted_int && ! longlong
9838 && ! (RIDBIT_SETP (RID_LONG, specbits)
9839 || RIDBIT_SETP (RID_SHORT, specbits)
9840 || RIDBIT_SETP (RID_SIGNED, specbits)
9841 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
9842 type = complex_double_type_node;
9843 else if (type == integer_type_node)
9844 type = complex_integer_type_node;
9845 else if (type == float_type_node)
9846 type = complex_float_type_node;
9847 else if (type == double_type_node)
9848 type = complex_double_type_node;
9849 else if (type == long_double_type_node)
9850 type = complex_long_double_type_node;
9852 type = build_complex_type (type);
9855 if (return_type == return_conversion
9856 && (RIDBIT_SETP (RID_CONST, specbits)
9857 || RIDBIT_SETP (RID_VOLATILE, specbits)
9858 || RIDBIT_SETP (RID_RESTRICT, specbits)))
9859 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
9862 /* Set CONSTP if this declaration is `const', whether by
9863 explicit specification or via a typedef.
9864 Likewise for VOLATILEP. */
9866 constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
9868 !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
9870 !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
9871 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
9872 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
9873 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
9874 type = cp_build_qualified_type (type, type_quals);
9876 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
9877 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
9878 RIDBIT_RESET (RID_VIRTUAL, specbits);
9879 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
9880 RIDBIT_RESET (RID_EXPLICIT, specbits);
9882 if (RIDBIT_SETP (RID_STATIC, specbits))
9883 staticp = 1 + (decl_context == FIELD);
9885 if (virtualp && staticp == 2)
9887 cp_error ("member `%D' cannot be declared both virtual and static",
9891 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
9892 RIDBIT_RESET (RID_FRIEND, specbits);
9894 /* Warn if two storage classes are given. Default to `auto'. */
9896 if (RIDBIT_ANY_SET (specbits))
9898 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
9899 if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
9900 if (decl_context == PARM && nclasses > 0)
9901 error ("storage class specifiers invalid in parameter declarations");
9902 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9904 if (decl_context == PARM)
9905 error ("typedef declaration invalid in parameter declaration");
9908 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
9909 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
9912 /* Give error if `virtual' is used outside of class declaration. */
9914 && (current_class_name == NULL_TREE || decl_context != FIELD))
9916 error ("virtual outside class declaration");
9920 /* Static anonymous unions are dealt with here. */
9921 if (staticp && decl_context == TYPENAME
9922 && TREE_CODE (declspecs) == TREE_LIST
9923 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
9924 decl_context = FIELD;
9926 /* Warn about storage classes that are invalid for certain
9927 kinds of declarations (parameters, typenames, etc.). */
9930 error ("multiple storage classes in declaration of `%s'", name);
9931 else if (decl_context != NORMAL && nclasses > 0)
9933 if ((decl_context == PARM || decl_context == CATCHPARM)
9934 && (RIDBIT_SETP (RID_REGISTER, specbits)
9935 || RIDBIT_SETP (RID_AUTO, specbits)))
9937 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
9939 else if (decl_context == FIELD
9940 /* C++ allows static class elements */
9941 && RIDBIT_SETP (RID_STATIC, specbits))
9942 /* C++ also allows inlines and signed and unsigned elements,
9943 but in those cases we don't come in here. */
9947 if (decl_context == FIELD)
9949 tree tmp = NULL_TREE;
9950 register int op = 0;
9954 /* Avoid trying to get an operand off an identifier node. */
9955 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
9958 tmp = TREE_OPERAND (declarator, 0);
9959 op = IDENTIFIER_OPNAME_P (tmp);
9961 error ("storage class specified for %s `%s'",
9962 op ? "member operator" : "field",
9963 op ? operator_name_string (tmp) : name);
9967 if (decl_context == PARM || decl_context == CATCHPARM)
9968 error ("storage class specified for parameter `%s'", name);
9970 error ("storage class specified for typename");
9972 RIDBIT_RESET (RID_REGISTER, specbits);
9973 RIDBIT_RESET (RID_AUTO, specbits);
9974 RIDBIT_RESET (RID_EXTERN, specbits);
9977 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
9979 if (toplevel_bindings_p ())
9981 /* It's common practice (and completely valid) to have a const
9982 be initialized and declared extern. */
9983 if (!(type_quals & TYPE_QUAL_CONST))
9984 warning ("`%s' initialized and declared `extern'", name);
9987 error ("`%s' has both `extern' and initializer", name);
9989 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
9990 && ! toplevel_bindings_p ())
9991 error ("nested function `%s' declared `extern'", name);
9992 else if (toplevel_bindings_p ())
9994 if (RIDBIT_SETP (RID_AUTO, specbits))
9995 error ("top-level declaration of `%s' specifies `auto'", name);
9998 if (nclasses > 0 && friendp)
9999 error ("storage class specifiers invalid in friend function declarations");
10001 /* Now figure out the structure of the declarator proper.
10002 Descend through it, creating more complex types, until we reach
10003 the declared identifier (or NULL_TREE, in an absolute declarator). */
10005 inner_attrs = NULL_TREE;
10008 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10009 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10011 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10012 an INDIRECT_REF (for *...),
10013 a CALL_EXPR (for ...(...)),
10014 an identifier (for the name being declared)
10015 or a null pointer (for the place in an absolute declarator
10016 where the name was omitted).
10017 For the last two cases, we have just exited the loop.
10019 For C++ it could also be
10020 a SCOPE_REF (for class :: ...). In this case, we have converted
10021 sensible names to types, and those are the values we use to
10022 qualify the member name.
10023 an ADDR_EXPR (for &...),
10024 a BIT_NOT_EXPR (for destructors)
10026 At this point, TYPE is the type of elements of an array,
10027 or for a function to return, or for a pointer to point to.
10028 After this sequence of ifs, TYPE is the type of the
10029 array or function or pointer, and DECLARATOR has had its
10030 outermost layer removed. */
10032 if (type == error_mark_node)
10034 if (TREE_CODE (declarator) == SCOPE_REF)
10035 declarator = TREE_OPERAND (declarator, 1);
10037 declarator = TREE_OPERAND (declarator, 0);
10040 if (quals != NULL_TREE
10041 && (declarator == NULL_TREE
10042 || TREE_CODE (declarator) != SCOPE_REF))
10044 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10045 ctype = TYPE_METHOD_BASETYPE (type);
10046 if (ctype != NULL_TREE)
10048 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10049 grok_method_quals (ctype, dummy, quals);
10050 type = TREE_TYPE (dummy);
10051 ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10056 /* See the comment for the TREE_LIST case, below. */
10059 else if (inner_attrs)
10061 decl_attributes (type, inner_attrs, NULL_TREE);
10062 inner_attrs = NULL_TREE;
10065 switch (TREE_CODE (declarator))
10069 /* We encode a declarator with embedded attributes using
10070 a TREE_LIST. The attributes apply to the declarator
10071 directly inside them, so we have to skip an iteration
10072 before applying them to the type. If the declarator just
10073 inside is the declarator-id, we apply the attrs to the
10075 inner_attrs = TREE_PURPOSE (declarator);
10077 declarator = TREE_VALUE (declarator);
10083 register tree size;
10085 size = TREE_OPERAND (declarator, 1);
10087 /* VC++ spells a zero-sized array with []. */
10088 if (size == NULL_TREE && decl_context == FIELD && ! staticp
10089 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10090 size = integer_zero_node;
10092 declarator = TREE_OPERAND (declarator, 0);
10094 type = create_array_type_for_decl (dname, type, size);
10103 tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10104 tree inner_decl = TREE_OPERAND (declarator, 0);
10106 /* Declaring a function type.
10107 Make sure we have a valid type for the function to return. */
10109 /* We now know that the TYPE_QUALS don't apply to the
10110 decl, but to its return type. */
10111 type_quals = TYPE_UNQUALIFIED;
10113 /* Warn about some types functions can't return. */
10115 if (TREE_CODE (type) == FUNCTION_TYPE)
10117 error ("`%s' declared as function returning a function", name);
10118 type = integer_type_node;
10120 if (TREE_CODE (type) == ARRAY_TYPE)
10122 error ("`%s' declared as function returning an array", name);
10123 type = integer_type_node;
10126 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10127 inner_decl = TREE_OPERAND (inner_decl, 1);
10129 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10130 inner_decl = dname;
10132 /* Pick up type qualifiers which should be applied to `this'. */
10133 quals = CALL_DECLARATOR_QUALS (declarator);
10135 /* Pick up the exception specifications. */
10136 raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10138 /* Say it's a definition only for the CALL_EXPR
10139 closest to the identifier. */
10142 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10143 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10144 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10146 if (ctype == NULL_TREE
10147 && decl_context == FIELD
10149 && (friendp == 0 || dname == current_class_name))
10150 ctype = current_class_type;
10152 if (ctype && return_type == return_conversion)
10153 TYPE_HAS_CONVERSION (ctype) = 1;
10154 if (ctype && constructor_name (ctype) == dname)
10156 /* We are within a class's scope. If our declarator name
10157 is the same as the class name, and we are defining
10158 a function, then it is a constructor/destructor, and
10159 therefore returns a void type. */
10161 if (flags == DTOR_FLAG)
10163 /* ANSI C++ June 5 1992 WP 12.4.1. A destructor may
10164 not be declared const or volatile. A destructor
10165 may not be static. */
10167 error ("destructor cannot be static member function");
10170 cp_error ("destructors may not be `%s'",
10171 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10174 if (decl_context == FIELD)
10176 if (! member_function_or_else (ctype, current_class_type,
10177 "destructor for alien class `%s' cannot be a member"))
10178 return void_type_node;
10181 else /* It's a constructor. */
10183 if (explicitp == 1)
10185 /* ANSI C++ June 5 1992 WP 12.1.2. A constructor may
10186 not be declared const or volatile. A constructor may
10187 not be virtual. A constructor may not be static. */
10189 error ("constructor cannot be static member function");
10192 pedwarn ("constructors cannot be declared virtual");
10197 cp_error ("constructors may not be `%s'",
10198 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10202 RID_BIT_TYPE tmp_bits;
10203 bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10204 RIDBIT_RESET (RID_INLINE, tmp_bits);
10205 RIDBIT_RESET (RID_STATIC, tmp_bits);
10206 if (RIDBIT_ANY_SET (tmp_bits))
10207 error ("return value type specifier for constructor ignored");
10209 type = build_pointer_type (ctype);
10210 if (decl_context == FIELD)
10212 if (! member_function_or_else (ctype, current_class_type,
10213 "constructor for alien class `%s' cannot be member"))
10214 return void_type_node;
10215 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10216 if (return_type != return_ctor)
10220 if (decl_context == FIELD)
10226 error ("can't initialize friend function `%s'", name);
10229 /* Cannot be both friend and virtual. */
10230 error ("virtual functions cannot be friends");
10231 RIDBIT_RESET (RID_FRIEND, specbits);
10234 if (decl_context == NORMAL)
10235 error ("friend declaration not in class definition");
10236 if (current_function_decl && funcdef_flag)
10237 cp_error ("can't define friend function `%s' in a local class definition",
10241 /* Construct the function type and go to the next
10242 inner layer of declarator. */
10244 declarator = TREE_OPERAND (declarator, 0);
10246 /* FIXME: This is where default args should be fully
10249 arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10251 if (declarator && flags == DTOR_FLAG)
10253 /* A destructor declared in the body of a class will
10254 be represented as a BIT_NOT_EXPR. But, we just
10255 want the underlying IDENTIFIER. */
10256 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10257 declarator = TREE_OPERAND (declarator, 0);
10259 if (strict_prototype == 0 && arg_types == NULL_TREE)
10260 arg_types = void_list_node;
10261 else if (arg_types == NULL_TREE
10262 || arg_types != void_list_node)
10264 cp_error ("destructors may not have parameters");
10265 arg_types = void_list_node;
10266 last_function_parms = NULL_TREE;
10270 /* ANSI says that `const int foo ();'
10271 does not make the function foo const. */
10272 type = build_function_type (type, arg_types);
10276 for (t = arg_types; t; t = TREE_CHAIN (t))
10277 if (TREE_PURPOSE (t)
10278 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10280 add_defarg_fn (type);
10289 /* Filter out pointers-to-references and references-to-references.
10290 We can get these if a TYPE_DECL is used. */
10292 if (TREE_CODE (type) == REFERENCE_TYPE)
10294 error ("cannot declare %s to references",
10295 TREE_CODE (declarator) == ADDR_EXPR
10296 ? "references" : "pointers");
10297 declarator = TREE_OPERAND (declarator, 0);
10301 if (TREE_CODE (type) == OFFSET_TYPE
10302 && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10303 || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10305 cp_error ("cannot declare pointer to `%#T' member",
10307 type = TREE_TYPE (type);
10310 /* Merge any constancy or volatility into the target type
10311 for the pointer. */
10313 /* We now know that the TYPE_QUALS don't apply to the decl,
10314 but to the target of the pointer. */
10315 type_quals = TYPE_UNQUALIFIED;
10317 if (TREE_CODE (declarator) == ADDR_EXPR)
10319 if (TREE_CODE (type) == VOID_TYPE)
10320 error ("invalid type: `void &'");
10322 type = build_reference_type (type);
10324 else if (TREE_CODE (type) == METHOD_TYPE)
10325 type = build_ptrmemfunc_type (build_pointer_type (type));
10327 type = build_pointer_type (type);
10329 /* Process a list of type modifier keywords (such as
10330 const or volatile) that were given inside the `*' or `&'. */
10332 if (TREE_TYPE (declarator))
10334 register tree typemodlist;
10340 for (typemodlist = TREE_TYPE (declarator); typemodlist;
10341 typemodlist = TREE_CHAIN (typemodlist))
10343 tree qualifier = TREE_VALUE (typemodlist);
10345 if (qualifier == ridpointers[(int) RID_CONST])
10347 else if (qualifier == ridpointers[(int) RID_VOLATILE])
10349 else if (qualifier == ridpointers[(int) RID_RESTRICT])
10354 error ("invalid type modifier within pointer declarator");
10358 pedwarn ("duplicate `const'");
10360 pedwarn ("duplicate `volatile'");
10362 pedwarn ("duplicate `restrict'");
10364 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10365 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10366 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10367 if (TREE_CODE (declarator) == ADDR_EXPR
10368 && (constp || volatilep))
10371 pedwarn ("discarding `const' applied to a reference");
10373 pedwarn ("discarding `volatile' applied to a reference");
10374 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10376 type = cp_build_qualified_type (type, type_quals);
10378 declarator = TREE_OPERAND (declarator, 0);
10384 /* We have converted type names to NULL_TREE if the
10385 name was bogus, or to a _TYPE node, if not.
10387 The variable CTYPE holds the type we will ultimately
10388 resolve to. The code here just needs to build
10389 up appropriate member types. */
10390 tree sname = TREE_OPERAND (declarator, 1);
10393 /* Destructors can have their visibilities changed as well. */
10394 if (TREE_CODE (sname) == BIT_NOT_EXPR)
10395 sname = TREE_OPERAND (sname, 0);
10397 if (TREE_COMPLEXITY (declarator) == 0)
10398 /* This needs to be here, in case we are called
10399 multiple times. */ ;
10400 else if (TREE_COMPLEXITY (declarator) == -1)
10401 /* Namespace member. */
10402 pop_decl_namespace ();
10403 else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10404 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10405 else if (! IS_AGGR_TYPE_CODE
10406 (TREE_CODE (TREE_OPERAND (declarator, 0))))
10408 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10410 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10411 that refer to ctype. They couldn't be resolved earlier
10412 because we hadn't pushed into the class yet.
10413 Example: resolve 'B<T>::type' in
10414 'B<typename B<T>::type> B<T>::f () { }'. */
10415 if (current_template_parms
10416 && uses_template_parms (type)
10417 && uses_template_parms (current_class_type))
10419 tree args = current_template_args ();
10420 type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10423 /* This pop_nested_class corresponds to the
10424 push_nested_class used to push into class scope for
10425 parsing the argument list of a function decl, in
10427 pop_nested_class ();
10428 TREE_COMPLEXITY (declarator) = current_class_depth;
10431 my_friendly_abort (16);
10433 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10435 /* We had a reference to a global decl, or
10436 perhaps we were given a non-aggregate typedef,
10437 in which case we cleared this out, and should just
10438 keep going as though it wasn't there. */
10439 declarator = sname;
10442 ctype = TREE_OPERAND (declarator, 0);
10445 while (t != NULL_TREE && CLASS_TYPE_P (t))
10447 if (CLASSTYPE_TEMPLATE_INFO (t) &&
10448 !CLASSTYPE_TEMPLATE_SPECIALIZATION (t))
10449 template_count += 1;
10450 t = TYPE_MAIN_DECL (t);
10451 if (DECL_LANG_SPECIFIC (t))
10452 t = DECL_CLASS_CONTEXT (t);
10457 if (sname == NULL_TREE)
10460 if (TREE_CODE (sname) == IDENTIFIER_NODE)
10462 /* This is the `standard' use of the scoping operator:
10463 basetype :: member . */
10465 if (ctype == current_class_type)
10471 Is this ill-formed? */
10474 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10477 else if (TREE_CODE (type) == FUNCTION_TYPE)
10479 if (current_class_type == NULL_TREE
10481 type = build_cplus_method_type (ctype, TREE_TYPE (type),
10482 TYPE_ARG_TYPES (type));
10485 cp_error ("cannot declare member function `%T::%s' within `%T'",
10486 ctype, name, current_class_type);
10487 return void_type_node;
10490 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10491 || TYPE_SIZE (complete_type (ctype)) != NULL_TREE)
10493 /* Have to move this code elsewhere in this function.
10494 this code is used for i.e., typedef int A::M; M *pm;
10496 It is? How? jason 10/2/94 */
10498 if (current_class_type)
10500 cp_error ("cannot declare member `%T::%s' within `%T'",
10501 ctype, name, current_class_type);
10502 return void_type_node;
10504 type = build_offset_type (ctype, type);
10506 else if (uses_template_parms (ctype))
10508 if (TREE_CODE (type) == FUNCTION_TYPE)
10510 = build_cplus_method_type (ctype, TREE_TYPE (type),
10511 TYPE_ARG_TYPES (type));
10515 cp_error ("structure `%T' not yet defined", ctype);
10516 return error_mark_node;
10519 declarator = sname;
10521 else if (TREE_CODE (sname) == SCOPE_REF)
10522 my_friendly_abort (17);
10526 declarator = TREE_OPERAND (declarator, 1);
10527 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10528 /* In this case, we will deal with it later. */
10532 if (TREE_CODE (type) == FUNCTION_TYPE)
10533 type = build_cplus_method_type (ctype, TREE_TYPE (type),
10534 TYPE_ARG_TYPES (type));
10536 type = build_offset_type (ctype, type);
10543 declarator = TREE_OPERAND (declarator, 0);
10548 case ENUMERAL_TYPE:
10549 declarator = NULL_TREE;
10553 declarator = NULL_TREE;
10557 my_friendly_abort (158);
10561 /* See the comment for the TREE_LIST case, above. */
10564 if (! ignore_attrs)
10565 decl_attributes (type, inner_attrs, NULL_TREE);
10567 TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10569 attrlist = build_decl_list (NULL_TREE, inner_attrs);
10572 /* Now TYPE has the actual type. */
10574 if (explicitp == 1 || (explicitp && friendp))
10576 /* [dcl.fct.spec] The explicit specifier shall only be used in
10577 declarations of constructors within a class definition. */
10578 error ("only declarations of constructors can be `explicit'");
10582 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10584 if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10586 error ("non-member `%s' cannot be declared `mutable'", name);
10587 RIDBIT_RESET (RID_MUTABLE, specbits);
10589 else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10591 error ("non-object member `%s' cannot be declared `mutable'", name);
10592 RIDBIT_RESET (RID_MUTABLE, specbits);
10594 else if (TREE_CODE (type) == FUNCTION_TYPE
10595 || TREE_CODE (type) == METHOD_TYPE)
10597 error ("function `%s' cannot be declared `mutable'", name);
10598 RIDBIT_RESET (RID_MUTABLE, specbits);
10602 error ("static `%s' cannot be declared `mutable'", name);
10603 RIDBIT_RESET (RID_MUTABLE, specbits);
10605 else if (type_quals & TYPE_QUAL_CONST)
10607 error ("const `%s' cannot be declared `mutable'", name);
10608 RIDBIT_RESET (RID_MUTABLE, specbits);
10612 if (declarator == NULL_TREE
10613 || TREE_CODE (declarator) == IDENTIFIER_NODE
10614 || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10615 && (TREE_CODE (type) == FUNCTION_TYPE
10616 || TREE_CODE (type) == METHOD_TYPE)))
10618 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10620 cp_error ("template-id `%D' used as a declarator", declarator);
10621 declarator = dname;
10624 /* Unexpected declarator format. */
10625 my_friendly_abort (990210);
10627 /* If this is declaring a typedef name, return a TYPE_DECL. */
10629 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10633 /* Note that the grammar rejects storage classes
10634 in typenames, fields or parameters. */
10635 if (current_lang_name == lang_name_java)
10636 TYPE_FOR_JAVA (type) = 1;
10638 if (decl_context == FIELD)
10640 if (declarator == constructor_name (current_class_type))
10641 cp_pedwarn ("ANSI C++ forbids nested type `%D' with same name as enclosing class",
10643 decl = build_lang_decl (TYPE_DECL, declarator, type);
10647 /* Make sure this typedef lives as long as its type,
10648 since it might be used as a template parameter. */
10649 if (processing_template_decl)
10650 decl = build_lang_decl (TYPE_DECL, declarator, type);
10652 decl = build_decl (TYPE_DECL, declarator, type);
10655 /* If the user declares "typedef struct {...} foo" then the
10656 struct will have an anonymous name. Fill that name in now.
10657 Nothing can refer to it, so nothing needs know about the name
10659 if (type != error_mark_node
10660 && TYPE_NAME (type)
10661 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10662 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10663 && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10665 tree oldname = TYPE_NAME (type);
10668 /* Replace the anonymous name with the real name everywhere. */
10669 lookup_tag_reverse (type, declarator);
10670 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10671 if (TYPE_NAME (t) == oldname)
10672 TYPE_NAME (t) = decl;
10674 if (TYPE_LANG_SPECIFIC (type))
10675 TYPE_WAS_ANONYMOUS (type) = 1;
10677 /* If this is a typedef within a template class, the nested
10678 type is a (non-primary) template. The name for the
10679 template needs updating as well. */
10680 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10681 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10682 = TYPE_IDENTIFIER (type);
10684 /* XXX Temporarily set the scope.
10685 When returning, start_decl expects it as NULL_TREE,
10686 and will then then set it using pushdecl. */
10687 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10688 if (current_class_type)
10689 DECL_CONTEXT (decl) = current_class_type;
10691 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10693 DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10694 DECL_ASSEMBLER_NAME (decl)
10695 = get_identifier (build_overload_name (type, 1, 1));
10696 DECL_CONTEXT (decl) = NULL_TREE;
10698 /* FIXME remangle member functions; member functions of a
10699 type with external linkage have external linkage. */
10702 if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10704 cp_error_at ("typedef name may not be class-qualified", decl);
10709 if (ctype == NULL_TREE)
10711 if (TREE_CODE (type) != METHOD_TYPE)
10712 cp_error_at ("invalid type qualifier for non-method type", decl);
10714 ctype = TYPE_METHOD_BASETYPE (type);
10716 if (ctype != NULL_TREE)
10717 grok_method_quals (ctype, decl, quals);
10720 if (RIDBIT_SETP (RID_SIGNED, specbits)
10721 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10722 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10724 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
10725 inlinep, friendp, raises != NULL_TREE);
10728 error ("typedef declaration includes an initializer");
10733 /* Detect the case of an array type of unspecified size
10734 which came, as such, direct from a typedef name.
10735 We must copy the type, so that each identifier gets
10736 a distinct type, so that each identifier's size can be
10737 controlled separately by its own initializer. */
10739 if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
10740 && TYPE_DOMAIN (type) == NULL_TREE)
10742 type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
10745 /* If this is a type name (such as, in a cast or sizeof),
10746 compute the type and return it now. */
10748 if (decl_context == TYPENAME)
10750 /* Note that the grammar rejects storage classes
10751 in typenames, fields or parameters. */
10752 if (type_quals != TYPE_UNQUALIFIED)
10753 type_quals = TYPE_UNQUALIFIED;
10755 /* Special case: "friend class foo" looks like a TYPENAME context. */
10758 if (type_quals != TYPE_UNQUALIFIED)
10760 cp_error ("type qualifiers specified for friend class declaration");
10761 type_quals = TYPE_UNQUALIFIED;
10765 cp_error ("`inline' specified for friend class declaration");
10769 /* Only try to do this stuff if we didn't already give up. */
10770 if (type != integer_type_node)
10772 /* A friendly class? */
10773 if (current_class_type)
10774 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
10776 error ("trying to make class `%s' a friend of global scope",
10777 TYPE_NAME_STRING (type));
10778 type = void_type_node;
10783 tree dummy = build_decl (TYPE_DECL, declarator, type);
10784 if (ctype == NULL_TREE)
10786 my_friendly_assert (TREE_CODE (type) == METHOD_TYPE, 159);
10787 ctype = TYPE_METHOD_BASETYPE (type);
10789 grok_method_quals (ctype, dummy, quals);
10790 type = TREE_TYPE (dummy);
10795 else if (declarator == NULL_TREE && decl_context != PARM
10796 && decl_context != CATCHPARM
10797 && TREE_CODE (type) != UNION_TYPE
10800 cp_error ("abstract declarator `%T' used as declaration", type);
10801 declarator = make_anon_name ();
10804 /* `void' at top level (not within pointer)
10805 is allowed only in typedefs or type names.
10806 We don't complain about parms either, but that is because
10807 a better error message can be made later. */
10809 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
10812 error ("unnamed variable or field declared void");
10813 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10815 if (IDENTIFIER_OPNAME_P (declarator))
10816 my_friendly_abort (356);
10818 error ("variable or field `%s' declared void", name);
10821 error ("variable or field declared void");
10822 type = integer_type_node;
10825 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10826 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10828 if (decl_context == PARM || decl_context == CATCHPARM)
10830 if (ctype || in_namespace)
10831 error ("cannot use `::' in parameter declaration");
10833 /* A parameter declared as an array of T is really a pointer to T.
10834 One declared as a function is really a pointer to a function.
10835 One declared as a member is really a pointer to member. */
10837 if (TREE_CODE (type) == ARRAY_TYPE)
10839 /* Transfer const-ness of array into that of type pointed to. */
10840 type = build_pointer_type (TREE_TYPE (type));
10841 type_quals = TYPE_UNQUALIFIED;
10843 else if (TREE_CODE (type) == FUNCTION_TYPE)
10844 type = build_pointer_type (type);
10845 else if (TREE_CODE (type) == OFFSET_TYPE)
10846 type = build_pointer_type (type);
10847 else if (TREE_CODE (type) == VOID_TYPE && declarator)
10849 error ("declaration of `%s' as void", name);
10855 register tree decl;
10857 if (decl_context == PARM)
10859 decl = build_decl (PARM_DECL, declarator, type);
10861 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
10862 inlinep, friendp, raises != NULL_TREE);
10864 /* Compute the type actually passed in the parmlist,
10865 for the case where there is no prototype.
10866 (For example, shorts and chars are passed as ints.)
10867 When there is a prototype, this is overridden later. */
10869 DECL_ARG_TYPE (decl) = type_promotes_to (type);
10871 else if (decl_context == FIELD)
10873 if (type == error_mark_node)
10875 /* Happens when declaring arrays of sizes which
10876 are error_mark_node, for example. */
10879 else if (in_namespace && !friendp)
10881 /* Something like struct S { int N::j; }; */
10882 cp_error ("invalid use of `::'");
10885 else if (TREE_CODE (type) == FUNCTION_TYPE)
10888 tree function_context;
10890 /* We catch the others as conflicts with the builtin
10892 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
10894 cp_error ("function `%D' cannot be declared friend",
10901 if (ctype == NULL_TREE)
10902 ctype = current_class_type;
10904 if (ctype == NULL_TREE)
10906 cp_error ("can't make `%D' into a method -- not in a class",
10908 return void_type_node;
10911 /* ``A union may [ ... ] not [ have ] virtual functions.''
10913 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10915 cp_error ("function `%D' declared virtual inside a union",
10917 return void_type_node;
10920 if (declarator == ansi_opname[(int) NEW_EXPR]
10921 || declarator == ansi_opname[(int) VEC_NEW_EXPR]
10922 || declarator == ansi_opname[(int) DELETE_EXPR]
10923 || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
10927 cp_error ("`%D' cannot be declared virtual, since it is always static",
10932 else if (staticp < 2)
10933 type = build_cplus_method_type (ctype, TREE_TYPE (type),
10934 TYPE_ARG_TYPES (type));
10937 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10938 function_context = (ctype != NULL_TREE) ?
10939 hack_decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10940 publicp = (! friendp || ! staticp)
10941 && function_context == NULL_TREE;
10942 decl = grokfndecl (ctype, type,
10943 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
10944 ? declarator : dname,
10946 virtualp, flags, quals, raises,
10947 friendp ? -1 : 0, friendp, publicp, inlinep,
10948 funcdef_flag, template_count, in_namespace);
10949 if (decl == NULL_TREE)
10952 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10953 /* The decl and setting of decl_machine_attr is also turned off. */
10954 decl = build_decl_attribute_variant (decl, decl_machine_attr);
10957 /* [class.conv.ctor]
10959 A constructor declared without the function-specifier
10960 explicit that can be called with a single parameter
10961 specifies a conversion from the type of its first
10962 parameter to the type of its class. Such a constructor
10963 is called a converting constructor. */
10964 if (explicitp == 2)
10965 DECL_NONCONVERTING_P (decl) = 1;
10966 else if (DECL_CONSTRUCTOR_P (decl))
10968 /* The constructor can be called with exactly one
10969 parameter if there is at least one parameter, and
10970 any subsequent parameters have default arguments.
10971 We don't look at the first parameter, which is
10972 really just the `this' parameter for the new
10975 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
10977 /* Skip the `in_chrg' argument too, if present. */
10978 if (TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (decl)))
10979 arg_types = TREE_CHAIN (arg_types);
10981 if (arg_types == void_list_node
10983 && TREE_CHAIN (arg_types)
10984 && TREE_CHAIN (arg_types) != void_list_node
10985 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
10986 DECL_NONCONVERTING_P (decl) = 1;
10989 else if (TREE_CODE (type) == METHOD_TYPE)
10991 /* We only get here for friend declarations of
10992 members of other classes. */
10993 /* All method decls are public, so tell grokfndecl to set
10994 TREE_PUBLIC, also. */
10995 decl = grokfndecl (ctype, type, declarator, declarator,
10996 virtualp, flags, quals, raises,
10997 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
10998 template_count, in_namespace);
10999 if (decl == NULL_TREE)
11002 else if (!staticp && ! processing_template_decl
11003 && TYPE_SIZE (complete_type (type)) == NULL_TREE
11004 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11007 cp_error ("field `%D' has incomplete type", declarator);
11009 cp_error ("name `%T' has incomplete type", type);
11011 /* If we're instantiating a template, tell them which
11012 instantiation made the field's type be incomplete. */
11013 if (current_class_type
11014 && TYPE_NAME (current_class_type)
11015 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11016 && declspecs && TREE_VALUE (declspecs)
11017 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11018 cp_error (" in instantiation of template `%T'",
11019 current_class_type);
11021 type = error_mark_node;
11028 error ("`%s' is neither function nor method; cannot be declared friend",
11029 IDENTIFIER_POINTER (declarator));
11037 /* Friends are treated specially. */
11038 if (ctype == current_class_type)
11039 warning ("member functions are implicitly friends of their class");
11042 tree t = NULL_TREE;
11043 if (decl && DECL_NAME (decl))
11045 if (template_class_depth (current_class_type) == 0)
11048 = check_explicit_specialization
11050 template_count, 2 * (funcdef_flag != 0) + 4);
11051 if (decl == error_mark_node)
11052 return error_mark_node;
11055 t = do_friend (ctype, declarator, decl,
11056 last_function_parms, attrlist, flags, quals,
11059 if (t && funcdef_flag)
11062 return void_type_node;
11066 /* Structure field. It may not be a function, except for C++ */
11068 if (decl == NULL_TREE)
11074 /* An attempt is being made to initialize a non-static
11075 member. But, from [class.mem]:
11077 4 A member-declarator can contain a
11078 constant-initializer only if it declares a static
11079 member (_class.static_) of integral or enumeration
11080 type, see _class.static.data_.
11082 This used to be relatively common practice, but
11083 the rest of the compiler does not correctly
11084 handle the initialization unless the member is
11085 static so we make it static below. */
11086 cp_pedwarn ("ANSI C++ forbids initialization of member `%D'",
11088 cp_pedwarn ("making `%D' static", declarator);
11092 if (uses_template_parms (type))
11093 /* We'll check at instantiation time. */
11095 else if (check_static_variable_definition (declarator,
11097 /* If we just return the declaration, crashes
11098 will sometimes occur. We therefore return
11099 void_type_node, as if this was a friend
11100 declaration, to cause callers to completely
11101 ignore this declaration. */
11102 return void_type_node;
11105 /* 9.2p13 [class.mem] */
11106 if (declarator == constructor_name (current_class_type)
11107 /* Divergence from the standard: In extern "C", we
11108 allow non-static data members here, because C does
11109 and /usr/include/netinet/in.h uses that. */
11110 && (staticp || ! in_system_header))
11111 cp_pedwarn ("ANSI C++ forbids data member `%D' with same name as enclosing class",
11116 /* C++ allows static class members. All other work
11117 for this is done by grokfield. */
11118 decl = build_lang_decl (VAR_DECL, declarator, type);
11119 TREE_STATIC (decl) = 1;
11120 /* In class context, 'static' means public access. */
11121 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11125 decl = build_lang_decl (FIELD_DECL, declarator, type);
11126 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11128 DECL_MUTABLE_P (decl) = 1;
11129 RIDBIT_RESET (RID_MUTABLE, specbits);
11133 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11134 inlinep, friendp, raises != NULL_TREE);
11137 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11139 tree original_name;
11145 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11146 original_name = dname;
11148 original_name = declarator;
11150 if (RIDBIT_SETP (RID_AUTO, specbits))
11151 error ("storage class `auto' invalid for function `%s'", name);
11152 else if (RIDBIT_SETP (RID_REGISTER, specbits))
11153 error ("storage class `register' invalid for function `%s'", name);
11155 /* Function declaration not at top level.
11156 Storage classes other than `extern' are not allowed
11157 and `extern' makes no difference. */
11158 if (! toplevel_bindings_p ()
11159 && (RIDBIT_SETP (RID_STATIC, specbits)
11160 || RIDBIT_SETP (RID_INLINE, specbits))
11163 if (RIDBIT_SETP (RID_STATIC, specbits))
11164 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11166 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11169 if (ctype == NULL_TREE)
11173 error ("virtual non-class function `%s'", name);
11177 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11178 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11179 TYPE_ARG_TYPES (type));
11181 /* Record presence of `static'. */
11182 publicp = (ctype != NULL_TREE
11183 || RIDBIT_SETP (RID_EXTERN, specbits)
11184 || !RIDBIT_SETP (RID_STATIC, specbits));
11186 decl = grokfndecl (ctype, type, original_name, declarator,
11187 virtualp, flags, quals, raises,
11189 publicp, inlinep, funcdef_flag,
11190 template_count, in_namespace);
11191 if (decl == NULL_TREE)
11196 int illegal_static = 0;
11198 /* Don't allow a static member function in a class, and forbid
11199 declaring main to be static. */
11200 if (TREE_CODE (type) == METHOD_TYPE)
11202 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11203 illegal_static = 1;
11205 else if (current_function_decl)
11207 /* FIXME need arm citation */
11208 error ("cannot declare static function inside another function");
11209 illegal_static = 1;
11212 if (illegal_static)
11215 RIDBIT_RESET (RID_STATIC, specbits);
11221 /* It's a variable. */
11223 /* An uninitialized decl with `extern' is a reference. */
11224 decl = grokvardecl (type, declarator, &specbits,
11226 (type_quals & TYPE_QUAL_CONST) != 0,
11228 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11229 inlinep, friendp, raises != NULL_TREE);
11233 DECL_CONTEXT (decl) = ctype;
11236 cp_pedwarn ("static member `%D' re-declared as static", decl);
11238 RIDBIT_RESET (RID_STATIC, specbits);
11240 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11242 cp_error ("static member `%D' declared `register'", decl);
11243 RIDBIT_RESET (RID_REGISTER, specbits);
11245 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11247 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11249 RIDBIT_RESET (RID_EXTERN, specbits);
11254 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11256 /* Record `register' declaration for warnings on &
11257 and in case doing stupid register allocation. */
11259 if (RIDBIT_SETP (RID_REGISTER, specbits))
11260 DECL_REGISTER (decl) = 1;
11262 if (RIDBIT_SETP (RID_EXTERN, specbits))
11263 DECL_THIS_EXTERN (decl) = 1;
11265 if (RIDBIT_SETP (RID_STATIC, specbits))
11266 DECL_THIS_STATIC (decl) = 1;
11268 /* Record constancy and volatility. There's no need to do this
11269 when processing a template; we'll do this for the instantiated
11270 declaration based on the type of DECL. */
11271 if (!processing_template_decl)
11272 c_apply_type_quals_to_decl (type_quals, decl);
11278 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11279 An empty exprlist is a parmlist. An exprlist which
11280 contains only identifiers at the global level
11281 is a parmlist. Otherwise, it is an exprlist. */
11284 parmlist_is_exprlist (exprs)
11287 if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11290 if (toplevel_bindings_p ())
11292 /* At the global level, if these are all identifiers,
11293 then it is a parmlist. */
11296 if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11298 exprs = TREE_CHAIN (exprs);
11305 /* Subroutine of start_function. Ensure that each of the parameter
11306 types (as listed in PARMS) is complete, as is required for a
11307 function definition. */
11310 require_complete_types_for_parms (parms)
11313 for (; parms; parms = TREE_CHAIN (parms))
11315 tree type = TREE_TYPE (parms);
11317 /* Try to complete the TYPE. */
11318 type = complete_type (type);
11320 if (type == error_mark_node)
11323 if (TYPE_SIZE (type) == NULL_TREE)
11325 if (DECL_NAME (parms))
11326 error ("parameter `%s' has incomplete type",
11327 IDENTIFIER_POINTER (DECL_NAME (parms)));
11329 error ("parameter has incomplete type");
11330 TREE_TYPE (parms) = error_mark_node;
11333 layout_decl (parms, 0);
11337 /* Returns non-zero if T is a local variable. */
11340 local_variable_p (t)
11343 if ((TREE_CODE (t) == VAR_DECL
11344 /* A VAR_DECL with a context that is a _TYPE is a static data
11346 && !TYPE_P (CP_DECL_CONTEXT (t))
11347 /* Any other non-local variable must be at namespace scope. */
11348 && !DECL_NAMESPACE_SCOPE_P (t))
11349 || (TREE_CODE (t) == PARM_DECL))
11355 /* Returns non-zero if T is an automatic local variable or a label.
11356 (These are the declarations that need to be remapped when the code
11357 containing them is duplicated.) */
11360 nonstatic_local_decl_p (t)
11363 return ((local_variable_p (t) && !TREE_STATIC (t))
11364 || TREE_CODE (t) == LABEL_DECL
11365 || TREE_CODE (t) == RESULT_DECL);
11368 /* Like local_variable_p, but suitable for use as a tree-walking
11372 local_variable_p_walkfn (tp, walk_subtrees, data)
11374 int *walk_subtrees ATTRIBUTE_UNUSED;
11375 void *data ATTRIBUTE_UNUSED;
11377 return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11378 ? *tp : NULL_TREE);
11381 /* Check that ARG, which is a default-argument expression for a
11382 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11383 something goes wrong. DECL may also be a _TYPE node, rather than a
11384 DECL, if there is no DECL available. */
11387 check_default_argument (decl, arg)
11394 if (TREE_CODE (arg) == DEFAULT_ARG)
11395 /* We get a DEFAULT_ARG when looking at an in-class declaration
11396 with a default argument. Ignore the argument for now; we'll
11397 deal with it after the class is complete. */
11400 if (processing_template_decl || uses_template_parms (arg))
11401 /* We don't do anything checking until instantiation-time. Note
11402 that there may be uninstantiated arguments even for an
11403 instantiated function, since default arguments are not
11404 instantiated until they are needed. */
11413 decl_type = TREE_TYPE (decl);
11415 if (arg == error_mark_node
11416 || decl == error_mark_node
11417 || TREE_TYPE (arg) == error_mark_node
11418 || decl_type == error_mark_node)
11419 /* Something already went wrong. There's no need to check
11421 return error_mark_node;
11423 /* [dcl.fct.default]
11425 A default argument expression is implicitly converted to the
11427 if (!TREE_TYPE (arg)
11428 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11431 cp_error ("default argument for `%#D' has type `%T'",
11432 decl, TREE_TYPE (arg));
11434 cp_error ("default argument for parameter of type `%T' has type `%T'",
11435 decl_type, TREE_TYPE (arg));
11437 return error_mark_node;
11440 /* [dcl.fct.default]
11442 Local variables shall not be used in default argument
11445 The keyword `this' shall not be used in a default argument of a
11446 member function. */
11447 var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11450 cp_error ("default argument `%E' uses local variable `%D'",
11452 return error_mark_node;
11459 /* Decode the list of parameter types for a function type.
11460 Given the list of things declared inside the parens,
11461 return a list of types.
11463 The list we receive can have three kinds of elements:
11464 an IDENTIFIER_NODE for names given without types,
11465 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11466 or void_type_node, to mark the end of an argument list
11467 when additional arguments are not permitted (... was not used).
11469 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11470 a mere declaration. A nonempty identifier-list gets an error message
11471 when FUNCDEF_FLAG is zero.
11472 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11473 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11475 If all elements of the input list contain types,
11476 we return a list of the types.
11477 If all elements contain no type (except perhaps a void_type_node
11478 at the end), we return a null list.
11479 If some have types and some do not, it is an error, and we
11480 return a null list.
11482 Also set last_function_parms to either
11483 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11484 A list of names is converted to a chain of PARM_DECLs
11485 by store_parm_decls so that ultimately it is always a chain of decls.
11487 Note that in C++, parameters can take default values. These default
11488 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11489 an error to specify default values which are followed by parameters
11490 that have no default values, or an ELLIPSES. For simplicities sake,
11491 only parameters which are specified with their types can take on
11495 grokparms (first_parm, funcdef_flag)
11499 tree result = NULL_TREE;
11500 tree decls = NULL_TREE;
11502 if (first_parm != NULL_TREE
11503 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11505 if (! funcdef_flag)
11506 pedwarn ("parameter names (without types) in function declaration");
11507 last_function_parms = first_parm;
11510 else if (first_parm != NULL_TREE
11511 && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11512 && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11513 my_friendly_abort (145);
11516 /* Types were specified. This is a list of declarators
11517 each represented as a TREE_LIST node. */
11518 register tree parm, chain;
11519 int any_init = 0, any_error = 0;
11521 if (first_parm != NULL_TREE)
11523 tree last_result = NULL_TREE;
11524 tree last_decl = NULL_TREE;
11526 for (parm = first_parm; parm != NULL_TREE; parm = chain)
11528 tree type = NULL_TREE, list_node = parm;
11529 register tree decl = TREE_VALUE (parm);
11530 tree init = TREE_PURPOSE (parm);
11532 chain = TREE_CHAIN (parm);
11533 /* @@ weak defense against parse errors. */
11534 if (TREE_CODE (decl) != VOID_TYPE
11535 && TREE_CODE (decl) != TREE_LIST)
11537 /* Give various messages as the need arises. */
11538 if (TREE_CODE (decl) == STRING_CST)
11539 cp_error ("invalid string constant `%E'", decl);
11540 else if (TREE_CODE (decl) == INTEGER_CST)
11541 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11545 if (TREE_CODE (decl) != VOID_TYPE)
11547 decl = grokdeclarator (TREE_VALUE (decl),
11548 TREE_PURPOSE (decl),
11549 PARM, init != NULL_TREE,
11551 if (! decl || TREE_TYPE (decl) == error_mark_node)
11554 /* Top-level qualifiers on the parameters are
11555 ignored for function types. */
11556 type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11558 if (TREE_CODE (type) == VOID_TYPE)
11559 decl = void_type_node;
11560 else if (TREE_CODE (type) == METHOD_TYPE)
11562 if (DECL_NAME (decl))
11563 /* Cannot use the decl here because
11564 we don't have DECL_CONTEXT set up yet. */
11565 cp_error ("parameter `%D' invalidly declared method type",
11568 error ("parameter invalidly declared method type");
11569 type = build_pointer_type (type);
11570 TREE_TYPE (decl) = type;
11572 else if (TREE_CODE (type) == OFFSET_TYPE)
11574 if (DECL_NAME (decl))
11575 cp_error ("parameter `%D' invalidly declared offset type",
11578 error ("parameter invalidly declared offset type");
11579 type = build_pointer_type (type);
11580 TREE_TYPE (decl) = type;
11582 else if (abstract_virtuals_error (decl, type))
11583 any_error = 1; /* Seems like a good idea. */
11584 else if (POINTER_TYPE_P (type))
11587 while (POINTER_TYPE_P (t)
11588 || (TREE_CODE (t) == ARRAY_TYPE
11589 && TYPE_DOMAIN (t) != NULL_TREE))
11591 if (TREE_CODE (t) == ARRAY_TYPE)
11592 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11594 TYPE_PTR_P (type) ? "pointer" : "reference");
11598 if (TREE_CODE (decl) == VOID_TYPE)
11600 if (result == NULL_TREE)
11602 result = void_list_node;
11603 last_result = result;
11607 TREE_CHAIN (last_result) = void_list_node;
11608 last_result = void_list_node;
11611 && (chain != void_list_node || TREE_CHAIN (chain)))
11612 error ("`void' in parameter list must be entire list");
11616 /* Since there is a prototype, args are passed in their own types. */
11617 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11618 if (PROMOTE_PROTOTYPES
11619 && (TREE_CODE (type) == INTEGER_TYPE
11620 || TREE_CODE (type) == ENUMERAL_TYPE)
11621 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11622 DECL_ARG_TYPE (decl) = integer_type_node;
11623 if (!any_error && init)
11626 init = check_default_argument (decl, init);
11631 if (decls == NULL_TREE)
11638 TREE_CHAIN (last_decl) = decl;
11641 list_node = tree_cons (init, type, NULL_TREE);
11642 if (result == NULL_TREE)
11644 result = list_node;
11645 last_result = result;
11649 TREE_CHAIN (last_result) = list_node;
11650 last_result = list_node;
11654 TREE_CHAIN (last_result) = NULL_TREE;
11655 /* If there are no parameters, and the function does not end
11656 with `...', then last_decl will be NULL_TREE. */
11657 if (last_decl != NULL_TREE)
11658 TREE_CHAIN (last_decl) = NULL_TREE;
11662 last_function_parms = decls;
11667 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11668 FUNCTION_TYPE with the newly parsed version of its default argument, which
11669 was previously digested as text. See snarf_defarg et al in lex.c. */
11672 replace_defarg (arg, init)
11675 if (! processing_template_decl
11676 && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11677 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11678 TREE_TYPE (init), TREE_VALUE (arg));
11679 TREE_PURPOSE (arg) = init;
11686 tree t = FUNCTION_ARG_CHAIN (d);
11687 if (DECL_CONSTRUCTOR_P (d)
11688 && TYPE_USES_VIRTUAL_BASECLASSES (DECL_CONTEXT (d)))
11689 t = TREE_CHAIN (t);
11690 if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11691 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11692 == DECL_CLASS_CONTEXT (d))
11693 && (TREE_CHAIN (t) == NULL_TREE
11694 || TREE_CHAIN (t) == void_list_node
11695 || TREE_PURPOSE (TREE_CHAIN (t))))
11700 /* These memoizing functions keep track of special properties which
11701 a class may have. `grok_ctor_properties' notices whether a class
11702 has a constructor of the form X(X&), and also complains
11703 if the class has a constructor of the form X(X).
11704 `grok_op_properties' takes notice of the various forms of
11705 operator= which are defined, as well as what sorts of type conversion
11706 may apply. Both functions take a FUNCTION_DECL as an argument. */
11709 grok_ctor_properties (ctype, decl)
11712 tree parmtypes = FUNCTION_ARG_CHAIN (decl);
11713 tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
11715 /* When a type has virtual baseclasses, a magical first int argument is
11716 added to any ctor so we can tell if the class has been initialized
11717 yet. This could screw things up in this function, so we deliberately
11718 ignore the leading int if we're in that situation. */
11719 if (TYPE_USES_VIRTUAL_BASECLASSES (ctype))
11721 my_friendly_assert (parmtypes
11722 && TREE_VALUE (parmtypes) == integer_type_node,
11724 parmtypes = TREE_CHAIN (parmtypes);
11725 parmtype = TREE_VALUE (parmtypes);
11730 A non-template constructor for class X is a copy constructor if
11731 its first parameter is of type X&, const X&, volatile X& or const
11732 volatile X&, and either there are no other parameters or else all
11733 other parameters have default arguments. */
11734 if (TREE_CODE (parmtype) == REFERENCE_TYPE
11735 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
11736 && (TREE_CHAIN (parmtypes) == NULL_TREE
11737 || TREE_CHAIN (parmtypes) == void_list_node
11738 || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11739 && !(DECL_TEMPLATE_INSTANTIATION (decl)
11740 && is_member_template (DECL_TI_TEMPLATE (decl))))
11742 TYPE_HAS_INIT_REF (ctype) = 1;
11743 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11744 TYPE_HAS_CONST_INIT_REF (ctype) = 1;
11748 A declaration of a constructor for a class X is ill-formed if its
11749 first parameter is of type (optionally cv-qualified) X and either
11750 there are no other parameters or else all other parameters have
11753 We *don't* complain about member template instantiations that
11754 have this form, though; they can occur as we try to decide what
11755 constructor to use during overload resolution. Since overload
11756 resolution will never prefer such a constructor to the
11757 non-template copy constructor (which is either explicitly or
11758 implicitly defined), there's no need to worry about their
11759 existence. Theoretically, they should never even be
11760 instantiated, but that's hard to forestall. */
11761 else if (TYPE_MAIN_VARIANT (parmtype) == ctype
11762 && (TREE_CHAIN (parmtypes) == NULL_TREE
11763 || TREE_CHAIN (parmtypes) == void_list_node
11764 || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
11765 && !(DECL_TEMPLATE_INSTANTIATION (decl)
11766 && is_member_template (DECL_TI_TEMPLATE (decl))))
11768 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
11770 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
11773 else if (TREE_CODE (parmtype) == VOID_TYPE
11774 || TREE_PURPOSE (parmtypes) != NULL_TREE)
11775 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
11780 /* An operator with this name can be either unary or binary. */
11786 return (name == ansi_opname [(int) INDIRECT_REF]
11787 || name == ansi_opname [(int) ADDR_EXPR]
11788 || name == ansi_opname [(int) NEGATE_EXPR]
11789 || name == ansi_opname[(int) POSTINCREMENT_EXPR]
11790 || name == ansi_opname[(int) POSTDECREMENT_EXPR]
11791 || name == ansi_opname [(int) CONVERT_EXPR]);
11794 /* An operator with this name can only be unary. */
11800 return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
11801 || name == ansi_opname [(int) BIT_NOT_EXPR]
11802 || name == ansi_opname [(int) COMPONENT_REF]
11803 || IDENTIFIER_TYPENAME_P (name));
11806 /* Do a little sanity-checking on how they declared their operator. */
11809 grok_op_properties (decl, virtualp, friendp)
11811 int virtualp, friendp;
11813 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11814 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11815 tree name = DECL_NAME (decl);
11817 if (current_class_type == NULL_TREE)
11824 A user-declared copy assignment operator X::operator= is a
11825 non-static non-template member function of class X with
11826 exactly one parameter of type X, X&, const X&, volatile X& or
11827 const volatile X&. */
11828 if (name == ansi_opname[(int) MODIFY_EXPR]
11829 && !(DECL_TEMPLATE_INSTANTIATION (decl)
11830 && is_member_template (DECL_TI_TEMPLATE (decl))))
11832 else if (name == ansi_opname[(int) CALL_EXPR])
11833 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
11834 else if (name == ansi_opname[(int) ARRAY_REF])
11835 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
11836 else if (name == ansi_opname[(int) COMPONENT_REF]
11837 || name == ansi_opname[(int) MEMBER_REF])
11838 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
11839 else if (name == ansi_opname[(int) NEW_EXPR])
11840 TYPE_GETS_NEW (current_class_type) |= 1;
11841 else if (name == ansi_opname[(int) DELETE_EXPR])
11842 TYPE_GETS_DELETE (current_class_type) |= 1;
11843 else if (name == ansi_opname[(int) VEC_NEW_EXPR])
11844 TYPE_GETS_NEW (current_class_type) |= 2;
11845 else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
11846 TYPE_GETS_DELETE (current_class_type) |= 2;
11849 if (name == ansi_opname[(int) NEW_EXPR]
11850 || name == ansi_opname[(int) VEC_NEW_EXPR])
11852 /* When the compiler encounters the definition of A::operator new, it
11853 doesn't look at the class declaration to find out if it's static. */
11855 revert_static_member_fn (&decl, NULL, NULL);
11857 /* Take care of function decl if we had syntax errors. */
11858 if (argtypes == NULL_TREE)
11860 = build_function_type (ptr_type_node,
11861 hash_tree_chain (integer_type_node,
11864 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11866 else if (name == ansi_opname[(int) DELETE_EXPR]
11867 || name == ansi_opname[(int) VEC_DELETE_EXPR])
11870 revert_static_member_fn (&decl, NULL, NULL);
11872 if (argtypes == NULL_TREE)
11874 = build_function_type (void_type_node,
11875 hash_tree_chain (ptr_type_node,
11879 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11881 if (! friendp && name == ansi_opname[(int) VEC_DELETE_EXPR]
11882 && (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)))
11883 != void_list_node))
11884 TYPE_VEC_DELETE_TAKES_SIZE (current_class_type) = 1;
11889 /* An operator function must either be a non-static member function
11890 or have at least one parameter of a class, a reference to a class,
11891 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11892 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11894 if (IDENTIFIER_TYPENAME_P (name)
11895 || name == ansi_opname[(int) CALL_EXPR]
11896 || name == ansi_opname[(int) MODIFY_EXPR]
11897 || name == ansi_opname[(int) COMPONENT_REF]
11898 || name == ansi_opname[(int) ARRAY_REF])
11899 cp_error ("`%D' must be a nonstatic member function", decl);
11904 if (DECL_STATIC_FUNCTION_P (decl))
11905 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
11908 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
11910 tree arg = TREE_VALUE (p);
11911 if (TREE_CODE (arg) == REFERENCE_TYPE)
11912 arg = TREE_TYPE (arg);
11914 /* This lets bad template code slip through. */
11915 if (IS_AGGR_TYPE (arg)
11916 || TREE_CODE (arg) == ENUMERAL_TYPE
11917 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
11918 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
11922 ("`%D' must have an argument of class or enumerated type",
11929 if (name == ansi_opname[(int) CALL_EXPR])
11930 return; /* No restrictions on args. */
11932 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
11934 tree t = TREE_TYPE (name);
11935 if (TREE_CODE (t) == VOID_TYPE)
11936 pedwarn ("void is not a valid type conversion operator");
11937 else if (! friendp)
11939 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11940 const char *what = 0;
11942 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11944 if (t == current_class_type)
11945 what = "the same type";
11946 /* Don't force t to be complete here. */
11947 else if (IS_AGGR_TYPE (t)
11949 && DERIVED_FROM_P (t, current_class_type))
11950 what = "a base class";
11953 warning ("conversion to %s%s will never use a type conversion operator",
11954 ref ? "a reference to " : "", what);
11958 if (name == ansi_opname[(int) MODIFY_EXPR])
11962 if (list_length (argtypes) != 3 && methodp)
11964 cp_error ("`%D' must take exactly one argument", decl);
11967 parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
11969 if (copy_assignment_arg_p (parmtype, virtualp)
11972 TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
11973 if (TREE_CODE (parmtype) != REFERENCE_TYPE
11974 || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
11975 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
11978 else if (name == ansi_opname[(int) COND_EXPR])
11981 cp_error ("ANSI C++ prohibits overloading operator ?:");
11983 else if (ambi_op_p (name))
11985 if (list_length (argtypes) == 2)
11987 else if (list_length (argtypes) == 3)
11989 if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
11990 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
11991 && ! processing_template_decl
11992 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11995 cp_error ("postfix `%D' must take `int' as its argument",
11999 ("postfix `%D' must take `int' as its second argument",
12006 cp_error ("`%D' must take either zero or one argument", decl);
12008 cp_error ("`%D' must take either one or two arguments", decl);
12011 /* More Effective C++ rule 6. */
12013 && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12014 || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12016 tree arg = TREE_VALUE (argtypes);
12017 tree ret = TREE_TYPE (TREE_TYPE (decl));
12018 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12019 arg = TREE_TYPE (arg);
12020 arg = TYPE_MAIN_VARIANT (arg);
12021 if (list_length (argtypes) == 2)
12023 if (TREE_CODE (ret) != REFERENCE_TYPE
12024 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12026 cp_warning ("prefix `%D' should return `%T'", decl,
12027 build_reference_type (arg));
12031 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12032 cp_warning ("postfix `%D' should return `%T'", decl, arg);
12036 else if (unary_op_p (name))
12038 if (list_length (argtypes) != 2)
12041 cp_error ("`%D' must take `void'", decl);
12043 cp_error ("`%D' must take exactly one argument", decl);
12046 else /* if (binary_op_p (name)) */
12048 if (list_length (argtypes) != 3)
12051 cp_error ("`%D' must take exactly one argument", decl);
12053 cp_error ("`%D' must take exactly two arguments", decl);
12056 /* More Effective C++ rule 7. */
12058 && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12059 || name == ansi_opname [TRUTH_ORIF_EXPR]
12060 || name == ansi_opname [COMPOUND_EXPR]))
12061 cp_warning ("user-defined `%D' always evaluates both arguments",
12065 /* Effective C++ rule 23. */
12067 && list_length (argtypes) == 3
12068 && (name == ansi_opname [PLUS_EXPR]
12069 || name == ansi_opname [MINUS_EXPR]
12070 || name == ansi_opname [TRUNC_DIV_EXPR]
12071 || name == ansi_opname [MULT_EXPR])
12072 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12073 cp_warning ("`%D' should return by value", decl);
12077 for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12078 if (TREE_PURPOSE (argtypes))
12080 TREE_PURPOSE (argtypes) = NULL_TREE;
12081 if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12082 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12085 cp_pedwarn ("`%D' cannot have default arguments", decl);
12088 cp_error ("`%D' cannot have default arguments", decl);
12093 static const char *
12095 enum tag_types code;
12108 my_friendly_abort (981122);
12112 /* Get the struct, enum or union (CODE says which) with tag NAME.
12113 Define the tag as a forward-reference if it is not defined.
12115 C++: If a class derivation is given, process it here, and report
12116 an error if multiple derivation declarations are not identical.
12118 If this is a definition, come in through xref_tag and only look in
12119 the current frame for the name (since C++ allows new names in any
12123 xref_tag (code_type_node, name, globalize)
12124 tree code_type_node;
12128 enum tag_types tag_code;
12129 enum tree_code code;
12130 register tree ref, t;
12131 struct binding_level *b = current_binding_level;
12133 tree attributes = NULL_TREE;
12134 tree context = NULL_TREE;
12136 /* If we are called from the parser, code_type_node will sometimes be a
12137 TREE_LIST. This indicates that the user wrote
12138 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12140 if (TREE_CODE (code_type_node) == TREE_LIST)
12142 attributes = TREE_PURPOSE (code_type_node);
12143 code_type_node = TREE_VALUE (code_type_node);
12146 tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12151 code = RECORD_TYPE;
12157 code = ENUMERAL_TYPE;
12160 my_friendly_abort (18);
12163 /* If a cross reference is requested, look up the type
12164 already defined for this tag and return it. */
12165 if (TREE_CODE_CLASS (TREE_CODE (name)) == 't')
12168 name = TYPE_IDENTIFIER (t);
12172 t = IDENTIFIER_TYPE_VALUE (name);
12174 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12175 && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12180 /* If we know we are defining this tag, only look it up in
12181 this scope and don't try to find it as a type. */
12182 ref = lookup_tag (code, name, b, 1);
12188 /* [dcl.type.elab] If the identifier resolves to a
12189 typedef-name or a template type-parameter, the
12190 elaborated-type-specifier is ill-formed. */
12191 if (t != TYPE_MAIN_VARIANT (t)
12192 || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12193 cp_pedwarn ("using typedef-name `%D' after `%s'",
12194 TYPE_NAME (t), tag_name (tag_code));
12195 else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12196 cp_error ("using template type parameter `%T' after `%s'",
12197 t, tag_name (tag_code));
12202 ref = lookup_tag (code, name, b, 0);
12206 /* Try finding it as a type declaration. If that wins,
12208 ref = lookup_name (name, 1);
12210 if (ref != NULL_TREE
12211 && processing_template_decl
12212 && DECL_CLASS_TEMPLATE_P (ref)
12213 && template_class_depth (current_class_type) == 0)
12214 /* Since GLOBALIZE is true, we're declaring a global
12215 template, so we want this type. */
12216 ref = DECL_RESULT (ref);
12218 if (ref && TREE_CODE (ref) == TYPE_DECL
12219 && TREE_CODE (TREE_TYPE (ref)) == code)
12220 ref = TREE_TYPE (ref);
12225 if (ref && current_class_type
12226 && template_class_depth (current_class_type)
12227 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12229 /* Since GLOBALIZE is non-zero, we are not looking at a
12230 definition of this tag. Since, in addition, we are currently
12231 processing a (member) template declaration of a template
12232 class, we must be very careful; consider:
12239 { template <class V>
12240 friend struct S1; };
12242 Here, the S2::S1 declaration should not be confused with the
12243 outer declaration. In particular, the inner version should
12244 have a template parameter of level 2, not level 1. This
12245 would be particularly important if the member declaration
12248 template <class V = U> friend struct S1;
12250 say, when we should tsubst into `U' when instantiating
12251 S2. On the other hand, when presented with:
12261 we must find the inner binding eventually. We
12262 accomplish this by making sure that the new type we
12263 create to represent this declaration has the right
12265 context = TYPE_CONTEXT (ref);
12272 /* If no such tag is yet defined, create a forward-reference node
12273 and record it as the "definition".
12274 When a real declaration of this type is found,
12275 the forward-reference will be altered into a real type. */
12276 if (code == ENUMERAL_TYPE)
12278 cp_error ("use of enum `%#D' without previous declaration", name);
12280 ref = make_node (ENUMERAL_TYPE);
12282 /* Give the type a default layout like unsigned int
12283 to avoid crashing if it does not get defined. */
12284 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12285 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12286 TREE_UNSIGNED (ref) = 1;
12287 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12288 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12289 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12291 /* Enable us to recognize when a type is created in class context.
12292 To do nested classes correctly, this should probably be cleared
12293 out when we leave this classes scope. Currently this in only
12294 done in `start_enum'. */
12296 pushtag (name, ref, globalize);
12300 struct binding_level *old_b = class_binding_level;
12302 ref = make_aggr_type (code);
12303 TYPE_CONTEXT (ref) = context;
12305 #ifdef NONNESTED_CLASSES
12306 /* Class types don't nest the way enums do. */
12307 class_binding_level = (struct binding_level *)0;
12309 pushtag (name, ref, globalize);
12310 class_binding_level = old_b;
12315 /* If it no longer looks like a nested type, make sure it's
12317 If it is not an IDENTIFIER, this is not a declaration */
12318 if (b->namespace_p && !class_binding_level
12319 && TREE_CODE (name) == IDENTIFIER_NODE
12320 && IDENTIFIER_NAMESPACE_VALUE (name) == NULL_TREE)
12321 SET_IDENTIFIER_NAMESPACE_VALUE (name, TYPE_NAME (ref));
12323 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12324 redeclare_class_template (ref, current_template_parms);
12327 /* Until the type is defined, tentatively accept whatever
12328 structure tag the user hands us. */
12329 if (TYPE_SIZE (ref) == NULL_TREE
12330 && ref != current_class_type
12331 /* Have to check this, in case we have contradictory tag info. */
12332 && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12334 if (tag_code == class_type)
12335 CLASSTYPE_DECLARED_CLASS (ref) = 1;
12336 else if (tag_code == record_type)
12337 CLASSTYPE_DECLARED_CLASS (ref) = 0;
12340 TREE_TYPE (ref) = attributes;
12346 xref_tag_from_type (old, id, globalize)
12350 tree code_type_node;
12352 if (TREE_CODE (old) == RECORD_TYPE)
12353 code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12354 ? class_type_node : record_type_node);
12356 code_type_node = union_type_node;
12358 if (id == NULL_TREE)
12359 id = TYPE_IDENTIFIER (old);
12361 return xref_tag (code_type_node, id, globalize);
12364 /* REF is a type (named NAME), for which we have just seen some
12365 baseclasses. BINFO is a list of those baseclasses; the
12366 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12367 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12368 struct, or union. */
12371 xref_basetypes (code_type_node, name, ref, binfo)
12372 tree code_type_node;
12376 /* In the declaration `A : X, Y, ... Z' we mark all the types
12377 (A, X, Y, ..., Z) so we can check for duplicates. */
12382 enum tag_types tag_code = (enum tag_types) TREE_INT_CST_LOW (code_type_node);
12384 if (tag_code == union_type)
12386 cp_error ("derived union `%T' invalid", ref);
12390 len = list_length (binfo);
12392 /* First, make sure that any templates in base-classes are
12393 instantiated. This ensures that if we call ourselves recursively
12394 we do not get confused about which classes are marked and which
12396 for (base = binfo; base; base = TREE_CHAIN (base))
12397 complete_type (TREE_VALUE (base));
12399 SET_CLASSTYPE_MARKED (ref);
12400 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12402 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12404 /* The base of a derived struct is public by default. */
12406 = (TREE_PURPOSE (binfo) == access_public_node
12407 || TREE_PURPOSE (binfo) == access_public_virtual_node
12408 || (tag_code != class_type
12409 && (TREE_PURPOSE (binfo) == access_default_node
12410 || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12412 = (TREE_PURPOSE (binfo) == access_protected_node
12413 || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12415 = (TREE_PURPOSE (binfo) == access_private_virtual_node
12416 || TREE_PURPOSE (binfo) == access_protected_virtual_node
12417 || TREE_PURPOSE (binfo) == access_public_virtual_node
12418 || TREE_PURPOSE (binfo) == access_default_virtual_node);
12419 tree basetype = TREE_VALUE (binfo);
12422 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12423 basetype = TREE_TYPE (basetype);
12425 || (TREE_CODE (basetype) != RECORD_TYPE
12426 && TREE_CODE (basetype) != TYPENAME_TYPE
12427 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12428 && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12430 cp_error ("base type `%T' fails to be a struct or class type",
12431 TREE_VALUE (binfo));
12435 GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12437 /* This code replaces similar code in layout_basetypes.
12438 We put the complete_type first for implicit `typename'. */
12439 if (TYPE_SIZE (basetype) == NULL_TREE
12440 && ! (current_template_parms && uses_template_parms (basetype)))
12442 cp_error ("base class `%T' has incomplete type", basetype);
12447 if (CLASSTYPE_MARKED (basetype))
12449 if (basetype == ref)
12450 cp_error ("recursive type `%T' undefined", basetype);
12452 cp_error ("duplicate base type `%T' invalid", basetype);
12456 if (TYPE_FOR_JAVA (basetype)
12457 && (current_lang_stack
12458 == &VARRAY_TREE (current_lang_base, 0)))
12459 TYPE_FOR_JAVA (ref) = 1;
12461 /* Note that the BINFO records which describe individual
12462 inheritances are *not* shared in the lattice! They
12463 cannot be shared because a given baseclass may be
12464 inherited with different `accessibility' by different
12465 derived classes. (Each BINFO record describing an
12466 individual inheritance contains flags which say what
12467 the `accessibility' of that particular inheritance is.) */
12470 = make_binfo (integer_zero_node, basetype,
12471 CLASS_TYPE_P (basetype)
12472 ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12473 CLASS_TYPE_P (basetype)
12474 ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12476 TREE_VEC_ELT (binfos, i) = base_binfo;
12477 TREE_VIA_PUBLIC (base_binfo) = via_public;
12478 TREE_VIA_PROTECTED (base_binfo) = via_protected;
12479 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12480 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12482 /* We need to unshare the binfos now so that lookups during class
12483 definition work. */
12484 unshare_base_binfos (base_binfo);
12486 SET_CLASSTYPE_MARKED (basetype);
12488 /* We are free to modify these bits because they are meaningless
12489 at top level, and BASETYPE is a top-level type. */
12490 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12492 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12493 /* Converting to a virtual base class requires looking
12494 up the offset of the virtual base. */
12495 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12498 if (CLASS_TYPE_P (basetype))
12500 TYPE_GETS_NEW (ref) |= TYPE_GETS_NEW (basetype);
12501 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12502 /* If the base-class uses multiple inheritance, so do we. */
12503 TYPE_USES_MULTIPLE_INHERITANCE (ref)
12504 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12505 /* Likewise, if converting to a base of the base may require
12506 code, then we may need to generate code to convert to a
12508 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12509 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12516 TREE_VEC_LENGTH (binfos) = i;
12518 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12522 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12523 /* If there is more than one non-empty they cannot be at the same
12525 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12528 /* Unmark all the types. */
12530 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12531 CLEAR_CLASSTYPE_MARKED (ref);
12533 /* Now that we know all the base-classes, set up the list of virtual
12535 get_vbase_types (ref);
12539 /* Begin compiling the definition of an enumeration type.
12540 NAME is its name (or null if anonymous).
12541 Returns the type object, as yet incomplete.
12542 Also records info about it so that build_enumerator
12543 may be used to declare the individual values as they are read. */
12549 register tree enumtype = NULL_TREE;
12550 struct binding_level *b = current_binding_level;
12552 /* If this is the real definition for a previous forward reference,
12553 fill in the contents in the same object that used to be the
12554 forward reference. */
12556 if (name != NULL_TREE)
12557 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12559 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12561 cp_error ("multiple definition of `%#T'", enumtype);
12562 cp_error_at ("previous definition here", enumtype);
12563 /* Clear out TYPE_VALUES, and start again. */
12564 TYPE_VALUES (enumtype) = NULL_TREE;
12568 enumtype = make_node (ENUMERAL_TYPE);
12569 pushtag (name, enumtype, 0);
12572 if (current_class_type)
12573 TREE_ADDRESSABLE (b->tags) = 1;
12575 GNU_xref_decl (current_function_decl, enumtype);
12579 /* After processing and defining all the values of an enumeration type,
12580 install their decls in the enumeration type and finish it off.
12581 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12582 Returns ENUMTYPE. */
12585 finish_enum (enumtype)
12588 register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12589 /* Calculate the maximum value of any enumerator in this type. */
12591 tree values = TYPE_VALUES (enumtype);
12596 for (pair = values; pair; pair = TREE_CHAIN (pair))
12601 /* The TREE_VALUE is a CONST_DECL for this enumeration
12603 decl = TREE_VALUE (pair);
12607 Following the closing brace of an enum-specifier, each
12608 enumerator has the type of its enumeration. Prior to the
12609 closing brace, the type of each enumerator is the type of
12610 its initializing value. */
12611 TREE_TYPE (decl) = enumtype;
12613 /* The DECL_INITIAL will be NULL if we are processing a
12614 template declaration and this enumeration constant had no
12615 explicit initializer. */
12616 value = DECL_INITIAL (decl);
12617 if (value && !processing_template_decl)
12619 /* Set the TREE_TYPE for the VALUE as well. That's so
12620 that when we call decl_constant_value we get an
12621 entity of the right type (but with the constant
12622 value). Since we shouldn't ever call
12623 decl_constant_value on a template type, there's no
12624 reason to do that when processing_template_decl.
12625 And, if the expression is something like a
12626 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12627 wreak havoc on the intended type of the expression.
12629 Of course, there's also no point in trying to compute
12630 minimum or maximum values if we're in a template. */
12631 TREE_TYPE (value) = enumtype;
12634 minnode = maxnode = value;
12635 else if (tree_int_cst_lt (maxnode, value))
12637 else if (tree_int_cst_lt (value, minnode))
12641 if (processing_template_decl)
12642 /* If this is just a template, leave the CONST_DECL
12643 alone. That way tsubst_copy will find CONST_DECLs for
12644 CONST_DECLs, and not INTEGER_CSTs. */
12647 /* In the list we're building up, we want the enumeration
12648 values, not the CONST_DECLs. */
12649 TREE_VALUE (pair) = value;
12653 maxnode = minnode = integer_zero_node;
12655 TYPE_VALUES (enumtype) = nreverse (values);
12657 if (processing_template_decl)
12659 tree scope = current_scope ();
12660 if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12661 add_tree (build_min (TAG_DEFN, enumtype));
12665 int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12666 int lowprec = min_precision (minnode, unsignedp);
12667 int highprec = min_precision (maxnode, unsignedp);
12668 int precision = MAX (lowprec, highprec);
12671 TYPE_SIZE (enumtype) = NULL_TREE;
12673 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12675 TYPE_PRECISION (enumtype) = precision;
12677 fixup_unsigned_type (enumtype);
12679 fixup_signed_type (enumtype);
12681 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12682 /* Use the width of the narrowest normal C type which is wide
12684 TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12687 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12689 TYPE_SIZE (enumtype) = 0;
12690 layout_type (enumtype);
12692 /* Fix up all variant types of this enum type. */
12693 for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12694 tem = TYPE_NEXT_VARIANT (tem))
12696 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12697 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12698 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12699 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12700 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12701 TYPE_MODE (tem) = TYPE_MODE (enumtype);
12702 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12703 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12704 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12707 /* Finish debugging output for this type. */
12708 rest_of_type_compilation (enumtype, namespace_bindings_p ());
12714 /* Build and install a CONST_DECL for an enumeration constant of the
12715 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12716 Assignment of sequential values by default is handled here. */
12719 build_enumerator (name, value, enumtype)
12729 /* Remove no-op casts from the value. */
12731 STRIP_TYPE_NOPS (value);
12733 if (! processing_template_decl)
12735 /* Validate and default VALUE. */
12736 if (value != NULL_TREE)
12738 if (TREE_READONLY_DECL_P (value))
12739 value = decl_constant_value (value);
12741 if (TREE_CODE (value) == INTEGER_CST)
12743 value = default_conversion (value);
12744 constant_expression_warning (value);
12748 cp_error ("enumerator value for `%D' not integer constant", name);
12753 /* Default based on previous value. */
12754 if (value == NULL_TREE && ! processing_template_decl)
12758 if (TYPE_VALUES (enumtype))
12760 /* The next value is the previous value ... */
12761 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12762 /* ... plus one. */
12763 value = build_binary_op_nodefault (PLUS_EXPR,
12768 if (tree_int_cst_lt (value, prev_value))
12769 cp_error ("overflow in enumeration values at `%D'", name);
12772 value = integer_zero_node;
12775 /* Remove no-op casts from the value. */
12777 STRIP_TYPE_NOPS (value);
12779 /* To fix MAX_VAL enum consts. (bkoz) */
12780 TREE_TYPE (value) = integer_type_node;
12784 /* We always have to copy here; not all INTEGER_CSTs are unshared.
12785 Even in other cases, we will later (in finish_enum) be setting
12786 the type of VALUE. But, we don't need to make a copy if this
12787 VALUE is one of the enumeration constants for this same
12788 enumeration type. */
12789 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12790 if (TREE_VALUE (values) == value)
12792 /* If we didn't break out of the loop, then we do need a copy. */
12793 if (!values && value)
12794 value = copy_node (value);
12796 /* C++ associates enums with global, function, or class declarations. */
12797 context = current_scope ();
12799 /* Build the actual enumeration constant. Note that the enumeration
12800 constants have the type of their initializers until the
12801 enumeration is complete:
12805 Following the closing brace of an enum-specifier, each enumer-
12806 ator has the type of its enumeration. Prior to the closing
12807 brace, the type of each enumerator is the type of its
12808 initializing value.
12810 In finish_enum we will reset the type. Of course, if we're
12811 processing a template, there may be no value. */
12812 type = value ? TREE_TYPE (value) : NULL_TREE;
12814 if (context && context == current_class_type)
12815 /* This enum declaration is local to the class. We need the full
12816 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
12817 decl = build_lang_decl (CONST_DECL, name, type);
12819 /* It's a global enum, or it's local to a function. (Note local to
12820 a function could mean local to a class method. */
12821 decl = build_decl (CONST_DECL, name, type);
12823 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
12824 DECL_INITIAL (decl) = value;
12825 TREE_READONLY (decl) = 1;
12827 if (context && context == current_class_type)
12828 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12829 on the TYPE_FIELDS list for `S'. (That's so that you can say
12830 things like `S::i' later.) */
12831 finish_member_declaration (decl);
12835 GNU_xref_decl (current_function_decl, decl);
12838 /* Add this enumeration constant to the list for this type. */
12839 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12843 static int function_depth;
12845 /* We're defining DECL. Make sure that it's type is OK. */
12848 check_function_type (decl)
12851 tree fntype = TREE_TYPE (decl);
12853 /* In a function definition, arg types must be complete. */
12854 require_complete_types_for_parms (current_function_parms);
12856 if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
12858 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
12860 /* Make it return void instead, but don't change the
12861 type of the DECL_RESULT, in case we have a named return value. */
12862 if (TREE_CODE (fntype) == METHOD_TYPE)
12864 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
12866 = build_cplus_method_type (ctype,
12868 FUNCTION_ARG_CHAIN (decl));
12872 = build_function_type (void_type_node,
12873 TYPE_ARG_TYPES (TREE_TYPE (decl)));
12875 = build_exception_variant (fntype,
12876 TYPE_RAISES_EXCEPTIONS (fntype));
12879 abstract_virtuals_error (decl, TREE_TYPE (fntype));
12882 /* Create the FUNCTION_DECL for a function definition.
12883 DECLSPECS and DECLARATOR are the parts of the declaration;
12884 they describe the function's name and the type it returns,
12885 but twisted together in a fashion that parallels the syntax of C.
12887 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12888 DECLARATOR is really the DECL for the function we are about to
12889 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12890 indicating that the function is an inline defined in-class, and
12891 SF_EXPAND indicating that we should generate RTL for this
12894 This function creates a binding context for the function body
12895 as well as setting up the FUNCTION_DECL in current_function_decl.
12897 Returns 1 on success. If the DECLARATOR is not suitable for a function
12898 (it defines a datum instead), we return 0, which tells
12899 yyparse to report a parse error.
12901 For C++, we must first check whether that datum makes any sense.
12902 For example, "class A local_a(1,2);" means that variable local_a
12903 is an aggregate of type A, which should have a constructor
12904 applied to it with the argument list [1, 2]. */
12907 start_function (declspecs, declarator, attrs, flags)
12908 tree declspecs, declarator, attrs;
12912 tree ctype = NULL_TREE;
12915 extern int have_extern_spec;
12916 extern int used_extern_spec;
12917 int doing_friend = 0;
12918 struct binding_level *bl;
12920 /* Sanity check. */
12921 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
12922 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
12924 /* This should only be done once on the top most decl. */
12925 if (have_extern_spec && !used_extern_spec)
12927 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
12928 used_extern_spec = 1;
12931 if (flags & SF_PRE_PARSED)
12933 decl1 = declarator;
12935 fntype = TREE_TYPE (decl1);
12936 if (TREE_CODE (fntype) == METHOD_TYPE)
12937 ctype = TYPE_METHOD_BASETYPE (fntype);
12939 /* ANSI C++ June 5 1992 WP 11.4.5. A friend function defined in a
12940 class is in the (lexical) scope of the class in which it is
12942 if (!ctype && DECL_FRIEND_P (decl1))
12944 ctype = DECL_CLASS_CONTEXT (decl1);
12946 /* CTYPE could be null here if we're dealing with a template;
12947 for example, `inline friend float foo()' inside a template
12948 will have no CTYPE set. */
12949 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12955 last_function_parms = DECL_ARGUMENTS (decl1);
12956 last_function_parm_tags = NULL_TREE;
12960 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
12961 /* If the declarator is not suitable for a function definition,
12962 cause a syntax error. */
12963 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
12965 fntype = TREE_TYPE (decl1);
12967 restype = TREE_TYPE (fntype);
12968 if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
12970 cp_error ("semicolon missing after declaration of `%#T'", restype);
12971 shadow_tag (build_tree_list (NULL_TREE, restype));
12972 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
12973 if (TREE_CODE (fntype) == FUNCTION_TYPE)
12974 fntype = build_function_type (integer_type_node,
12975 TYPE_ARG_TYPES (fntype));
12977 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
12979 TYPE_ARG_TYPES (fntype));
12980 TREE_TYPE (decl1) = fntype;
12983 if (TREE_CODE (fntype) == METHOD_TYPE)
12984 ctype = TYPE_METHOD_BASETYPE (fntype);
12985 else if (DECL_MAIN_P (decl1))
12987 /* If this doesn't return integer_type, complain. */
12988 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
12990 if (pedantic || warn_return_type)
12991 pedwarn ("return type for `main' changed to `int'");
12992 TREE_TYPE (decl1) = fntype = default_function_type;
12997 /* Sometimes we don't notice that a function is a static member, and
12998 build a METHOD_TYPE for it. Fix that up now. */
12999 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13000 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13002 revert_static_member_fn (&decl1, NULL, NULL);
13003 last_function_parms = TREE_CHAIN (last_function_parms);
13007 /* Warn if function was previously implicitly declared
13008 (but not if we warned then). */
13009 if (! warn_implicit
13010 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13011 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13013 /* Set up current_class_type, and enter the scope of the class, if
13016 push_nested_class (ctype, 1);
13017 else if (DECL_STATIC_FUNCTION_P (decl1))
13018 push_nested_class (DECL_CONTEXT (decl1), 2);
13020 /* Now that we have entered the scope of the class, we must restore
13021 the bindings for any template parameters surrounding DECL1, if it
13022 is an inline member template. (Order is important; consider the
13023 case where a template parameter has the same name as a field of
13024 the class.) It is not until after this point that
13025 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13026 if (flags & SF_INCLASS_INLINE)
13027 maybe_begin_member_template_processing (decl1);
13029 /* Effective C++ rule 15. See also c_expand_return. */
13031 && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13032 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13033 cp_warning ("`operator=' should return a reference to `*this'");
13035 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13036 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13037 if (!DECL_INITIAL (decl1))
13038 DECL_INITIAL (decl1) = error_mark_node;
13040 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13041 SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13044 /* This function exists in static storage.
13045 (This does not mean `static' in the C sense!) */
13046 TREE_STATIC (decl1) = 1;
13048 /* We must call push_template_decl after current_class_type is set
13049 up. (If we are processing inline definitions after exiting a
13050 class scope, current_class_type will be NULL_TREE until set above
13051 by push_nested_class.) */
13052 if (processing_template_decl)
13053 decl1 = push_template_decl (decl1);
13055 /* We are now in the scope of the function being defined. */
13056 current_function_decl = decl1;
13058 /* Save the parm names or decls from this function's declarator
13059 where store_parm_decls will find them. */
13060 current_function_parms = last_function_parms;
13061 current_function_parm_tags = last_function_parm_tags;
13063 /* Make sure the parameter and return types are reasonable. When
13064 you declare a function, these types can be incomplete, but they
13065 must be complete when you define the function. */
13066 if (! processing_template_decl)
13067 check_function_type (decl1);
13069 /* Build the return declaration for the function. */
13070 restype = TREE_TYPE (fntype);
13071 if (!processing_template_decl)
13073 if (!DECL_RESULT (decl1))
13075 DECL_RESULT (decl1)
13076 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13077 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13078 DECL_RESULT (decl1));
13082 /* Just use `void'. Nobody will ever look at this anyhow. */
13083 DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13085 /* Initialize RTL machinery. We cannot do this until
13086 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13087 even when processing a template; this is how we get
13088 CFUN set up, and our per-function variables initialized. */
13089 bl = current_binding_level;
13090 init_function_start (decl1, input_filename, lineno);
13091 current_binding_level = bl;
13092 expanding_p = (flags & SF_EXPAND) != 0;
13094 /* Even though we're inside a function body, we still don't want to
13095 call expand_expr to calculate the size of a variable-sized array.
13096 We haven't necessarily assigned RTL to all variables yet, so it's
13097 not safe to try to expand expressions involving them. */
13098 immediate_size_expand = 0;
13099 cfun->x_dont_save_pending_sizes_p = 1;
13101 /* If we're building a statement-tree, start the tree now. */
13102 if (processing_template_decl || !expanding_p)
13103 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13105 /* Let the user know we're compiling this function. */
13106 if (processing_template_decl || !building_stmt_tree ())
13107 announce_function (decl1);
13109 /* Record the decl so that the function name is defined.
13110 If we already have a decl for this name, and it is a FUNCTION_DECL,
13111 use the old decl. */
13112 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13114 /* A specialization is not used to guide overload resolution. */
13115 if ((flag_guiding_decls
13116 || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13117 && ! DECL_FUNCTION_MEMBER_P (decl1))
13118 decl1 = pushdecl (decl1);
13121 /* We need to set the DECL_CONTEXT. */
13122 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13123 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13124 /* And make sure we have enough default args. */
13125 check_default_args (decl1);
13127 DECL_MAIN_VARIANT (decl1) = decl1;
13128 fntype = TREE_TYPE (decl1);
13131 /* Reset these in case the call to pushdecl changed them. */
13132 current_function_decl = decl1;
13133 cfun->decl = decl1;
13135 /* Initialize the per-function data. */
13136 if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13138 /* If we already parsed this function, and we're just expanding it
13139 now, restore saved state. */
13140 struct binding_level *bl = current_binding_level;
13141 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13142 current_binding_level = bl;
13144 /* This function is being processed in whole-function mode; we
13145 already did semantic analysis. */
13146 cfun->x_whole_function_mode_p = 1;
13148 /* If we decided that we didn't want to inline this function,
13149 make sure the back-end knows that. */
13150 if (!current_function_cannot_inline)
13151 current_function_cannot_inline = cp_function_chain->cannot_inline;
13153 /* We don't need the saved data anymore. */
13154 free (DECL_SAVED_FUNCTION_DATA (decl1));
13155 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13157 else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13159 /* We know that this was set up by `grokclassfn'. We do not
13160 wait until `store_parm_decls', since evil parse errors may
13161 never get us to that point. Here we keep the consistency
13162 between `current_class_type' and `current_class_ptr'. */
13163 tree t = DECL_ARGUMENTS (decl1);
13165 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13167 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13170 cp_function_chain->x_current_class_ref
13171 = build_indirect_ref (t, NULL_PTR);
13172 cp_function_chain->x_current_class_ptr = t;
13174 /* Constructors and destructors need to know whether they're "in
13175 charge" of initializing virtual base classes. */
13176 if (DECL_DESTRUCTOR_P (decl1))
13177 current_in_charge_parm = TREE_CHAIN (t);
13178 else if (DECL_CONSTRUCTOR_P (decl1)
13180 && DECL_ARTIFICIAL (TREE_CHAIN (t))
13181 && (DECL_NAME (TREE_CHAIN (t))
13182 == in_charge_identifier))
13183 current_in_charge_parm = TREE_CHAIN (t);
13186 if (DECL_INTERFACE_KNOWN (decl1))
13188 tree ctx = hack_decl_function_context (decl1);
13190 if (DECL_NOT_REALLY_EXTERN (decl1))
13191 DECL_EXTERNAL (decl1) = 0;
13193 if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13194 && TREE_PUBLIC (ctx))
13195 /* This is a function in a local class in an extern inline
13197 comdat_linkage (decl1);
13199 /* If this function belongs to an interface, it is public.
13200 If it belongs to someone else's interface, it is also external.
13201 This only affects inlines and template instantiations. */
13202 else if (interface_unknown == 0
13203 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13204 || flag_alt_external_templates))
13206 if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13207 || processing_template_decl)
13209 DECL_EXTERNAL (decl1)
13211 || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13212 && !DECL_VINDEX (decl1)));
13214 /* For WIN32 we also want to put these in linkonce sections. */
13215 maybe_make_one_only (decl1);
13218 DECL_EXTERNAL (decl1) = 0;
13219 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13220 DECL_INTERFACE_KNOWN (decl1) = 1;
13222 else if (interface_unknown && interface_only
13223 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13224 || flag_alt_external_templates))
13226 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13227 interface, we will have interface_only set but not
13228 interface_known. In that case, we don't want to use the normal
13229 heuristics because someone will supply a #pragma implementation
13230 elsewhere, and deducing it here would produce a conflict. */
13231 comdat_linkage (decl1);
13232 DECL_EXTERNAL (decl1) = 0;
13233 DECL_INTERFACE_KNOWN (decl1) = 1;
13234 DECL_DEFER_OUTPUT (decl1) = 1;
13238 /* This is a definition, not a reference.
13239 So clear DECL_EXTERNAL. */
13240 DECL_EXTERNAL (decl1) = 0;
13242 if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13243 && ! DECL_INTERFACE_KNOWN (decl1)
13244 /* Don't try to defer nested functions for now. */
13245 && ! hack_decl_function_context (decl1))
13246 DECL_DEFER_OUTPUT (decl1) = 1;
13248 DECL_INTERFACE_KNOWN (decl1) = 1;
13251 if (doing_semantic_analysis_p ())
13254 current_binding_level->parm_flag = 1;
13258 cplus_decl_attributes (decl1, NULL_TREE, attrs);
13260 if (!building_stmt_tree ())
13262 GNU_xref_function (decl1, current_function_parms);
13263 make_function_rtl (decl1);
13266 /* Promote the value to int before returning it. */
13267 if (C_PROMOTING_INTEGER_TYPE_P (restype))
13268 restype = type_promotes_to (restype);
13270 /* If this fcn was already referenced via a block-scope `extern' decl
13271 (or an implicit decl), propagate certain information about the usage. */
13272 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13273 TREE_ADDRESSABLE (decl1) = 1;
13275 if (DECL_RESULT (decl1) == NULL_TREE)
13277 DECL_RESULT (decl1)
13278 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13279 TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13280 TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13285 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13286 && DECL_LANGUAGE (decl1) == lang_cplusplus)
13288 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13289 DECL_CONTEXT (dtor_label) = current_function_decl;
13291 else if (DECL_CONSTRUCTOR_P (decl1))
13293 ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13294 DECL_CONTEXT (ctor_label) = current_function_decl;
13300 /* Called after store_parm_decls for a function-try-block. */
13303 expand_start_early_try_stmts ()
13305 expand_start_try_stmts ();
13308 /* Store the parameter declarations into the current function declaration.
13309 This is called after parsing the parameter declarations, before
13310 digesting the body of the function.
13312 Also install to binding contour return value identifier, if any. */
13315 store_parm_decls ()
13317 register tree fndecl = current_function_decl;
13318 register tree parm;
13319 int parms_have_cleanups = 0;
13320 tree cleanups = NULL_TREE;
13322 /* This is a list of types declared among parms in a prototype. */
13323 tree parmtags = current_function_parm_tags;
13325 /* This is a chain of any other decls that came in among the parm
13326 declarations. If a parm is declared with enum {foo, bar} x;
13327 then CONST_DECLs for foo and bar are put here. */
13328 tree nonparms = NULL_TREE;
13330 /* Create a binding level for the parms. */
13331 if (!building_stmt_tree ())
13332 expand_start_bindings (2);
13334 if (current_function_parms)
13336 /* This case is when the function was defined with an ANSI prototype.
13337 The parms already have decls, so we need not do anything here
13338 except record them as in effect
13339 and complain if any redundant old-style parm decls were written. */
13341 tree specparms = current_function_parms;
13344 if (doing_semantic_analysis_p ())
13346 /* Must clear this because it might contain TYPE_DECLs declared
13348 storedecls (NULL_TREE);
13350 /* If we're doing semantic analysis, then we'll call pushdecl
13351 for each of these. We must do them in reverse order so that
13352 they end in the correct forward order. */
13353 specparms = nreverse (specparms);
13356 for (parm = specparms; parm; parm = next)
13358 next = TREE_CHAIN (parm);
13359 if (TREE_CODE (parm) == PARM_DECL)
13361 tree type = TREE_TYPE (parm);
13363 if (doing_semantic_analysis_p ())
13367 if (DECL_NAME (parm) == NULL_TREE
13368 || TREE_CODE (parm) != VOID_TYPE)
13371 cp_error ("parameter `%D' declared void", parm);
13373 cleanup = maybe_build_cleanup (parm);
13376 cleanups = tree_cons (parm, cleanup, cleanups);
13378 else if (type != error_mark_node
13379 && TYPE_NEEDS_DESTRUCTOR (type))
13380 parms_have_cleanups = 1;
13384 /* If we find an enum constant or a type tag,
13385 put it aside for the moment. */
13386 TREE_CHAIN (parm) = NULL_TREE;
13387 nonparms = chainon (nonparms, parm);
13391 if (doing_semantic_analysis_p ())
13393 /* Get the decls in their original chain order
13394 and record in the function. This is all and only the
13395 PARM_DECLs that were pushed into scope by the loop above. */
13396 DECL_ARGUMENTS (fndecl) = getdecls ();
13397 storetags (chainon (parmtags, gettags ()));
13401 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13403 /* Now store the final chain of decls for the arguments
13404 as the decl-chain of the current lexical scope.
13405 Put the enumerators in as well, at the front so that
13406 DECL_ARGUMENTS is not modified. */
13407 if (doing_semantic_analysis_p ())
13408 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13410 /* Initialize the RTL code for the function. */
13411 DECL_SAVED_INSNS (fndecl) = 0;
13412 if (! building_stmt_tree ())
13413 expand_function_start (fndecl, parms_have_cleanups);
13415 current_function_parms_stored = 1;
13417 /* If this function is `main', emit a call to `__main'
13418 to run global initializers, etc. */
13419 if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13420 expand_main_function ();
13422 /* Now that we have initialized the parms, we can start their
13423 cleanups. We cannot do this before, since expand_decl_cleanup
13424 should not be called before the parm can be used. */
13427 finish_decl_cleanup (TREE_PURPOSE (cleanups),
13428 TREE_VALUE (cleanups));
13429 cleanups = TREE_CHAIN (cleanups);
13432 /* Create a binding contour which can be used to catch
13433 cleanup-generated temporaries. Also, if the return value needs or
13434 has initialization, deal with that now. */
13435 if (parms_have_cleanups)
13438 if (!building_stmt_tree ())
13439 expand_start_bindings (2);
13442 /* Do the starting of the exception specifications, if we have any. */
13443 if (flag_exceptions && !processing_template_decl
13444 && building_stmt_tree ()
13445 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13446 current_eh_spec_try_block = expand_start_eh_spec ();
13449 /* Bind a name and initialization to the return value of
13450 the current function. */
13453 store_return_init (decl)
13456 /* If this named return value comes in a register, put it in a
13457 pseudo-register. */
13458 if (DECL_REGISTER (decl))
13460 original_result_rtx = DECL_RTL (decl);
13461 /* Note that the mode of the old DECL_RTL may be wider than the
13462 mode of DECL_RESULT, depending on the calling conventions for
13463 the processor. For example, on the Alpha, a 32-bit integer
13464 is returned in a DImode register -- the DECL_RESULT has
13465 SImode but the DECL_RTL for the DECL_RESULT has DImode. So,
13466 here, we use the mode the back-end has already assigned for
13467 the return value. */
13468 DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13473 /* We have finished doing semantic analysis on DECL, but have not yet
13474 generated RTL for its body. Save away our current state, so that
13475 when we want to generate RTL later we know what to do. */
13478 save_function_data (decl)
13481 struct language_function *f;
13483 /* Save the language-specific per-function data so that we can
13484 get it back when we really expand this function. */
13485 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13489 f = ((struct language_function *)
13490 xmalloc (sizeof (struct language_function)));
13491 bcopy ((char *) cp_function_chain, (char *) f,
13492 sizeof (struct language_function));
13493 DECL_SAVED_FUNCTION_DATA (decl) = f;
13495 /* Clear out the bits we don't need. */
13496 f->x_base_init_list = NULL_TREE;
13497 f->x_member_init_list = NULL_TREE;
13498 f->x_stmt_tree.x_last_stmt = NULL_TREE;
13499 f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13500 f->x_result_rtx = NULL_RTX;
13501 f->x_named_label_uses = NULL;
13502 f->bindings = NULL;
13504 /* When we get back here again, we will be expanding. */
13505 f->x_expanding_p = 1;
13507 /* If we've already decided that we cannot inline this function, we
13508 must remember that fact when we actually go to expand the
13510 f->cannot_inline = current_function_cannot_inline;
13513 /* At the end of every constructor we generate to code to return
13514 `this'. Do that now. */
13517 finish_constructor_body ()
13519 /* Any return from a constructor will end up here. */
13520 add_tree (build_min_nt (LABEL_STMT, ctor_label));
13522 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13523 generate the return, rather than a goto to CTOR_LABEL. */
13524 ctor_label = NULL_TREE;
13525 /* In check_return_expr we translate an empty return from a
13526 constructor to a return of `this'. */
13527 finish_return_stmt (NULL_TREE);
13528 /* Mark the end of the constructor. */
13529 add_tree (build_min_nt (CTOR_STMT));
13532 /* At the end of every destructor we generate code to restore virtual
13533 function tables to the values desired by base classes and to call
13534 to base class destructors. Do that now. */
13537 finish_destructor_body ()
13539 tree compound_stmt;
13544 /* Create a block to contain all the extra code. */
13545 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13547 /* Any return from a destructor will end up here. */
13548 add_tree (build_min_nt (LABEL_STMT, dtor_label));
13550 /* Generate the code to call destructor on base class. If this
13551 destructor belongs to a class with virtual functions, then set
13552 the virtual function table pointer to represent the type of our
13555 /* This side-effect makes call to `build_delete' generate the code
13556 we have to have at the end of this destructor. `build_delete'
13557 will set the flag again. */
13558 TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13560 /* These are two cases where we cannot delegate deletion. */
13561 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)
13562 || TYPE_GETS_REG_DELETE (current_class_type))
13563 in_charge = integer_zero_node;
13565 in_charge = current_in_charge_parm;
13567 exprstmt = build_delete (current_class_type,
13570 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13573 if (exprstmt != error_mark_node
13574 && (TREE_CODE (exprstmt) != NOP_EXPR
13575 || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13576 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13578 if (exprstmt != void_zero_node)
13579 /* Don't call `expand_expr_stmt' if we're not going to do
13580 anything, since -Wall will give a diagnostic. */
13581 finish_expr_stmt (exprstmt);
13583 /* Run destructors for all virtual baseclasses. */
13584 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13586 tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13587 tree if_stmt = begin_if_stmt ();
13588 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13589 current_in_charge_parm,
13595 if (TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (vbases)))
13597 tree vb = get_vbase
13598 (BINFO_TYPE (vbases),
13599 TYPE_BINFO (current_class_type));
13601 (build_scoped_method_call
13602 (current_class_ref, vb, dtor_identifier,
13603 build_tree_list (NULL_TREE, integer_zero_node)));
13605 vbases = TREE_CHAIN (vbases);
13608 finish_then_clause (if_stmt);
13613 virtual_size = c_sizeof (current_class_type);
13615 /* At the end, call delete if that's what's requested. */
13617 /* FDIS sez: At the point of definition of a virtual destructor
13618 (including an implicit definition), non-placement operator delete
13619 shall be looked up in the scope of the destructor's class and if
13620 found shall be accessible and unambiguous.
13622 This is somewhat unclear, but I take it to mean that if the class
13623 only defines placement deletes we don't do anything here. So we
13624 pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13625 they ever try to delete one of these. */
13626 if (TYPE_GETS_REG_DELETE (current_class_type)
13627 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13631 exprstmt = build_op_delete_call
13632 (DELETE_EXPR, current_class_ptr, virtual_size,
13633 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13635 if_stmt = begin_if_stmt ();
13636 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13637 current_in_charge_parm,
13640 finish_expr_stmt (exprstmt);
13641 finish_then_clause (if_stmt);
13645 /* Close the block we started above. */
13646 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13649 /* Finish up a function declaration and compile that function
13650 all the way to assembler language output. The free the storage
13651 for the function definition.
13653 This is called after parsing the body of the function definition.
13654 LINENO is the current line number.
13656 FLAGS is a bitwise or of the following values:
13658 An extra call to poplevel (and expand_end_bindings) must be
13659 made to take care of the binding contour for the base
13660 initializers. This is only relevant for constructors.
13662 We just finished processing the body of an in-class inline
13663 function definition. (This processing will have taken place
13664 after the class definition is complete.) */
13667 finish_function (lineno, flags)
13671 register tree fndecl = current_function_decl;
13672 tree fntype, ctype = NULL_TREE;
13673 /* Label to use if this function is supposed to return a value. */
13674 tree no_return_label = NULL_TREE;
13675 int call_poplevel = (flags & 1) != 0;
13676 int inclass_inline = (flags & 2) != 0;
13680 /* When we get some parse errors, we can end up without a
13681 current_function_decl, so cope. */
13682 if (fndecl == NULL_TREE)
13683 return error_mark_node;
13685 nested = function_depth > 1;
13686 fntype = TREE_TYPE (fndecl);
13688 /* TREE_READONLY (fndecl) = 1;
13689 This caused &foo to be of type ptr-to-const-function
13690 which then got a warning when stored in a ptr-to-function variable. */
13692 /* This happens on strange parse errors. */
13693 if (! current_function_parms_stored)
13696 store_parm_decls ();
13699 if (building_stmt_tree ())
13701 if (DECL_CONSTRUCTOR_P (fndecl))
13703 finish_constructor_body ();
13707 else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13708 finish_destructor_body ();
13709 else if (DECL_MAIN_P (fndecl))
13711 /* Make it so that `main' always returns 0 by default. */
13713 finish_return_stmt (integer_one_node);
13715 finish_return_stmt (integer_zero_node);
13719 /* Finish dealing with exception specifiers. */
13720 if (flag_exceptions && !processing_template_decl
13721 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13722 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13723 (TREE_TYPE (current_function_decl)),
13724 current_eh_spec_try_block);
13729 if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
13731 /* Keep this code around in case we later want to control debug info
13732 based on whether a type is "used". (jason 1999-11-11) */
13734 tree ttype = target_type (fntype);
13737 if (IS_AGGR_TYPE (ttype))
13738 /* Let debugger know it should output info for this type. */
13739 note_debug_info_needed (ttype);
13741 for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
13743 ttype = target_type (TREE_TYPE (parmdecl));
13744 if (IS_AGGR_TYPE (ttype))
13745 /* Let debugger know it should output info for this type. */
13746 note_debug_info_needed (ttype);
13751 /* Clean house because we will need to reorder insns here. */
13752 do_pending_stack_adjust ();
13756 else if (DECL_CONSTRUCTOR_P (fndecl))
13761 else if (return_label != NULL_RTX
13762 && flag_this_is_variable <= 0
13763 && current_function_return_value == NULL_TREE
13764 && ! DECL_NAME (DECL_RESULT (current_function_decl)))
13765 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13767 if (flag_exceptions)
13768 expand_exception_blocks ();
13770 /* If this function is supposed to return a value, ensure that
13771 we do not fall into the cleanups by mistake. The end of our
13772 function will look like this:
13774 user code (may have return stmt somewhere)
13775 goto no_return_label
13780 NOTE_INSN_FUNCTION_END
13784 If the user omits a return stmt in the USER CODE section, we
13785 will have a control path which reaches NOTE_INSN_FUNCTION_END.
13786 Otherwise, we won't. */
13787 if (no_return_label)
13789 DECL_CONTEXT (no_return_label) = fndecl;
13790 DECL_INITIAL (no_return_label) = error_mark_node;
13791 DECL_SOURCE_FILE (no_return_label) = input_filename;
13792 DECL_SOURCE_LINE (no_return_label) = lineno;
13793 expand_goto (no_return_label);
13798 /* Remove the binding contour which is used
13799 to catch cleanup-generated temporaries. */
13800 expand_end_bindings (0, 0, 0);
13801 poplevel (0, 0, 0);
13803 /* Emit label at beginning of cleanup code for parameters. */
13804 emit_label (cleanup_label);
13807 /* Get return value into register if that's where it's supposed
13809 if (original_result_rtx)
13810 fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
13812 /* Finish building code that will trigger warnings if users forget
13813 to make their functions return values. */
13814 if (no_return_label || cleanup_label)
13815 emit_jump (return_label);
13816 if (no_return_label)
13818 /* We don't need to call `expand_*_return' here because we
13819 don't need any cleanups here--this path of code is only
13820 for error checking purposes. */
13821 expand_label (no_return_label);
13824 /* We hard-wired immediate_size_expand to zero in
13825 start_function. Expand_function_end will decrement this
13826 variable. So, we set the variable to one here, so that after
13827 the decrement it will remain zero. */
13828 immediate_size_expand = 1;
13830 /* Generate rtl for function exit. */
13831 expand_function_end (input_filename, lineno, 1);
13834 /* We have to save this value here in case
13835 maybe_end_member_template_processing decides to pop all the
13836 template parameters. */
13837 expand_p = !building_stmt_tree ();
13839 /* If we're saving up tree structure, tie off the function now. */
13841 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
13843 /* This must come after expand_function_end because cleanups might
13844 have declarations (from inline functions) that need to go into
13845 this function's blocks. */
13846 if (doing_semantic_analysis_p ())
13848 if (current_binding_level->parm_flag != 1)
13849 my_friendly_abort (122);
13850 poplevel (1, 0, 1);
13853 /* Remember that we were in class scope. */
13854 if (current_class_name)
13855 ctype = current_class_type;
13857 /* Must mark the RESULT_DECL as being in this function. */
13858 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13860 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13861 to the FUNCTION_DECL node itself. */
13862 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13864 /* Save away current state, if appropriate. */
13865 if (!expanding_p && !processing_template_decl)
13866 save_function_data (fndecl);
13868 /* If this function calls `setjmp' it cannot be inlined. When
13869 `longjmp' is called it is not guaranteed to restore the value of
13870 local variables that have been modified since the call to
13871 `setjmp'. So, if were to inline this function into some caller
13872 `c', then when we `longjmp', we might not restore all variables
13873 in `c'. (It might seem, at first blush, that there's no way for
13874 this function to modify local variables in `c', but their
13875 addresses may have been stored somewhere accessible to this
13877 if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
13878 DECL_UNINLINABLE (fndecl) = 1;
13884 int saved_flag_keep_inline_functions =
13885 flag_keep_inline_functions;
13887 /* So we can tell if jump_optimize sets it to 1. */
13890 if (DECL_CONTEXT (fndecl) != NULL_TREE
13891 && hack_decl_function_context (fndecl))
13892 /* Trick rest_of_compilation into not deferring output of this
13893 function, even if it is inline, since the rtl_obstack for
13894 this function is the function_obstack of the enclosing
13895 function and will be deallocated when the enclosing
13896 function is gone. See save_tree_status. */
13897 flag_keep_inline_functions = 1;
13899 /* Before we call rest_of_compilation (which will pop the
13900 CURRENT_FUNCTION), we must save these values. */
13901 returns_null = current_function_returns_null;
13902 returns_value = current_function_returns_value;
13904 /* If this is a nested function (like a template instantiation
13905 that we're compiling in the midst of compiling something
13906 else), push a new GC context. That will keep local variables
13907 on the stack from being collected while we're doing the
13908 compilation of this function. */
13909 if (function_depth > 1)
13910 ggc_push_context ();
13912 /* Run the optimizers and output the assembler code for this
13914 if (DECL_ARTIFICIAL (fndecl))
13916 /* Do we really *want* to inline this synthesized method? */
13918 int save_fif = flag_inline_functions;
13919 flag_inline_functions = 1;
13921 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
13922 will check our size. */
13923 DECL_INLINE (fndecl) = 0;
13925 rest_of_compilation (fndecl);
13926 flag_inline_functions = save_fif;
13929 rest_of_compilation (fndecl);
13931 /* Undo the call to ggc_push_context above. */
13932 if (function_depth > 1)
13933 ggc_pop_context ();
13935 flag_keep_inline_functions = saved_flag_keep_inline_functions;
13937 if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
13939 /* Set DECL_EXTERNAL so that assemble_external will be called as
13940 necessary. We'll clear it again in finish_file. */
13941 if (! DECL_EXTERNAL (fndecl))
13942 DECL_NOT_REALLY_EXTERN (fndecl) = 1;
13943 DECL_EXTERNAL (fndecl) = 1;
13944 mark_inline_for_output (fndecl);
13948 /* Keep this code around in case we later want to control debug info
13949 based on whether a type is "used". (jason 1999-11-11) */
13951 if (ctype && TREE_ASM_WRITTEN (fndecl))
13952 note_debug_info_needed (ctype);
13955 returns_null |= can_reach_end;
13957 /* Since we don't normally go through c_expand_return for constructors,
13958 this normally gets the wrong value.
13959 Also, named return values have their return codes emitted after
13960 NOTE_INSN_FUNCTION_END, confusing jump.c. */
13961 if (DECL_CONSTRUCTOR_P (fndecl)
13962 || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
13965 if (TREE_THIS_VOLATILE (fndecl) && returns_null)
13966 cp_warning ("`noreturn' function `%D' does return", fndecl);
13967 else if ((warn_return_type || pedantic)
13969 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
13971 /* If this function returns non-void and control can drop through,
13973 cp_warning ("control reaches end of non-void function `%D'", fndecl);
13975 /* With just -W, complain only if function returns both with
13976 and without a value. */
13977 else if (extra_warnings && returns_value && returns_null)
13978 warning ("this function may return with or without a value");
13982 /* Clear out memory we no longer need. */
13983 free_after_parsing (cfun);
13984 /* Since we never call rest_of_compilation, we never clear
13985 CFUN. Do so explicitly. */
13986 free_after_compilation (cfun);
13990 /* If this is a in-class inline definition, we may have to pop the
13991 bindings for the template parameters that we added in
13992 maybe_begin_member_template_processing when start_function was
13994 if (inclass_inline)
13995 maybe_end_member_template_processing ();
13997 /* Leave the scope of the class. */
13999 pop_nested_class ();
14003 if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14004 && !(flag_inline_trees && DECL_INLINE (fndecl)))
14008 /* Stop pointing to the local nodes about to be freed. */
14009 /* But DECL_INITIAL must remain nonzero so we know this
14010 was an actual function definition. */
14011 DECL_INITIAL (fndecl) = error_mark_node;
14012 for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14013 DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14016 if (DECL_STATIC_CONSTRUCTOR (fndecl))
14017 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14018 if (DECL_STATIC_DESTRUCTOR (fndecl))
14019 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14024 /* Let the error reporting routines know that we're outside a
14025 function. For a nested function, this value is used in
14026 pop_cp_function_context and then reset via pop_function_context. */
14027 current_function_decl = NULL_TREE;
14028 /* We don't really care about obstacks, but the middle-end
14029 sometimes cares on what obstck things are located. */
14030 permanent_allocation (1);
14036 /* Create the FUNCTION_DECL for a function definition.
14037 DECLSPECS and DECLARATOR are the parts of the declaration;
14038 they describe the return type and the name of the function,
14039 but twisted together in a fashion that parallels the syntax of C.
14041 This function creates a binding context for the function body
14042 as well as setting up the FUNCTION_DECL in current_function_decl.
14044 Returns a FUNCTION_DECL on success.
14046 If the DECLARATOR is not suitable for a function (it defines a datum
14047 instead), we return 0, which tells yyparse to report a parse error.
14049 May return void_type_node indicating that this method is actually
14050 a friend. See grokfield for more details.
14052 Came here with a `.pushlevel' .
14054 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14055 CHANGES TO CODE IN `grokfield'. */
14058 start_method (declspecs, declarator, attrlist)
14059 tree declarator, declspecs, attrlist;
14061 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14064 /* Something too ugly to handle. */
14065 if (fndecl == NULL_TREE)
14068 /* Pass friends other than inline friend functions back. */
14069 if (fndecl == void_type_node)
14072 if (TREE_CODE (fndecl) != FUNCTION_DECL)
14073 /* Not a function, tell parser to report parse error. */
14076 if (DECL_IN_AGGR_P (fndecl))
14078 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14080 if (DECL_CONTEXT (fndecl)
14081 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14082 cp_error ("`%D' is already defined in class %s", fndecl,
14083 TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14085 return void_type_node;
14088 check_template_shadow (fndecl);
14090 DECL_THIS_INLINE (fndecl) = 1;
14092 if (flag_default_inline)
14093 DECL_INLINE (fndecl) = 1;
14095 /* We process method specializations in finish_struct_1. */
14096 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14097 fndecl = push_template_decl (fndecl);
14099 /* We read in the parameters on the maybepermanent_obstack,
14100 but we won't be getting back to them until after we
14101 may have clobbered them. So the call to preserve_data
14102 will keep them safe. */
14105 if (! DECL_FRIEND_P (fndecl))
14107 if (TREE_CHAIN (fndecl))
14109 fndecl = copy_node (fndecl);
14110 TREE_CHAIN (fndecl) = NULL_TREE;
14113 if (DECL_CONSTRUCTOR_P (fndecl))
14115 if (! grok_ctor_properties (current_class_type, fndecl))
14116 return void_type_node;
14118 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14119 grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14122 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14124 /* Make a place for the parms */
14126 current_binding_level->parm_flag = 1;
14128 DECL_IN_AGGR_P (fndecl) = 1;
14132 /* Go through the motions of finishing a function definition.
14133 We don't compile this method until after the whole class has
14136 FINISH_METHOD must return something that looks as though it
14137 came from GROKFIELD (since we are defining a method, after all).
14139 This is called after parsing the body of the function definition.
14140 STMTS is the chain of statements that makes up the function body.
14142 DECL is the ..._DECL that `start_method' provided. */
14145 finish_method (decl)
14148 register tree fndecl = decl;
14151 register tree link;
14153 if (decl == void_type_node)
14156 old_initial = DECL_INITIAL (fndecl);
14158 /* Undo the level for the parms (from start_method).
14159 This is like poplevel, but it causes nothing to be
14160 saved. Saving information here confuses symbol-table
14161 output routines. Besides, this information will
14162 be correctly output when this method is actually
14165 /* Clear out the meanings of the local variables of this level;
14166 also record in each decl which block it belongs to. */
14168 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14170 if (DECL_NAME (link) != NULL_TREE)
14171 pop_binding (DECL_NAME (link), link);
14172 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14173 DECL_CONTEXT (link) = NULL_TREE;
14176 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14177 (HOST_WIDE_INT) current_binding_level->level_chain,
14178 current_binding_level->parm_flag,
14179 current_binding_level->keep);
14181 poplevel (0, 0, 0);
14183 DECL_INITIAL (fndecl) = old_initial;
14185 /* We used to check if the context of FNDECL was different from
14186 current_class_type as another way to get inside here. This didn't work
14187 for String.cc in libg++. */
14188 if (DECL_FRIEND_P (fndecl))
14190 CLASSTYPE_INLINE_FRIENDS (current_class_type)
14191 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14192 decl = void_type_node;
14198 /* Called when a new struct TYPE is defined.
14199 If this structure or union completes the type of any previous
14200 variable declaration, lay it out and output its rtl. */
14203 hack_incomplete_structures (type)
14208 if (current_binding_level->incomplete == NULL_TREE)
14211 if (!type) /* Don't do this for class templates. */
14214 for (list = ¤t_binding_level->incomplete; *list; )
14216 tree decl = TREE_VALUE (*list);
14217 if ((decl && TREE_TYPE (decl) == type)
14218 || (TREE_TYPE (decl)
14219 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14220 && TREE_TYPE (TREE_TYPE (decl)) == type))
14222 int toplevel = toplevel_bindings_p ();
14223 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14224 && TREE_TYPE (TREE_TYPE (decl)) == type)
14225 layout_type (TREE_TYPE (decl));
14226 layout_decl (decl, 0);
14227 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14231 expand_decl (decl);
14232 cleanup = maybe_build_cleanup (decl);
14233 expand_decl_init (decl);
14234 if (! expand_decl_cleanup (decl, cleanup))
14235 cp_error ("parser lost in parsing declaration of `%D'",
14238 *list = TREE_CHAIN (*list);
14241 list = &TREE_CHAIN (*list);
14245 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14246 See build_delete for information about AUTO_DELETE.
14248 Don't build these on the momentary obstack; they must live
14249 the life of the binding contour. */
14252 maybe_build_cleanup_1 (decl, auto_delete)
14253 tree decl, auto_delete;
14255 tree type = TREE_TYPE (decl);
14256 if (type != error_mark_node && TYPE_NEEDS_DESTRUCTOR (type))
14258 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14261 if (TREE_CODE (type) == ARRAY_TYPE)
14265 mark_addressable (decl);
14266 rval = build_unary_op (ADDR_EXPR, decl, 0);
14269 /* Optimize for space over speed here. */
14270 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14271 || flag_expensive_optimizations)
14272 flags |= LOOKUP_NONVIRTUAL;
14274 rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14276 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14277 && ! TYPE_HAS_DESTRUCTOR (type))
14278 rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14279 build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14286 /* If DECL is of a type which needs a cleanup, build that cleanup
14287 here. The cleanup does free the storage with a call to delete. */
14290 maybe_build_cleanup_and_delete (decl)
14293 return maybe_build_cleanup_1 (decl, integer_three_node);
14296 /* If DECL is of a type which needs a cleanup, build that cleanup
14297 here. The cleanup does not free the storage with a call a delete. */
14300 maybe_build_cleanup (decl)
14303 return maybe_build_cleanup_1 (decl, integer_two_node);
14306 /* Expand a C++ expression at the statement level.
14307 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14308 The C++ type checker should get all of these out when
14309 expressions are combined with other, type-providing, expressions,
14310 leaving only orphan expressions, such as:
14312 &class::bar; / / takes its address, but does nothing with it. */
14315 cplus_expand_expr_stmt (exp)
14318 if (stmts_are_full_exprs_p)
14319 exp = convert_to_void (exp, "statement");
14322 /* We should do this eventually, but right now this causes regex.o from
14323 libg++ to miscompile, and tString to core dump. */
14324 exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14327 /* If we don't do this, we end up down inside expand_expr
14328 trying to do TYPE_MODE on the ERROR_MARK, and really
14329 go outside the bounds of the type. */
14330 if (exp != error_mark_node)
14331 expand_expr_stmt (exp);
14334 /* When a stmt has been parsed, this function is called. */
14339 /* Always assume this statement was not an expression statement. If
14340 it actually was an expression statement, its our callers
14341 responsibility to fix this up. */
14342 last_expr_type = NULL_TREE;
14345 /* Change a static member function definition into a FUNCTION_TYPE, instead
14346 of the METHOD_TYPE that we create when it's originally parsed.
14348 WARNING: DO NOT pass &TREE_TYPE (decl) to FN or &TYPE_ARG_TYPES
14349 (TREE_TYPE (decl)) to ARGTYPES, as doing so will corrupt the types of
14350 other decls. Either pass the addresses of local variables or NULL. */
14353 revert_static_member_fn (decl, fn, argtypes)
14354 tree *decl, *fn, *argtypes;
14357 tree function = fn ? *fn : TREE_TYPE (*decl);
14358 tree args = argtypes ? *argtypes : TYPE_ARG_TYPES (function);
14360 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14361 != TYPE_UNQUALIFIED)
14362 cp_error ("static member function `%#D' declared with type qualifiers",
14365 args = TREE_CHAIN (args);
14366 tmp = build_function_type (TREE_TYPE (function), args);
14367 tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14368 tmp = build_exception_variant (tmp,
14369 TYPE_RAISES_EXCEPTIONS (function));
14370 TREE_TYPE (*decl) = tmp;
14371 if (DECL_ARGUMENTS (*decl))
14372 DECL_ARGUMENTS (*decl) = TREE_CHAIN (DECL_ARGUMENTS (*decl));
14373 DECL_STATIC_FUNCTION_P (*decl) = 1;
14380 /* Initialize the variables used during compilation of a C++
14384 push_cp_function_context (f)
14385 struct function *f;
14387 struct language_function *p
14388 = ((struct language_function *)
14389 xcalloc (1, sizeof (struct language_function)));
14392 /* It takes an explicit call to expand_body to generate RTL for a
14396 /* Whenever we start a new function, we destroy temporaries in the
14398 stmts_are_full_exprs_p = 1;
14401 /* Free the language-specific parts of F, now that we've finished
14402 compiling the function. */
14405 pop_cp_function_context (f)
14406 struct function *f;
14409 free (f->language);
14413 /* Mark P for GC. */
14416 mark_lang_function (p)
14417 struct language_function *p;
14422 ggc_mark_tree (p->x_named_labels);
14423 ggc_mark_tree (p->x_ctor_label);
14424 ggc_mark_tree (p->x_dtor_label);
14425 ggc_mark_tree (p->x_base_init_list);
14426 ggc_mark_tree (p->x_member_init_list);
14427 ggc_mark_tree (p->x_current_class_ptr);
14428 ggc_mark_tree (p->x_current_class_ref);
14429 ggc_mark_tree (p->x_eh_spec_try_block);
14430 ggc_mark_tree (p->x_scope_stmt_stack);
14432 ggc_mark_rtx (p->x_result_rtx);
14434 mark_stmt_tree (&p->x_stmt_tree);
14435 mark_binding_level (&p->bindings);
14438 /* Mark the language-specific data in F for GC. */
14441 mark_cp_function_context (f)
14442 struct function *f;
14444 mark_lang_function (f->language);
14450 return function_depth != 0;
14455 lang_mark_false_label_stack (l)
14456 struct label_node *l;
14458 /* C++ doesn't use false_label_stack. It better be NULL. */
14459 my_friendly_assert (l == NULL, 19990904);
14466 enum tree_code code = TREE_CODE (t);
14467 if (code == IDENTIFIER_NODE)
14469 struct lang_identifier *li = (struct lang_identifier *) t;
14470 struct lang_id2 *li2 = li->x;
14471 ggc_mark_tree (li->namespace_bindings);
14472 ggc_mark_tree (li->bindings);
14473 ggc_mark_tree (li->class_value);
14474 ggc_mark_tree (li->class_template_info);
14478 ggc_mark_tree (li2->label_value);
14479 ggc_mark_tree (li2->implicit_decl);
14480 ggc_mark_tree (li2->error_locus);
14483 else if (code == CPLUS_BINDING)
14485 if (BINDING_HAS_LEVEL_P (t))
14486 mark_binding_level (&BINDING_LEVEL (t));
14488 ggc_mark_tree (BINDING_SCOPE (t));
14489 ggc_mark_tree (BINDING_VALUE (t));
14491 else if (code == OVERLOAD)
14492 ggc_mark_tree (OVL_FUNCTION (t));
14493 else if (code == TEMPLATE_PARM_INDEX)
14494 ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14495 else if (TREE_CODE_CLASS (code) == 'd')
14497 struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14502 if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14503 ggc_mark_tree (ld->decl_flags.u2.access);
14504 ggc_mark_tree (ld->decl_flags.context);
14505 if (TREE_CODE (t) != NAMESPACE_DECL)
14506 ggc_mark_tree (ld->decl_flags.u.template_info);
14508 mark_binding_level (&NAMESPACE_LEVEL (t));
14509 if (CAN_HAVE_FULL_LANG_DECL_P (t))
14511 ggc_mark_tree (ld->main_decl_variant);
14512 ggc_mark_tree (ld->befriending_classes);
14513 ggc_mark_tree (ld->saved_tree);
14514 if (TREE_CODE (t) == TYPE_DECL)
14515 ggc_mark_tree (ld->u.sorted_fields);
14516 else if (TREE_CODE (t) == FUNCTION_DECL
14517 && !DECL_PENDING_INLINE_P (t))
14518 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14522 else if (TREE_CODE_CLASS (code) == 't')
14524 struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14526 if (lt && !(TREE_CODE (t) == POINTER_TYPE
14527 && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14530 ggc_mark_tree (lt->vfields);
14531 ggc_mark_tree (lt->vbases);
14532 ggc_mark_tree (lt->tags);
14533 ggc_mark_tree (lt->search_slot);
14534 ggc_mark_tree (lt->size);
14535 ggc_mark_tree (lt->pure_virtuals);
14536 ggc_mark_tree (lt->friend_classes);
14537 ggc_mark_tree (lt->rtti);
14538 ggc_mark_tree (lt->methods);
14539 ggc_mark_tree (lt->template_info);
14540 ggc_mark_tree (lt->befriending_classes);
14543 /* In the case of pointer-to-member function types, the
14544 TYPE_LANG_SPECIFIC is really just a tree. */
14545 ggc_mark_tree ((tree) lt);