1 /* Process declarations and variables for C compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* Process declarations and symbol lookup for C front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
48 extern int current_class_depth;
50 extern tree static_ctors, static_dtors;
52 extern tree global_namespace;
54 extern int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree));
56 /* Use garbage collection. */
60 #ifndef WCHAR_UNSIGNED
61 #define WCHAR_UNSIGNED 0
64 #ifndef CHAR_TYPE_SIZE
65 #define CHAR_TYPE_SIZE BITS_PER_UNIT
68 #ifndef BOOL_TYPE_SIZE
69 #ifdef SLOW_BYTE_ACCESS
70 /* In the new ABI, `bool' has size and alignment `1', on all
72 #define BOOL_TYPE_SIZE \
73 ((SLOW_BYTE_ACCESS && !flag_new_abi) ? (POINTER_SIZE) : (CHAR_TYPE_SIZE))
75 #define BOOL_TYPE_SIZE CHAR_TYPE_SIZE
79 /* We let tm.h override the types used here, to handle trivial differences
80 such as the choice of unsigned int or long unsigned int for size_t.
81 When machines start needing nontrivial differences in the size type,
82 it would be best to do something here to figure out automatically
83 from other information what type to use. */
86 #define SIZE_TYPE "long unsigned int"
90 #define PTRDIFF_TYPE "long int"
94 #define WCHAR_TYPE "int"
97 static tree grokparms PARAMS ((tree, int));
98 static const char *redeclaration_error_message PARAMS ((tree, tree));
100 static void push_binding_level PARAMS ((struct binding_level *, int,
102 static void pop_binding_level PARAMS ((void));
103 static void suspend_binding_level PARAMS ((void));
104 static void resume_binding_level PARAMS ((struct binding_level *));
105 static struct binding_level *make_binding_level PARAMS ((void));
106 static void declare_namespace_level PARAMS ((void));
107 static void signal_catch PARAMS ((int)) ATTRIBUTE_NORETURN;
108 static void storedecls PARAMS ((tree));
109 static void require_complete_types_for_parms PARAMS ((tree));
110 static int ambi_op_p PARAMS ((tree));
111 static int unary_op_p PARAMS ((tree));
112 static tree store_bindings PARAMS ((tree, tree));
113 static tree lookup_tag_reverse PARAMS ((tree, tree));
114 static tree obscure_complex_init PARAMS ((tree, tree));
115 static tree maybe_build_cleanup_1 PARAMS ((tree, tree));
116 static tree lookup_name_real PARAMS ((tree, int, int, int));
117 static void warn_extern_redeclared_static PARAMS ((tree, tree));
118 static void grok_reference_init PARAMS ((tree, tree, tree));
119 static tree grokfndecl PARAMS ((tree, tree, tree, tree, int,
120 enum overload_flags, tree,
121 tree, int, int, int, int, int, int, tree));
122 static tree grokvardecl PARAMS ((tree, tree, RID_BIT_TYPE *, int, int, tree));
123 static tree lookup_tag PARAMS ((enum tree_code, tree,
124 struct binding_level *, int));
125 static void set_identifier_type_value_with_scope
126 PARAMS ((tree, tree, struct binding_level *));
127 static void record_builtin_type PARAMS ((enum rid, const char *, tree));
128 static void record_unknown_type PARAMS ((tree, const char *));
129 static tree build_library_fn_1 PARAMS ((tree, tree));
130 static int member_function_or_else PARAMS ((tree, tree, enum overload_flags));
131 static void bad_specifiers PARAMS ((tree, const char *, int, int, int, int,
133 static void lang_print_error_function PARAMS ((const char *));
134 static tree maybe_process_template_type_declaration PARAMS ((tree, int, struct binding_level*));
135 static void check_for_uninitialized_const_var PARAMS ((tree));
136 static unsigned long typename_hash PARAMS ((hash_table_key));
137 static boolean typename_compare PARAMS ((hash_table_key, hash_table_key));
138 static void push_binding PARAMS ((tree, tree, struct binding_level*));
139 static int add_binding PARAMS ((tree, tree));
140 static void pop_binding PARAMS ((tree, tree));
141 static tree local_variable_p_walkfn PARAMS ((tree *, int *, void *));
142 static tree find_binding PARAMS ((tree, tree));
143 static tree select_decl PARAMS ((tree, int));
144 static int lookup_flags PARAMS ((int, int));
145 static tree qualify_lookup PARAMS ((tree, int));
146 static tree record_builtin_java_type PARAMS ((const char *, int));
147 static const char *tag_name PARAMS ((enum tag_types code));
148 static void find_class_binding_level PARAMS ((void));
149 static struct binding_level *innermost_nonclass_level PARAMS ((void));
150 static void warn_about_implicit_typename_lookup PARAMS ((tree, tree));
151 static int walk_namespaces_r PARAMS ((tree, walk_namespaces_fn, void *));
152 static int walk_globals_r PARAMS ((tree, void *));
153 static void add_decl_to_level PARAMS ((tree, struct binding_level *));
154 static tree make_label_decl PARAMS ((tree, int));
155 static void pop_label PARAMS ((tree));
156 static void pop_labels PARAMS ((tree));
157 static void maybe_deduce_size_from_array_init PARAMS ((tree, tree));
158 static void layout_var_decl PARAMS ((tree));
159 static void maybe_commonize_var PARAMS ((tree));
160 static tree check_initializer PARAMS ((tree, tree));
161 static void make_rtl_for_nonlocal_decl PARAMS ((tree, tree, const char *));
162 static void push_cp_function_context PARAMS ((struct function *));
163 static void pop_cp_function_context PARAMS ((struct function *));
164 static void mark_binding_level PARAMS ((void *));
165 static void mark_cp_function_context PARAMS ((struct function *));
166 static void mark_saved_scope PARAMS ((void *));
167 static void mark_lang_function PARAMS ((struct language_function *));
168 static void mark_stmt_tree PARAMS ((struct stmt_tree *));
169 static void save_function_data PARAMS ((tree));
170 static void check_function_type PARAMS ((tree));
171 static void destroy_local_var PARAMS ((tree));
172 static void finish_constructor_body PARAMS ((void));
173 static void finish_destructor_body PARAMS ((void));
174 static tree create_array_type_for_decl PARAMS ((tree, tree, tree));
175 static tree get_atexit_node PARAMS ((void));
176 static tree get_dso_handle_node PARAMS ((void));
177 static tree start_cleanup_fn PARAMS ((void));
178 static void end_cleanup_fn PARAMS ((void));
179 static tree cp_make_fname_decl PARAMS ((tree, const char *, int));
180 static void initialize_predefined_identifiers PARAMS ((void));
181 static tree check_special_function_return_type
182 PARAMS ((special_function_kind, tree, tree, tree));
184 #if defined (DEBUG_CP_BINDING_LEVELS)
185 static void indent PARAMS ((void));
188 /* Erroneous argument lists can use this *IFF* they do not modify it. */
189 tree error_mark_list;
191 /* The following symbols are subsumed in the cp_global_trees array, and
192 listed here individually for documentation purposes.
195 tree wchar_decl_node;
198 tree vtable_entry_type;
199 tree delta_type_node;
202 tree __baselist_desc_type_node;
203 tree __i_desc_type_node, __m_desc_type_node;
204 tree __t_desc_array_type, __i_desc_array_type, __m_desc_array_type;
206 tree __t_desc_type_node;
208 tree __tp_desc_type_node;
210 tree ti_desc_type_node;
211 tree bltn_desc_type_node, ptr_desc_type_node;
212 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
213 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
214 tree ptmd_desc_type_node;
215 tree base_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_type_node, record_type_node, union_type_node, enum_type_node;
224 tree unknown_type_node;
226 Array type `vtable_entry_type[]'
229 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_decl_id, tinfo_decl_type;
252 tree cp_global_trees[CPTI_MAX];
254 /* Indicates that there is a type value in some namespace, although
255 that is not necessarily in scope at the moment. */
257 static tree global_type_node;
262 /* Expect only namespace names now. */
263 static int only_namespace_names;
265 /* If original DECL_RESULT of current function was a register,
266 but due to being an addressable named return value, would up
267 on the stack, this variable holds the named return value's
268 original location. */
270 #define original_result_rtx cp_function_chain->x_result_rtx
272 struct named_label_list
274 struct binding_level *binding_level;
277 const char *filename_o_goto;
279 struct named_label_list *next;
282 /* Used only for jumps to as-yet undefined labels, since jumps to
283 defined labels can have their validity checked by stmt.c. */
285 #define named_label_uses cp_function_chain->x_named_label_uses
287 /* A list of objects which have constructors or destructors
288 which reside in the global scope. The decl is stored in
289 the TREE_VALUE slot and the initializer is stored
290 in the TREE_PURPOSE slot. */
291 tree static_aggregates;
295 /* A node for the integer constants 2, and 3. */
297 tree integer_two_node, integer_three_node;
299 /* Parsing a function declarator leaves here a chain of structure
300 and enum types declared in the parmlist. */
302 static tree last_function_parm_tags;
304 /* Similar, for last_function_parm_tags. */
305 tree last_function_parms;
306 static tree current_function_parm_tags;
308 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
309 that have names. Here so we can clear out their names' definitions
310 at the end of the function. The TREE_VALUE is a LABEL_DECL; the
311 TREE_PURPOSE is the previous binding of the label. */
313 #define named_labels cp_function_chain->x_named_labels
315 /* Set to 0 at beginning of a function definition, and whenever
316 a label (case or named) is defined. Set to value of expression
317 returned from function when that value can be transformed into
318 a named return value. */
320 tree current_function_return_value;
322 /* Nonzero means use the ISO C99 dialect of C. */
326 /* Nonzero means give `double' the same size as `float'. */
328 extern int flag_short_double;
330 /* Nonzero means don't recognize any builtin functions. */
332 extern int flag_no_builtin;
334 /* Nonzero means don't recognize the non-ANSI builtin functions.
337 extern int flag_no_nonansi_builtin;
339 /* Nonzero if we want to support huge (> 2^(sizeof(short)*8-1) bytes)
341 extern int flag_huge_objects;
343 /* Nonzero if we want to conserve space in the .o files. We do this
344 by putting uninitialized data and runtime initialized data into
345 .common instead of .data at the expense of not flagging multiple
347 extern int flag_conserve_space;
349 /* C and C++ flags are in decl2.c. */
351 /* Flag used when debugging spew.c */
353 extern int spew_debug;
355 /* A expression of value 0 with the same precision as a sizetype
357 tree signed_size_zero_node;
359 /* The name of the anonymous namespace, throughout this translation
361 tree anonymous_namespace_name;
364 /* For each binding contour we allocate a binding_level structure
365 which records the names defined in that contour.
368 1) one for each function definition,
369 where internal declarations of the parameters appear.
370 2) one for each compound statement,
371 to record its declarations.
373 The current meaning of a name can be found by searching the levels
374 from the current one out to the global one.
376 Off to the side, may be the class_binding_level. This exists only
377 to catch class-local declarations. It is otherwise nonexistent.
379 Also there may be binding levels that catch cleanups that must be
380 run when exceptions occur. Thus, to see whether a name is bound in
381 the current scope, it is not enough to look in the
382 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
385 /* Note that the information in the `names' component of the global contour
386 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
390 /* A chain of _DECL nodes for all variables, constants, functions,
391 and typedef types. These are in the reverse of the order
392 supplied. There may be OVERLOADs on this list, too, but they
393 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
396 /* A list of structure, union and enum definitions, for looking up
398 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
399 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
400 or ENUMERAL_TYPE node.
402 C++: the TREE_VALUE nodes can be simple types for
403 component_bindings. */
406 /* A list of USING_DECL nodes. */
409 /* A list of used namespaces. PURPOSE is the namespace,
410 VALUE the common ancestor with this binding_level's namespace. */
411 tree using_directives;
413 /* If this binding level is the binding level for a class, then
414 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
415 is the name of an entity bound in the class; the TREE_VALUE is
416 the IDENTIFIER_CLASS_VALUE before we entered the class. Thus,
417 when leaving class scope, we can restore the
418 IDENTIFIER_CLASS_VALUE by walking this list. The TREE_TYPE is
419 the DECL bound by this name in the class. */
422 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
423 is used for all binding levels. */
426 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
427 label in this scope. The TREE_PURPOSE is the previous value of
428 the IDENTIFIER_LABEL VALUE. */
429 tree shadowed_labels;
431 /* For each level (except not the global one),
432 a chain of BLOCK nodes for all the levels
433 that were entered and exited one level down. */
436 /* The BLOCK node for this level, if one has been preallocated.
437 If 0, the BLOCK is allocated (if needed) when the level is popped. */
440 /* The _TYPE node for this level, if parm_flag == 2. */
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 ISO-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 unsigned parm_flag : 2;
460 /* 1 means make a BLOCK for this level regardless of all else.
461 2 for temporary binding contours created by the compiler. */
464 /* Nonzero if this level "doesn't exist" for tags. */
465 unsigned tag_transparent : 1;
467 /* Nonzero if this level can safely have additional
468 cleanup-needing variables added to it. */
469 unsigned more_cleanups_ok : 1;
470 unsigned have_cleanups : 1;
472 /* Nonzero if this scope is for storing the decls for template
473 parameters and generic decls; these decls will be discarded and
474 replaced with a TEMPLATE_DECL. */
475 unsigned template_parms_p : 1;
477 /* Nonzero if this scope corresponds to the `<>' in a
478 `template <>' clause. Whenever this flag is set,
479 TEMPLATE_PARMS_P will be set as well. */
480 unsigned template_spec_p : 1;
482 /* This is set for a namespace binding level. */
483 unsigned namespace_p : 1;
485 /* True if this level is that of a for-statement where we need to
486 worry about ambiguous (ARM or ISO) scope rules. */
487 unsigned is_for_scope : 1;
489 /* True if this level corresponds to an EH region, as for a try block. */
490 unsigned eh_region : 1;
492 /* Four bits left for this word. */
494 #if defined(DEBUG_CP_BINDING_LEVELS)
495 /* Binding depth at which this level began. */
496 unsigned binding_depth;
497 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
500 #define NULL_BINDING_LEVEL ((struct binding_level *) NULL)
502 /* The binding level currently in effect. */
504 #define current_binding_level \
506 ? cp_function_chain->bindings \
507 : scope_chain->bindings)
509 /* The binding level of the current class, if any. */
511 #define class_binding_level scope_chain->class_bindings
513 /* A chain of binding_level structures awaiting reuse. */
515 static struct binding_level *free_binding_level;
517 /* The outermost binding level, for names of file scope.
518 This is created when the compiler is started and exists
519 through the entire run. */
521 static struct binding_level *global_binding_level;
523 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
525 static int keep_next_level_flag;
527 #if defined(DEBUG_CP_BINDING_LEVELS)
528 static int binding_depth = 0;
529 static int is_class_level = 0;
536 for (i = 0; i < binding_depth*2; i++)
539 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
541 static tree pushdecl_with_scope PARAMS ((tree, struct binding_level *));
544 push_binding_level (newlevel, tag_transparent, keep)
545 struct binding_level *newlevel;
546 int tag_transparent, keep;
548 /* Add this level to the front of the chain (stack) of levels that
550 bzero ((char*) newlevel, sizeof (struct binding_level));
551 newlevel->level_chain = current_binding_level;
552 current_binding_level = newlevel;
553 newlevel->tag_transparent = tag_transparent;
554 newlevel->more_cleanups_ok = 1;
556 /* We are called before expand_start_bindings, but after
557 expand_eh_region_start for a try block; so we check this now,
558 before the EH block is covered up. */
559 newlevel->eh_region = is_eh_region ();
561 newlevel->keep = keep;
562 #if defined(DEBUG_CP_BINDING_LEVELS)
563 newlevel->binding_depth = binding_depth;
565 fprintf (stderr, "push %s level 0x%08x line %d\n",
566 (is_class_level) ? "class" : "block", newlevel, lineno);
569 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
572 /* Find the innermost enclosing class scope, and reset
573 CLASS_BINDING_LEVEL appropriately. */
576 find_class_binding_level ()
578 struct binding_level *level = current_binding_level;
580 while (level && level->parm_flag != 2)
581 level = level->level_chain;
582 if (level && level->parm_flag == 2)
583 class_binding_level = level;
585 class_binding_level = 0;
591 if (global_binding_level)
593 /* Cannot pop a level, if there are none left to pop. */
594 if (current_binding_level == global_binding_level)
595 my_friendly_abort (123);
597 /* Pop the current level, and free the structure for reuse. */
598 #if defined(DEBUG_CP_BINDING_LEVELS)
601 fprintf (stderr, "pop %s level 0x%08x line %d\n",
602 (is_class_level) ? "class" : "block",
603 current_binding_level, lineno);
604 if (is_class_level != (current_binding_level == class_binding_level))
607 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
610 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
612 register struct binding_level *level = current_binding_level;
613 current_binding_level = current_binding_level->level_chain;
614 level->level_chain = free_binding_level;
615 #if 0 /* defined(DEBUG_CP_BINDING_LEVELS) */
616 if (level->binding_depth != binding_depth)
618 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
619 free_binding_level = level;
620 find_class_binding_level ();
625 suspend_binding_level ()
627 if (class_binding_level)
628 current_binding_level = class_binding_level;
630 if (global_binding_level)
632 /* Cannot suspend a level, if there are none left to suspend. */
633 if (current_binding_level == global_binding_level)
634 my_friendly_abort (123);
636 /* Suspend the current level. */
637 #if defined(DEBUG_CP_BINDING_LEVELS)
640 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
641 (is_class_level) ? "class" : "block",
642 current_binding_level, lineno);
643 if (is_class_level != (current_binding_level == class_binding_level))
646 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
649 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
650 current_binding_level = current_binding_level->level_chain;
651 find_class_binding_level ();
655 resume_binding_level (b)
656 struct binding_level *b;
658 /* Resuming binding levels is meant only for namespaces,
659 and those cannot nest into classes. */
660 my_friendly_assert(!class_binding_level, 386);
661 /* Also, resuming a non-directly nested namespace is a no-no. */
662 my_friendly_assert(b->level_chain == current_binding_level, 386);
663 current_binding_level = b;
664 #if defined(DEBUG_CP_BINDING_LEVELS)
665 b->binding_depth = binding_depth;
667 fprintf (stderr, "resume %s level 0x%08x line %d\n",
668 (is_class_level) ? "class" : "block", b, lineno);
671 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
674 /* Create a new `struct binding_level'. */
677 struct binding_level *
678 make_binding_level ()
681 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
684 /* Nonzero if we are currently in the global binding level. */
689 return current_binding_level == global_binding_level;
692 /* Return the innermost binding level that is not for a class scope. */
694 static struct binding_level *
695 innermost_nonclass_level ()
697 struct binding_level *b;
699 b = current_binding_level;
700 while (b->parm_flag == 2)
706 /* Nonzero if we are currently in a toplevel binding level. This
707 means either the global binding level or a namespace in a toplevel
708 binding level. Since there are no non-toplevel namespace levels,
709 this really means any namespace or template parameter level. We
710 also include a class whose context is toplevel. */
713 toplevel_bindings_p ()
715 struct binding_level *b = innermost_nonclass_level ();
717 return b->namespace_p || b->template_parms_p;
720 /* Nonzero if this is a namespace scope, or if we are defining a class
721 which is itself at namespace scope, or whose enclosing class is
722 such a class, etc. */
725 namespace_bindings_p ()
727 struct binding_level *b = innermost_nonclass_level ();
729 return b->namespace_p;
732 /* If KEEP is non-zero, make a BLOCK node for the next binding level,
733 unconditionally. Otherwise, use the normal logic to decide whether
734 or not to create a BLOCK. */
737 keep_next_level (keep)
740 keep_next_level_flag = keep;
743 /* Nonzero if the current level needs to have a BLOCK made. */
748 return (current_binding_level->blocks != NULL_TREE
749 || current_binding_level->keep
750 || current_binding_level->names != NULL_TREE
751 || (current_binding_level->tags != NULL_TREE
752 && !current_binding_level->tag_transparent));
756 declare_namespace_level ()
758 current_binding_level->namespace_p = 1;
761 /* Returns non-zero if this scope was created to store template
765 template_parm_scope_p ()
767 return current_binding_level->template_parms_p;
770 /* Returns the kind of template specialization we are currently
771 processing, given that it's declaration contained N_CLASS_SCOPES
772 explicit scope qualifications. */
775 current_tmpl_spec_kind (n_class_scopes)
778 int n_template_parm_scopes = 0;
779 int seen_specialization_p = 0;
780 int innermost_specialization_p = 0;
781 struct binding_level *b;
783 /* Scan through the template parameter scopes. */
784 for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
786 /* If we see a specialization scope inside a parameter scope,
787 then something is wrong. That corresponds to a declaration
790 template <class T> template <> ...
792 which is always illegal since [temp.expl.spec] forbids the
793 specialization of a class member template if the enclosing
794 class templates are not explicitly specialized as well. */
795 if (b->template_spec_p)
797 if (n_template_parm_scopes == 0)
798 innermost_specialization_p = 1;
800 seen_specialization_p = 1;
802 else if (seen_specialization_p == 1)
803 return tsk_invalid_member_spec;
805 ++n_template_parm_scopes;
808 /* Handle explicit instantiations. */
809 if (processing_explicit_instantiation)
811 if (n_template_parm_scopes != 0)
812 /* We've seen a template parameter list during an explicit
813 instantiation. For example:
815 template <class T> template void f(int);
817 This is erroneous. */
818 return tsk_invalid_expl_inst;
820 return tsk_expl_inst;
823 if (n_template_parm_scopes < n_class_scopes)
824 /* We've not seen enough template headers to match all the
825 specialized classes present. For example:
827 template <class T> void R<T>::S<T>::f(int);
829 This is illegal; there needs to be one set of template
830 parameters for each class. */
831 return tsk_insufficient_parms;
832 else if (n_template_parm_scopes == n_class_scopes)
833 /* We're processing a non-template declaration (even though it may
834 be a member of a template class.) For example:
836 template <class T> void S<T>::f(int);
838 The `class T' maches the `S<T>', leaving no template headers
839 corresponding to the `f'. */
841 else if (n_template_parm_scopes > n_class_scopes + 1)
842 /* We've got too many template headers. For example:
844 template <> template <class T> void f (T);
846 There need to be more enclosing classes. */
847 return tsk_excessive_parms;
849 /* This must be a template. It's of the form:
851 template <class T> template <class U> void S<T>::f(U);
853 This is a specialization if the innermost level was a
854 specialization; otherwise it's just a definition of the
856 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
860 set_class_shadows (shadows)
863 class_binding_level->class_shadowed = shadows;
866 /* Enter a new binding level.
867 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
868 not for that of tags. */
871 pushlevel (tag_transparent)
874 struct binding_level *newlevel;
876 if (cfun && !doing_semantic_analysis_p ())
879 /* Reuse or create a struct for this binding level. */
880 #if defined(DEBUG_CP_BINDING_LEVELS)
882 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
883 if (free_binding_level)
884 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
886 newlevel = free_binding_level;
887 free_binding_level = free_binding_level->level_chain;
890 newlevel = make_binding_level ();
892 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
893 GNU_xref_start_scope ((HOST_WIDE_INT) newlevel);
894 keep_next_level_flag = 0;
897 /* Enter a new scope. The KIND indicates what kind of scope is being
908 case sk_template_spec:
909 current_binding_level->template_spec_p = 1;
912 case sk_template_parms:
913 current_binding_level->template_parms_p = 1;
917 my_friendly_abort (20000309);
921 /* Exit the current scope. */
930 note_level_for_for ()
932 current_binding_level->is_for_scope = 1;
935 /* For a binding between a name and an entity at a block scope,
936 this is the `struct binding_level' for the block. */
937 #define BINDING_LEVEL(NODE) \
938 (((struct tree_binding*)NODE)->scope.level)
940 /* Make DECL the innermost binding for ID. The LEVEL is the binding
941 level at which this declaration is being bound. */
944 push_binding (id, decl, level)
947 struct binding_level* level;
951 binding = make_node (CPLUS_BINDING);
953 /* Now, fill in the binding information. */
954 BINDING_VALUE (binding) = decl;
955 BINDING_TYPE (binding) = NULL_TREE;
956 BINDING_LEVEL (binding) = level;
957 INHERITED_VALUE_BINDING_P (binding) = 0;
958 LOCAL_BINDING_P (binding) = (level != class_binding_level);
959 BINDING_HAS_LEVEL_P (binding) = 1;
961 /* And put it on the front of the list of bindings for ID. */
962 TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
963 IDENTIFIER_BINDING (id) = binding;
966 /* ID is already bound in the current scope. But, DECL is an
967 additional binding for ID in the same scope. This is the `struct
968 stat' hack whereby a non-typedef class-name or enum-name can be
969 bound at the same level as some other kind of entity. It's the
970 responsibility of the caller to check that inserting this name is
971 legal here. Returns nonzero if the new binding was successful. */
973 add_binding (id, decl)
977 tree binding = IDENTIFIER_BINDING (id);
980 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
981 /* The new name is the type name. */
982 BINDING_TYPE (binding) = decl;
983 else if (!BINDING_VALUE (binding))
984 /* This situation arises when push_class_level_binding moves an
985 inherited type-binding out of the way to make room for a new
987 BINDING_VALUE (binding) = decl;
988 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
989 && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
991 /* The old binding was a type name. It was placed in
992 BINDING_VALUE because it was thought, at the point it was
993 declared, to be the only entity with such a name. Move the
994 type name into the type slot; it is now hidden by the new
996 BINDING_TYPE (binding) = BINDING_VALUE (binding);
997 BINDING_VALUE (binding) = decl;
998 INHERITED_VALUE_BINDING_P (binding) = 0;
1000 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
1001 && TREE_CODE (decl) == TYPE_DECL
1002 && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
1003 && same_type_p (TREE_TYPE (decl),
1004 TREE_TYPE (BINDING_VALUE (binding))))
1005 /* We have two typedef-names, both naming the same type to have
1006 the same name. This is OK because of:
1010 In a given scope, a typedef specifier can be used to redefine
1011 the name of any type declared in that scope to refer to the
1012 type to which it already refers. */
1016 cp_error ("declaration of `%#D'", decl);
1017 cp_error_at ("conflicts with previous declaration `%#D'",
1018 BINDING_VALUE (binding));
1025 /* Add DECL to the list of things declared in B. */
1028 add_decl_to_level (decl, b)
1030 struct binding_level *b;
1032 /* We build up the list in reverse order, and reverse it later if
1034 TREE_CHAIN (decl) = b->names;
1038 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1039 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1040 doesn't really belong to this binding level, that it got here
1041 through a using-declaration. */
1044 push_local_binding (id, decl, flags)
1049 struct binding_level *b;
1051 /* Skip over any local classes. This makes sense if we call
1052 push_local_binding with a friend decl of a local class. */
1053 b = current_binding_level;
1054 while (b->parm_flag == 2)
1057 if (lookup_name_current_level (id))
1059 /* Supplement the existing binding. */
1060 if (!add_binding (id, decl))
1061 /* It didn't work. Something else must be bound at this
1062 level. Do not add DECL to the list of things to pop
1067 /* Create a new binding. */
1068 push_binding (id, decl, b);
1070 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1071 /* We must put the OVERLOAD into a TREE_LIST since the
1072 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1073 decls that got here through a using-declaration. */
1074 decl = build_tree_list (NULL_TREE, decl);
1076 /* And put DECL on the list of things declared by the current
1078 add_decl_to_level (decl, b);
1081 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1082 binding was successful. */
1085 push_class_binding (id, decl)
1090 tree binding = IDENTIFIER_BINDING (id);
1093 /* Note that we declared this value so that we can issue an error if
1094 this an illegal redeclaration of a name already used for some
1096 note_name_declared_in_class (id, decl);
1098 if (binding && BINDING_LEVEL (binding) == class_binding_level)
1099 /* Supplement the existing binding. */
1100 result = add_binding (id, decl);
1102 /* Create a new binding. */
1103 push_binding (id, decl, class_binding_level);
1105 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1106 class-level declaration. Note that we do not use DECL here
1107 because of the possibility of the `struct stat' hack; if DECL is
1108 a class-name or enum-name we might prefer a field-name, or some
1110 IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1112 /* If this is a binding from a base class, mark it as such. */
1113 binding = IDENTIFIER_BINDING (id);
1114 if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1116 /* Any implicit typename must be from a base-class. The
1117 context for an implicit typename declaration is always
1118 the derived class in which the lookup was done, so the checks
1119 based on the context of DECL below will not trigger. */
1120 if (IMPLICIT_TYPENAME_TYPE_DECL_P (decl))
1121 INHERITED_VALUE_BINDING_P (binding) = 1;
1124 if (TREE_CODE (decl) == OVERLOAD)
1125 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1128 my_friendly_assert (DECL_P (decl), 0);
1129 context = CP_DECL_CONTEXT (decl);
1132 if (is_properly_derived_from (current_class_type, context))
1133 INHERITED_VALUE_BINDING_P (binding) = 1;
1135 INHERITED_VALUE_BINDING_P (binding) = 0;
1138 else if (BINDING_VALUE (binding) == decl)
1139 /* We only encounter a TREE_LIST when push_class_decls detects an
1140 ambiguity. Such an ambiguity can be overridden by a definition
1142 INHERITED_VALUE_BINDING_P (binding) = 1;
1147 /* Remove the binding for DECL which should be the innermost binding
1151 pop_binding (id, decl)
1157 if (id == NULL_TREE)
1158 /* It's easiest to write the loops that call this function without
1159 checking whether or not the entities involved have names. We
1160 get here for such an entity. */
1163 /* Get the innermost binding for ID. */
1164 binding = IDENTIFIER_BINDING (id);
1166 /* The name should be bound. */
1167 my_friendly_assert (binding != NULL_TREE, 0);
1169 /* The DECL will be either the ordinary binding or the type
1170 binding for this identifier. Remove that binding. */
1171 if (BINDING_VALUE (binding) == decl)
1172 BINDING_VALUE (binding) = NULL_TREE;
1173 else if (BINDING_TYPE (binding) == decl)
1174 BINDING_TYPE (binding) = NULL_TREE;
1176 my_friendly_abort (0);
1178 if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1179 /* We're completely done with the innermost binding for this
1180 identifier. Unhook it from the list of bindings. */
1181 IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1184 /* When a label goes out of scope, check to see if that label was used
1185 in a valid manner, and issue any appropriate warnings or errors. */
1191 tree label = TREE_VALUE (link);
1193 if (!processing_template_decl && doing_semantic_analysis_p ())
1195 if (DECL_INITIAL (label) == NULL_TREE)
1197 cp_error_at ("label `%D' used but not defined", label);
1198 /* Avoid crashing later. */
1199 define_label (input_filename, 1, DECL_NAME (label));
1201 else if (warn_unused && !TREE_USED (label))
1202 cp_warning_at ("label `%D' defined but not used", label);
1205 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), TREE_PURPOSE (link));
1208 /* At the end of a function, all labels declared within the fucntion
1209 go out of scope. BLOCK is the top-level block for the
1218 /* Clear out the definitions of all label names, since their scopes
1220 for (link = named_labels; link; link = TREE_CHAIN (link))
1223 /* Put the labels into the "variables" of the top-level block,
1224 so debugger can see them. */
1225 TREE_CHAIN (TREE_VALUE (link)) = BLOCK_VARS (block);
1226 BLOCK_VARS (block) = TREE_VALUE (link);
1229 named_labels = NULL_TREE;
1232 /* Exit a binding level.
1233 Pop the level off, and restore the state of the identifier-decl mappings
1234 that were in effect when this level was entered.
1236 If KEEP == 1, this level had explicit declarations, so
1237 and create a "block" (a BLOCK node) for the level
1238 to record its declarations and subblocks for symbol table output.
1240 If FUNCTIONBODY is nonzero, this level is the body of a function,
1241 so create a block as if KEEP were set and also clear out all
1244 If REVERSE is nonzero, reverse the order of decls before putting
1245 them into the BLOCK. */
1248 poplevel (keep, reverse, functionbody)
1254 /* The chain of decls was accumulated in reverse order.
1255 Put it into forward order, just for cleanliness. */
1257 int tmp = functionbody;
1258 int real_functionbody;
1261 tree block = NULL_TREE;
1263 int block_previously_created;
1264 int leaving_for_scope;
1266 if (cfun && !doing_semantic_analysis_p ())
1269 my_friendly_assert (current_binding_level->parm_flag != 2,
1272 real_functionbody = (current_binding_level->keep == 2
1273 ? ((functionbody = 0), tmp) : functionbody);
1274 tags = functionbody >= 0 ? current_binding_level->tags : 0;
1275 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1277 my_friendly_assert (!current_binding_level->class_shadowed,
1280 /* We used to use KEEP == 2 to indicate that the new block should go
1281 at the beginning of the list of blocks at this binding level,
1282 rather than the end. This hack is no longer used. */
1283 my_friendly_assert (keep == 0 || keep == 1, 0);
1285 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
1286 (HOST_WIDE_INT) current_binding_level->level_chain,
1287 current_binding_level->parm_flag,
1288 current_binding_level->keep);
1290 if (current_binding_level->keep == 1)
1293 /* Get the decls in the order they were written.
1294 Usually current_binding_level->names is in reverse order.
1295 But parameter decls were previously put in forward order. */
1298 current_binding_level->names
1299 = decls = nreverse (current_binding_level->names);
1301 decls = current_binding_level->names;
1303 /* Output any nested inline functions within this block
1304 if they weren't already output. */
1305 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1306 if (TREE_CODE (decl) == FUNCTION_DECL
1307 && ! TREE_ASM_WRITTEN (decl)
1308 && DECL_INITIAL (decl) != NULL_TREE
1309 && TREE_ADDRESSABLE (decl)
1310 && decl_function_context (decl) == current_function_decl)
1312 /* If this decl was copied from a file-scope decl
1313 on account of a block-scope extern decl,
1314 propagate TREE_ADDRESSABLE to the file-scope decl. */
1315 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1316 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1319 push_function_context ();
1320 output_inline_function (decl);
1321 pop_function_context ();
1325 /* When not in function-at-a-time mode, expand_end_bindings will
1326 warn about unused variables. But, in function-at-a-time mode
1327 expand_end_bindings is not passed the list of variables in the
1328 current scope, and therefore no warning is emitted. So, we
1329 explicitly warn here. */
1330 if (!processing_template_decl)
1331 warn_about_unused_variables (getdecls ());
1333 /* If there were any declarations or structure tags in that level,
1334 or if this level is a function body,
1335 create a BLOCK to record them for the life of this function. */
1337 block_previously_created = (current_binding_level->this_block != NULL_TREE);
1338 if (block_previously_created)
1339 block = current_binding_level->this_block;
1340 else if (keep == 1 || functionbody)
1341 block = make_node (BLOCK);
1342 if (block != NULL_TREE)
1344 if (block_previously_created)
1346 if (decls || tags || subblocks)
1348 if (BLOCK_VARS (block))
1349 warning ("internal compiler error: debugging info corrupted");
1351 BLOCK_VARS (block) = decls;
1353 /* We can have previous subblocks and new subblocks when
1354 doing fixup_gotos with complex cleanups. We chain the new
1355 subblocks onto the end of any pre-existing subblocks. */
1356 BLOCK_SUBBLOCKS (block) = chainon (BLOCK_SUBBLOCKS (block),
1362 BLOCK_VARS (block) = decls;
1363 BLOCK_SUBBLOCKS (block) = subblocks;
1367 /* In each subblock, record that this is its superior. */
1369 for (link = subblocks; link; link = TREE_CHAIN (link))
1370 BLOCK_SUPERCONTEXT (link) = block;
1372 /* We still support the old for-scope rules, whereby the variables
1373 in a for-init statement were in scope after the for-statement
1374 ended. We only use the new rules in flag_new_for_scope is
1377 = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1379 /* Remove declarations for all the DECLs in this level. */
1380 for (link = decls; link; link = TREE_CHAIN (link))
1382 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL)
1385 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1389 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1391 ns_binding = NULL_TREE;
1394 && (BINDING_LEVEL (outer_binding)
1395 == current_binding_level->level_chain))
1396 /* We have something like:
1401 and we are leaving the `for' scope. There's no reason to
1402 keep the binding of the inner `i' in this case. */
1403 pop_binding (DECL_NAME (link), link);
1404 else if ((outer_binding
1405 && (TREE_CODE (BINDING_VALUE (outer_binding))
1408 && TREE_CODE (ns_binding) == TYPE_DECL))
1409 /* Here, we have something like:
1417 We must pop the for-scope binding so we know what's a
1418 type and what isn't. */
1419 pop_binding (DECL_NAME (link), link);
1422 /* Mark this VAR_DECL as dead so that we can tell we left it
1423 there only for backward compatibility. */
1424 DECL_DEAD_FOR_LOCAL (link) = 1;
1426 /* Keep track of what should of have happenned when we
1427 popped the binding. */
1428 if (outer_binding && BINDING_VALUE (outer_binding))
1429 DECL_SHADOWED_FOR_VAR (link)
1430 = BINDING_VALUE (outer_binding);
1432 /* Add it to the list of dead variables in the next
1433 outermost binding to that we can remove these when we
1434 leave that binding. */
1435 current_binding_level->level_chain->dead_vars_from_for
1436 = tree_cons (NULL_TREE, link,
1437 current_binding_level->level_chain->
1438 dead_vars_from_for);
1440 /* Although we don't pop the CPLUS_BINDING, we do clear
1441 its BINDING_LEVEL since the level is going away now. */
1442 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1448 /* Remove the binding. */
1450 if (TREE_CODE (decl) == TREE_LIST)
1451 decl = TREE_VALUE (decl);
1453 pop_binding (DECL_NAME (decl), decl);
1454 else if (TREE_CODE (decl) == OVERLOAD)
1455 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1457 my_friendly_abort (0);
1461 /* Remove declarations for any `for' variables from inner scopes
1462 that we kept around. */
1463 for (link = current_binding_level->dead_vars_from_for;
1464 link; link = TREE_CHAIN (link))
1465 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1467 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1468 for (link = current_binding_level->type_shadowed;
1469 link; link = TREE_CHAIN (link))
1470 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1472 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1473 for (link = current_binding_level->shadowed_labels;
1475 link = TREE_CHAIN (link))
1478 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1479 list if a `using' declaration put them there. The debugging
1480 back-ends won't understand OVERLOAD, so we remove them here.
1481 Because the BLOCK_VARS are (temporarily) shared with
1482 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1483 popped all the bindings. */
1488 for (d = &BLOCK_VARS (block); *d; )
1490 if (TREE_CODE (*d) == TREE_LIST)
1491 *d = TREE_CHAIN (*d);
1493 d = &TREE_CHAIN (*d);
1497 /* If the level being exited is the top level of a function,
1498 check over all the labels. */
1501 /* Since this is the top level block of a function, the vars are
1502 the function's parameters. Don't leave them in the BLOCK
1503 because they are found in the FUNCTION_DECL instead. */
1504 BLOCK_VARS (block) = 0;
1508 /* Any uses of undefined labels now operate under constraints
1509 of next binding contour. */
1512 struct binding_level *level_chain;
1513 level_chain = current_binding_level->level_chain;
1516 struct named_label_list *labels;
1517 for (labels = named_label_uses; labels; labels = labels->next)
1518 if (labels->binding_level == current_binding_level)
1520 labels->binding_level = level_chain;
1521 labels->names_in_scope = level_chain->names;
1526 tmp = current_binding_level->keep;
1528 pop_binding_level ();
1530 DECL_INITIAL (current_function_decl) = block;
1533 if (!block_previously_created)
1534 current_binding_level->blocks
1535 = chainon (current_binding_level->blocks, block);
1537 /* If we did not make a block for the level just exited,
1538 any blocks made for inner levels
1539 (since they cannot be recorded as subblocks in that level)
1540 must be carried forward so they will later become subblocks
1541 of something else. */
1543 current_binding_level->blocks
1544 = chainon (current_binding_level->blocks, subblocks);
1546 /* Each and every BLOCK node created here in `poplevel' is important
1547 (e.g. for proper debugging information) so if we created one
1548 earlier, mark it as "used". */
1550 TREE_USED (block) = 1;
1552 /* Take care of compiler's internal binding structures. */
1558 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1561 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1562 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1565 block = poplevel (keep, reverse, functionbody);
1571 /* Delete the node BLOCK from the current binding level.
1572 This is used for the block inside a stmt expr ({...})
1573 so that the block can be reinserted where appropriate. */
1576 delete_block (block)
1580 if (current_binding_level->blocks == block)
1581 current_binding_level->blocks = TREE_CHAIN (block);
1582 for (t = current_binding_level->blocks; t;)
1584 if (TREE_CHAIN (t) == block)
1585 TREE_CHAIN (t) = TREE_CHAIN (block);
1589 TREE_CHAIN (block) = NULL_TREE;
1590 /* Clear TREE_USED which is always set by poplevel.
1591 The flag is set again if insert_block is called. */
1592 TREE_USED (block) = 0;
1595 /* Insert BLOCK at the end of the list of subblocks of the
1596 current binding level. This is used when a BIND_EXPR is expanded,
1597 to handle the BLOCK node inside the BIND_EXPR. */
1600 insert_block (block)
1603 TREE_USED (block) = 1;
1604 current_binding_level->blocks
1605 = chainon (current_binding_level->blocks, block);
1608 /* Set the BLOCK node for the innermost scope
1609 (the one we are currently in). */
1613 register tree block;
1615 current_binding_level->this_block = block;
1618 /* Do a pushlevel for class declarations. */
1623 register struct binding_level *newlevel;
1625 /* Reuse or create a struct for this binding level. */
1626 #if defined(DEBUG_CP_BINDING_LEVELS)
1628 #else /* !defined(DEBUG_CP_BINDING_LEVELS) */
1629 if (free_binding_level)
1630 #endif /* !defined(DEBUG_CP_BINDING_LEVELS) */
1632 newlevel = free_binding_level;
1633 free_binding_level = free_binding_level->level_chain;
1636 newlevel = make_binding_level ();
1638 #if defined(DEBUG_CP_BINDING_LEVELS)
1640 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1642 push_binding_level (newlevel, 0, 0);
1644 class_binding_level = current_binding_level;
1645 class_binding_level->parm_flag = 2;
1646 class_binding_level->this_class = current_class_type;
1649 /* ...and a poplevel for class declarations. */
1654 register struct binding_level *level = class_binding_level;
1657 my_friendly_assert (level != 0, 354);
1659 /* If we're leaving a toplevel class, don't bother to do the setting
1660 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1661 shouldn't even be used when current_class_type isn't set, and second,
1662 if we don't touch it here, we're able to use the cache effect if the
1663 next time we're entering a class scope, it is the same class. */
1664 if (current_class_depth != 1)
1666 struct binding_level* b;
1668 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1669 for (shadowed = level->class_shadowed;
1671 shadowed = TREE_CHAIN (shadowed))
1672 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1674 /* Find the next enclosing class, and recreate
1675 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1676 b = level->level_chain;
1677 while (b && b->parm_flag != 2)
1681 for (shadowed = b->class_shadowed;
1683 shadowed = TREE_CHAIN (shadowed))
1687 t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1688 while (t && BINDING_LEVEL (t) != b)
1692 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1693 = BINDING_VALUE (t);
1697 /* Remember to save what IDENTIFIER's were bound in this scope so we
1698 can recover from cache misses. */
1700 previous_class_type = current_class_type;
1701 previous_class_values = class_binding_level->class_shadowed;
1703 for (shadowed = level->type_shadowed;
1705 shadowed = TREE_CHAIN (shadowed))
1706 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1708 /* Remove the bindings for all of the class-level declarations. */
1709 for (shadowed = level->class_shadowed;
1711 shadowed = TREE_CHAIN (shadowed))
1712 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1714 GNU_xref_end_scope ((HOST_WIDE_INT) class_binding_level,
1715 (HOST_WIDE_INT) class_binding_level->level_chain,
1716 class_binding_level->parm_flag,
1717 class_binding_level->keep);
1719 /* Now, pop out of the binding level which we created up in the
1720 `pushlevel_class' routine. */
1721 #if defined(DEBUG_CP_BINDING_LEVELS)
1723 #endif /* defined(DEBUG_CP_BINDING_LEVELS) */
1725 pop_binding_level ();
1728 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1729 for any names in enclosing classes. */
1732 clear_identifier_class_values ()
1736 if (!class_binding_level)
1739 for (t = class_binding_level->class_shadowed;
1742 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1745 /* Returns non-zero if T is a virtual function table. */
1748 vtable_decl_p (t, data)
1750 void *data ATTRIBUTE_UNUSED;
1752 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1755 /* Returns non-zero if T is a TYPE_DECL for a type with virtual
1759 vtype_decl_p (t, data)
1761 void *data ATTRIBUTE_UNUSED;
1763 return (TREE_CODE (t) == TYPE_DECL
1764 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1765 && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1768 /* Return the declarations that are members of the namespace NS. */
1771 cp_namespace_decls (ns)
1774 return NAMESPACE_LEVEL (ns)->names;
1777 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1778 itself, calling F for each. The DATA is passed to F as well. */
1781 walk_namespaces_r (namespace, f, data)
1783 walk_namespaces_fn f;
1789 result |= (*f) (namespace, data);
1791 for (current = cp_namespace_decls (namespace);
1793 current = TREE_CHAIN (current))
1795 if (TREE_CODE (current) != NAMESPACE_DECL
1796 || DECL_NAMESPACE_ALIAS (current))
1798 if (!DECL_LANG_SPECIFIC (current))
1801 my_friendly_assert (current == std_node, 393);
1805 /* We found a namespace. */
1806 result |= walk_namespaces_r (current, f, data);
1812 /* Walk all the namespaces, calling F for each. The DATA is passed to
1816 walk_namespaces (f, data)
1817 walk_namespaces_fn f;
1820 return walk_namespaces_r (global_namespace, f, data);
1823 struct walk_globals_data {
1824 walk_globals_pred p;
1829 /* Walk the global declarations in NAMESPACE. Whenever one is found
1830 for which P returns non-zero, call F with its address. If any call
1831 to F returns a non-zero value, return a non-zero value. */
1834 walk_globals_r (namespace, data)
1838 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1839 walk_globals_pred p = wgd->p;
1840 walk_globals_fn f = wgd->f;
1841 void *d = wgd->data;
1845 t = &NAMESPACE_LEVEL (namespace)->names;
1852 result |= (*f) (t, d);
1854 /* If F changed *T, then *T still points at the next item to
1857 t = &TREE_CHAIN (*t);
1863 /* Walk the global declarations. Whenever one is found for which P
1864 returns non-zero, call F with its address. If any call to F
1865 returns a non-zero value, return a non-zero value. */
1868 walk_globals (p, f, data)
1869 walk_globals_pred p;
1873 struct walk_globals_data wgd;
1878 return walk_namespaces (walk_globals_r, &wgd);
1881 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1882 DATA is non-NULL, this is the last time we will call
1883 wrapup_global_declarations for this NAMESPACE. */
1886 wrapup_globals_for_namespace (namespace, data)
1890 tree globals = cp_namespace_decls (namespace);
1891 int len = list_length (globals);
1892 tree *vec = (tree *) alloca (sizeof (tree) * len);
1896 int last_time = (data != 0);
1898 if (last_time && namespace == global_namespace)
1899 /* Let compile_file handle the global namespace. */
1902 /* Process the decls in reverse order--earliest first.
1903 Put them into VEC from back to front, then take out from front. */
1905 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1907 /* Pretend we've output an unused static variable. This ensures
1908 that the toplevel __FUNCTION__ etc won't be emitted, unless
1910 if (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)
1911 && !TREE_PUBLIC (decl) && !TREE_USED (decl))
1913 TREE_ASM_WRITTEN (decl) = 1;
1914 DECL_IGNORED_P (decl) = 1;
1916 vec[len - i - 1] = decl;
1921 check_global_declarations (vec, len);
1925 /* Temporarily mark vtables as external. That prevents
1926 wrapup_global_declarations from writing them out; we must process
1927 them ourselves in finish_vtable_vardecl. */
1928 for (i = 0; i < len; ++i)
1929 if (vtable_decl_p (vec[i], /*data=*/0) && !DECL_EXTERNAL (vec[i]))
1931 DECL_NOT_REALLY_EXTERN (vec[i]) = 1;
1932 DECL_EXTERNAL (vec[i]) = 1;
1935 /* Write out any globals that need to be output. */
1936 result = wrapup_global_declarations (vec, len);
1938 /* Undo the hack to DECL_EXTERNAL above. */
1939 for (i = 0; i < len; ++i)
1940 if (vtable_decl_p (vec[i], /*data=*/0)
1941 && DECL_NOT_REALLY_EXTERN (vec[i]))
1943 DECL_NOT_REALLY_EXTERN (vec[i]) = 0;
1944 DECL_EXTERNAL (vec[i]) = 0;
1951 /* Mark ARG (which is really a struct binding_level **) for GC. */
1954 mark_binding_level (arg)
1957 struct binding_level *lvl = *(struct binding_level **)arg;
1961 ggc_mark_tree (lvl->names);
1962 ggc_mark_tree (lvl->tags);
1963 ggc_mark_tree (lvl->usings);
1964 ggc_mark_tree (lvl->using_directives);
1965 ggc_mark_tree (lvl->class_shadowed);
1966 ggc_mark_tree (lvl->type_shadowed);
1967 ggc_mark_tree (lvl->shadowed_labels);
1968 ggc_mark_tree (lvl->blocks);
1969 ggc_mark_tree (lvl->this_block);
1970 ggc_mark_tree (lvl->this_class);
1971 ggc_mark_tree (lvl->incomplete);
1972 ggc_mark_tree (lvl->dead_vars_from_for);
1974 lvl = lvl->level_chain;
1978 /* For debugging. */
1979 static int no_print_functions = 0;
1980 static int no_print_builtins = 0;
1983 print_binding_level (lvl)
1984 struct binding_level *lvl;
1988 fprintf (stderr, " blocks=");
1989 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1990 fprintf (stderr, " n_incomplete=%d parm_flag=%d keep=%d",
1991 list_length (lvl->incomplete), lvl->parm_flag, lvl->keep);
1992 if (lvl->tag_transparent)
1993 fprintf (stderr, " tag-transparent");
1994 if (lvl->more_cleanups_ok)
1995 fprintf (stderr, " more-cleanups-ok");
1996 if (lvl->have_cleanups)
1997 fprintf (stderr, " have-cleanups");
1998 fprintf (stderr, "\n");
2001 fprintf (stderr, " names:\t");
2002 /* We can probably fit 3 names to a line? */
2003 for (t = lvl->names; t; t = TREE_CHAIN (t))
2005 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
2007 if (no_print_builtins
2008 && (TREE_CODE (t) == TYPE_DECL)
2009 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
2012 /* Function decls tend to have longer names. */
2013 if (TREE_CODE (t) == FUNCTION_DECL)
2020 fprintf (stderr, "\n\t");
2023 print_node_brief (stderr, "", t, 0);
2024 if (t == error_mark_node)
2028 fprintf (stderr, "\n");
2032 fprintf (stderr, " tags:\t");
2034 for (t = lvl->tags; t; t = TREE_CHAIN (t))
2036 if (TREE_PURPOSE (t) == NULL_TREE)
2038 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2045 fprintf (stderr, "\n\t");
2048 if (TREE_PURPOSE (t) == NULL_TREE)
2050 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
2051 fprintf (stderr, ">");
2053 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
2054 print_node_brief (stderr, "", TREE_VALUE (t), 0);
2057 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
2058 print_node_brief (stderr, "", TREE_VALUE (t), 0);
2059 fprintf (stderr, ">");
2063 fprintf (stderr, "\n");
2065 if (lvl->class_shadowed)
2067 fprintf (stderr, " class-shadowed:");
2068 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
2070 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2072 fprintf (stderr, "\n");
2074 if (lvl->type_shadowed)
2076 fprintf (stderr, " type-shadowed:");
2077 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
2079 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
2081 fprintf (stderr, "\n");
2086 print_other_binding_stack (stack)
2087 struct binding_level *stack;
2089 struct binding_level *level;
2090 for (level = stack; level != global_binding_level; level = level->level_chain)
2092 fprintf (stderr, "binding level ");
2093 fprintf (stderr, HOST_PTR_PRINTF, level);
2094 fprintf (stderr, "\n");
2095 print_binding_level (level);
2100 print_binding_stack ()
2102 struct binding_level *b;
2103 fprintf (stderr, "current_binding_level=");
2104 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2105 fprintf (stderr, "\nclass_binding_level=");
2106 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2107 fprintf (stderr, "\nglobal_binding_level=");
2108 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2109 fprintf (stderr, "\n");
2110 if (class_binding_level)
2112 for (b = class_binding_level; b; b = b->level_chain)
2113 if (b == current_binding_level)
2116 b = class_binding_level;
2118 b = current_binding_level;
2121 b = current_binding_level;
2122 print_other_binding_stack (b);
2123 fprintf (stderr, "global:\n");
2124 print_binding_level (global_binding_level);
2127 /* Namespace binding access routines: The namespace_bindings field of
2128 the identifier is polymorphic, with three possible values:
2129 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2130 indicating the BINDING_VALUE of global_namespace. */
2132 /* Check whether the a binding for the name to scope is known.
2133 Assumes that the bindings of the name are already a list
2134 of bindings. Returns the binding found, or NULL_TREE. */
2137 find_binding (name, scope)
2141 tree iter, prev = NULL_TREE;
2143 scope = ORIGINAL_NAMESPACE (scope);
2145 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2146 iter = TREE_CHAIN (iter))
2148 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2149 if (BINDING_SCOPE (iter) == scope)
2151 /* Move binding found to the front of the list, so
2152 subsequent lookups will find it faster. */
2155 TREE_CHAIN (prev) = TREE_CHAIN (iter);
2156 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2157 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2166 /* Always returns a binding for name in scope. If the
2167 namespace_bindings is not a list, convert it to one first.
2168 If no binding is found, make a new one. */
2171 binding_for_name (name, scope)
2175 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2178 scope = ORIGINAL_NAMESPACE (scope);
2180 if (b && TREE_CODE (b) != CPLUS_BINDING)
2182 /* Get rid of optimization for global scope. */
2183 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2184 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2185 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2187 if (b && (result = find_binding (name, scope)))
2189 /* Not found, make a new one. */
2190 result = make_node (CPLUS_BINDING);
2191 TREE_CHAIN (result) = b;
2192 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2193 BINDING_SCOPE (result) = scope;
2194 BINDING_TYPE (result) = NULL_TREE;
2195 BINDING_VALUE (result) = NULL_TREE;
2199 /* Return the binding value for name in scope, considering that
2200 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2203 namespace_binding (name, scope)
2207 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2210 if (scope == NULL_TREE)
2211 scope = global_namespace;
2212 if (TREE_CODE (b) != CPLUS_BINDING)
2213 return (scope == global_namespace) ? b : NULL_TREE;
2214 name = find_binding (name,scope);
2215 if (name == NULL_TREE)
2217 return BINDING_VALUE (name);
2220 /* Set the binding value for name in scope. If modifying the binding
2221 of global_namespace is attempted, try to optimize it. */
2224 set_namespace_binding (name, scope, val)
2231 if (scope == NULL_TREE)
2232 scope = global_namespace;
2234 if (scope == global_namespace)
2236 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2237 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2239 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2243 b = binding_for_name (name, scope);
2244 BINDING_VALUE (b) = val;
2247 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2248 select a name that is unique to this compilation unit. */
2251 push_namespace (name)
2256 int implicit_use = 0;
2258 if (!global_namespace)
2260 /* This must be ::. */
2261 my_friendly_assert (name == get_identifier ("::"), 377);
2266 /* The name of anonymous namespace is unique for the translation
2268 if (!anonymous_namespace_name)
2269 anonymous_namespace_name = get_file_function_name ('N');
2270 name = anonymous_namespace_name;
2271 d = IDENTIFIER_NAMESPACE_VALUE (name);
2273 /* Reopening anonymous namespace. */
2277 else if (current_namespace == global_namespace
2278 && name == DECL_NAME (std_node))
2285 /* Check whether this is an extended namespace definition. */
2286 d = IDENTIFIER_NAMESPACE_VALUE (name);
2287 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2290 if (DECL_NAMESPACE_ALIAS (d))
2292 cp_error ("namespace alias `%D' not allowed here, assuming `%D'",
2293 d, DECL_NAMESPACE_ALIAS (d));
2294 d = DECL_NAMESPACE_ALIAS (d);
2301 /* Make a new namespace, binding the name to it. */
2302 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2303 /* The global namespace is not pushed, and the global binding
2304 level is set elsewhere. */
2309 declare_namespace_level ();
2310 NAMESPACE_LEVEL (d) = current_binding_level;
2314 resume_binding_level (NAMESPACE_LEVEL (d));
2317 do_using_directive (d);
2318 /* Enter the name space. */
2319 current_namespace = d;
2322 /* Pop from the scope of the current namespace. */
2327 if (current_namespace == global_namespace)
2329 my_friendly_assert (in_std>0, 980421);
2333 current_namespace = CP_DECL_CONTEXT (current_namespace);
2334 /* The binding level is not popped, as it might be re-opened later. */
2335 suspend_binding_level ();
2338 /* Push into the scope of the namespace NS, even if it is deeply
2339 nested within another namespace. */
2342 push_nested_namespace (ns)
2345 if (ns == global_namespace)
2346 push_to_top_level ();
2349 push_nested_namespace (CP_DECL_CONTEXT (ns));
2350 push_namespace (DECL_NAME (ns));
2354 /* Pop back from the scope of the namespace NS, which was previously
2355 entered with push_nested_namespace. */
2358 pop_nested_namespace (ns)
2361 while (ns != global_namespace)
2364 ns = CP_DECL_CONTEXT (ns);
2367 pop_from_top_level ();
2371 /* Subroutines for reverting temporarily to top-level for instantiation
2372 of templates and such. We actually need to clear out the class- and
2373 local-value slots of all identifiers, so that only the global values
2374 are at all visible. Simply setting current_binding_level to the global
2375 scope isn't enough, because more binding levels may be pushed. */
2376 struct saved_scope *scope_chain;
2378 /* Mark ST for GC. */
2382 struct stmt_tree *st;
2384 ggc_mark_tree (st->x_last_stmt);
2385 ggc_mark_tree (st->x_last_expr_type);
2388 /* Mark ARG (which is really a struct saved_scope **) for GC. */
2391 mark_saved_scope (arg)
2394 struct saved_scope *t = *(struct saved_scope **)arg;
2397 mark_binding_level (&t->class_bindings);
2398 ggc_mark_tree (t->old_bindings);
2399 ggc_mark_tree (t->old_namespace);
2400 ggc_mark_tree (t->class_name);
2401 ggc_mark_tree (t->class_type);
2402 ggc_mark_tree (t->access_specifier);
2403 ggc_mark_tree (t->function_decl);
2405 ggc_mark_tree_varray (t->lang_base);
2406 ggc_mark_tree (t->lang_name);
2407 ggc_mark_tree (t->x_function_parms);
2408 ggc_mark_tree (t->template_parms);
2409 ggc_mark_tree (t->x_previous_class_type);
2410 ggc_mark_tree (t->x_previous_class_values);
2411 ggc_mark_tree (t->x_saved_tree);
2412 ggc_mark_tree (t->incomplete);
2413 ggc_mark_tree (t->lookups);
2415 mark_stmt_tree (&t->x_stmt_tree);
2416 mark_binding_level (&t->bindings);
2422 store_bindings (names, old_bindings)
2423 tree names, old_bindings;
2426 for (t = names; t; t = TREE_CHAIN (t))
2428 tree binding, t1, id;
2430 if (TREE_CODE (t) == TREE_LIST)
2431 id = TREE_PURPOSE (t);
2436 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2437 we have no IDENTIFIER_BINDING if we have left the class
2438 scope, but cached the class-level declarations. */
2439 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2442 for (t1 = old_bindings; t1; t1 = TREE_CHAIN (t1))
2443 if (TREE_VEC_ELT (t1, 0) == id)
2446 binding = make_tree_vec (4);
2450 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2451 TREE_VEC_ELT (binding, 0) = id;
2452 TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2453 TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2454 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2455 IDENTIFIER_BINDING (id) = NULL_TREE;
2456 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2458 TREE_CHAIN (binding) = old_bindings;
2459 old_bindings = binding;
2463 return old_bindings;
2467 maybe_push_to_top_level (pseudo)
2470 struct saved_scope *s;
2471 struct binding_level *b;
2475 s = (struct saved_scope *) xcalloc (1, sizeof (struct saved_scope));
2477 b = scope_chain ? current_binding_level : 0;
2479 /* If we're in the middle of some function, save our state. */
2483 push_function_context_to (NULL_TREE);
2488 old_bindings = NULL_TREE;
2489 if (scope_chain && previous_class_type)
2490 old_bindings = store_bindings (previous_class_values, old_bindings);
2492 /* Have to include global_binding_level, because class-level decls
2493 aren't listed anywhere useful. */
2494 for (; b; b = b->level_chain)
2498 /* Template IDs are inserted into the global level. If they were
2499 inserted into namespace level, finish_file wouldn't find them
2500 when doing pending instantiations. Therefore, don't stop at
2501 namespace level, but continue until :: . */
2502 if (b == global_binding_level || (pseudo && b->template_parms_p))
2505 old_bindings = store_bindings (b->names, old_bindings);
2506 /* We also need to check class_shadowed to save class-level type
2507 bindings, since pushclass doesn't fill in b->names. */
2508 if (b->parm_flag == 2)
2509 old_bindings = store_bindings (b->class_shadowed, old_bindings);
2511 /* Unwind type-value slots back to top level. */
2512 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2513 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2515 s->prev = scope_chain;
2516 s->old_bindings = old_bindings;
2518 s->need_pop_function_context = need_pop;
2519 s->function_decl = current_function_decl;
2522 current_function_decl = NULL_TREE;
2523 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2524 current_lang_stack = &VARRAY_TREE (current_lang_base, 0);
2525 current_lang_name = lang_name_cplusplus;
2526 strict_prototype = strict_prototypes_lang_cplusplus;
2527 current_namespace = global_namespace;
2531 push_to_top_level ()
2533 maybe_push_to_top_level (0);
2537 pop_from_top_level ()
2539 struct saved_scope *s = scope_chain;
2542 /* Clear out class-level bindings cache. */
2543 if (previous_class_type)
2544 invalidate_class_lookup_cache ();
2546 VARRAY_FREE (current_lang_base);
2548 scope_chain = s->prev;
2549 for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2551 tree id = TREE_VEC_ELT (t, 0);
2554 SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2555 IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2556 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2560 if (current_lang_name == lang_name_cplusplus)
2561 strict_prototype = strict_prototypes_lang_cplusplus;
2562 else if (current_lang_name == lang_name_c)
2563 strict_prototype = strict_prototypes_lang_c;
2565 /* If we were in the middle of compiling a function, restore our
2567 if (s->need_pop_function_context)
2568 pop_function_context_from (NULL_TREE);
2569 current_function_decl = s->function_decl;
2574 /* Push a definition of struct, union or enum tag "name".
2575 into binding_level "b". "type" should be the type node,
2576 We assume that the tag "name" is not already defined.
2578 Note that the definition may really be just a forward reference.
2579 In that case, the TYPE_SIZE will be a NULL_TREE.
2581 C++ gratuitously puts all these tags in the name space. */
2583 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2584 record the shadowed value for this binding contour. TYPE is
2585 the type that ID maps to. */
2588 set_identifier_type_value_with_scope (id, type, b)
2591 struct binding_level *b;
2593 if (!b->namespace_p)
2595 /* Shadow the marker, not the real thing, so that the marker
2596 gets restored later. */
2597 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2599 = tree_cons (id, old_type_value, b->type_shadowed);
2603 tree binding = binding_for_name (id, current_namespace);
2604 BINDING_TYPE (binding) = type;
2605 /* Store marker instead of real type. */
2606 type = global_type_node;
2608 SET_IDENTIFIER_TYPE_VALUE (id, type);
2611 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2614 set_identifier_type_value (id, type)
2618 set_identifier_type_value_with_scope (id, type, current_binding_level);
2621 /* Return the type associated with id. */
2624 identifier_type_value (id)
2627 /* There is no type with that name, anywhere. */
2628 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2630 /* This is not the type marker, but the real thing. */
2631 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2632 return REAL_IDENTIFIER_TYPE_VALUE (id);
2633 /* Have to search for it. It must be on the global level, now.
2634 Ask lookup_name not to return non-types. */
2635 id = lookup_name_real (id, 2, 1, 0);
2637 return TREE_TYPE (id);
2641 /* Pop off extraneous binding levels left over due to syntax errors.
2643 We don't pop past namespaces, as they might be valid. */
2648 #ifdef DEBUG_CP_BINDING_LEVELS
2649 fprintf (stderr, "XXX entering pop_everything ()\n");
2651 while (!toplevel_bindings_p ())
2653 if (current_binding_level->parm_flag == 2)
2654 pop_nested_class ();
2658 #ifdef DEBUG_CP_BINDING_LEVELS
2659 fprintf (stderr, "XXX leaving pop_everything ()\n");
2663 /* The type TYPE is being declared. If it is a class template, or a
2664 specialization of a class template, do any processing required and
2665 perform error-checking. If IS_FRIEND is non-zero, this TYPE is
2666 being declared a friend. B is the binding level at which this TYPE
2669 Returns the TYPE_DECL for TYPE, which may have been altered by this
2673 maybe_process_template_type_declaration (type, globalize, b)
2676 struct binding_level* b;
2678 tree decl = TYPE_NAME (type);
2680 if (processing_template_parmlist)
2681 /* You can't declare a new template type in a template parameter
2682 list. But, you can declare a non-template type:
2684 template <class A*> struct S;
2686 is a forward-declaration of `A'. */
2690 maybe_check_template_type (type);
2692 my_friendly_assert (IS_AGGR_TYPE (type)
2693 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2696 if (processing_template_decl)
2698 /* This may change after the call to
2699 push_template_decl_real, but we want the original value. */
2700 tree name = DECL_NAME (decl);
2702 decl = push_template_decl_real (decl, globalize);
2703 /* If the current binding level is the binding level for the
2704 template parameters (see the comment in
2705 begin_template_parm_list) and the enclosing level is a class
2706 scope, and we're not looking at a friend, push the
2707 declaration of the member class into the class scope. In the
2708 friend case, push_template_decl will already have put the
2709 friend into global scope, if appropriate. */
2710 if (TREE_CODE (type) != ENUMERAL_TYPE
2711 && !globalize && b->template_parms_p
2712 && b->level_chain->parm_flag == 2)
2714 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2715 /* Put this tag on the list of tags for the class, since
2716 that won't happen below because B is not the class
2717 binding level, but is instead the pseudo-global level. */
2718 b->level_chain->tags =
2719 tree_cons (name, type, b->level_chain->tags);
2720 if (!COMPLETE_TYPE_P (current_class_type))
2721 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2729 /* In C++, you don't have to write `struct S' to refer to `S'; you
2730 can just use `S'. We accomplish this by creating a TYPE_DECL as
2731 if the user had written `typedef struct S S'. Create and return
2732 the TYPE_DECL for TYPE. */
2735 create_implicit_typedef (name, type)
2741 decl = build_decl (TYPE_DECL, name, type);
2742 SET_DECL_ARTIFICIAL (decl);
2743 /* There are other implicit type declarations, like the one *within*
2744 a class that allows you to write `S::S'. We must distinguish
2746 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2747 TYPE_NAME (type) = decl;
2752 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2753 Normally put it into the inner-most non-tag-transparent scope,
2754 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2755 The latter is needed for implicit declarations. */
2758 pushtag (name, type, globalize)
2762 register struct binding_level *b;
2764 b = current_binding_level;
2765 while (b->tag_transparent
2766 || (globalize && b->parm_flag == 2))
2769 b->tags = tree_cons (name, type, b->tags);
2773 /* Do C++ gratuitous typedefing. */
2774 if (IDENTIFIER_TYPE_VALUE (name) != type)
2776 register tree d = NULL_TREE;
2778 tree context = TYPE_CONTEXT (type);
2782 tree cs = current_scope ();
2786 else if (cs != NULL_TREE && TYPE_P (cs))
2787 /* When declaring a friend class of a local class, we want
2788 to inject the newly named class into the scope
2789 containing the local class, not the namespace scope. */
2790 context = decl_function_context (get_type_decl (cs));
2793 context = current_namespace;
2795 if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2796 || b->parm_flag == 2)
2799 if (current_lang_name == lang_name_java)
2800 TYPE_FOR_JAVA (type) = 1;
2802 d = create_implicit_typedef (name, type);
2803 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2805 set_identifier_type_value_with_scope (name, type, b);
2807 d = maybe_process_template_type_declaration (type,
2810 if (b->parm_flag == 2)
2812 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2813 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2814 class. But if it's a member template class, we
2815 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2817 finish_member_declaration (d);
2819 pushdecl_class_level (d);
2822 d = pushdecl_with_scope (d, b);
2824 if (ANON_AGGRNAME_P (name))
2825 DECL_IGNORED_P (d) = 1;
2827 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2828 DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
2829 if (!uses_template_parms (type))
2830 DECL_ASSEMBLER_NAME (d)
2831 = get_identifier (build_overload_name (type, 1, 1));
2833 if (b->parm_flag == 2)
2835 if (!COMPLETE_TYPE_P (current_class_type))
2836 CLASSTYPE_TAGS (current_class_type) = b->tags;
2840 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2841 /* Use the canonical TYPE_DECL for this node. */
2842 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2845 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2846 will be the tagged type we just added to the current
2847 binding level. This fake NULL-named TYPE_DECL node helps
2848 dwarfout.c to know when it needs to output a
2849 representation of a tagged type, and it also gives us a
2850 convenient place to record the "scope start" address for
2853 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2854 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2858 /* Counter used to create anonymous type names. */
2860 static int anon_cnt = 0;
2862 /* Return an IDENTIFIER which can be used as a name for
2863 anonymous structs and unions. */
2870 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2871 return get_identifier (buf);
2874 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2875 This keeps dbxout from getting confused. */
2880 register struct binding_level *b;
2882 static int last_cnt = 0;
2884 /* Fast out if no new anon names were declared. */
2885 if (last_cnt == anon_cnt)
2888 b = current_binding_level;
2889 while (b->tag_transparent)
2894 /* A NULL purpose means we have already processed all tags
2895 from here to the end of the list. */
2896 if (TREE_PURPOSE (tags) == NULL_TREE)
2898 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2899 TREE_PURPOSE (tags) = NULL_TREE;
2900 tags = TREE_CHAIN (tags);
2902 last_cnt = anon_cnt;
2905 /* Subroutine of duplicate_decls: return truthvalue of whether
2906 or not types of these decls match.
2908 For C++, we must compare the parameter list so that `int' can match
2909 `int&' in a parameter position, but `int&' is not confused with
2913 decls_match (newdecl, olddecl)
2914 tree newdecl, olddecl;
2918 if (newdecl == olddecl)
2921 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2922 /* If the two DECLs are not even the same kind of thing, we're not
2923 interested in their types. */
2926 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2928 tree f1 = TREE_TYPE (newdecl);
2929 tree f2 = TREE_TYPE (olddecl);
2930 tree p1 = TYPE_ARG_TYPES (f1);
2931 tree p2 = TYPE_ARG_TYPES (f2);
2933 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2934 && ! (DECL_LANGUAGE (newdecl) == lang_c
2935 && DECL_LANGUAGE (olddecl) == lang_c))
2938 if (TREE_CODE (f1) != TREE_CODE (f2))
2941 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2943 if (! strict_prototypes_lang_c && DECL_LANGUAGE (olddecl) == lang_c
2946 types_match = self_promoting_args_p (p1);
2947 if (p1 == void_list_node)
2948 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2950 else if (!strict_prototypes_lang_c && DECL_LANGUAGE (olddecl)==lang_c
2951 && DECL_LANGUAGE (newdecl) == lang_c && p1 == NULL_TREE)
2953 types_match = self_promoting_args_p (p2);
2954 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2957 types_match = compparms (p1, p2);
2962 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2964 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2965 DECL_TEMPLATE_PARMS (olddecl)))
2968 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2971 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2972 DECL_TEMPLATE_RESULT (newdecl));
2976 if (TREE_TYPE (newdecl) == error_mark_node)
2977 types_match = TREE_TYPE (olddecl) == error_mark_node;
2978 else if (TREE_TYPE (olddecl) == NULL_TREE)
2979 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2980 else if (TREE_TYPE (newdecl) == NULL_TREE)
2983 types_match = comptypes (TREE_TYPE (newdecl),
2984 TREE_TYPE (olddecl),
2985 COMPARE_REDECLARATION);
2991 /* If NEWDECL is `static' and an `extern' was seen previously,
2992 warn about it. OLDDECL is the previous declaration.
2994 Note that this does not apply to the C++ case of declaring
2995 a variable `extern const' and then later `const'.
2997 Don't complain about built-in functions, since they are beyond
2998 the user's control. */
3001 warn_extern_redeclared_static (newdecl, olddecl)
3002 tree newdecl, olddecl;
3004 static const char *explicit_extern_static_warning
3005 = "`%D' was declared `extern' and later `static'";
3006 static const char *implicit_extern_static_warning
3007 = "`%D' was declared implicitly `extern' and later `static'";
3011 if (TREE_CODE (newdecl) == TYPE_DECL
3012 || TREE_CODE (newdecl) == TEMPLATE_DECL)
3015 /* Don't get confused by static member functions; that's a different
3017 if (TREE_CODE (newdecl) == FUNCTION_DECL
3018 && DECL_STATIC_FUNCTION_P (newdecl))
3021 /* If the old declaration was `static', or the new one isn't, then
3022 then everything is OK. */
3023 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
3026 /* It's OK to declare a builtin function as `static'. */
3027 if (TREE_CODE (olddecl) == FUNCTION_DECL
3028 && DECL_ARTIFICIAL (olddecl))
3031 name = DECL_ASSEMBLER_NAME (newdecl);
3032 cp_pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
3033 ? implicit_extern_static_warning
3034 : explicit_extern_static_warning, newdecl);
3035 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
3038 /* Handle when a new declaration NEWDECL has the same name as an old
3039 one OLDDECL in the same binding contour. Prints an error message
3042 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
3043 Otherwise, return 0. */
3046 duplicate_decls (newdecl, olddecl)
3047 tree newdecl, olddecl;
3049 unsigned olddecl_uid = DECL_UID (olddecl);
3050 int olddecl_friend = 0, types_match = 0;
3051 int new_defines_function = 0;
3053 if (newdecl == olddecl)
3056 types_match = decls_match (newdecl, olddecl);
3058 /* If either the type of the new decl or the type of the old decl is an
3059 error_mark_node, then that implies that we have already issued an
3060 error (earlier) for some bogus type specification, and in that case,
3061 it is rather pointless to harass the user with yet more error message
3062 about the same declaration, so just pretend the types match here. */
3063 if (TREE_TYPE (newdecl) == error_mark_node
3064 || TREE_TYPE (olddecl) == error_mark_node)
3067 /* Check for redeclaration and other discrepancies. */
3068 if (TREE_CODE (olddecl) == FUNCTION_DECL
3069 && DECL_ARTIFICIAL (olddecl))
3071 if (TREE_CODE (newdecl) != FUNCTION_DECL)
3073 /* If you declare a built-in or predefined function name as static,
3074 the old definition is overridden, but optionally warn this was a
3075 bad choice of name. */
3076 if (! TREE_PUBLIC (newdecl))
3079 cp_warning ("shadowing %s function `%#D'",
3080 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3082 /* Discard the old built-in function. */
3085 /* If the built-in is not ansi, then programs can override
3086 it even globally without an error. */
3087 else if (! DECL_BUILT_IN (olddecl))
3088 cp_warning ("library function `%#D' redeclared as non-function `%#D'",
3092 cp_error ("declaration of `%#D'", newdecl);
3093 cp_error ("conflicts with built-in declaration `%#D'",
3098 else if (!types_match)
3100 if ((DECL_LANGUAGE (newdecl) == lang_c
3101 && DECL_LANGUAGE (olddecl) == lang_c)
3102 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3103 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3105 /* A near match; override the builtin. */
3107 if (TREE_PUBLIC (newdecl))
3109 cp_warning ("new declaration `%#D'", newdecl);
3110 cp_warning ("ambiguates built-in declaration `%#D'",
3113 else if (warn_shadow)
3114 cp_warning ("shadowing %s function `%#D'",
3115 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3119 /* Discard the old built-in function. */
3123 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3125 /* If a builtin function is redeclared as `static', merge
3126 the declarations, but make the original one static. */
3127 DECL_THIS_STATIC (olddecl) = 1;
3128 TREE_PUBLIC (olddecl) = 0;
3130 /* Make the olddeclaration consistent with the new one so that
3131 all remnants of the builtin-ness of this function will be
3133 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3134 DECL_RTL (olddecl) = DECL_RTL (newdecl);
3135 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3136 SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
3140 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3142 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3143 && TREE_CODE (newdecl) != TYPE_DECL
3144 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3145 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3146 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3147 && TREE_CODE (olddecl) != TYPE_DECL
3148 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3149 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3152 /* We do nothing special here, because C++ does such nasty
3153 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3154 get shadowed, and know that if we need to find a TYPE_DECL
3155 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3156 slot of the identifier. */
3160 if ((TREE_CODE (newdecl) == FUNCTION_DECL
3161 && DECL_FUNCTION_TEMPLATE_P (olddecl))
3162 || (TREE_CODE (olddecl) == FUNCTION_DECL
3163 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3166 cp_error ("`%#D' redeclared as different kind of symbol", newdecl);
3167 if (TREE_CODE (olddecl) == TREE_LIST)
3168 olddecl = TREE_VALUE (olddecl);
3169 cp_error_at ("previous declaration of `%#D'", olddecl);
3171 /* New decl is completely inconsistent with the old one =>
3172 tell caller to replace the old one. */
3176 else if (!types_match)
3178 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3179 /* These are certainly not duplicate declarations; they're
3180 from different scopes. */
3183 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3185 /* The name of a class template may not be declared to refer to
3186 any other template, class, function, object, namespace, value,
3187 or type in the same scope. */
3188 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3189 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3191 cp_error ("declaration of template `%#D'", newdecl);
3192 cp_error_at ("conflicts with previous declaration `%#D'",
3195 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3196 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3197 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3198 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3199 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3200 DECL_TEMPLATE_PARMS (olddecl)))
3202 cp_error ("new declaration `%#D'", newdecl);
3203 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3207 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3209 if (DECL_LANGUAGE (newdecl) == lang_c
3210 && DECL_LANGUAGE (olddecl) == lang_c)
3212 cp_error ("declaration of C function `%#D' conflicts with",
3214 cp_error_at ("previous declaration `%#D' here", olddecl);
3216 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3217 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3219 cp_error ("new declaration `%#D'", newdecl);
3220 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3226 /* Already complained about this, so don't do so again. */
3227 else if (current_class_type == NULL_TREE
3228 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3230 cp_error ("conflicting types for `%#D'", newdecl);
3231 cp_error_at ("previous declaration as `%#D'", olddecl);
3234 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3235 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3236 && (!DECL_TEMPLATE_INFO (newdecl)
3237 || (DECL_TI_TEMPLATE (newdecl)
3238 != DECL_TI_TEMPLATE (olddecl))))
3239 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3240 && (!DECL_TEMPLATE_INFO (olddecl)
3241 || (DECL_TI_TEMPLATE (olddecl)
3242 != DECL_TI_TEMPLATE (newdecl))))))
3243 /* It's OK to have a template specialization and a non-template
3244 with the same type, or to have specializations of two
3245 different templates with the same type. Note that if one is a
3246 specialization, and the other is an instantiation of the same
3247 template, that we do not exit at this point. That situation
3248 can occur if we instantiate a template class, and then
3249 specialize one of its methods. This situation is legal, but
3250 the declarations must be merged in the usual way. */
3252 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3253 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3254 && !DECL_USE_TEMPLATE (newdecl))
3255 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3256 && !DECL_USE_TEMPLATE (olddecl))))
3257 /* One of the declarations is a template instantiation, and the
3258 other is not a template at all. That's OK. */
3260 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3261 && DECL_NAMESPACE_ALIAS (newdecl)
3262 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3263 /* Redeclaration of namespace alias, ignore it. */
3267 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3270 cp_error (errmsg, newdecl);
3271 if (DECL_NAME (olddecl) != NULL_TREE)
3272 cp_error_at ((DECL_INITIAL (olddecl)
3273 && namespace_bindings_p ())
3274 ? "`%#D' previously defined here"
3275 : "`%#D' previously declared here", olddecl);
3277 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3278 && DECL_INITIAL (olddecl) != NULL_TREE
3279 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3280 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3282 /* Prototype decl follows defn w/o prototype. */
3283 cp_warning_at ("prototype for `%#D'", newdecl);
3284 cp_warning_at ("follows non-prototype definition here", olddecl);
3286 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3287 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3289 /* extern "C" int foo ();
3290 int foo () { bar (); }
3292 if (current_lang_stack
3293 == &VARRAY_TREE (current_lang_base, 0))
3294 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3297 cp_error_at ("previous declaration of `%#D' with %L linkage",
3298 olddecl, DECL_LANGUAGE (olddecl));
3299 cp_error ("conflicts with new declaration with %L linkage",
3300 DECL_LANGUAGE (newdecl));
3304 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3306 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3308 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3309 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3312 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3313 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3315 for (; t1 && t1 != void_list_node;
3316 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3317 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3319 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3324 cp_pedwarn ("default argument given for parameter %d of `%#D'",
3326 cp_pedwarn_at ("after previous specification in `%#D'",
3332 cp_error ("default argument given for parameter %d of `%#D'",
3334 cp_error_at ("after previous specification in `%#D'",
3339 if (DECL_THIS_INLINE (newdecl) && ! DECL_THIS_INLINE (olddecl)
3340 && TREE_ADDRESSABLE (olddecl) && warn_inline)
3342 cp_warning ("`%#D' was used before it was declared inline",
3344 cp_warning_at ("previous non-inline declaration here",
3350 /* If new decl is `static' and an `extern' was seen previously,
3352 warn_extern_redeclared_static (newdecl, olddecl);
3354 /* We have committed to returning 1 at this point. */
3355 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3357 /* Now that functions must hold information normally held
3358 by field decls, there is extra work to do so that
3359 declaration information does not get destroyed during
3361 if (DECL_VINDEX (olddecl))
3362 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3363 if (DECL_VIRTUAL_CONTEXT (olddecl))
3364 DECL_VIRTUAL_CONTEXT (newdecl) = DECL_VIRTUAL_CONTEXT (olddecl);
3365 if (DECL_CONTEXT (olddecl))
3366 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3367 if (DECL_PENDING_INLINE_INFO (newdecl) == (struct pending_inline *)0)
3368 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3369 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3370 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3371 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3372 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3373 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3374 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3375 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3377 /* Optionally warn about more than one declaration for the same
3378 name, but don't warn about a function declaration followed by a
3380 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3381 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3382 /* Don't warn about extern decl followed by definition. */
3383 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3384 /* Don't warn about friends, let add_friend take care of it. */
3385 && ! DECL_FRIEND_P (newdecl))
3387 cp_warning ("redundant redeclaration of `%D' in same scope", newdecl);
3388 cp_warning_at ("previous declaration of `%D'", olddecl);
3392 /* Deal with C++: must preserve virtual function table size. */
3393 if (TREE_CODE (olddecl) == TYPE_DECL)
3395 register tree newtype = TREE_TYPE (newdecl);
3396 register tree oldtype = TREE_TYPE (olddecl);
3398 if (newtype != error_mark_node && oldtype != error_mark_node
3399 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3401 CLASSTYPE_VSIZE (newtype) = CLASSTYPE_VSIZE (oldtype);
3402 CLASSTYPE_FRIEND_CLASSES (newtype)
3403 = CLASSTYPE_FRIEND_CLASSES (oldtype);
3407 /* Copy all the DECL_... slots specified in the new decl
3408 except for any that we copy here from the old type. */
3409 DECL_MACHINE_ATTRIBUTES (newdecl)
3410 = merge_machine_decl_attributes (olddecl, newdecl);
3412 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3414 if (! duplicate_decls (DECL_TEMPLATE_RESULT (newdecl),
3415 DECL_TEMPLATE_RESULT (olddecl)))
3416 cp_error ("invalid redeclaration of %D", newdecl);
3417 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3418 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3419 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3420 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3427 /* Automatically handles default parameters. */
3428 tree oldtype = TREE_TYPE (olddecl);
3431 /* Merge the data types specified in the two decls. */
3432 newtype = common_type (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3434 if (TREE_CODE (newdecl) == VAR_DECL)
3435 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3436 /* Do this after calling `common_type' so that default
3437 parameters don't confuse us. */
3438 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3439 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3440 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3442 TREE_TYPE (newdecl) = build_exception_variant (newtype,
3443 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3444 TREE_TYPE (olddecl) = build_exception_variant (newtype,
3445 TYPE_RAISES_EXCEPTIONS (oldtype));
3447 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3448 && DECL_SOURCE_LINE (olddecl) != 0
3450 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3451 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3453 cp_error ("declaration of `%F' throws different exceptions",
3455 cp_error_at ("than previous declaration `%F'", olddecl);
3458 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3460 /* Lay the type out, unless already done. */
3461 if (! same_type_p (newtype, oldtype)
3462 && TREE_TYPE (newdecl) != error_mark_node
3463 && !(processing_template_decl && uses_template_parms (newdecl)))
3464 layout_type (TREE_TYPE (newdecl));
3466 if ((TREE_CODE (newdecl) == VAR_DECL
3467 || TREE_CODE (newdecl) == PARM_DECL
3468 || TREE_CODE (newdecl) == RESULT_DECL
3469 || TREE_CODE (newdecl) == FIELD_DECL
3470 || TREE_CODE (newdecl) == TYPE_DECL)
3471 && !(processing_template_decl && uses_template_parms (newdecl)))
3472 layout_decl (newdecl, 0);
3474 /* Merge the type qualifiers. */
3475 if (TREE_READONLY (newdecl))
3476 TREE_READONLY (olddecl) = 1;
3477 if (TREE_THIS_VOLATILE (newdecl))
3478 TREE_THIS_VOLATILE (olddecl) = 1;
3480 /* Merge the initialization information. */
3481 if (DECL_INITIAL (newdecl) == NULL_TREE
3482 && DECL_INITIAL (olddecl) != NULL_TREE)
3484 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3485 DECL_SOURCE_FILE (newdecl) = DECL_SOURCE_FILE (olddecl);
3486 DECL_SOURCE_LINE (newdecl) = DECL_SOURCE_LINE (olddecl);
3487 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3488 && DECL_LANG_SPECIFIC (newdecl)
3489 && DECL_LANG_SPECIFIC (olddecl))
3490 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3493 /* Merge the section attribute.
3494 We want to issue an error if the sections conflict but that must be
3495 done later in decl_attributes since we are called before attributes
3497 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3498 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3500 /* Keep the old rtl since we can safely use it. */
3501 DECL_RTL (newdecl) = DECL_RTL (olddecl);
3503 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3505 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3506 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3507 DECL_NO_CHECK_MEMORY_USAGE (newdecl)
3508 |= DECL_NO_CHECK_MEMORY_USAGE (olddecl);
3509 DECL_NO_LIMIT_STACK (newdecl)
3510 |= DECL_NO_LIMIT_STACK (olddecl);
3513 /* If cannot merge, then use the new type and qualifiers,
3514 and don't preserve the old rtl. */
3517 /* Clean out any memory we had of the old declaration. */
3518 tree oldstatic = value_member (olddecl, static_aggregates);
3520 TREE_VALUE (oldstatic) = error_mark_node;
3522 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3523 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3524 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3525 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3528 /* Merge the storage class information. */
3529 DECL_WEAK (newdecl) |= DECL_WEAK (olddecl);
3530 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3531 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3532 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3533 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3534 if (! DECL_EXTERNAL (olddecl))
3535 DECL_EXTERNAL (newdecl) = 0;
3537 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3539 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3540 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3541 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3542 DECL_TEMPLATE_INSTANTIATED (newdecl)
3543 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3544 /* Don't really know how much of the language-specific
3545 values we should copy from old to new. */
3546 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3547 DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
3548 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3549 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3550 olddecl_friend = DECL_FRIEND_P (olddecl);
3552 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3553 if (TREE_CODE (newdecl) == FUNCTION_DECL
3554 || DECL_FUNCTION_TEMPLATE_P (newdecl))
3555 DECL_BEFRIENDING_CLASSES (newdecl)
3556 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3557 DECL_BEFRIENDING_CLASSES (olddecl));
3560 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3562 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3563 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3565 /* If newdecl is not a specialization, then it is not a
3566 template-related function at all. And that means that we
3567 shoud have exited above, returning 0. */
3568 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3571 if (TREE_USED (olddecl))
3572 /* From [temp.expl.spec]:
3574 If a template, a member template or the member of a class
3575 template is explicitly specialized then that
3576 specialization shall be declared before the first use of
3577 that specialization that would cause an implicit
3578 instantiation to take place, in every translation unit in
3579 which such a use occurs. */
3580 cp_error ("explicit specialization of %D after first use",
3583 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3585 DECL_THIS_INLINE (newdecl) |= DECL_THIS_INLINE (olddecl);
3587 /* If either decl says `inline', this fn is inline, unless its
3588 definition was passed already. */
3589 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3590 DECL_INLINE (olddecl) = 1;
3591 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3595 DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
3596 DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
3597 DECL_RTL (olddecl) = DECL_RTL (newdecl);
3599 if (! types_match || new_defines_function)
3601 /* These need to be copied so that the names are available.
3602 Note that if the types do match, we'll preserve inline
3603 info and other bits, but if not, we won't. */
3604 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3605 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3607 if (new_defines_function)
3608 /* If defining a function declared with other language
3609 linkage, use the previously declared language linkage. */
3610 DECL_LANGUAGE (newdecl) = DECL_LANGUAGE (olddecl);
3611 else if (types_match)
3613 /* If redeclaring a builtin function, and not a definition,
3614 it stays built in. */
3615 if (DECL_BUILT_IN (olddecl))
3617 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3618 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3619 /* If we're keeping the built-in definition, keep the rtl,
3620 regardless of declaration matches. */
3621 DECL_RTL (newdecl) = DECL_RTL (olddecl);
3624 DECL_FRAME_SIZE (newdecl) = DECL_FRAME_SIZE (olddecl);
3626 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3627 if ((DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl)))
3628 /* Previously saved insns go together with
3629 the function's previous definition. */
3630 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3631 /* Don't clear out the arguments if we're redefining a function. */
3632 if (DECL_ARGUMENTS (olddecl))
3633 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3637 if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3639 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3642 /* Now preserve various other info from the definition. */
3643 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3644 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3645 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3646 DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
3648 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3652 function_size = sizeof (struct tree_decl);
3654 bcopy ((char *) newdecl + sizeof (struct tree_common),
3655 (char *) olddecl + sizeof (struct tree_common),
3656 function_size - sizeof (struct tree_common));
3658 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3660 /* If newdecl is a template instantiation, it is possible that
3661 the following sequence of events has occurred:
3663 o A friend function was declared in a class template. The
3664 class template was instantiated.
3666 o The instantiation of the friend declaration was
3667 recorded on the instantiation list, and is newdecl.
3669 o Later, however, instantiate_class_template called pushdecl
3670 on the newdecl to perform name injection. But, pushdecl in
3671 turn called duplicate_decls when it discovered that another
3672 declaration of a global function with the same name already
3675 o Here, in duplicate_decls, we decided to clobber newdecl.
3677 If we're going to do that, we'd better make sure that
3678 olddecl, and not newdecl, is on the list of
3679 instantiations so that if we try to do the instantiation
3680 again we won't get the clobbered declaration. */
3682 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3683 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3685 for (; decls; decls = TREE_CHAIN (decls))
3686 if (TREE_VALUE (decls) == newdecl)
3687 TREE_VALUE (decls) = olddecl;
3692 bcopy ((char *) newdecl + sizeof (struct tree_common),
3693 (char *) olddecl + sizeof (struct tree_common),
3694 sizeof (struct tree_decl) - sizeof (struct tree_common)
3695 + tree_code_length [(int)TREE_CODE (newdecl)] * sizeof (char *));
3698 DECL_UID (olddecl) = olddecl_uid;
3700 DECL_FRIEND_P (olddecl) = 1;
3702 /* NEWDECL contains the merged attribute lists.
3703 Update OLDDECL to be the same. */
3704 DECL_MACHINE_ATTRIBUTES (olddecl) = DECL_MACHINE_ATTRIBUTES (newdecl);
3709 /* Record a decl-node X as belonging to the current lexical scope.
3710 Check for errors (such as an incompatible declaration for the same
3711 name already seen in the same scope).
3713 Returns either X or an old decl for the same name.
3714 If an old decl is returned, it may have been smashed
3715 to agree with what X says. */
3723 int need_new_binding;
3725 /* We shouldn't be calling pushdecl when we're generating RTL for a
3726 function that we already did semantic analysis on previously. */
3727 my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3730 name = DECL_ASSEMBLER_NAME (x);
3731 need_new_binding = 1;
3733 if (DECL_TEMPLATE_PARM_P (x))
3734 /* Template parameters have no context; they are not X::T even
3735 when declared within a class or namespace. */
3739 if (current_function_decl && x != current_function_decl
3740 /* A local declaration for a function doesn't constitute
3742 && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3743 /* A local declaration for an `extern' variable is in the
3744 scoped of the current namespace, not the current
3746 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3747 && !DECL_CONTEXT (x))
3748 DECL_CONTEXT (x) = current_function_decl;
3749 if (!DECL_CONTEXT (x))
3750 DECL_CONTEXT (x) = FROB_CONTEXT (current_namespace);
3752 /* If this is the declaration for a namespace-scope function,
3753 but the declaration itself is in a local scope, mark the
3755 if (TREE_CODE (x) == FUNCTION_DECL
3756 && DECL_NAMESPACE_SCOPE_P (x)
3757 && current_function_decl
3758 && x != current_function_decl)
3759 DECL_LOCAL_FUNCTION_P (x) = 1;
3762 /* Type are looked up using the DECL_NAME, as that is what the rest of the
3763 compiler wants to use. */
3764 if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
3765 || TREE_CODE (x) == NAMESPACE_DECL)
3766 name = DECL_NAME (x);
3771 /* Not needed...see below. */
3775 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3776 name = TREE_OPERAND (name, 0);
3778 /* Namespace-scoped variables are not found in the current level. */
3779 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x))
3780 t = namespace_binding (name, DECL_CONTEXT (x));
3782 t = lookup_name_current_level (name);
3783 if (t == error_mark_node)
3785 /* error_mark_node is 0 for a while during initialization! */
3787 cp_error_at ("`%#D' used prior to declaration", x);
3790 else if (t != NULL_TREE)
3793 /* This is turned off until I have time to do it right (bpk). */
3794 /* With the code below that uses it... */
3795 file = DECL_SOURCE_FILE (t);
3796 line = DECL_SOURCE_LINE (t);
3798 if (TREE_CODE (t) == PARM_DECL)
3800 if (DECL_CONTEXT (t) == NULL_TREE)
3801 fatal ("parse errors have confused me too much");
3803 /* Check for duplicate params. */
3804 if (duplicate_decls (x, t))
3807 else if (((TREE_CODE (x) == FUNCTION_DECL && DECL_LANGUAGE (x) == lang_c)
3808 || DECL_FUNCTION_TEMPLATE_P (x))
3809 && is_overloaded_fn (t))
3810 /* Don't do anything just yet. */;
3811 else if (t == wchar_decl_node)
3813 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3814 cp_pedwarn ("redeclaration of wchar_t as `%T'", TREE_TYPE (x));
3816 /* Throw away the redeclaration. */
3819 else if (TREE_CODE (t) != TREE_CODE (x))
3821 if (duplicate_decls (x, t))
3824 else if (duplicate_decls (x, t))
3827 /* This is turned off until I have time to do it right (bpk). */
3829 /* Also warn if they did a prototype with `static' on it, but
3830 then later left the `static' off. */
3831 if (! TREE_PUBLIC (name) && TREE_PUBLIC (x))
3833 if (DECL_LANG_SPECIFIC (t) && DECL_FRIEND_P (t))
3838 cp_warning ("`static' missing from declaration of `%D'",
3840 warning_with_file_and_line (file, line,
3841 "previous declaration of `%s'",
3842 decl_as_string (t, 0));
3845 /* Now fix things so it'll do what they expect. */
3846 if (current_function_decl)
3847 TREE_PUBLIC (current_function_decl) = 0;
3849 /* Due to interference in memory reclamation (X may be
3850 obstack-deallocated at this point), we must guard against
3851 one really special case. [jason: This should be handled
3852 by start_function] */
3853 if (current_function_decl == x)
3854 current_function_decl = t;
3856 if (TREE_CODE (t) == TYPE_DECL)
3857 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3858 else if (TREE_CODE (t) == FUNCTION_DECL)
3859 check_default_args (t);
3863 else if (DECL_MAIN_P (x))
3865 /* A redeclaration of main, but not a duplicate of the
3870 This function shall not be overloaded. */
3871 cp_error_at ("invalid redeclaration of `%D'", t);
3872 cp_error ("as `%D'", x);
3873 /* We don't try to push this declaration since that
3879 check_template_shadow (x);
3881 /* If this is a function conjured up by the backend, massage it
3882 so it looks friendly. */
3883 if (TREE_CODE (x) == FUNCTION_DECL
3884 && ! DECL_LANG_SPECIFIC (x))
3886 retrofit_lang_decl (x);
3887 DECL_LANGUAGE (x) = lang_c;
3890 if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_FUNCTION_MEMBER_P (x))
3892 t = push_overloaded_decl (x, PUSH_LOCAL);
3895 if (!namespace_bindings_p ())
3896 /* We do not need to create a binding for this name;
3897 push_overloaded_decl will have already done so if
3899 need_new_binding = 0;
3901 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3903 t = push_overloaded_decl (x, PUSH_GLOBAL);
3905 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3909 /* If declaring a type as a typedef, copy the type (unless we're
3910 at line 0), and install this TYPE_DECL as the new type's typedef
3911 name. See the extensive comment in ../c-decl.c (pushdecl). */
3912 if (TREE_CODE (x) == TYPE_DECL)
3914 tree type = TREE_TYPE (x);
3915 if (DECL_SOURCE_LINE (x) == 0)
3917 if (TYPE_NAME (type) == 0)
3918 TYPE_NAME (type) = x;
3920 else if (type != error_mark_node && TYPE_NAME (type) != x
3921 /* We don't want to copy the type when all we're
3922 doing is making a TYPE_DECL for the purposes of
3924 && (!TYPE_NAME (type)
3925 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3927 DECL_ORIGINAL_TYPE (x) = type;
3928 type = build_type_copy (type);
3929 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3930 TYPE_NAME (type) = x;
3931 TREE_TYPE (x) = type;
3934 if (type != error_mark_node
3936 && TYPE_IDENTIFIER (type))
3937 set_identifier_type_value_with_scope (DECL_NAME (x), type,
3938 current_binding_level);
3942 /* Multiple external decls of the same identifier ought to match.
3944 We get warnings about inline functions where they are defined.
3945 We get warnings about other functions from push_overloaded_decl.
3947 Avoid duplicate warnings where they are used. */
3948 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3952 if (IDENTIFIER_NAMESPACE_VALUE (name) != NULL_TREE
3953 && (DECL_EXTERNAL (IDENTIFIER_NAMESPACE_VALUE (name))
3954 || TREE_PUBLIC (IDENTIFIER_NAMESPACE_VALUE (name))))
3955 decl = IDENTIFIER_NAMESPACE_VALUE (name);
3960 /* If different sort of thing, we already gave an error. */
3961 && TREE_CODE (decl) == TREE_CODE (x)
3962 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3964 cp_pedwarn ("type mismatch with previous external decl", x);
3965 cp_pedwarn_at ("previous external decl of `%#D'", decl);
3969 /* This name is new in its binding level.
3970 Install the new declaration and return it. */
3971 if (namespace_bindings_p ())
3973 /* Install a global value. */
3975 /* If the first global decl has external linkage,
3976 warn if we later see static one. */
3977 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3978 TREE_PUBLIC (name) = 1;
3980 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3982 /* For an ordinary function, we create a binding from
3983 the mangled name (i.e., NAME) to the DECL. But, for
3984 an `extern "C"' function, the mangled name and the
3985 ordinary name are the same so we need not do this. */
3986 && !(TREE_CODE (x) == FUNCTION_DECL &&
3987 DECL_LANGUAGE (x) == lang_c))
3989 if (TREE_CODE (x) == FUNCTION_DECL)
3991 ((IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE)
3992 || (IDENTIFIER_GLOBAL_VALUE (name) == x), 378);
3993 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3996 /* Don't forget if the function was used via an implicit decl. */
3997 if (IDENTIFIER_IMPLICIT_DECL (name)
3998 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4001 /* Don't forget if its address was taken in that way. */
4002 if (IDENTIFIER_IMPLICIT_DECL (name)
4003 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4004 TREE_ADDRESSABLE (x) = 1;
4006 /* Warn about mismatches against previous implicit decl. */
4007 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4008 /* If this real decl matches the implicit, don't complain. */
4009 && ! (TREE_CODE (x) == FUNCTION_DECL
4010 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4012 ("`%D' was previously implicitly declared to return `int'", x);
4014 /* If new decl is `static' and an `extern' was seen previously,
4016 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4017 warn_extern_redeclared_static (x, t);
4021 /* Here to install a non-global value. */
4022 tree oldlocal = IDENTIFIER_VALUE (name);
4023 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4025 if (need_new_binding)
4027 push_local_binding (name, x, 0);
4028 /* Because push_local_binding will hook X on to the
4029 current_binding_level's name list, we don't want to
4030 do that again below. */
4031 need_new_binding = 0;
4034 /* If this is a TYPE_DECL, push it into the type value slot. */
4035 if (TREE_CODE (x) == TYPE_DECL)
4036 set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4037 current_binding_level);
4039 /* Clear out any TYPE_DECL shadowed by a namespace so that
4040 we won't think this is a type. The C struct hack doesn't
4041 go through namespaces. */
4042 if (TREE_CODE (x) == NAMESPACE_DECL)
4043 set_identifier_type_value_with_scope (name, NULL_TREE,
4044 current_binding_level);
4051 && TREE_CODE (oldlocal) == VAR_DECL
4052 && DECL_DEAD_FOR_LOCAL (oldlocal))
4053 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4055 if (oldlocal == NULL_TREE)
4056 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4059 /* If this is an extern function declaration, see if we
4060 have a global definition or declaration for the function. */
4061 if (oldlocal == NULL_TREE
4062 && DECL_EXTERNAL (x)
4063 && oldglobal != NULL_TREE
4064 && TREE_CODE (x) == FUNCTION_DECL
4065 && TREE_CODE (oldglobal) == FUNCTION_DECL)
4067 /* We have one. Their types must agree. */
4068 if (decls_match (x, oldglobal))
4072 cp_warning ("extern declaration of `%#D' doesn't match", x);
4073 cp_warning_at ("global declaration `%#D'", oldglobal);
4076 /* If we have a local external declaration,
4077 and no file-scope declaration has yet been seen,
4078 then if we later have a file-scope decl it must not be static. */
4079 if (oldlocal == NULL_TREE
4080 && oldglobal == NULL_TREE
4081 && DECL_EXTERNAL (x)
4083 TREE_PUBLIC (name) = 1;
4085 /* Warn if shadowing an argument at the top level of the body. */
4086 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4087 /* Inline decls shadow nothing. */
4088 && !DECL_FROM_INLINE (x)
4089 && TREE_CODE (oldlocal) == PARM_DECL
4090 /* Don't complain if it's from an enclosing function. */
4091 && DECL_CONTEXT (oldlocal) == current_function_decl
4092 && TREE_CODE (x) != PARM_DECL)
4094 /* Go to where the parms should be and see if we
4096 struct binding_level *b = current_binding_level->level_chain;
4102 if (b->parm_flag == 1)
4103 cp_error ("declaration of `%#D' shadows a parameter", name);
4106 /* Maybe warn if shadowing something else. */
4107 if (warn_shadow && !DECL_EXTERNAL (x)
4108 /* Inline decls shadow nothing. */
4109 && !DECL_FROM_INLINE (x)
4110 /* No shadow warnings for internally generated vars. */
4111 && ! DECL_ARTIFICIAL (x)
4112 /* No shadow warnings for vars made for inlining. */
4113 && ! DECL_FROM_INLINE (x))
4115 if (oldlocal != NULL_TREE && TREE_CODE (oldlocal) == PARM_DECL)
4116 warning ("declaration of `%s' shadows a parameter",
4117 IDENTIFIER_POINTER (name));
4118 else if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4119 && current_class_ptr
4120 && !TREE_STATIC (name))
4121 warning ("declaration of `%s' shadows a member of `this'",
4122 IDENTIFIER_POINTER (name));
4123 else if (oldlocal != NULL_TREE)
4124 warning ("declaration of `%s' shadows previous local",
4125 IDENTIFIER_POINTER (name));
4126 else if (oldglobal != NULL_TREE)
4127 /* XXX shadow warnings in outer-more namespaces */
4128 warning ("declaration of `%s' shadows global declaration",
4129 IDENTIFIER_POINTER (name));
4133 if (TREE_CODE (x) == FUNCTION_DECL)
4134 check_default_args (x);
4136 /* Keep count of variables in this level with incomplete type. */
4137 if (TREE_CODE (x) == VAR_DECL
4138 && TREE_TYPE (x) != error_mark_node
4139 && ((!COMPLETE_TYPE_P (TREE_TYPE (x))
4140 && PROMOTES_TO_AGGR_TYPE (TREE_TYPE (x), ARRAY_TYPE))
4141 /* RTTI TD entries are created while defining the type_info. */
4142 || (TYPE_LANG_SPECIFIC (TREE_TYPE (x))
4143 && TYPE_BEING_DEFINED (TREE_TYPE (x)))))
4145 if (namespace_bindings_p ())
4146 namespace_scope_incomplete
4147 = tree_cons (NULL_TREE, x, namespace_scope_incomplete);
4149 current_binding_level->incomplete
4150 = tree_cons (NULL_TREE, x, current_binding_level->incomplete);
4154 if (need_new_binding)
4155 add_decl_to_level (x,
4156 DECL_NAMESPACE_SCOPE_P (x)
4157 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4158 : current_binding_level);
4163 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4164 caller to set DECL_CONTEXT properly. */
4167 pushdecl_with_scope (x, level)
4169 struct binding_level *level;
4171 register struct binding_level *b;
4172 tree function_decl = current_function_decl;
4174 current_function_decl = NULL_TREE;
4175 if (level->parm_flag == 2)
4177 b = class_binding_level;
4178 class_binding_level = level;
4179 pushdecl_class_level (x);
4180 class_binding_level = b;
4184 b = current_binding_level;
4185 current_binding_level = level;
4187 current_binding_level = b;
4189 current_function_decl = function_decl;
4193 /* Like pushdecl, only it places X in the current namespace,
4197 pushdecl_namespace_level (x)
4200 register struct binding_level *b = current_binding_level;
4203 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4205 /* Now, the type_shadowed stack may screw us. Munge it so it does
4207 if (TREE_CODE (x) == TYPE_DECL)
4209 tree name = DECL_NAME (x);
4211 tree *ptr = (tree *)0;
4212 for (; b != global_binding_level; b = b->level_chain)
4214 tree shadowed = b->type_shadowed;
4215 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4216 if (TREE_PURPOSE (shadowed) == name)
4218 ptr = &TREE_VALUE (shadowed);
4219 /* Can't break out of the loop here because sometimes
4220 a binding level will have duplicate bindings for
4221 PT names. It's gross, but I haven't time to fix it. */
4224 newval = TREE_TYPE (x);
4225 if (ptr == (tree *)0)
4227 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4228 up here if this is changed to an assertion. --KR */
4229 SET_IDENTIFIER_TYPE_VALUE (name, newval);
4239 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4243 pushdecl_top_level (x)
4246 push_to_top_level ();
4247 x = pushdecl_namespace_level (x);
4248 pop_from_top_level ();
4252 /* Make the declaration of X appear in CLASS scope. */
4255 pushdecl_class_level (x)
4258 /* Don't use DECL_ASSEMBLER_NAME here! Everything that looks in class
4259 scope looks for the pre-mangled name. */
4262 if (TREE_CODE (x) == OVERLOAD)
4263 x = OVL_CURRENT (x);
4264 name = DECL_NAME (x);
4268 push_class_level_binding (name, x);
4269 if (TREE_CODE (x) == TYPE_DECL)
4270 set_identifier_type_value (name, TREE_TYPE (x));
4272 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4276 for (f = TYPE_FIELDS (TREE_TYPE (x));
4279 pushdecl_class_level (f);
4283 /* Enter DECL into the symbol table, if that's appropriate. Returns
4284 DECL, or a modified version thereof. */
4287 maybe_push_decl (decl)
4290 tree type = TREE_TYPE (decl);
4292 /* Add this decl to the current binding level, but not if it comes
4293 from another scope, e.g. a static member variable. TEM may equal
4294 DECL or it may be a previous decl of the same name. */
4295 if (decl == error_mark_node
4296 || (TREE_CODE (decl) != PARM_DECL
4297 && DECL_CONTEXT (decl) != NULL_TREE
4298 /* Definitions of namespace members outside their namespace are
4300 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4301 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4302 || TREE_CODE (type) == UNKNOWN_TYPE
4303 /* The declaration of a template specialization does not affect
4304 the functions available for overload resolution, so we do not
4306 || (TREE_CODE (decl) == FUNCTION_DECL
4307 && DECL_TEMPLATE_SPECIALIZATION (decl)))
4310 return pushdecl (decl);
4313 /* Make the declaration(s) of X appear in CLASS scope
4314 under the name NAME. */
4317 push_class_level_binding (name, x)
4322 /* The class_binding_level will be NULL if x is a template
4323 parameter name in a member template. */
4324 if (!class_binding_level)
4327 /* Make sure that this new member does not have the same name
4328 as a template parameter. */
4329 if (TYPE_BEING_DEFINED (current_class_type))
4330 check_template_shadow (x);
4332 /* If this declaration shadows a declaration from an enclosing
4333 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4334 we leave this class. Record the shadowed declaration here. */
4335 binding = IDENTIFIER_BINDING (name);
4337 && ((TREE_CODE (x) == OVERLOAD
4338 && BINDING_VALUE (binding)
4339 && is_overloaded_fn (BINDING_VALUE (binding)))
4340 || INHERITED_VALUE_BINDING_P (binding)))
4345 /* If the old binding was from a base class, and was for a tag
4346 name, slide it over to make room for the new binding. The
4347 old binding is still visible if explicitly qualified with a
4349 if (INHERITED_VALUE_BINDING_P (binding)
4350 && BINDING_VALUE (binding)
4351 && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4352 && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4353 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4355 old_decl = BINDING_TYPE (binding);
4356 BINDING_TYPE (binding) = BINDING_VALUE (binding);
4357 BINDING_VALUE (binding) = NULL_TREE;
4358 INHERITED_VALUE_BINDING_P (binding) = 0;
4361 old_decl = BINDING_VALUE (binding);
4363 /* There was already a binding for X containing fewer
4364 functions than are named in X. Find the previous
4365 declaration of X on the class-shadowed list, and update it. */
4366 for (shadow = class_binding_level->class_shadowed;
4368 shadow = TREE_CHAIN (shadow))
4369 if (TREE_PURPOSE (shadow) == name
4370 && TREE_TYPE (shadow) == old_decl)
4372 BINDING_VALUE (binding) = x;
4373 INHERITED_VALUE_BINDING_P (binding) = 0;
4374 TREE_TYPE (shadow) = x;
4379 /* If we didn't replace an existing binding, put the binding on the
4380 stack of bindings for the identifier, and update
4381 IDENTIFIER_CLASS_VALUE. */
4382 if (push_class_binding (name, x))
4384 class_binding_level->class_shadowed
4385 = tree_cons (name, IDENTIFIER_CLASS_VALUE (name),
4386 class_binding_level->class_shadowed);
4387 /* Record the value we are binding NAME to so that we can know
4388 what to pop later. */
4389 TREE_TYPE (class_binding_level->class_shadowed) = x;
4393 /* Insert another USING_DECL into the current binding level,
4394 returning this declaration. If this is a redeclaration,
4395 do nothing and return NULL_TREE. */
4398 push_using_decl (scope, name)
4404 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4405 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4406 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4407 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4411 decl = build_lang_decl (USING_DECL, name, void_type_node);
4412 DECL_INITIAL (decl) = scope;
4413 TREE_CHAIN (decl) = current_binding_level->usings;
4414 current_binding_level->usings = decl;
4418 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4419 changed (i.e. there was already a directive), or the fresh
4420 TREE_LIST otherwise. */
4423 push_using_directive (used)
4426 tree ud = current_binding_level->using_directives;
4427 tree iter, ancestor;
4429 /* Check if we already have this. */
4430 if (purpose_member (used, ud) != NULL_TREE)
4433 /* Recursively add all namespaces used. */
4434 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4435 push_using_directive (TREE_PURPOSE (iter));
4437 ancestor = namespace_ancestor (current_decl_namespace (), used);
4438 ud = current_binding_level->using_directives;
4439 ud = tree_cons (used, ancestor, ud);
4440 current_binding_level->using_directives = ud;
4444 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4445 other definitions already in place. We get around this by making
4446 the value of the identifier point to a list of all the things that
4447 want to be referenced by that name. It is then up to the users of
4448 that name to decide what to do with that list.
4450 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4451 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4453 FLAGS is a bitwise-or of the following values:
4454 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4456 PUSH_USING: DECL is being pushed as the result of a using
4459 The value returned may be a previous declaration if we guessed wrong
4460 about what language DECL should belong to (C or C++). Otherwise,
4461 it's always DECL (and never something that's not a _DECL). */
4464 push_overloaded_decl (decl, flags)
4468 tree name = DECL_NAME (decl);
4471 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4474 old = namespace_binding (name, DECL_CONTEXT (decl));
4476 old = lookup_name_current_level (name);
4480 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4482 tree t = TREE_TYPE (old);
4483 if (IS_AGGR_TYPE (t) && warn_shadow
4484 && (! DECL_IN_SYSTEM_HEADER (decl)
4485 || ! DECL_IN_SYSTEM_HEADER (old)))
4486 cp_warning ("`%#D' hides constructor for `%#T'", decl, t);
4489 else if (is_overloaded_fn (old))
4493 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4495 tree fn = OVL_CURRENT (tmp);
4497 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4498 && !(flags & PUSH_USING)
4499 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4500 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4501 cp_error ("`%#D' conflicts with previous using declaration `%#D'",
4504 if (duplicate_decls (decl, fn))
4510 cp_error_at ("previous non-function declaration `%#D'", old);
4511 cp_error ("conflicts with function declaration `%#D'", decl);
4516 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4518 if (old && TREE_CODE (old) != OVERLOAD)
4519 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4521 new_binding = ovl_cons (decl, old);
4522 if (flags & PUSH_USING)
4523 OVL_USED (new_binding) = 1;
4526 /* NAME is not ambiguous. */
4530 set_namespace_binding (name, current_namespace, new_binding);
4533 /* We only create an OVERLOAD if there was a previous binding at
4534 this level, or if decl is a template. In the former case, we
4535 need to remove the old binding and replace it with the new
4536 binding. We must also run through the NAMES on the binding
4537 level where the name was bound to update the chain. */
4539 if (TREE_CODE (new_binding) == OVERLOAD && old)
4543 for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4545 d = &TREE_CHAIN (*d))
4547 || (TREE_CODE (*d) == TREE_LIST
4548 && TREE_VALUE (*d) == old))
4550 if (TREE_CODE (*d) == TREE_LIST)
4551 /* Just replace the old binding with the new. */
4552 TREE_VALUE (*d) = new_binding;
4554 /* Build a TREE_LIST to wrap the OVERLOAD. */
4555 *d = tree_cons (NULL_TREE, new_binding,
4558 /* And update the CPLUS_BINDING node. */
4559 BINDING_VALUE (IDENTIFIER_BINDING (name))
4564 /* We should always find a previous binding in this case. */
4565 my_friendly_abort (0);
4568 /* Install the new binding. */
4569 push_local_binding (name, new_binding, flags);
4575 /* Generate an implicit declaration for identifier FUNCTIONID
4576 as a function of type int (). Print a warning if appropriate. */
4579 implicitly_declare (functionid)
4584 /* We used to reuse an old implicit decl here,
4585 but this loses with inline functions because it can clobber
4586 the saved decl chains. */
4587 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4589 DECL_EXTERNAL (decl) = 1;
4590 TREE_PUBLIC (decl) = 1;
4592 /* ISO standard says implicit declarations are in the innermost block.
4593 So we record the decl in the standard fashion. */
4595 rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
4598 /* Only one warning per identifier. */
4599 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4601 cp_pedwarn ("implicit declaration of function `%#D'", decl);
4604 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4609 /* Return zero if the declaration NEWDECL is valid
4610 when the declaration OLDDECL (assumed to be for the same name)
4611 has already been seen.
4612 Otherwise return an error message format string with a %s
4613 where the identifier should go. */
4616 redeclaration_error_message (newdecl, olddecl)
4617 tree newdecl, olddecl;
4619 if (TREE_CODE (newdecl) == TYPE_DECL)
4621 /* Because C++ can put things into name space for free,
4622 constructs like "typedef struct foo { ... } foo"
4623 would look like an erroneous redeclaration. */
4624 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4627 return "redefinition of `%#D'";
4629 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4631 /* If this is a pure function, its olddecl will actually be
4632 the original initialization to `0' (which we force to call
4633 abort()). Don't complain about redefinition in this case. */
4634 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4637 /* If both functions come from different namespaces, this is not
4638 a redeclaration - this is a conflict with a used function. */
4639 if (DECL_NAMESPACE_SCOPE_P (olddecl)
4640 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4641 return "`%D' conflicts with used function";
4643 /* We'll complain about linkage mismatches in
4644 warn_extern_redeclared_static. */
4646 /* Defining the same name twice is no good. */
4647 if (DECL_INITIAL (olddecl) != NULL_TREE
4648 && DECL_INITIAL (newdecl) != NULL_TREE)
4650 if (DECL_NAME (olddecl) == NULL_TREE)
4651 return "`%#D' not declared in class";
4653 return "redefinition of `%#D'";
4657 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4659 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4660 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4661 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4662 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4663 && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4664 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4665 return "redefinition of `%#D'";
4668 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4670 /* Objects declared at top level: */
4671 /* If at least one is a reference, it's ok. */
4672 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4674 /* Reject two definitions. */
4675 return "redefinition of `%#D'";
4679 /* Objects declared with block scope: */
4680 /* Reject two definitions, and reject a definition
4681 together with an external reference. */
4682 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4683 return "redeclaration of `%#D'";
4688 /* Create a new label, named ID. */
4691 make_label_decl (id, local_p)
4697 decl = build_decl (LABEL_DECL, id, void_type_node);
4699 /* Make sure every label has an rtx. */
4702 DECL_CONTEXT (decl) = current_function_decl;
4703 DECL_MODE (decl) = VOIDmode;
4704 C_DECLARED_LABEL_FLAG (decl) = local_p;
4706 /* Say where one reference is to the label, for the sake of the
4707 error if it is not defined. */
4708 DECL_SOURCE_LINE (decl) = lineno;
4709 DECL_SOURCE_FILE (decl) = input_filename;
4711 /* Record the fact that this identifier is bound to this label. */
4712 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4714 /* Record this label on the list of used labels so that we can check
4715 at the end of the function to see whether or not the label was
4716 actually defined. */
4717 if ((named_label_uses == NULL || named_label_uses->label_decl != decl)
4718 && (named_label_uses == NULL
4719 || named_label_uses->names_in_scope != current_binding_level->names
4720 || named_label_uses->label_decl != decl))
4722 struct named_label_list *new_ent;
4724 = (struct named_label_list*)oballoc (sizeof (struct named_label_list));
4725 new_ent->label_decl = decl;
4726 new_ent->names_in_scope = current_binding_level->names;
4727 new_ent->binding_level = current_binding_level;
4728 new_ent->lineno_o_goto = lineno;
4729 new_ent->filename_o_goto = input_filename;
4730 new_ent->next = named_label_uses;
4731 named_label_uses = new_ent;
4737 /* Look for a label named ID in the current function. If one cannot
4738 be found, create one. (We keep track of used, but undefined,
4739 labels, and complain about them at the end of a function.) */
4747 /* You can't use labels at global scope. */
4748 if (current_function_decl == NULL_TREE)
4750 error ("label `%s' referenced outside of any function",
4751 IDENTIFIER_POINTER (id));
4755 /* See if we've already got this label. */
4756 decl = IDENTIFIER_LABEL_VALUE (id);
4757 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4760 /* Record this label on the list of labels used in this function.
4761 We do this before calling make_label_decl so that we get the
4762 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4763 named_labels = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4765 /* We need a new label. */
4766 decl = make_label_decl (id, /*local_p=*/0);
4767 /* Now fill in the information we didn't have before. */
4768 TREE_VALUE (named_labels) = decl;
4773 /* Declare a local label named ID. */
4776 declare_local_label (id)
4781 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4782 this scope we can restore the old value of
4783 IDENTIFIER_TYPE_VALUE. */
4784 current_binding_level->shadowed_labels
4785 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4786 current_binding_level->shadowed_labels);
4787 /* Look for the label. */
4788 decl = make_label_decl (id, /*local_p=*/1);
4789 /* Now fill in the information we didn't have before. */
4790 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4795 /* Define a label, specifying the location in the source file.
4796 Return the LABEL_DECL node for the label, if the definition is valid.
4797 Otherwise return 0. */
4800 define_label (filename, line, name)
4805 tree decl = lookup_label (name);
4807 /* After labels, make any new cleanups go into their
4808 own new (temporary) binding contour. */
4809 current_binding_level->more_cleanups_ok = 0;
4811 if (name == get_identifier ("wchar_t"))
4812 cp_pedwarn ("label named wchar_t");
4814 if (DECL_INITIAL (decl) != NULL_TREE)
4816 cp_error ("duplicate label `%D'", decl);
4821 struct named_label_list *uses, *prev;
4825 /* Mark label as having been defined. */
4826 DECL_INITIAL (decl) = error_mark_node;
4827 /* Say where in the source. */
4828 DECL_SOURCE_FILE (decl) = filename;
4829 DECL_SOURCE_LINE (decl) = line;
4832 uses = named_label_uses;
4833 while (uses != NULL)
4834 if (uses->label_decl == decl)
4836 struct binding_level *b = current_binding_level;
4839 tree new_decls = b->names;
4840 tree old_decls = (b == uses->binding_level)
4841 ? uses->names_in_scope : NULL_TREE;
4842 while (new_decls != old_decls)
4844 if (TREE_CODE (new_decls) == VAR_DECL
4845 /* Don't complain about crossing initialization
4846 of internal entities. They can't be accessed,
4847 and they should be cleaned up
4848 by the time we get to the label. */
4849 && ! DECL_ARTIFICIAL (new_decls)
4850 && !(DECL_INITIAL (new_decls) == NULL_TREE
4851 && pod_type_p (TREE_TYPE (new_decls))))
4853 /* This is really only important if we're crossing
4854 an initialization. The POD stuff is just
4855 pedantry; why should it matter if the class
4856 contains a field of pointer to member type? */
4857 int problem = (DECL_INITIAL (new_decls)
4858 || (TYPE_NEEDS_CONSTRUCTING
4859 (TREE_TYPE (new_decls))));
4865 cp_error ("jump to label `%D'", decl);
4866 error_with_file_and_line
4867 (uses->filename_o_goto,
4868 uses->lineno_o_goto, " from here");
4872 cp_pedwarn ("jump to label `%D'", decl);
4873 pedwarn_with_file_and_line
4874 (uses->filename_o_goto,
4875 uses->lineno_o_goto, " from here");
4881 cp_error_at (" crosses initialization of `%#D'",
4884 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4887 new_decls = TREE_CHAIN (new_decls);
4889 if (b == uses->binding_level)
4891 if (b->eh_region && ! saw_eh)
4895 cp_error ("jump to label `%D'", decl);
4896 error_with_file_and_line
4897 (uses->filename_o_goto,
4898 uses->lineno_o_goto, " from here");
4901 error (" enters exception handling block");
4908 prev->next = uses->next;
4910 named_label_uses = uses->next;
4919 current_function_return_value = NULL_TREE;
4926 struct binding_level *level;
4927 struct cp_switch *next;
4930 static struct cp_switch *switch_stack;
4936 = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
4937 p->level = current_binding_level;
4938 p->next = switch_stack;
4945 struct cp_switch *cs;
4948 switch_stack = switch_stack->next;
4952 /* Note that we've seen a definition of a case label, and complain if this
4953 is a bad place for one. */
4956 define_case_label ()
4958 tree cleanup = last_cleanup_this_contour ();
4959 struct binding_level *b = current_binding_level;
4963 /* Don't crash; we'll complain in do_case. */
4968 static int explained = 0;
4969 cp_warning_at ("destructor needed for `%#D'", TREE_PURPOSE (cleanup));
4970 warning ("where case label appears here");
4973 warning ("(enclose actions of previous case statements requiring");
4974 warning ("destructors in their own binding contours.)");
4979 for (; b && b != switch_stack->level; b = b->level_chain)
4981 tree new_decls = b->names;
4982 for (; new_decls; new_decls = TREE_CHAIN (new_decls))
4984 if (TREE_CODE (new_decls) == VAR_DECL
4985 /* Don't complain about crossing initialization
4986 of internal entities. They can't be accessed,
4987 and they should be cleaned up
4988 by the time we get to the label. */
4989 && ! DECL_ARTIFICIAL (new_decls)
4990 && ((DECL_INITIAL (new_decls) != NULL_TREE
4991 && DECL_INITIAL (new_decls) != error_mark_node)
4992 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (new_decls))))
4995 error ("jump to case label");
4997 cp_error_at (" crosses initialization of `%#D'",
5003 /* After labels, make any new cleanups go into their
5004 own new (temporary) binding contour. */
5006 current_binding_level->more_cleanups_ok = 0;
5007 current_function_return_value = NULL_TREE;
5010 /* Return the list of declarations of the current level.
5011 Note that this list is in reverse order unless/until
5012 you nreverse it; and when you do nreverse it, you must
5013 store the result back using `storedecls' or you will lose. */
5018 return current_binding_level->names;
5021 /* Return the list of type-tags (for structs, etc) of the current level. */
5026 return current_binding_level->tags;
5029 /* Store the list of declarations of the current level.
5030 This is done for the parameter declarations of a function being defined,
5031 after they are modified in the light of any missing parameters. */
5037 current_binding_level->names = decls;
5040 /* Similarly, store the list of tags of the current level. */
5046 current_binding_level->tags = tags;
5049 /* Given NAME, an IDENTIFIER_NODE,
5050 return the structure (or union or enum) definition for that name.
5051 Searches binding levels from BINDING_LEVEL up to the global level.
5052 If THISLEVEL_ONLY is nonzero, searches only the specified context
5053 (but skips any tag-transparent contexts to find one that is
5054 meaningful for tags).
5055 FORM says which kind of type the caller wants;
5056 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5057 If the wrong kind of type is found, and it's not a template, an error is
5061 lookup_tag (form, name, binding_level, thislevel_only)
5062 enum tree_code form;
5064 struct binding_level *binding_level;
5067 register struct binding_level *level;
5068 /* Non-zero if, we should look past a template parameter level, even
5069 if THISLEVEL_ONLY. */
5070 int allow_template_parms_p = 1;
5072 for (level = binding_level; level; level = level->level_chain)
5075 if (ANON_AGGRNAME_P (name))
5076 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5078 /* There's no need for error checking here, because
5079 anon names are unique throughout the compilation. */
5080 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5081 return TREE_VALUE (tail);
5083 else if (level->namespace_p)
5084 /* Do namespace lookup. */
5085 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5087 tree old = binding_for_name (name, tail);
5089 /* If we just skipped past a template parameter level,
5090 even though THISLEVEL_ONLY, and we find a template
5091 class declaration, then we use the _TYPE node for the
5092 template. See the example below. */
5093 if (thislevel_only && !allow_template_parms_p
5094 && old && BINDING_VALUE (old)
5095 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5096 old = TREE_TYPE (BINDING_VALUE (old));
5098 old = BINDING_TYPE (old);
5100 /* If it has an original type, it is a typedef, and we
5101 should not return it. */
5102 if (old && DECL_ORIGINAL_TYPE (TYPE_NAME (old)))
5104 if (old && TREE_CODE (old) != form
5105 && !(form != ENUMERAL_TYPE && TREE_CODE (old) == TEMPLATE_DECL))
5107 cp_error ("`%#D' redeclared as %C", old, form);
5112 if (thislevel_only || tail == global_namespace)
5116 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5118 if (TREE_PURPOSE (tail) == name)
5120 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5121 /* Should tighten this up; it'll probably permit
5122 UNION_TYPE and a struct template, for example. */
5124 && !(form != ENUMERAL_TYPE && code == TEMPLATE_DECL))
5126 /* Definition isn't the kind we were looking for. */
5127 cp_error ("`%#D' redeclared as %C", TREE_VALUE (tail),
5131 return TREE_VALUE (tail);
5134 if (thislevel_only && ! level->tag_transparent)
5136 if (level->template_parms_p && allow_template_parms_p)
5138 /* We must deal with cases like this:
5140 template <class T> struct S;
5141 template <class T> struct S {};
5143 When looking up `S', for the second declaration, we
5144 would like to find the first declaration. But, we
5145 are in the pseudo-global level created for the
5146 template parameters, rather than the (surrounding)
5147 namespace level. Thus, we keep going one more level,
5148 even though THISLEVEL_ONLY is non-zero. */
5149 allow_template_parms_p = 0;
5161 set_current_level_tags_transparency (tags_transparent)
5162 int tags_transparent;
5164 current_binding_level->tag_transparent = tags_transparent;
5168 /* Given a type, find the tag that was defined for it and return the tag name.
5169 Otherwise return 0. However, the value can never be 0
5170 in the cases in which this is used.
5172 C++: If NAME is non-zero, this is the new name to install. This is
5173 done when replacing anonymous tags with real tag names. */
5176 lookup_tag_reverse (type, name)
5180 register struct binding_level *level;
5182 for (level = current_binding_level; level; level = level->level_chain)
5185 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5187 if (TREE_VALUE (tail) == type)
5190 TREE_PURPOSE (tail) = name;
5191 return TREE_PURPOSE (tail);
5198 /* Look up NAME in the NAMESPACE. */
5201 lookup_namespace_name (namespace, name)
5202 tree namespace, name;
5205 tree template_id = NULL_TREE;
5207 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5209 if (TREE_CODE (name) == NAMESPACE_DECL)
5210 /* This happens for A::B<int> when B is a namespace. */
5212 else if (TREE_CODE (name) == TEMPLATE_DECL)
5214 /* This happens for A::B where B is a template, and there are no
5215 template arguments. */
5216 cp_error ("invalid use of `%D'", name);
5217 return error_mark_node;
5220 namespace = ORIGINAL_NAMESPACE (namespace);
5222 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5225 name = TREE_OPERAND (name, 0);
5226 if (TREE_CODE (name) == OVERLOAD)
5227 name = DECL_NAME (OVL_CURRENT (name));
5228 else if (DECL_P (name))
5229 name = DECL_NAME (name);
5232 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5234 val = make_node (CPLUS_BINDING);
5235 if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5236 return error_mark_node;
5238 if (BINDING_VALUE (val))
5240 val = BINDING_VALUE (val);
5244 if (DECL_CLASS_TEMPLATE_P (val))
5245 val = lookup_template_class (val,
5246 TREE_OPERAND (template_id, 1),
5247 /*in_decl=*/NULL_TREE,
5248 /*context=*/NULL_TREE,
5249 /*entering_scope=*/0);
5250 else if (DECL_FUNCTION_TEMPLATE_P (val)
5251 || TREE_CODE (val) == OVERLOAD)
5252 val = lookup_template_function (val,
5253 TREE_OPERAND (template_id, 1));
5256 cp_error ("`%D::%D' is not a template",
5258 return error_mark_node;
5262 /* If we have a single function from a using decl, pull it out. */
5263 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5264 val = OVL_FUNCTION (val);
5268 cp_error ("`%D' undeclared in namespace `%D'", name, namespace);
5269 return error_mark_node;
5272 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5274 static unsigned long
5282 hash = (((unsigned long) TYPE_CONTEXT (t))
5283 ^ ((unsigned long) DECL_NAME (TYPE_NAME (t))));
5288 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5291 typename_compare (k1, k2)
5302 d1 = TYPE_NAME (t1);
5303 d2 = TYPE_NAME (t2);
5305 return (DECL_NAME (d1) == DECL_NAME (d2)
5306 && same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))
5307 && ((TREE_TYPE (t1) != NULL_TREE)
5308 == (TREE_TYPE (t2) != NULL_TREE))
5309 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5310 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5313 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5314 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5315 is non-NULL, this type is being created by the implicit typename
5316 extension, and BASE_TYPE is a type named `t' in some base class of
5317 `T' which depends on template parameters.
5319 Returns the new TYPENAME_TYPE. */
5322 build_typename_type (context, name, fullname, base_type)
5330 struct hash_entry* e;
5332 static struct hash_table ht;
5336 static struct hash_table *h = &ht;
5337 if (!hash_table_init (&ht, &hash_newfunc, &typename_hash,
5339 fatal ("virtual memory exhausted");
5340 ggc_add_tree_hash_table_root (&h, 1);
5343 /* Build the TYPENAME_TYPE. */
5344 t = make_aggr_type (TYPENAME_TYPE);
5345 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5346 TYPENAME_TYPE_FULLNAME (t) = fullname;
5347 TREE_TYPE (t) = base_type;
5349 /* Build the corresponding TYPE_DECL. */
5350 d = build_decl (TYPE_DECL, name, t);
5351 TYPE_NAME (TREE_TYPE (d)) = d;
5352 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5353 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5354 DECL_ARTIFICIAL (d) = 1;
5356 /* See if we already have this type. */
5357 e = hash_lookup (&ht, t, /*create=*/false, /*copy=*/0);
5361 /* Insert the type into the table. */
5362 hash_lookup (&ht, t, /*create=*/true, /*copy=*/0);
5367 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5368 unless an error occurs, in which case error_mark_node is returned.
5369 If COMPLAIN zero, don't complain about any errors that occur. */
5372 make_typename_type (context, name, complain)
5380 if (!(TYPE_LANG_SPECIFIC (name)
5381 && (CLASSTYPE_IS_TEMPLATE (name)
5382 || CLASSTYPE_USE_TEMPLATE (name))))
5383 name = TYPE_IDENTIFIER (name);
5385 /* Create a TEMPLATE_ID_EXPR for the type. */
5386 name = build_nt (TEMPLATE_ID_EXPR,
5387 CLASSTYPE_TI_TEMPLATE (name),
5388 CLASSTYPE_TI_ARGS (name));
5390 else if (TREE_CODE (name) == TYPE_DECL)
5391 name = DECL_NAME (name);
5395 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5397 name = TREE_OPERAND (name, 0);
5398 if (TREE_CODE (name) == TEMPLATE_DECL)
5399 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5401 if (TREE_CODE (name) != IDENTIFIER_NODE)
5402 my_friendly_abort (2000);
5404 if (TREE_CODE (context) == NAMESPACE_DECL)
5406 /* We can get here from typename_sub0 in the explicit_template_type
5407 expansion. Just fail. */
5409 cp_error ("no class template named `%#T' in `%#T'",
5411 return error_mark_node;
5414 if (! uses_template_parms (context)
5415 || currently_open_class (context))
5417 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5419 tree tmpl = NULL_TREE;
5420 if (IS_AGGR_TYPE (context))
5421 tmpl = lookup_field (context, name, 0, 0);
5422 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5425 cp_error ("no class template named `%#T' in `%#T'",
5427 return error_mark_node;
5430 return lookup_template_class (tmpl,
5431 TREE_OPERAND (fullname, 1),
5433 /*entering_scope=*/0);
5439 if (!IS_AGGR_TYPE (context))
5442 cp_error ("no type named `%#T' in `%#T'", name, context);
5443 return error_mark_node;
5446 t = lookup_field (context, name, 0, 1);
5448 return TREE_TYPE (t);
5452 /* If the CONTEXT is not a template type, then either the field is
5453 there now or its never going to be. */
5454 if (!uses_template_parms (context))
5457 cp_error ("no type named `%#T' in `%#T'", name, context);
5458 return error_mark_node;
5462 return build_typename_type (context, name, fullname, NULL_TREE);
5465 /* Select the right _DECL from multiple choices. */
5468 select_decl (binding, flags)
5473 val = BINDING_VALUE (binding);
5474 if (LOOKUP_NAMESPACES_ONLY (flags))
5476 /* We are not interested in types. */
5477 if (val && TREE_CODE (val) == NAMESPACE_DECL)
5482 /* If we could have a type and
5483 we have nothing or we need a type and have none. */
5484 if (BINDING_TYPE (binding)
5485 && (!val || ((flags & LOOKUP_PREFER_TYPES)
5486 && TREE_CODE (val) != TYPE_DECL)))
5487 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5488 /* Don't return non-types if we really prefer types. */
5489 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
5490 && (TREE_CODE (val) != TEMPLATE_DECL
5491 || !DECL_CLASS_TEMPLATE_P (val)))
5497 /* Unscoped lookup of a global: iterate over current namespaces,
5498 considering using-directives. If SPACESP is non-NULL, store a list
5499 of the namespaces we've considered in it. */
5502 unqualified_namespace_lookup (name, flags, spacesp)
5507 tree b = make_node (CPLUS_BINDING);
5508 tree initial = current_decl_namespace();
5509 tree scope = initial;
5511 struct binding_level *level;
5512 tree val = NULL_TREE;
5515 *spacesp = NULL_TREE;
5517 for (; !val; scope = CP_DECL_CONTEXT (scope))
5520 *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5521 val = binding_for_name (name, scope);
5523 /* Initialize binding for this context. */
5524 BINDING_VALUE (b) = BINDING_VALUE (val);
5525 BINDING_TYPE (b) = BINDING_TYPE (val);
5527 /* Add all _DECLs seen through local using-directives. */
5528 for (level = current_binding_level;
5529 !level->namespace_p;
5530 level = level->level_chain)
5531 if (!lookup_using_namespace (name, b, level->using_directives,
5532 scope, flags, spacesp))
5533 /* Give up because of error. */
5534 return error_mark_node;
5536 /* Add all _DECLs seen through global using-directives. */
5537 /* XXX local and global using lists should work equally. */
5541 if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5542 scope, flags, spacesp))
5543 /* Give up because of error. */
5544 return error_mark_node;
5545 if (siter == scope) break;
5546 siter = CP_DECL_CONTEXT (siter);
5549 val = select_decl (b, flags);
5550 if (scope == global_namespace)
5556 /* Combine prefer_type and namespaces_only into flags. */
5559 lookup_flags (prefer_type, namespaces_only)
5560 int prefer_type, namespaces_only;
5562 if (namespaces_only)
5563 return LOOKUP_PREFER_NAMESPACES;
5564 if (prefer_type > 1)
5565 return LOOKUP_PREFER_TYPES;
5566 if (prefer_type > 0)
5567 return LOOKUP_PREFER_BOTH;
5571 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5572 ignore it or not. Subroutine of lookup_name_real. */
5575 qualify_lookup (val, flags)
5579 if (val == NULL_TREE)
5581 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5583 if ((flags & LOOKUP_PREFER_TYPES)
5584 && (TREE_CODE (val) == TYPE_DECL
5585 || ((flags & LOOKUP_TEMPLATES_EXPECTED)
5586 && DECL_CLASS_TEMPLATE_P (val))))
5588 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5593 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5597 warn_about_implicit_typename_lookup (typename, binding)
5601 tree subtype = TREE_TYPE (TREE_TYPE (typename));
5602 tree name = DECL_NAME (typename);
5604 if (! (TREE_CODE (binding) == TEMPLATE_DECL
5605 && CLASSTYPE_TEMPLATE_INFO (subtype)
5606 && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5607 && ! (TREE_CODE (binding) == TYPE_DECL
5608 && same_type_p (TREE_TYPE (binding), subtype)))
5610 cp_warning ("lookup of `%D' finds `%#D'",
5612 cp_warning (" instead of `%D' from dependent base class",
5614 cp_warning (" (use `typename %T::%D' if that's what you meant)",
5615 constructor_name (current_class_type), name);
5619 /* Look up NAME in the current binding level and its superiors in the
5620 namespace of variables, functions and typedefs. Return a ..._DECL
5621 node of some kind representing its definition if there is only one
5622 such declaration, or return a TREE_LIST with all the overloaded
5623 definitions if there are many, or return 0 if it is undefined.
5625 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5626 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5627 If PREFER_TYPE is -2, we're being called from yylex(). (UGLY)
5628 Otherwise we prefer non-TYPE_DECLs.
5630 If NONCLASS is non-zero, we don't look for the NAME in class scope,
5631 using IDENTIFIER_CLASS_VALUE. */
5634 lookup_name_real (name, prefer_type, nonclass, namespaces_only)
5636 int prefer_type, nonclass, namespaces_only;
5639 tree val = NULL_TREE;
5641 tree from_obj = NULL_TREE;
5643 int val_is_implicit_typename = 0;
5645 /* Hack: copy flag set by parser, if set. */
5646 if (only_namespace_names)
5647 namespaces_only = 1;
5649 if (prefer_type == -2)
5651 extern int looking_for_typename;
5652 tree type = NULL_TREE;
5655 prefer_type = looking_for_typename;
5657 flags = lookup_flags (prefer_type, namespaces_only);
5658 /* If the next thing is '<', class templates are types. */
5659 if (looking_for_template)
5660 flags |= LOOKUP_TEMPLATES_EXPECTED;
5662 /* std:: becomes :: for now. */
5663 if (got_scope == std_node)
5664 got_scope = void_type_node;
5668 else if (got_object != error_mark_node)
5673 if (type == error_mark_node)
5674 return error_mark_node;
5675 if (TREE_CODE (type) == TYPENAME_TYPE && TREE_TYPE (type))
5676 type = TREE_TYPE (type);
5679 type = complete_type (type);
5681 if (TREE_CODE (type) == VOID_TYPE)
5682 type = global_namespace;
5683 if (TREE_CODE (type) == NAMESPACE_DECL)
5685 val = make_node (CPLUS_BINDING);
5686 flags |= LOOKUP_COMPLAIN;
5687 if (!qualified_lookup_using_namespace (name, type, val, flags))
5689 val = select_decl (val, flags);
5691 else if (! IS_AGGR_TYPE (type)
5692 || TREE_CODE (type) == TEMPLATE_TYPE_PARM
5693 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
5694 || TREE_CODE (type) == TYPENAME_TYPE)
5695 /* Someone else will give an error about this if needed. */
5697 else if (type == current_class_type)
5698 val = IDENTIFIER_CLASS_VALUE (name);
5701 val = lookup_member (type, name, 0, prefer_type);
5702 type_access_control (type, val);
5710 else if (got_object && val)
5715 flags = lookup_flags (prefer_type, namespaces_only);
5716 /* If we're not parsing, we need to complain. */
5717 flags |= LOOKUP_COMPLAIN;
5720 /* First, look in non-namespace scopes. */
5722 if (current_class_type == NULL_TREE)
5725 for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5729 if (!LOCAL_BINDING_P (t) && nonclass)
5730 /* We're not looking for class-scoped bindings, so keep going. */
5733 /* If this is the kind of thing we're looking for, we're done. */
5734 if (qualify_lookup (BINDING_VALUE (t), flags))
5735 binding = BINDING_VALUE (t);
5736 else if ((flags & LOOKUP_PREFER_TYPES)
5737 && qualify_lookup (BINDING_TYPE (t), flags))
5738 binding = BINDING_TYPE (t);
5740 binding = NULL_TREE;
5742 /* Handle access control on types from enclosing or base classes. */
5743 if (binding && ! yylex
5744 && BINDING_LEVEL (t) && BINDING_LEVEL (t)->parm_flag == 2)
5745 type_access_control (BINDING_LEVEL (t)->this_class, binding);
5748 && (!val || !IMPLICIT_TYPENAME_TYPE_DECL_P (binding)))
5750 if (val_is_implicit_typename && !yylex)
5751 warn_about_implicit_typename_lookup (val, binding);
5753 val_is_implicit_typename
5754 = IMPLICIT_TYPENAME_TYPE_DECL_P (val);
5755 if (!val_is_implicit_typename)
5760 /* Now lookup in namespace scopes. */
5761 if (!val || val_is_implicit_typename)
5763 t = unqualified_namespace_lookup (name, flags, 0);
5766 if (val_is_implicit_typename && !yylex)
5767 warn_about_implicit_typename_lookup (val, t);
5775 /* This should only warn about types used in qualified-ids. */
5776 if (from_obj && from_obj != val)
5778 if (looking_for_typename && TREE_CODE (from_obj) == TYPE_DECL
5779 && TREE_CODE (val) == TYPE_DECL
5780 && TREE_TYPE (from_obj) != TREE_TYPE (val))
5782 cp_pedwarn ("lookup of `%D' in the scope of `%#T' (`%#T')",
5783 name, got_object, TREE_TYPE (from_obj));
5784 cp_pedwarn (" does not match lookup in the current scope (`%#T')",
5788 /* We don't change val to from_obj if got_object depends on
5789 template parms because that breaks implicit typename for
5790 destructor calls. */
5791 if (! uses_template_parms (got_object))
5795 /* If we have a single function from a using decl, pull it out. */
5796 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5797 val = OVL_FUNCTION (val);
5806 lookup_name_nonclass (name)
5809 return lookup_name_real (name, 0, 1, 0);
5813 lookup_function_nonclass (name, args)
5817 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
5821 lookup_name_namespace_only (name)
5824 /* type-or-namespace, nonclass, namespace_only */
5825 return lookup_name_real (name, 1, 1, 1);
5829 lookup_name (name, prefer_type)
5833 return lookup_name_real (name, prefer_type, 0, 0);
5836 /* Similar to `lookup_name' but look only in the innermost non-class
5840 lookup_name_current_level (name)
5843 struct binding_level *b;
5846 b = current_binding_level;
5847 while (b->parm_flag == 2)
5852 t = IDENTIFIER_NAMESPACE_VALUE (name);
5854 /* extern "C" function() */
5855 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
5858 else if (IDENTIFIER_BINDING (name)
5859 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
5863 if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
5864 return IDENTIFIER_VALUE (name);
5876 /* Like lookup_name_current_level, but for types. */
5879 lookup_type_current_level (name)
5882 register tree t = NULL_TREE;
5884 my_friendly_assert (! current_binding_level->namespace_p, 980716);
5886 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
5887 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
5889 struct binding_level *b = current_binding_level;
5892 if (purpose_member (name, b->type_shadowed))
5893 return REAL_IDENTIFIER_TYPE_VALUE (name);
5905 begin_only_namespace_names ()
5907 only_namespace_names = 1;
5911 end_only_namespace_names ()
5913 only_namespace_names = 0;
5916 /* Arrange for the user to get a source line number, even when the
5917 compiler is going down in flames, so that she at least has a
5918 chance of working around problems in the compiler. We used to
5919 call error(), but that let the segmentation fault continue
5920 through; now, it's much more passive by asking them to send the
5921 maintainers mail about the problem. */
5925 int sig ATTRIBUTE_UNUSED;
5927 signal (SIGSEGV, SIG_DFL);
5929 signal (SIGIOT, SIG_DFL);
5932 signal (SIGILL, SIG_DFL);
5935 signal (SIGABRT, SIG_DFL);
5938 signal (SIGBUS, SIG_DFL);
5940 my_friendly_abort (0);
5943 /* Push the declarations of builtin types into the namespace.
5944 RID_INDEX, if < RID_MAX is the index of the builtin type
5945 in the array RID_POINTERS. NAME is the name used when looking
5946 up the builtin type. TYPE is the _TYPE node for the builtin type. */
5949 record_builtin_type (rid_index, name, type)
5954 tree rname = NULL_TREE, tname = NULL_TREE;
5955 tree tdecl = NULL_TREE;
5957 if ((int) rid_index < (int) RID_MAX)
5958 rname = ridpointers[(int) rid_index];
5960 tname = get_identifier (name);
5962 TYPE_BUILT_IN (type) = 1;
5966 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
5967 set_identifier_type_value (tname, NULL_TREE);
5968 if ((int) rid_index < (int) RID_MAX)
5969 /* Built-in types live in the global namespace. */
5970 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
5972 if (rname != NULL_TREE)
5974 if (tname != NULL_TREE)
5976 set_identifier_type_value (rname, NULL_TREE);
5977 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
5981 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
5982 set_identifier_type_value (rname, NULL_TREE);
5987 /* Record one of the standard Java types.
5988 * Declare it as having the given NAME.
5989 * If SIZE > 0, it is the size of one of the integral types;
5990 * otherwise it is the negative of the size of one of the other types. */
5993 record_builtin_java_type (name, size)
5999 type = make_signed_type (size);
6000 else if (size > -32)
6001 { /* "__java_char" or ""__java_boolean". */
6002 type = make_unsigned_type (-size);
6003 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6006 { /* "__java_float" or ""__java_double". */
6007 type = make_node (REAL_TYPE);
6008 TYPE_PRECISION (type) = - size;
6011 record_builtin_type (RID_MAX, name, type);
6012 decl = TYPE_NAME (type);
6014 /* Suppress generate debug symbol entries for these types,
6015 since for normal C++ they are just clutter.
6016 However, push_lang_context undoes this if extern "Java" is seen. */
6017 DECL_IGNORED_P (decl) = 1;
6019 TYPE_FOR_JAVA (type) = 1;
6023 /* Push a type into the namespace so that the back-ends ignore it. */
6026 record_unknown_type (type, name)
6030 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6031 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6032 DECL_IGNORED_P (decl) = 1;
6033 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6034 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6035 TYPE_ALIGN (type) = 1;
6036 TYPE_MODE (type) = TYPE_MODE (void_type_node);
6039 /* An string for which we should create an IDENTIFIER_NODE at
6042 typedef struct predefined_identifier
6044 /* The name of the identifier. */
6046 /* The place where the IDENTIFIER_NODE should be stored. */
6048 /* Non-zero if this is the name of a constructor or destructor. */
6050 } predefined_identifier;
6052 /* Create all the predefined identifiers. */
6055 initialize_predefined_identifiers ()
6057 struct predefined_identifier *pid;
6059 /* A table of identifiers to create at startup. */
6060 static predefined_identifier predefined_identifiers[] = {
6061 { "C++", &lang_name_cplusplus, 0 },
6062 { "C", &lang_name_c, 0 },
6063 { "Java", &lang_name_java, 0 },
6064 { CTOR_NAME, &ctor_identifier, 1 },
6065 { "__base_ctor", &base_ctor_identifier, 1 },
6066 { "__comp_ctor", &complete_ctor_identifier, 1 },
6067 { DTOR_NAME, &dtor_identifier, 1 },
6068 { "__comp_dtor", &complete_dtor_identifier, 1 },
6069 { "__base_dtor", &base_dtor_identifier, 1 },
6070 { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6071 { VTABLE_DELTA2_NAME, &delta2_identifier, 0 },
6072 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6073 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6074 { VTABLE_INDEX_NAME, &index_identifier, 0 },
6075 { "nelts", &nelts_identifier, 0 },
6076 { THIS_NAME, &this_identifier, 0 },
6077 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6078 { "__pfn_or_delta2", &pfn_or_delta2_identifier, 0 },
6079 { "_vptr", &vptr_identifier, 0 },
6080 { "__cp_push_exception", &cp_push_exception_identifier, 0 },
6084 for (pid = predefined_identifiers; pid->name; ++pid)
6086 *pid->node = get_identifier (pid->name);
6087 if (pid->ctor_or_dtor_p)
6088 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6092 /* Create the predefined scalar types of C,
6093 and some nodes representing standard constants (0, 1, (void *)0).
6094 Initialize the global binding level.
6095 Make definitions for built-in primitive functions. */
6098 init_decl_processing ()
6101 int wchar_type_size;
6102 tree array_domain_type;
6104 /* Check to see that the user did not specify an invalid combination
6105 of command-line options. */
6106 if (flag_new_abi && !flag_vtable_thunks)
6107 fatal ("the new ABI requires vtable thunks");
6109 /* Create all the identifiers we need. */
6110 initialize_predefined_identifiers ();
6112 /* Let the back-end now how to save and restore language-specific
6113 per-function globals. */
6114 init_lang_status = &push_cp_function_context;
6115 free_lang_status = &pop_cp_function_context;
6116 mark_lang_status = &mark_cp_function_context;
6122 /* Create the global variables. */
6123 push_to_top_level ();
6125 /* Enter the global namespace. */
6126 my_friendly_assert (global_namespace == NULL_TREE, 375);
6127 push_namespace (get_identifier ("::"));
6128 global_namespace = current_namespace;
6129 current_lang_name = NULL_TREE;
6131 /* Adjust various flags based on command-line settings. */
6132 if (flag_strict_prototype == 2)
6133 flag_strict_prototype = pedantic;
6134 if (! flag_permissive && ! pedantic)
6135 flag_pedantic_errors = 1;
6136 if (!flag_no_inline)
6137 flag_inline_trees = 1;
6139 strict_prototypes_lang_c = flag_strict_prototype;
6142 current_lang_name = lang_name_c;
6144 current_function_decl = NULL_TREE;
6145 current_binding_level = NULL_BINDING_LEVEL;
6146 free_binding_level = NULL_BINDING_LEVEL;
6148 /* Because most segmentation signals can be traced back into user
6149 code, catch them and at least give the user a chance of working
6150 around compiler bugs. */
6151 signal (SIGSEGV, signal_catch);
6153 /* We will also catch aborts in the back-end through signal_catch and
6154 give the user a chance to see where the error might be, and to defeat
6155 aborts in the back-end when there have been errors previously in their
6158 signal (SIGIOT, signal_catch);
6161 signal (SIGILL, signal_catch);
6164 signal (SIGABRT, signal_catch);
6167 signal (SIGBUS, signal_catch);
6170 build_common_tree_nodes (flag_signed_char);
6172 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6173 TREE_TYPE (error_mark_list) = error_mark_node;
6175 /* Make the binding_level structure for global names. */
6177 global_binding_level = current_binding_level;
6178 /* The global level is the namespace level of ::. */
6179 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6180 declare_namespace_level ();
6182 /* Define `int' and `char' first so that dbx will output them first. */
6183 record_builtin_type (RID_INT, NULL_PTR, integer_type_node);
6184 record_builtin_type (RID_CHAR, "char", char_type_node);
6186 /* `signed' is the same as `int' */
6187 record_builtin_type (RID_SIGNED, NULL_PTR, integer_type_node);
6188 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
6189 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
6190 record_builtin_type (RID_MAX, "long unsigned int", long_unsigned_type_node);
6191 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
6192 record_builtin_type (RID_MAX, "long long int", long_long_integer_type_node);
6193 record_builtin_type (RID_MAX, "long long unsigned int",
6194 long_long_unsigned_type_node);
6195 record_builtin_type (RID_MAX, "long long unsigned",
6196 long_long_unsigned_type_node);
6197 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
6198 record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
6199 record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
6202 = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
6204 /* Define both `signed char' and `unsigned char'. */
6205 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
6206 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
6208 /* `unsigned long' is the standard type for sizeof.
6209 Note that stddef.h uses `unsigned long',
6210 and this must agree, even if long and int are the same size. */
6212 (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE))));
6214 /* Create the widest literal types. */
6215 widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
6216 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6217 widest_integer_literal_type_node));
6219 widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
6220 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
6221 widest_unsigned_literal_type_node));
6223 /* These are types that type_for_size and type_for_mode use. */
6224 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
6225 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
6226 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
6227 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
6228 #if HOST_BITS_PER_WIDE_INT >= 64
6229 pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
6231 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
6232 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
6233 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
6234 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
6235 #if HOST_BITS_PER_WIDE_INT >= 64
6236 pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
6239 build_common_tree_nodes_2 (flag_short_double);
6241 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6242 java_short_type_node = record_builtin_java_type ("__java_short", 16);
6243 java_int_type_node = record_builtin_java_type ("__java_int", 32);
6244 java_long_type_node = record_builtin_java_type ("__java_long", 64);
6245 java_float_type_node = record_builtin_java_type ("__java_float", -32);
6246 java_double_type_node = record_builtin_java_type ("__java_double", -64);
6247 java_char_type_node = record_builtin_java_type ("__java_char", -16);
6248 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6250 integer_two_node = build_int_2 (2, 0);
6251 TREE_TYPE (integer_two_node) = integer_type_node;
6252 integer_three_node = build_int_2 (3, 0);
6253 TREE_TYPE (integer_three_node) = integer_type_node;
6255 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6256 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6257 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6258 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6259 TYPE_PRECISION (boolean_type_node) = 1;
6260 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6261 boolean_false_node = build_int_2 (0, 0);
6262 TREE_TYPE (boolean_false_node) = boolean_type_node;
6263 boolean_true_node = build_int_2 (1, 0);
6264 TREE_TYPE (boolean_true_node) = boolean_type_node;
6266 signed_size_zero_node = build_int_2 (0, 0);
6267 record_builtin_type (RID_FLOAT, NULL_PTR, float_type_node);
6268 record_builtin_type (RID_DOUBLE, NULL_PTR, double_type_node);
6269 record_builtin_type (RID_MAX, "long double", long_double_type_node);
6271 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
6272 complex_integer_type_node));
6273 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
6274 complex_float_type_node));
6275 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
6276 complex_double_type_node));
6277 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
6278 complex_long_double_type_node));
6280 TREE_TYPE (signed_size_zero_node) = make_signed_type (TYPE_PRECISION (sizetype));
6282 record_builtin_type (RID_VOID, NULL_PTR, void_type_node);
6283 void_list_node = build_tree_list (NULL_TREE, void_type_node);
6284 TREE_PARMLIST (void_list_node) = 1;
6286 /* Used for expressions that do nothing, but are not errors. */
6287 void_zero_node = build_int_2 (0, 0);
6288 TREE_TYPE (void_zero_node) = void_type_node;
6290 string_type_node = build_pointer_type (char_type_node);
6291 const_string_type_node
6292 = build_pointer_type (build_qualified_type (char_type_node,
6294 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6296 record_builtin_type (RID_MAX, NULL_PTR, string_type_node);
6299 /* Make a type to be the domain of a few array types
6300 whose domains don't really matter.
6301 200 is small enough that it always fits in size_t. */
6302 array_domain_type = build_index_type (build_int_2 (200, 0));
6304 /* Make a type for arrays of characters.
6305 With luck nothing will ever really depend on the length of this
6307 char_array_type_node
6308 = build_array_type (char_type_node, array_domain_type);
6309 /* Likewise for arrays of ints. */
6311 = build_array_type (integer_type_node, array_domain_type);
6314 delta_type_node = ptrdiff_type_node;
6315 else if (flag_huge_objects)
6316 delta_type_node = long_integer_type_node;
6318 delta_type_node = short_integer_type_node;
6321 vtable_index_type = ptrdiff_type_node;
6323 vtable_index_type = delta_type_node;
6325 default_function_type
6326 = build_function_type (integer_type_node, NULL_TREE);
6328 ptr_type_node = build_pointer_type (void_type_node);
6330 = build_pointer_type (build_qualified_type (void_type_node,
6332 c_common_nodes_and_builtins (1, flag_no_builtin, flag_no_nonansi_builtin);
6333 lang_type_promotes_to = convert_type_from_ellipsis;
6336 = build_exception_variant (void_ftype_ptr, empty_except_spec);
6338 /* C++ extensions */
6340 unknown_type_node = make_node (UNKNOWN_TYPE);
6341 record_unknown_type (unknown_type_node, "unknown type");
6343 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6344 TREE_TYPE (unknown_type_node) = unknown_type_node;
6346 TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0);
6348 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6350 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6351 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6353 /* This is special for C++ so functions can be overloaded. */
6354 wchar_type_node = get_identifier (flag_short_wchar
6355 ? "short unsigned int"
6357 wchar_type_node = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (wchar_type_node));
6358 wchar_type_size = TYPE_PRECISION (wchar_type_node);
6359 signed_wchar_type_node = make_signed_type (wchar_type_size);
6360 unsigned_wchar_type_node = make_unsigned_type (wchar_type_size);
6362 = TREE_UNSIGNED (wchar_type_node)
6363 ? unsigned_wchar_type_node
6364 : signed_wchar_type_node;
6365 record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node);
6367 /* Artificial declaration of wchar_t -- can be bashed */
6368 wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"),
6370 pushdecl (wchar_decl_node);
6372 /* This is for wide string constants. */
6373 wchar_array_type_node
6374 = build_array_type (wchar_type_node, array_domain_type);
6376 if (flag_vtable_thunks)
6378 /* Make sure we get a unique function type, so we can give
6379 its pointer type a name. (This wins for gdb.) */
6380 tree vfunc_type = make_node (FUNCTION_TYPE);
6381 TREE_TYPE (vfunc_type) = integer_type_node;
6382 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6383 layout_type (vfunc_type);
6385 vtable_entry_type = build_pointer_type (vfunc_type);
6389 vtable_entry_type = make_aggr_type (RECORD_TYPE);
6390 fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
6392 fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
6394 fields[2] = build_lang_decl (FIELD_DECL, pfn_identifier,
6396 finish_builtin_type (vtable_entry_type, VTBL_PTR_TYPE, fields, 2,
6399 /* Make this part of an invisible union. */
6400 fields[3] = copy_node (fields[2]);
6401 TREE_TYPE (fields[3]) = delta_type_node;
6402 DECL_NAME (fields[3]) = delta2_identifier;
6403 DECL_MODE (fields[3]) = TYPE_MODE (delta_type_node);
6404 DECL_SIZE (fields[3]) = TYPE_SIZE (delta_type_node);
6405 DECL_SIZE_UNIT (fields[3]) = TYPE_SIZE_UNIT (delta_type_node);
6406 TREE_UNSIGNED (fields[3]) = 0;
6407 TREE_CHAIN (fields[2]) = fields[3];
6408 vtable_entry_type = build_qualified_type (vtable_entry_type,
6411 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6414 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6415 layout_type (vtbl_type_node);
6416 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6417 record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node);
6418 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6419 layout_type (vtbl_ptr_type_node);
6420 record_builtin_type (RID_MAX, NULL_PTR, vtbl_ptr_type_node);
6422 std_node = build_decl (NAMESPACE_DECL,
6423 get_identifier (flag_honor_std ? "fake std":"std"),
6425 pushdecl (std_node);
6429 push_namespace (get_identifier ("__cxxabiv1"));
6430 abi_node = current_namespace;
6434 global_type_node = make_node (LANG_TYPE);
6435 record_unknown_type (global_type_node, "global type");
6438 current_lang_name = lang_name_cplusplus;
6441 tree bad_alloc_type_node, newtype, deltype;
6443 push_namespace (get_identifier ("std"));
6444 bad_alloc_type_node = xref_tag
6445 (class_type_node, get_identifier ("bad_alloc"), 1);
6448 newtype = build_exception_variant
6449 (ptr_ftype_sizetype, add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1));
6450 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6451 push_cp_library_fn (ansi_opname[(int) NEW_EXPR], newtype);
6452 push_cp_library_fn (ansi_opname[(int) VEC_NEW_EXPR], newtype);
6453 global_delete_fndecl = push_cp_library_fn (ansi_opname[(int) DELETE_EXPR],
6455 push_cp_library_fn (ansi_opname[(int) VEC_DELETE_EXPR], deltype);
6459 = build_library_fn_ptr ("__pure_virtual", void_ftype);
6461 /* Perform other language dependent initializations. */
6462 init_class_processing ();
6463 init_init_processing ();
6464 init_search_processing ();
6465 init_rtti_processing ();
6467 if (flag_exceptions)
6468 init_exception_processing ();
6471 flag_inline_functions = 0;
6474 if (! supports_one_only ())
6477 /* Create the global bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
6478 make_fname_decl = cp_make_fname_decl;
6479 declare_function_name ();
6481 /* Prepare to check format strings against argument lists. */
6482 init_function_format_info ();
6484 /* Show we use EH for cleanups. */
6485 using_eh_for_cleanups ();
6487 print_error_function = lang_print_error_function;
6488 lang_get_alias_set = &c_get_alias_set;
6489 valid_lang_attribute = cp_valid_lang_attribute;
6491 /* Maintain consistency. Perhaps we should just complain if they
6492 say -fwritable-strings? */
6493 if (flag_writable_strings)
6494 flag_const_strings = 0;
6496 /* Add GC roots for all of our global variables. */
6497 ggc_add_tree_root (c_global_trees, sizeof c_global_trees / sizeof(tree));
6498 ggc_add_tree_root (cp_global_trees, sizeof cp_global_trees / sizeof(tree));
6499 ggc_add_tree_root (&integer_three_node, 1);
6500 ggc_add_tree_root (&integer_two_node, 1);
6501 ggc_add_tree_root (&signed_size_zero_node, 1);
6502 ggc_add_tree_root (&size_one_node, 1);
6503 ggc_add_tree_root (&size_zero_node, 1);
6504 ggc_add_root (&global_binding_level, 1, sizeof global_binding_level,
6505 mark_binding_level);
6506 ggc_add_root (&scope_chain, 1, sizeof scope_chain, &mark_saved_scope);
6507 ggc_add_tree_root (&static_ctors, 1);
6508 ggc_add_tree_root (&static_dtors, 1);
6509 ggc_add_tree_root (&lastiddecl, 1);
6511 ggc_add_tree_root (&last_function_parm_tags, 1);
6512 ggc_add_tree_root (¤t_function_return_value, 1);
6513 ggc_add_tree_root (¤t_function_parms, 1);
6514 ggc_add_tree_root (¤t_function_parm_tags, 1);
6515 ggc_add_tree_root (&last_function_parms, 1);
6516 ggc_add_tree_root (&error_mark_list, 1);
6518 ggc_add_tree_root (&global_namespace, 1);
6519 ggc_add_tree_root (&global_type_node, 1);
6520 ggc_add_tree_root (&anonymous_namespace_name, 1);
6522 ggc_add_tree_root (&got_object, 1);
6523 ggc_add_tree_root (&got_scope, 1);
6525 ggc_add_tree_root (¤t_lang_name, 1);
6526 ggc_add_tree_root (&static_aggregates, 1);
6529 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6530 decl, NAME is the initialization string and TYPE_DEP indicates whether
6531 NAME depended on the type of the function. We make use of that to detect
6532 __PRETTY_FUNCTION__ inside a template fn. Because we build a tree for
6533 the function before emitting any of it, we don't need to treat the
6534 VAR_DECL specially. We can decide whether to emit it later, if it was
6538 cp_make_fname_decl (id, name, type_dep)
6543 tree decl, type, init;
6544 size_t length = strlen (name);
6545 tree domain = NULL_TREE;
6547 if (!processing_template_decl)
6550 domain = build_index_type (build_int_2 (length, 0));
6552 type = build_cplus_array_type
6553 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
6556 decl = build_lang_decl (VAR_DECL, id, type);
6557 TREE_STATIC (decl) = 1;
6558 TREE_READONLY (decl) = 1;
6559 DECL_SOURCE_LINE (decl) = 0;
6560 DECL_ARTIFICIAL (decl) = 1;
6561 DECL_IN_SYSTEM_HEADER (decl) = 1;
6563 if (processing_template_decl)
6564 decl = push_template_decl (decl);
6567 init = build (FUNCTION_NAME, type);
6568 DECL_PRETTY_FUNCTION_P (decl) = 1;
6572 init = build_string (length + 1, name);
6573 TREE_TYPE (init) = type;
6575 DECL_INITIAL (decl) = init;
6576 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6578 /* We will have to make sure we only emit this, if it is actually used. */
6582 /* Function to print any language-specific context for an error message. */
6585 lang_print_error_function (file)
6588 default_print_error_function (file);
6589 maybe_print_template_context ();
6592 /* Entry point for the benefit of c_common_nodes_and_builtins.
6594 Make a definition for a builtin function named NAME and whose data type
6595 is TYPE. TYPE should be a function type with argument types.
6597 CLASS and CODE tell later passes how to compile calls to this function.
6598 See tree.h for possible values.
6600 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6601 the name to be called if we can't opencode the function. */
6604 builtin_function (name, type, code, class, libname)
6608 enum built_in_class class;
6609 const char *libname;
6611 tree decl = build_library_fn_1 (get_identifier (name), type);
6612 DECL_BUILT_IN_CLASS (decl) = class;
6613 DECL_FUNCTION_CODE (decl) = code;
6615 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 392);
6617 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6618 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6619 function in the namespace. */
6622 DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
6623 make_function_rtl (decl);
6627 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6628 function. Not called directly. */
6631 build_library_fn_1 (name, type)
6635 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6636 DECL_EXTERNAL (fn) = 1;
6637 TREE_PUBLIC (fn) = 1;
6638 DECL_ARTIFICIAL (fn) = 1;
6639 TREE_NOTHROW (fn) = 1;
6643 /* Returns the _DECL for a library function with C linkage.
6644 We assume that such functions never throw; if this is incorrect,
6645 callers should unset TREE_NOTHROW. */
6648 build_library_fn (name, type)
6652 tree fn = build_library_fn_1 (name, type);
6653 make_function_rtl (fn);
6657 /* Returns the _DECL for a library function with C++ linkage. */
6660 build_cp_library_fn (name, type)
6664 tree fn = build_library_fn_1 (name, type);
6665 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6666 set_mangled_name_for_decl (fn);
6667 make_function_rtl (fn);
6671 /* Like build_library_fn, but takes a C string instead of an
6675 build_library_fn_ptr (name, type)
6679 return build_library_fn (get_identifier (name), type);
6682 /* Like build_cp_library_fn, but takes a C string instead of an
6686 build_cp_library_fn_ptr (name, type)
6690 return build_cp_library_fn (get_identifier (name), type);
6693 /* Like build_library_fn, but also pushes the function so that we will
6694 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6697 push_library_fn (name, type)
6700 tree fn = build_library_fn (name, type);
6701 pushdecl_top_level (fn);
6705 /* Like build_cp_library_fn, but also pushes the function so that it
6706 will be found by normal lookup. */
6709 push_cp_library_fn (name, type)
6713 tree fn = build_cp_library_fn (name, type);
6718 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6722 push_void_library_fn (name, parmtypes)
6723 tree name, parmtypes;
6725 tree type = build_function_type (void_type_node, parmtypes);
6726 return push_library_fn (name, type);
6729 /* Like push_library_fn, but also note that this function throws
6730 and does not return. Used for __throw_foo and the like. */
6733 push_throw_library_fn (name, type)
6736 tree fn = push_library_fn (name, type);
6737 TREE_THIS_VOLATILE (fn) = 1;
6738 TREE_NOTHROW (fn) = 0;
6742 /* When we call finish_struct for an anonymous union, we create
6743 default copy constructors and such. But, an anonymous union
6744 shouldn't have such things; this function undoes the damage to the
6745 anonymous union type T.
6747 (The reason that we create the synthesized methods is that we don't
6748 distinguish `union { int i; }' from `typedef union { int i; } U'.
6749 The first is an anonymous union; the second is just an ordinary
6753 fixup_anonymous_aggr (t)
6758 /* Wipe out memory of synthesized methods */
6759 TYPE_HAS_CONSTRUCTOR (t) = 0;
6760 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6761 TYPE_HAS_INIT_REF (t) = 0;
6762 TYPE_HAS_CONST_INIT_REF (t) = 0;
6763 TYPE_HAS_ASSIGN_REF (t) = 0;
6764 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6766 /* Splice the implicitly generated functions out of the TYPE_METHODS
6768 q = &TYPE_METHODS (t);
6771 if (DECL_ARTIFICIAL (*q))
6772 *q = TREE_CHAIN (*q);
6774 q = &TREE_CHAIN (*q);
6777 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6778 if (TYPE_METHODS (t))
6779 error ("an anonymous union cannot have function members");
6782 /* Make sure that a declaration with no declarator is well-formed, i.e.
6783 just defines a tagged type or anonymous union.
6785 Returns the type defined, if any. */
6788 check_tag_decl (declspecs)
6793 tree ob_modifier = NULL_TREE;
6795 register tree t = NULL_TREE;
6797 for (link = declspecs; link; link = TREE_CHAIN (link))
6799 register tree value = TREE_VALUE (link);
6802 || (TREE_CODE (value) == IDENTIFIER_NODE
6803 && IDENTIFIER_GLOBAL_VALUE (value)
6804 && TYPE_P (IDENTIFIER_GLOBAL_VALUE (value))))
6808 if (IS_AGGR_TYPE (value) || TREE_CODE (value) == ENUMERAL_TYPE)
6810 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6814 else if (value == ridpointers[(int) RID_FRIEND])
6816 if (current_class_type == NULL_TREE
6817 || current_scope () != current_class_type)
6818 ob_modifier = value;
6822 else if (value == ridpointers[(int) RID_STATIC]
6823 || value == ridpointers[(int) RID_EXTERN]
6824 || value == ridpointers[(int) RID_AUTO]
6825 || value == ridpointers[(int) RID_REGISTER]
6826 || value == ridpointers[(int) RID_INLINE]
6827 || value == ridpointers[(int) RID_VIRTUAL]
6828 || value == ridpointers[(int) RID_CONST]
6829 || value == ridpointers[(int) RID_VOLATILE]
6830 || value == ridpointers[(int) RID_EXPLICIT])
6831 ob_modifier = value;
6835 error ("multiple types in one declaration");
6837 if (t == NULL_TREE && ! saw_friend)
6838 pedwarn ("declaration does not declare anything");
6840 /* Check for an anonymous union. We're careful
6841 accessing TYPE_IDENTIFIER because some built-in types, like
6842 pointer-to-member types, do not have TYPE_NAME. */
6843 else if (t && IS_AGGR_TYPE_CODE (TREE_CODE (t))
6845 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
6847 /* Anonymous unions are objects, so they can have specifiers. */;
6848 SET_ANON_AGGR_TYPE_P (t);
6850 if (TREE_CODE (t) != UNION_TYPE && pedantic && ! in_system_header)
6851 pedwarn ("ISO C++ prohibits anonymous structs");
6854 else if (ob_modifier)
6856 if (ob_modifier == ridpointers[(int) RID_INLINE]
6857 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6858 cp_error ("`%D' can only be specified for functions", ob_modifier);
6859 else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6860 cp_error ("`%D' can only be specified inside a class", ob_modifier);
6861 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6862 cp_error ("`%D' can only be specified for constructors",
6865 cp_error ("`%D' can only be specified for objects and functions",
6872 /* Called when a declaration is seen that contains no names to declare.
6873 If its type is a reference to a structure, union or enum inherited
6874 from a containing scope, shadow that tag name for the current scope
6875 with a forward reference.
6876 If its type defines a new named structure or union
6877 or defines an enum, it is valid but we need not do anything here.
6878 Otherwise, it is an error.
6880 C++: may have to grok the declspecs to learn about static,
6881 complain for anonymous unions. */
6884 shadow_tag (declspecs)
6887 tree t = check_tag_decl (declspecs);
6890 maybe_process_partial_specialization (t);
6892 /* This is where the variables in an anonymous union are
6893 declared. An anonymous union declaration looks like:
6895 because there is no declarator after the union, the parser
6896 sends that declaration here. */
6897 if (t && ANON_AGGR_TYPE_P (t))
6899 fixup_anonymous_aggr (t);
6901 if (TYPE_FIELDS (t))
6903 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6905 finish_anon_union (decl);
6910 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6913 groktypename (typename)
6916 if (TREE_CODE (typename) != TREE_LIST)
6918 return grokdeclarator (TREE_VALUE (typename),
6919 TREE_PURPOSE (typename),
6920 TYPENAME, 0, NULL_TREE);
6923 /* Decode a declarator in an ordinary declaration or data definition.
6924 This is called as soon as the type information and variable name
6925 have been parsed, before parsing the initializer if any.
6926 Here we create the ..._DECL node, fill in its type,
6927 and put it on the list of decls for the current context.
6928 The ..._DECL node is returned as the value.
6930 Exception: for arrays where the length is not specified,
6931 the type is left null, to be filled in by `cp_finish_decl'.
6933 Function definitions do not come here; they go to start_function
6934 instead. However, external and forward declarations of functions
6935 do go through here. Structure field declarations are done by
6936 grokfield and not through here. */
6939 start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
6940 tree declarator, declspecs;
6942 tree attributes, prefix_attributes;
6945 register tree type, tem;
6947 extern int have_extern_spec;
6948 extern int used_extern_spec;
6952 /* See code below that used this. */
6953 int init_written = initialized;
6956 /* This should only be done once on the top most decl. */
6957 if (have_extern_spec && !used_extern_spec)
6959 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"),
6961 used_extern_spec = 1;
6964 if (attributes || prefix_attributes)
6965 attrlist = build_tree_list (attributes, prefix_attributes);
6967 attrlist = NULL_TREE;
6969 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
6972 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
6975 type = TREE_TYPE (decl);
6977 if (type == error_mark_node)
6980 context = DECL_CONTEXT (decl);
6982 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
6983 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
6985 /* When parsing the initializer, lookup should use the object's
6987 push_decl_namespace (context);
6990 /* We are only interested in class contexts, later. */
6991 if (context && TREE_CODE (context) == NAMESPACE_DECL)
6992 context = NULL_TREE;
6995 /* Is it valid for this decl to have an initializer at all?
6996 If not, set INITIALIZED to zero, which will indirectly
6997 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
6998 switch (TREE_CODE (decl))
7001 /* typedef foo = bar means give foo the same type as bar.
7002 We haven't parsed bar yet, so `cp_finish_decl' will fix that up.
7003 Any other case of an initialization in a TYPE_DECL is an error. */
7004 if (pedantic || list_length (declspecs) > 1)
7006 cp_error ("typedef `%D' is initialized", decl);
7012 cp_error ("function `%#D' is initialized like a variable", decl);
7022 if (! toplevel_bindings_p ()
7023 && DECL_EXTERNAL (decl))
7024 cp_warning ("declaration of `%#D' has `extern' and is initialized",
7026 DECL_EXTERNAL (decl) = 0;
7027 if (toplevel_bindings_p ())
7028 TREE_STATIC (decl) = 1;
7030 /* Tell `pushdecl' this is an initialized decl
7031 even though we don't yet have the initializer expression.
7032 Also tell `cp_finish_decl' it may store the real initializer. */
7033 DECL_INITIAL (decl) = error_mark_node;
7036 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
7037 SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes);
7040 /* Set attributes here so if duplicate decl, will have proper attributes. */
7041 cplus_decl_attributes (decl, attributes, prefix_attributes);
7043 if (context && COMPLETE_TYPE_P (complete_type (context)))
7045 push_nested_class (context, 2);
7047 if (TREE_CODE (decl) == VAR_DECL)
7049 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7050 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7051 cp_error ("`%#D' is not a static member of `%#T'", decl, context);
7054 if (DECL_CONTEXT (field) != context)
7056 cp_pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7057 DECL_CONTEXT (field), DECL_NAME (decl),
7058 context, DECL_NAME (decl));
7059 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7061 /* Static data member are tricky; an in-class initialization
7062 still doesn't provide a definition, so the in-class
7063 declaration will have DECL_EXTERNAL set, but will have an
7064 initialization. Thus, duplicate_decls won't warn
7065 about this situation, and so we check here. */
7066 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7067 cp_error ("duplicate initialization of %D", decl);
7068 if (duplicate_decls (decl, field))
7074 tree field = check_classfn (context, decl);
7075 if (field && duplicate_decls (decl, field))
7079 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7080 DECL_IN_AGGR_P (decl) = 0;
7081 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7082 || CLASSTYPE_USE_TEMPLATE (context))
7084 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7085 /* [temp.expl.spec] An explicit specialization of a static data
7086 member of a template is a definition if the declaration
7087 includes an initializer; otherwise, it is a declaration.
7089 We check for processing_specialization so this only applies
7090 to the new specialization syntax. */
7091 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7092 DECL_EXTERNAL (decl) = 1;
7095 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7096 cp_pedwarn ("declaration of `%#D' outside of class is not definition",
7100 /* Enter this declaration into the symbol table. */
7101 tem = maybe_push_decl (decl);
7103 if (processing_template_decl)
7104 tem = push_template_decl (tem);
7106 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7107 /* Tell the back-end to use or not use .common as appropriate. If we say
7108 -fconserve-space, we want this to save .data space, at the expense of
7109 wrong semantics. If we say -fno-conserve-space, we want this to
7110 produce errors about redefs; to do this we force variables into the
7112 DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
7115 if (! processing_template_decl)
7125 tree type = TREE_TYPE (decl);
7126 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7128 if (type == error_mark_node)
7131 /* If this type of object needs a cleanup, but we're not allowed to
7132 add any more objects with cleanups to the current scope, create a
7133 new binding level. */
7134 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7135 && current_binding_level->more_cleanups_ok == 0)
7137 keep_next_level (2);
7140 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
7144 /* Is it valid for this decl to have an initializer at all?
7145 If not, set INITIALIZED to zero, which will indirectly
7146 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7148 /* Don't allow initializations for incomplete types except for
7149 arrays which might be completed by the initialization. */
7150 if (COMPLETE_TYPE_P (complete_type (type)))
7151 ; /* A complete type is ok. */
7152 else if (TREE_CODE (type) != ARRAY_TYPE)
7154 cp_error ("variable `%#D' has initializer but incomplete type",
7157 type = TREE_TYPE (decl) = error_mark_node;
7159 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7161 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7162 cp_error ("elements of array `%#D' have incomplete type", decl);
7163 /* else we already gave an error in start_decl. */
7169 && TREE_CODE (decl) != TYPE_DECL
7170 && TREE_CODE (decl) != TEMPLATE_DECL
7171 && type != error_mark_node
7172 && IS_AGGR_TYPE (type)
7173 && ! DECL_EXTERNAL (decl))
7175 if ((! processing_template_decl || ! uses_template_parms (type))
7176 && !COMPLETE_TYPE_P (complete_type (type)))
7178 cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
7180 /* Change the type so that assemble_variable will give
7181 DECL an rtl we can live with: (mem (const_int 0)). */
7182 type = TREE_TYPE (decl) = error_mark_node;
7186 /* If any base type in the hierarchy of TYPE needs a constructor,
7187 then we set initialized to 1. This way any nodes which are
7188 created for the purposes of initializing this aggregate
7189 will live as long as it does. This is necessary for global
7190 aggregates which do not have their initializers processed until
7191 the end of the file. */
7192 initialized = TYPE_NEEDS_CONSTRUCTING (type);
7197 DECL_INITIAL (decl) = NULL_TREE;
7200 /* Handle initialization of references.
7201 These three arguments are from `cp_finish_decl', and have the
7202 same meaning here that they do there.
7204 Quotes on semantics can be found in ARM 8.4.3. */
7207 grok_reference_init (decl, type, init)
7208 tree decl, type, init;
7212 if (init == NULL_TREE)
7214 if ((DECL_LANG_SPECIFIC (decl) == 0
7215 || DECL_IN_AGGR_P (decl) == 0)
7216 && ! DECL_THIS_EXTERN (decl))
7217 cp_error ("`%D' declared as reference but not initialized", decl);
7221 if (init == error_mark_node)
7224 if (TREE_CODE (init) == CONSTRUCTOR)
7226 cp_error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7230 if (TREE_CODE (init) == TREE_LIST)
7231 init = build_compound_expr (init);
7233 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7234 init = convert_from_reference (init);
7236 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7237 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7239 /* Note: default conversion is only called in very special cases. */
7240 init = default_conversion (init);
7243 /* Convert INIT to the reference type TYPE. This may involve the
7244 creation of a temporary, whose lifetime must be the same as that
7245 of the reference. If so, a DECL_STMT for the temporary will be
7246 added just after the DECL_STMT for DECL. That's why we don't set
7247 DECL_INITIAL for local references (instead assigning to them
7248 explicitly); we need to allow the temporary to be initialized
7250 tmp = convert_to_reference
7251 (type, init, CONV_IMPLICIT,
7252 LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND, decl);
7254 if (tmp == error_mark_node)
7256 else if (tmp != NULL_TREE)
7259 tmp = save_expr (tmp);
7260 if (building_stmt_tree ())
7262 /* Initialize the declaration. */
7263 tmp = build (INIT_EXPR, TREE_TYPE (decl), decl, tmp);
7264 finish_expr_stmt (tmp);
7267 DECL_INITIAL (decl) = tmp;
7271 cp_error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7275 if (TREE_STATIC (decl) && ! TREE_CONSTANT (DECL_INITIAL (decl)))
7277 expand_static_init (decl, DECL_INITIAL (decl));
7278 DECL_INITIAL (decl) = NULL_TREE;
7283 /* Fill in DECL_INITIAL with some magical value to prevent expand_decl from
7284 mucking with forces it does not comprehend (i.e. initialization with a
7285 constructor). If we are at global scope and won't go into COMMON, fill
7286 it in with a dummy CONSTRUCTOR to force the variable into .data;
7287 otherwise we can use error_mark_node. */
7290 obscure_complex_init (decl, init)
7293 if (! flag_no_inline && TREE_STATIC (decl))
7295 if (extract_init (decl, init))
7299 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7300 if (toplevel_bindings_p () && ! DECL_COMMON (decl))
7301 DECL_INITIAL (decl) = build (CONSTRUCTOR, TREE_TYPE (decl), NULL_TREE,
7305 DECL_INITIAL (decl) = error_mark_node;
7310 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7311 array until we finish parsing the initializer. If that's the
7312 situation we're in, update DECL accordingly. */
7315 maybe_deduce_size_from_array_init (decl, init)
7319 tree type = TREE_TYPE (decl);
7321 if (TREE_CODE (type) == ARRAY_TYPE
7322 && TYPE_DOMAIN (type) == NULL_TREE
7323 && TREE_CODE (decl) != TYPE_DECL)
7326 = (TREE_STATIC (decl)
7327 /* Even if pedantic, an external linkage array
7328 may have incomplete type at first. */
7329 ? pedantic && ! DECL_EXTERNAL (decl)
7330 : !DECL_EXTERNAL (decl));
7331 tree initializer = init ? init : DECL_INITIAL (decl);
7332 int failure = complete_array_type (type, initializer, do_default);
7335 cp_error ("initializer fails to determine size of `%D'", decl);
7340 cp_error ("array size missing in `%D'", decl);
7341 /* If a `static' var's size isn't known, make it extern as
7342 well as static, so it does not get allocated. If it's not
7343 `static', then don't mark it extern; finish_incomplete_decl
7344 will give it a default size and it will get allocated. */
7345 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7346 DECL_EXTERNAL (decl) = 1;
7349 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7350 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7352 cp_error ("zero-size array `%D'", decl);
7354 layout_decl (decl, 0);
7358 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7359 any appropriate error messages regarding the layout. */
7362 layout_var_decl (decl)
7365 tree type = TREE_TYPE (decl);
7367 tree ttype = target_type (type);
7370 /* If we haven't already layed out this declaration, do so now.
7371 Note that we must not call complete type for an external object
7372 because it's type might involve templates that we are not
7373 supposed to isntantiate yet. (And it's perfectly legal to say
7374 `extern X x' for some incomplete type `X'.) */
7375 if (!DECL_EXTERNAL (decl))
7376 complete_type (type);
7377 if (!DECL_SIZE (decl) && COMPLETE_TYPE_P (type))
7378 layout_decl (decl, 0);
7380 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7382 /* An automatic variable with an incomplete type: that is an error.
7383 Don't talk about array types here, since we took care of that
7384 message in grokdeclarator. */
7385 cp_error ("storage size of `%D' isn't known", decl);
7386 TREE_TYPE (decl) = error_mark_node;
7389 /* Keep this code around in case we later want to control debug info
7390 based on whether a type is "used". (jason 1999-11-11) */
7392 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7393 /* Let debugger know it should output info for this type. */
7394 note_debug_info_needed (ttype);
7396 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7397 note_debug_info_needed (DECL_CONTEXT (decl));
7400 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7401 && DECL_SIZE (decl) != NULL_TREE
7402 && ! TREE_CONSTANT (DECL_SIZE (decl)))
7404 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7405 constant_expression_warning (DECL_SIZE (decl));
7407 cp_error ("storage size of `%D' isn't constant", decl);
7411 /* If a local static variable is declared in an inline function, or if
7412 we have a weak definition, we must endeavor to create only one
7413 instance of the variable at link-time. */
7416 maybe_commonize_var (decl)
7419 /* Static data in a function with comdat linkage also has comdat
7421 if (TREE_STATIC (decl)
7422 /* Don't mess with __FUNCTION__. */
7423 && ! DECL_ARTIFICIAL (decl)
7424 && current_function_decl
7425 && DECL_CONTEXT (decl) == current_function_decl
7426 && (DECL_THIS_INLINE (current_function_decl)
7427 || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7428 && TREE_PUBLIC (current_function_decl))
7430 /* Rather than try to get this right with inlining, we suppress
7431 inlining of such functions. */
7432 current_function_cannot_inline
7433 = "function with static variable cannot be inline";
7435 /* If flag_weak, we don't need to mess with this, as we can just
7436 make the function weak, and let it refer to its unique local
7437 copy. This works because we don't allow the function to be
7441 if (DECL_INTERFACE_KNOWN (current_function_decl))
7443 TREE_PUBLIC (decl) = 1;
7444 DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7446 else if (DECL_INITIAL (decl) == NULL_TREE
7447 || DECL_INITIAL (decl) == error_mark_node)
7449 TREE_PUBLIC (decl) = 1;
7450 DECL_COMMON (decl) = 1;
7452 /* else we lose. We can only do this if we can use common,
7453 which we can't if it has been initialized. */
7455 if (TREE_PUBLIC (decl))
7456 DECL_ASSEMBLER_NAME (decl)
7457 = build_static_name (current_function_decl, DECL_NAME (decl));
7460 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7461 cp_warning_at (" you can work around this by removing the initializer", decl);
7465 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7466 /* Set it up again; we might have set DECL_INITIAL since the last
7468 comdat_linkage (decl);
7471 /* Issue an error message if DECL is an uninitialized const variable. */
7474 check_for_uninitialized_const_var (decl)
7477 tree type = TREE_TYPE (decl);
7479 /* ``Unless explicitly declared extern, a const object does not have
7480 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7482 if (TREE_CODE (decl) == VAR_DECL
7483 && TREE_CODE (type) != REFERENCE_TYPE
7484 && CP_TYPE_CONST_P (type)
7485 && !TYPE_NEEDS_CONSTRUCTING (type)
7486 && !DECL_INITIAL (decl))
7487 cp_error ("uninitialized const `%D'", decl);
7490 /* Verify INIT (the initializer for DECL), and record the
7491 initialization in DECL_INITIAL, if appropriate. Returns a new
7495 check_initializer (decl, init)
7501 if (TREE_CODE (decl) == FIELD_DECL)
7504 type = TREE_TYPE (decl);
7506 /* If `start_decl' didn't like having an initialization, ignore it now. */
7507 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7510 /* Check the initializer. */
7513 /* Things that are going to be initialized need to have complete
7515 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7517 if (type == error_mark_node)
7518 /* We will have already complained. */
7520 else if (COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
7522 cp_error ("variable-sized object `%D' may not be initialized", decl);
7525 else if (TREE_CODE (type) == ARRAY_TYPE
7526 && !COMPLETE_TYPE_P (TREE_TYPE (type)))
7528 cp_error ("elements of array `%#D' have incomplete type", decl);
7531 else if (!COMPLETE_TYPE_P (type))
7533 cp_error ("`%D' has incomplete type", decl);
7534 TREE_TYPE (decl) = error_mark_node;
7539 if (TREE_CODE (decl) == CONST_DECL)
7541 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7543 DECL_INITIAL (decl) = init;
7545 /* This will keep us from needing to worry about our obstacks. */
7546 my_friendly_assert (init != NULL_TREE, 149);
7549 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7551 if (TREE_STATIC (decl))
7552 make_decl_rtl (decl, NULL_PTR, toplevel_bindings_p ());
7553 grok_reference_init (decl, type, init);
7558 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7560 if (TREE_CODE (type) == ARRAY_TYPE)
7561 init = digest_init (type, init, (tree *) 0);
7562 else if (TREE_CODE (init) == CONSTRUCTOR
7563 && TREE_HAS_CONSTRUCTOR (init))
7565 if (TYPE_NON_AGGREGATE_CLASS (type))
7567 cp_error ("`%D' must be initialized by constructor, not by `{...}'",
7569 init = error_mark_node;
7572 goto dont_use_constructor;
7577 dont_use_constructor:
7578 if (TREE_CODE (init) != TREE_VEC)
7579 init = store_init_value (decl, init);
7583 /* We must hide the initializer so that expand_decl
7584 won't try to do something it does not understand. */
7585 init = obscure_complex_init (decl, init);
7587 else if (DECL_EXTERNAL (decl))
7589 else if (TYPE_P (type)
7590 && (IS_AGGR_TYPE (type) || TYPE_NEEDS_CONSTRUCTING (type)))
7592 tree core_type = strip_array_types (type);
7594 if (! TYPE_NEEDS_CONSTRUCTING (core_type))
7596 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7597 cp_error ("structure `%D' with uninitialized const members", decl);
7598 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7599 cp_error ("structure `%D' with uninitialized reference members",
7603 check_for_uninitialized_const_var (decl);
7605 if (COMPLETE_TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7606 init = obscure_complex_init (decl, NULL_TREE);
7610 check_for_uninitialized_const_var (decl);
7615 /* If DECL is not a local variable, give it RTL. */
7618 make_rtl_for_nonlocal_decl (decl, init, asmspec)
7621 const char *asmspec;
7626 type = TREE_TYPE (decl);
7627 toplev = toplevel_bindings_p ();
7629 /* Handle non-variables up front. */
7630 if (TREE_CODE (decl) != VAR_DECL)
7632 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7636 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7638 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
7640 if (DECL_VIRTUAL_P (decl))
7641 make_decl_rtl (decl, NULL_PTR, toplev);
7642 else if (TREE_READONLY (decl)
7643 && DECL_INITIAL (decl) != NULL_TREE
7644 && DECL_INITIAL (decl) != error_mark_node
7645 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
7647 DECL_INITIAL (decl) = save_expr (DECL_INITIAL (decl));
7649 if (toplev && ! TREE_PUBLIC (decl))
7651 /* If this is a static const, change its apparent linkage
7652 if it belongs to a #pragma interface. */
7653 if (!interface_unknown)
7655 TREE_PUBLIC (decl) = 1;
7656 DECL_EXTERNAL (decl) = interface_only;
7658 make_decl_rtl (decl, asmspec, toplev);
7661 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7663 else if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7665 my_friendly_assert (TREE_STATIC (decl), 19990828);
7667 if (init == NULL_TREE
7668 #ifdef DEFAULT_STATIC_DEFS
7669 /* If this code is dead, then users must
7670 explicitly declare static member variables
7671 outside the class def'n as well. */
7672 && TYPE_NEEDS_CONSTRUCTING (type)
7676 DECL_EXTERNAL (decl) = 1;
7677 make_decl_rtl (decl, asmspec, 1);
7680 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7682 else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == NAMESPACE_DECL
7683 || (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)))
7684 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7687 /* Create RTL for the local static variable DECL. */
7690 make_rtl_for_local_static (decl)
7693 const char *asmspec = NULL;
7695 /* If we inlined this variable, we could see it's declaration
7697 if (DECL_RTL (decl))
7700 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7702 /* The only way this situaton can occur is if the
7703 user specified a name for this DECL using the
7704 `attribute' syntax. */
7705 asmspec = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
7706 DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
7709 rest_of_decl_compilation (decl, asmspec, /*top_level=*/0, /*at_end=*/0);
7712 /* The old ARM scoping rules injected variables declared in the
7713 initialization statement of a for-statement into the surrounding
7714 scope. We support this usage, in order to be backward-compatible.
7715 DECL is a just-declared VAR_DECL; if necessary inject its
7716 declaration into the surrounding scope. */
7719 maybe_inject_for_scope_var (decl)
7722 if (current_binding_level->is_for_scope)
7724 struct binding_level *outer
7725 = current_binding_level->level_chain;
7727 /* Check to see if the same name is already bound at the outer
7728 level, either because it was directly declared, or because a
7729 dead for-decl got preserved. In either case, the code would
7730 not have been valid under the ARM scope rules, so clear
7731 is_for_scope for the current_binding_level.
7733 Otherwise, we need to preserve the temp slot for decl to last
7734 into the outer binding level. */
7737 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7739 if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7740 && (TREE_CODE (BINDING_VALUE (outer_binding))
7742 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7744 BINDING_VALUE (outer_binding)
7745 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7746 current_binding_level->is_for_scope = 0;
7748 else if (DECL_IN_MEMORY_P (decl))
7749 preserve_temp_slots (DECL_RTL (decl));
7753 /* Generate code to initialize DECL (a local variable). */
7756 initialize_local_var (decl, init, flags)
7761 tree type = TREE_TYPE (decl);
7763 /* If the type is bogus, don't bother initializing the variable. */
7764 if (type == error_mark_node)
7767 if (DECL_SIZE (decl) == NULL_TREE && !TREE_STATIC (decl))
7769 /* If we used it already as memory, it must stay in memory. */
7770 DECL_INITIAL (decl) = NULL_TREE;
7771 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7774 /* Local statics are handled differently from ordinary automatic
7776 if (TREE_STATIC (decl))
7778 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
7779 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7780 expand_static_init (decl, init);
7784 if (DECL_SIZE (decl) && type != error_mark_node)
7788 /* Compute and store the initial value. */
7789 already_used = TREE_USED (decl) || TREE_USED (type);
7791 if (init || TYPE_NEEDS_CONSTRUCTING (type))
7793 int saved_stmts_are_full_exprs_p;
7795 emit_line_note (DECL_SOURCE_FILE (decl),
7796 DECL_SOURCE_LINE (decl));
7797 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p;
7798 stmts_are_full_exprs_p = 1;
7799 finish_expr_stmt (build_aggr_init (decl, init, flags));
7800 stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p;
7803 /* Set this to 0 so we can tell whether an aggregate which was
7804 initialized was ever used. Don't do this if it has a
7805 destructor, so we don't complain about the 'resource
7806 allocation is initialization' idiom. Now set
7807 attribute((unused)) on types so decls of that type will be
7808 marked used. (see TREE_USED, above.) */
7809 if (TYPE_NEEDS_CONSTRUCTING (type)
7811 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
7812 && DECL_NAME (decl))
7813 TREE_USED (decl) = 0;
7814 else if (already_used)
7815 TREE_USED (decl) = 1;
7819 /* Generate code to destroy DECL (a local variable). */
7822 destroy_local_var (decl)
7825 tree type = TREE_TYPE (decl);
7828 /* Only variables get cleaned up. */
7829 if (TREE_CODE (decl) != VAR_DECL)
7832 /* And only things with destructors need cleaning up. */
7833 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7836 if (TREE_CODE (decl) == VAR_DECL &&
7837 (DECL_EXTERNAL (decl) || TREE_STATIC (decl)))
7838 /* We don't clean up things that aren't defined in this
7839 translation unit, or that need a static cleanup. The latter
7840 are handled by finish_file. */
7843 /* Compute the cleanup. */
7844 cleanup = maybe_build_cleanup (decl);
7846 /* Record the cleanup required for this declaration. */
7847 if (DECL_SIZE (decl) && TREE_TYPE (decl) != error_mark_node
7849 finish_decl_cleanup (decl, cleanup);
7852 /* Let the back-end know about DECL. */
7855 emit_local_var (decl)
7858 /* Create RTL for this variable. */
7859 if (DECL_RTL (decl))
7860 /* Only a RESULT_DECL should have non-NULL RTL when arriving here.
7861 All other local variables are assigned RTL in this function. */
7862 my_friendly_assert (TREE_CODE (decl) == RESULT_DECL,
7866 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7867 /* The user must have specified an assembler name for this
7868 variable. Set that up now. */
7869 rest_of_decl_compilation
7870 (decl, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
7871 /*top_level=*/0, /*at_end=*/0);
7876 /* Actually do the initialization. */
7877 expand_start_target_temps ();
7878 expand_decl_init (decl);
7879 expand_end_target_temps ();
7882 /* Finish processing of a declaration;
7883 install its line number and initial value.
7884 If the length of an array type is not known before,
7885 it must be determined now, from the initial value, or it is an error.
7887 INIT0 holds the value of an initializer that should be allowed to escape
7890 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
7891 if the (init) syntax was used. */
7894 cp_finish_decl (decl, init, asmspec_tree, flags)
7900 tree ttype = NULL_TREE;
7901 const char *asmspec = NULL;
7902 int was_readonly = 0;
7907 error ("assignment (not initialization) in declaration");
7911 /* If a name was specified, get the string. */
7913 asmspec = TREE_STRING_POINTER (asmspec_tree);
7915 if (init && TREE_CODE (init) == NAMESPACE_DECL)
7917 cp_error ("cannot initialize `%D' to namespace `%D'",
7922 if (current_class_type
7923 && CP_DECL_CONTEXT (decl) == current_class_type
7924 && TYPE_BEING_DEFINED (current_class_type)
7925 && (DECL_INITIAL (decl) || init))
7926 DECL_DEFINED_IN_CLASS_P (decl) = 1;
7928 if (TREE_CODE (decl) == VAR_DECL
7929 && DECL_CONTEXT (decl)
7930 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
7931 && DECL_CONTEXT (decl) != current_namespace
7934 /* Leave the namespace of the object. */
7935 pop_decl_namespace ();
7938 type = TREE_TYPE (decl);
7940 if (type == error_mark_node)
7943 /* Add this declaration to the statement-tree. */
7944 if (building_stmt_tree () && at_function_scope_p ())
7945 add_decl_stmt (decl);
7947 if (TYPE_HAS_MUTABLE_P (type))
7948 TREE_READONLY (decl) = 0;
7950 if (processing_template_decl)
7952 if (init && DECL_INITIAL (decl))
7953 DECL_INITIAL (decl) = init;
7957 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
7958 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
7960 /* Take care of TYPE_DECLs up front. */
7961 if (TREE_CODE (decl) == TYPE_DECL)
7963 if (init && DECL_INITIAL (decl))
7965 /* typedef foo = bar; store the type of bar as the type of foo. */
7966 TREE_TYPE (decl) = type = TREE_TYPE (init);
7967 DECL_INITIAL (decl) = init = NULL_TREE;
7969 if (type != error_mark_node
7970 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
7972 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7973 cp_warning ("shadowing previous type declaration of `%#D'", decl);
7974 set_identifier_type_value (DECL_NAME (decl), type);
7975 CLASSTYPE_GOT_SEMICOLON (type) = 1;
7977 GNU_xref_decl (current_function_decl, decl);
7979 /* If we have installed this as the canonical typedef for this
7980 type, and that type has not been defined yet, delay emitting
7981 the debug information for it, as we will emit it later. */
7982 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7983 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7984 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7986 rest_of_decl_compilation (decl, NULL_PTR,
7987 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
7991 if (TREE_CODE (decl) != FUNCTION_DECL)
7992 ttype = target_type (type);
7994 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
7995 && TYPE_NEEDS_CONSTRUCTING (type))
7997 /* Currently, GNU C++ puts constants in text space, making them
7998 impossible to initialize. In the future, one would hope for
7999 an operating system which understood the difference between
8000 initialization and the running of a program. */
8002 TREE_READONLY (decl) = 0;
8005 if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8007 /* This must override the asm specifier which was placed by
8008 grokclassfn. Lay this out fresh. */
8009 DECL_RTL (TREE_TYPE (decl)) = NULL_RTX;
8010 DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
8011 make_decl_rtl (decl, asmspec, 0);
8014 /* Deduce size of array from initialization, if not already known. */
8015 maybe_deduce_size_from_array_init (decl, init);
8016 init = check_initializer (decl, init);
8018 GNU_xref_decl (current_function_decl, decl);
8020 if (TREE_CODE (decl) == VAR_DECL)
8021 layout_var_decl (decl);
8023 /* Output the assembler code and/or RTL code for variables and functions,
8024 unless the type is an undefined structure or union.
8025 If not, it will get done when the type is completed. */
8026 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8027 || TREE_CODE (decl) == RESULT_DECL)
8029 if (TREE_CODE (decl) == VAR_DECL)
8030 maybe_commonize_var (decl);
8032 make_rtl_for_nonlocal_decl (decl, init, asmspec);
8034 if (TREE_CODE (type) == FUNCTION_TYPE
8035 || TREE_CODE (type) == METHOD_TYPE)
8036 abstract_virtuals_error (decl,
8037 strip_array_types (TREE_TYPE (type)));
8039 abstract_virtuals_error (decl, strip_array_types (type));
8041 if (TREE_CODE (decl) == FUNCTION_DECL)
8043 else if (DECL_EXTERNAL (decl)
8044 && ! (DECL_LANG_SPECIFIC (decl)
8045 && DECL_NOT_REALLY_EXTERN (decl)))
8048 DECL_INITIAL (decl) = init;
8050 else if (TREE_CODE (CP_DECL_CONTEXT (decl)) == FUNCTION_DECL)
8052 /* This is a local declaration. */
8053 if (doing_semantic_analysis_p ())
8054 maybe_inject_for_scope_var (decl);
8055 /* Initialize the local variable. But, if we're building a
8056 statement-tree, we'll do the initialization when we
8058 if (processing_template_decl)
8060 if (init || DECL_INITIAL (decl) == error_mark_node)
8061 DECL_INITIAL (decl) = init;
8065 /* If we're not building RTL, then we need to do so
8067 if (!building_stmt_tree ())
8068 emit_local_var (decl);
8069 /* Initialize the variable. */
8070 initialize_local_var (decl, init, flags);
8071 /* Clean up the variable. */
8072 destroy_local_var (decl);
8075 else if (TREE_STATIC (decl) && type != error_mark_node)
8077 /* Cleanups for static variables are handled by `finish_file'. */
8078 if (TYPE_NEEDS_CONSTRUCTING (type) || init != NULL_TREE
8079 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8080 expand_static_init (decl, init);
8084 /* Undo call to `pushclass' that was done in `start_decl'
8085 due to initialization of qualified member variable.
8086 I.e., Foo::x = 10; */
8088 tree context = CP_DECL_CONTEXT (decl);
8091 && (TREE_CODE (decl) == VAR_DECL
8092 /* We also have a pushclass done that we need to undo here
8093 if we're at top level and declare a method. */
8094 || TREE_CODE (decl) == FUNCTION_DECL)
8095 /* If size hasn't been set, we're still defining it,
8096 and therefore inside the class body; don't pop
8097 the binding level.. */
8098 && COMPLETE_TYPE_P (context)
8099 && context == current_class_type)
8100 pop_nested_class ();
8107 TREE_READONLY (decl) = 1;
8110 /* This is here for a midend callback from c-common.c */
8113 finish_decl (decl, init, asmspec_tree)
8117 cp_finish_decl (decl, init, asmspec_tree, 0);
8120 /* Returns a declaration for a VAR_DECL as if:
8122 extern "C" TYPE NAME;
8124 had been seen. Used to create compiler-generated global
8128 declare_global_var (name, type)
8134 push_to_top_level ();
8135 decl = build_decl (VAR_DECL, name, type);
8136 TREE_PUBLIC (decl) = 1;
8137 DECL_EXTERNAL (decl) = 1;
8138 DECL_ARTIFICIAL (decl) = 1;
8140 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8141 pop_from_top_level ();
8146 /* Returns a pointer to the `atexit' function. Note that if
8147 FLAG_USE_CXA_ATEXIT is non-zero, then this will actually be the new
8148 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8162 if (flag_use_cxa_atexit)
8164 /* The declaration for `__cxa_atexit' is:
8166 int __cxa_atexit (void (*)(void *), void *, void *)
8168 We build up the argument types and then then function type
8171 /* First, build the pointer-to-function type for the first
8173 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8174 fn_type = build_function_type (void_type_node, arg_types);
8175 fn_ptr_type = build_pointer_type (fn_type);
8176 /* Then, build the rest of the argument types. */
8177 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8178 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8179 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8180 /* And the final __cxa_atexit type. */
8181 fn_type = build_function_type (integer_type_node, arg_types);
8182 fn_ptr_type = build_pointer_type (fn_type);
8183 name = "__cxa_atexit";
8187 /* The declaration for `atexit' is:
8189 int atexit (void (*)());
8191 We build up the argument types and then then function type
8193 fn_type = build_function_type (void_type_node, void_list_node);
8194 fn_ptr_type = build_pointer_type (fn_type);
8195 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8196 /* Build the final atexit type. */
8197 fn_type = build_function_type (integer_type_node, arg_types);
8201 /* Now, build the function declaration. */
8202 push_lang_context (lang_name_c);
8203 atexit_fndecl = build_library_fn_ptr (name, fn_type);
8204 mark_used (atexit_fndecl);
8205 pop_lang_context ();
8206 atexit_node = default_conversion (atexit_fndecl);
8211 /* Returns the __dso_handle VAR_DECL. */
8214 get_dso_handle_node ()
8216 if (dso_handle_node)
8217 return dso_handle_node;
8219 /* Declare the variable. */
8220 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8223 return dso_handle_node;
8226 /* Begin a new function with internal linkage whose job will be simply
8227 to destroy some particular variable. */
8232 static int counter = 0;
8233 int old_interface_unknown = interface_unknown;
8239 push_to_top_level ();
8241 /* No need to mangle this. */
8242 push_lang_context (lang_name_c);
8244 interface_unknown = 1;
8246 /* Build the parameter-types. */
8247 parmtypes = void_list_node;
8248 /* Functions passed to __cxa_atexit take an additional parameter.
8249 We'll just ignore it. After we implement the new calling
8250 convention for destructors, we can eliminate the use of
8251 additional cleanup functions entirely in the -fnew-abi case. */
8252 if (flag_use_cxa_atexit)
8253 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8254 /* Build the function type itself. */
8255 fntype = build_function_type (void_type_node, parmtypes);
8256 /* Build the name of the function. */
8257 sprintf (name, "__tcf_%d", counter++);
8258 /* Build the function declaration. */
8259 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8260 /* It's a function with internal linkage, generated by the
8262 TREE_PUBLIC (fndecl) = 0;
8263 DECL_ARTIFICIAL (fndecl) = 1;
8264 /* Build the parameter. */
8265 if (flag_use_cxa_atexit)
8269 parmdecl = build_decl (PARM_DECL, NULL_TREE, ptr_type_node);
8270 DECL_CONTEXT (parmdecl) = fndecl;
8271 DECL_ARG_TYPE (parmdecl) = ptr_type_node;
8272 TREE_USED (parmdecl) = 1;
8273 DECL_ARGUMENTS (fndecl) = parmdecl;
8277 start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8280 interface_unknown = old_interface_unknown;
8282 pop_lang_context ();
8284 return current_function_decl;
8287 /* Finish the cleanup function begun by start_cleanup_fn. */
8294 expand_body (finish_function (0));
8296 pop_from_top_level ();
8299 /* Generate code to handle the destruction of DECL, an object with
8300 static storage duration. */
8303 register_dtor_fn (decl)
8311 int saved_flag_access_control;
8313 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8316 /* Call build_cleanup before we enter the anonymous function so that
8317 any access checks will be done relative to the current scope,
8318 rather than the scope of the anonymous function. */
8319 build_cleanup (decl);
8321 /* Now start the function. */
8322 cleanup = start_cleanup_fn ();
8324 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8325 to the original function, rather than the anonymous one. That
8326 will make the back-end think that nested functions are in use,
8327 which causes confusion. */
8328 saved_flag_access_control = flag_access_control;
8329 flag_access_control = 0;
8330 fcall = build_cleanup (decl);
8331 flag_access_control = saved_flag_access_control;
8333 /* Create the body of the anonymous function. */
8334 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8335 finish_expr_stmt (fcall);
8336 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8339 /* Call atexit with the cleanup function. */
8340 mark_addressable (cleanup);
8341 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8342 if (flag_use_cxa_atexit)
8344 args = tree_cons (NULL_TREE, get_dso_handle_node (), NULL_TREE);
8345 args = tree_cons (NULL_TREE, null_pointer_node, args);
8346 args = tree_cons (NULL_TREE, cleanup, args);
8349 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8350 finish_expr_stmt (build_function_call (get_atexit_node (), args));
8354 expand_static_init (decl, init)
8358 tree oldstatic = value_member (decl, static_aggregates);
8362 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8363 cp_error ("multiple initializations given for `%D'", decl);
8365 else if (! toplevel_bindings_p ())
8367 /* Emit code to perform this initialization but once. */
8374 /* Emit code to perform this initialization but once. This code
8377 static int temp = 0;
8379 // Do initialization.
8381 // Register variable for destruction at end of program.
8384 Note that the `temp' variable is only set to 1 *after* the
8385 initialization is complete. This ensures that an exception,
8386 thrown during the construction, will cause the variable to
8387 reinitialized when we pass through this code again, as per:
8391 If the initialization exits by throwing an exception, the
8392 initialization is not complete, so it will be tried again
8393 the next time control enters the declaration.
8395 In theory, this process should be thread-safe, too; multiple
8396 threads should not be able to initialize the variable more
8397 than once. We don't yet attempt to ensure thread-safety. */
8398 temp = get_temp_name (integer_type_node, 1);
8399 rest_of_decl_compilation (temp, NULL_PTR, 0, 0);
8401 /* Begin the conditional initialization. */
8402 if_stmt = begin_if_stmt ();
8403 finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
8406 then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8408 /* Do the initialization itself. */
8409 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8410 || (init && TREE_CODE (init) == TREE_LIST))
8411 assignment = build_aggr_init (decl, init, 0);
8413 /* The initialization we're doing here is just a bitwise
8415 assignment = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
8417 assignment = NULL_TREE;
8419 /* Once the assignment is complete, set TEMP to 1. Since the
8420 construction of the static object is complete at this point,
8421 we want to make sure TEMP is set to 1 even if a temporary
8422 constructed during the initialization throws an exception
8423 when it is destroyed. So, we combine the initialization and
8424 the assignment to TEMP into a single expression, ensuring
8425 that when we call finish_expr_stmt the cleanups will not be
8426 run until after TEMP is set to 1. */
8427 temp_init = build_modify_expr (temp, NOP_EXPR, integer_one_node);
8430 assignment = tree_cons (NULL_TREE, assignment,
8431 build_tree_list (NULL_TREE,
8433 assignment = build_compound_expr (assignment);
8436 assignment = temp_init;
8437 finish_expr_stmt (assignment);
8439 /* Use atexit to register a function for destroying this static
8441 register_dtor_fn (decl);
8443 finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8444 finish_then_clause (if_stmt);
8448 static_aggregates = tree_cons (init, decl, static_aggregates);
8451 /* Finish the declaration of a catch-parameter. */
8454 start_handler_parms (declspecs, declarator)
8461 decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8463 if (decl == NULL_TREE)
8464 error ("invalid catch parameter");
8473 /* Make TYPE a complete type based on INITIAL_VALUE.
8474 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8475 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8478 complete_array_type (type, initial_value, do_default)
8479 tree type, initial_value;
8482 register tree maxindex = NULL_TREE;
8487 /* Note MAXINDEX is really the maximum index,
8488 one less than the size. */
8489 if (TREE_CODE (initial_value) == STRING_CST)
8492 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8493 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8496 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8498 tree elts = CONSTRUCTOR_ELTS (initial_value);
8500 maxindex = ssize_int (-1);
8501 for (; elts; elts = TREE_CHAIN (elts))
8503 if (TREE_PURPOSE (elts))
8504 maxindex = TREE_PURPOSE (elts);
8506 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8508 maxindex = copy_node (maxindex);
8512 /* Make an error message unless that happened already. */
8513 if (initial_value != error_mark_node)
8516 initial_value = NULL_TREE;
8518 /* Prevent further error messages. */
8519 maxindex = build_int_2 (0, 0);
8526 maxindex = build_int_2 (0, 0);
8535 domain = build_index_type (maxindex);
8536 TYPE_DOMAIN (type) = domain;
8538 if (! TREE_TYPE (maxindex))
8539 TREE_TYPE (maxindex) = domain;
8541 itype = TREE_TYPE (initial_value);
8544 if (itype && !TYPE_DOMAIN (itype))
8545 TYPE_DOMAIN (itype) = domain;
8546 /* The type of the main variant should never be used for arrays
8547 of different sizes. It should only ever be completed with the
8548 size of the array. */
8549 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8550 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8553 /* Lay out the type now that we can get the real answer. */
8560 /* Return zero if something is declared to be a member of type
8561 CTYPE when in the context of CUR_TYPE. STRING is the error
8562 message to print in that case. Otherwise, quietly return 1. */
8565 member_function_or_else (ctype, cur_type, flags)
8566 tree ctype, cur_type;
8567 enum overload_flags flags;
8569 if (ctype && ctype != cur_type)
8571 if (flags == DTOR_FLAG)
8572 error ("destructor for alien class `%s' cannot be a member",
8573 TYPE_NAME_STRING (ctype));
8575 error ("constructor for alien class `%s' cannot be a member",
8576 TYPE_NAME_STRING (ctype));
8582 /* Subroutine of `grokdeclarator'. */
8584 /* Generate errors possibly applicable for a given set of specifiers.
8585 This is for ARM $7.1.2. */
8588 bad_specifiers (object, type, virtualp, quals, inlinep, friendp, raises)
8591 int virtualp, quals, friendp, raises, inlinep;
8594 cp_error ("`%D' declared as a `virtual' %s", object, type);
8596 cp_error ("`%D' declared as an `inline' %s", object, type);
8598 cp_error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8601 cp_error_at ("`%D' declared as a friend", object);
8603 cp_error_at ("`%D' declared with an exception specification", object);
8606 /* CTYPE is class type, or null if non-class.
8607 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8609 DECLARATOR is the function's name.
8610 VIRTUALP is truthvalue of whether the function is virtual or not.
8611 FLAGS are to be passed through to `grokclassfn'.
8612 QUALS are qualifiers indicating whether the function is `const'
8614 RAISES is a list of exceptions that this function can raise.
8615 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8616 not look, and -1 if we should not call `grokclassfn' at all.
8618 Returns `NULL_TREE' if something goes wrong, after issuing
8619 applicable error messages. */
8622 grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
8623 raises, check, friendp, publicp, inlinep, funcdef_flag,
8624 template_count, in_namespace)
8627 tree orig_declarator;
8629 enum overload_flags flags;
8631 int check, friendp, publicp, inlinep, funcdef_flag, template_count;
8635 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8636 int has_default_arg = 0;
8640 cname = TREE_CODE (TYPE_NAME (ctype)) == TYPE_DECL
8641 ? TYPE_IDENTIFIER (ctype) : TYPE_NAME (ctype);
8647 type = build_exception_variant (type, raises);
8650 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8651 /* Propagate volatile out from type to decl. */
8652 if (TYPE_VOLATILE (type))
8653 TREE_THIS_VOLATILE (decl) = 1;
8655 /* If this decl has namespace scope, set that up. */
8657 set_decl_namespace (decl, in_namespace, friendp);
8658 else if (publicp && ! ctype)
8659 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8661 /* `main' and builtins have implicit 'C' linkage. */
8662 if ((MAIN_NAME_P (declarator)
8663 || (IDENTIFIER_LENGTH (declarator) > 10
8664 && IDENTIFIER_POINTER (declarator)[0] == '_'
8665 && IDENTIFIER_POINTER (declarator)[1] == '_'
8666 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8667 && current_lang_name == lang_name_cplusplus
8668 && ctype == NULL_TREE
8669 /* NULL_TREE means global namespace. */
8670 && DECL_CONTEXT (decl) == NULL_TREE)
8671 DECL_LANGUAGE (decl) = lang_c;
8673 /* Should probably propagate const out from type to decl I bet (mrs). */
8676 DECL_STATIC_FUNCTION_P (decl) = 1;
8677 DECL_CONTEXT (decl) = ctype;
8681 DECL_CONTEXT (decl) = ctype;
8683 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8685 if (processing_template_decl)
8686 error ("cannot declare `::main' to be a template");
8688 error ("cannot declare `::main' to be inline");
8690 error ("cannot declare `::main' to be static");
8695 /* Members of anonymous types and local classes have no linkage; make
8697 if (ctype && (ANON_AGGRNAME_P (TYPE_IDENTIFIER (ctype))
8698 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8703 /* [basic.link]: A name with no linkage (notably, the name of a class
8704 or enumeration declared in a local scope) shall not be used to
8705 declare an entity with linkage.
8707 Only check this for public decls for now. */
8708 t = no_linkage_check (TREE_TYPE (decl));
8711 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8713 if (DECL_LANGUAGE (decl) == lang_c)
8714 /* Allow this; it's pretty common in C. */;
8716 cp_pedwarn ("non-local function `%#D' uses anonymous type",
8720 cp_pedwarn ("non-local function `%#D' uses local type `%T'",
8725 TREE_PUBLIC (decl) = publicp;
8728 DECL_INTERFACE_KNOWN (decl) = 1;
8729 DECL_NOT_REALLY_EXTERN (decl) = 1;
8733 DECL_THIS_INLINE (decl) = DECL_INLINE (decl) = 1;
8735 DECL_EXTERNAL (decl) = 1;
8736 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8738 cp_error ("%smember function `%D' cannot have `%T' method qualifier",
8739 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8743 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8744 grok_op_properties (decl, virtualp, check < 0);
8746 if (ctype && decl_function_context (decl))
8747 DECL_NO_STATIC_CHAIN (decl) = 1;
8749 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8750 if (TREE_PURPOSE (t)
8751 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8753 has_default_arg = 1;
8758 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8762 ("defining explicit specialization `%D' in friend declaration",
8766 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8768 /* Something like `template <class T> friend void f<T>()'. */
8769 cp_error ("invalid use of template-id `%D' in declaration of primary template",
8775 /* A friend declaration of the form friend void f<>(). Record
8776 the information in the TEMPLATE_ID_EXPR. */
8777 SET_DECL_IMPLICIT_INSTANTIATION (decl);
8778 DECL_TEMPLATE_INFO (decl)
8779 = tree_cons (TREE_OPERAND (orig_declarator, 0),
8780 TREE_OPERAND (orig_declarator, 1),
8783 if (has_default_arg)
8785 cp_error ("default arguments are not allowed in declaration of friend template specialization `%D'",
8792 cp_error ("`inline' is not allowed in declaration of friend template specialization `%D'",
8799 if (has_default_arg)
8800 add_defarg_fn (decl);
8802 /* Plain overloading: will not be grok'd by grokclassfn. */
8803 if (! ctype && ! processing_template_decl
8804 && DECL_LANGUAGE (decl) != lang_c
8805 && (! DECL_USE_TEMPLATE (decl) || name_mangling_version < 1))
8806 set_mangled_name_for_decl (decl);
8809 /* Make the init_value nonzero so pushdecl knows this is not
8810 tentative. error_mark_node is replaced later with the BLOCK. */
8811 DECL_INITIAL (decl) = error_mark_node;
8813 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
8814 TREE_NOTHROW (decl) = 1;
8816 /* Caller will do the rest of this. */
8820 if (flags == NO_SPECIAL && ctype && constructor_name (cname) == declarator)
8821 DECL_CONSTRUCTOR_P (decl) = 1;
8823 /* Function gets the ugly name, field gets the nice one. This call
8824 may change the type of the function (because of default
8826 if (ctype != NULL_TREE)
8827 grokclassfn (ctype, decl, flags, quals);
8829 decl = check_explicit_specialization (orig_declarator, decl,
8831 2 * (funcdef_flag != 0) +
8832 4 * (friendp != 0));
8833 if (decl == error_mark_node)
8836 if (ctype != NULL_TREE
8837 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
8842 old_decl = check_classfn (ctype, decl);
8844 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
8845 /* Because grokfndecl is always supposed to return a
8846 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8847 here. We depend on our callers to figure out that its
8848 really a template that's being returned. */
8849 old_decl = DECL_TEMPLATE_RESULT (old_decl);
8851 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
8852 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8854 /* Remove the `this' parm added by grokclassfn.
8855 XXX Isn't this done in start_function, too? */
8856 revert_static_member_fn (decl);
8857 last_function_parms = TREE_CHAIN (last_function_parms);
8859 if (old_decl && DECL_ARTIFICIAL (old_decl))
8860 cp_error ("definition of implicitly-declared `%D'", old_decl);
8864 /* Since we've smashed OLD_DECL to its
8865 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8866 if (TREE_CODE (decl) == TEMPLATE_DECL)
8867 decl = DECL_TEMPLATE_RESULT (decl);
8869 /* Attempt to merge the declarations. This can fail, in
8870 the case of some illegal specialization declarations. */
8871 if (!duplicate_decls (decl, old_decl))
8872 cp_error ("no `%#D' member function declared in class `%T'",
8878 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8881 if (ctype == NULL_TREE || check)
8886 DECL_VIRTUAL_P (decl) = 1;
8887 if (DECL_VINDEX (decl) == NULL_TREE)
8888 DECL_VINDEX (decl) = error_mark_node;
8889 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
8896 grokvardecl (type, declarator, specbits_in, initialized, constp, in_namespace)
8899 RID_BIT_TYPE *specbits_in;
8905 RID_BIT_TYPE specbits;
8907 specbits = *specbits_in;
8909 if (TREE_CODE (type) == OFFSET_TYPE)
8911 /* If you declare a static member so that it
8912 can be initialized, the code will reach here. */
8913 tree basetype = TYPE_OFFSET_BASETYPE (type);
8914 type = TREE_TYPE (type);
8915 decl = build_lang_decl (VAR_DECL, declarator, type);
8916 DECL_CONTEXT (decl) = basetype;
8917 DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator);
8924 context = in_namespace;
8925 else if (namespace_bindings_p () || RIDBIT_SETP (RID_EXTERN, specbits))
8926 context = current_namespace;
8928 context = NULL_TREE;
8930 if (processing_template_decl)
8931 /* If we're in a template, we need DECL_LANG_SPECIFIC so that
8932 we can call push_template_decl. */
8933 decl = build_lang_decl (VAR_DECL, declarator, type);
8935 decl = build_decl (VAR_DECL, declarator, type);
8938 set_decl_namespace (decl, context, 0);
8940 context = DECL_CONTEXT (decl);
8941 if (declarator && context && current_lang_name != lang_name_c)
8942 DECL_ASSEMBLER_NAME (decl) = build_static_name (context, declarator);
8946 set_decl_namespace (decl, in_namespace, 0);
8948 if (RIDBIT_SETP (RID_EXTERN, specbits))
8950 DECL_THIS_EXTERN (decl) = 1;
8951 DECL_EXTERNAL (decl) = !initialized;
8954 /* In class context, static means one per class,
8955 public access, and static storage. */
8956 if (DECL_CLASS_SCOPE_P (decl))
8958 TREE_PUBLIC (decl) = 1;
8959 TREE_STATIC (decl) = 1;
8960 DECL_EXTERNAL (decl) = 0;
8962 /* At top level, either `static' or no s.c. makes a definition
8963 (perhaps tentative), and absence of `static' makes it public. */
8964 else if (toplevel_bindings_p ())
8966 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
8967 && (DECL_THIS_EXTERN (decl) || ! constp));
8968 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8970 /* Not at top level, only `static' makes a static definition. */
8973 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
8974 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8977 if (TREE_PUBLIC (decl))
8979 /* [basic.link]: A name with no linkage (notably, the name of a class
8980 or enumeration declared in a local scope) shall not be used to
8981 declare an entity with linkage.
8983 Only check this for public decls for now. */
8984 tree t = no_linkage_check (TREE_TYPE (decl));
8987 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8988 /* Ignore for now; `enum { foo } e' is pretty common. */;
8990 cp_pedwarn ("non-local variable `%#D' uses local type `%T'",
8998 /* Create and return a canonical pointer to member function type, for
8999 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9002 build_ptrmemfunc_type (type)
9008 tree unqualified_variant = NULL_TREE;
9010 /* If a canonical type already exists for this type, use it. We use
9011 this method instead of type_hash_canon, because it only does a
9012 simple equality check on the list of field members. */
9014 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9017 /* Make sure that we always have the unqualified pointer-to-member
9019 if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9021 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9023 t = make_aggr_type (RECORD_TYPE);
9024 /* Let the front-end know this is a pointer to member function... */
9025 TYPE_PTRMEMFUNC_FLAG (t) = 1;
9026 /* ... and not really an aggregate. */
9027 SET_IS_AGGR_TYPE (t, 0);
9031 u = make_aggr_type (UNION_TYPE);
9032 SET_IS_AGGR_TYPE (u, 0);
9033 fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
9034 fields[1] = build_lang_decl (FIELD_DECL, delta2_identifier,
9036 finish_builtin_type (u, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9037 TYPE_NAME (u) = NULL_TREE;
9039 fields[0] = build_lang_decl (FIELD_DECL, delta_identifier,
9041 fields[1] = build_lang_decl (FIELD_DECL, index_identifier,
9043 fields[2] = build_lang_decl (FIELD_DECL, pfn_or_delta2_identifier, u);
9044 finish_builtin_type (t, "__ptrmemfunc_type", fields, 2, ptr_type_node);
9048 fields[0] = build_lang_decl (FIELD_DECL, pfn_identifier, type);
9049 fields[1] = build_lang_decl (FIELD_DECL, delta_identifier,
9051 finish_builtin_type (t, "__ptrmemfunc_type", fields, 1, ptr_type_node);
9054 /* Zap out the name so that the back-end will give us the debugging
9055 information for this anonymous RECORD_TYPE. */
9056 TYPE_NAME (t) = NULL_TREE;
9058 /* If this is not the unqualified form of this pointer-to-member
9059 type, set the TYPE_MAIN_VARIANT for this type to be the
9060 unqualified type. Since they are actually RECORD_TYPEs that are
9061 not variants of each other, we must do this manually. */
9062 if (CP_TYPE_QUALS (type) != TYPE_UNQUALIFIED)
9064 t = build_qualified_type (t, CP_TYPE_QUALS (type));
9065 TYPE_MAIN_VARIANT (t) = unqualified_variant;
9066 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9067 TYPE_NEXT_VARIANT (unqualified_variant) = t;
9070 /* Cache this pointer-to-member type so that we can find it again
9072 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9074 /* Seems to be wanted. */
9075 CLASSTYPE_GOT_SEMICOLON (t) = 1;
9080 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9081 Check to see that the definition is valid. Issue appropriate error
9082 messages. Return 1 if the definition is particularly bad, or 0
9086 check_static_variable_definition (decl, type)
9090 /* Motion 10 at San Diego: If a static const integral data member is
9091 initialized with an integral constant expression, the initializer
9092 may appear either in the declaration (within the class), or in
9093 the definition, but not both. If it appears in the class, the
9094 member is a member constant. The file-scope definition is always
9096 if (CLASS_TYPE_P (type) || TREE_CODE (type) == REFERENCE_TYPE)
9098 cp_error ("invalid in-class initialization of static data member of non-integral type `%T'",
9100 /* If we just return the declaration, crashes will sometimes
9101 occur. We therefore return void_type_node, as if this was a
9102 friend declaration, to cause callers to completely ignore
9103 this declaration. */
9106 else if (!CP_TYPE_CONST_P (type))
9107 cp_error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9109 else if (pedantic && !INTEGRAL_TYPE_P (type))
9110 cp_pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9115 /* Given the SIZE (i.e., number of elements) in an array, compute an
9116 appropriate index type for the array. If non-NULL, NAME is the
9117 name of the thing being declared. */
9120 compute_array_index_type (name, size)
9126 /* The size might be the result of a cast. */
9127 STRIP_TYPE_NOPS (size);
9129 /* It might be a const variable or enumeration constant. */
9130 if (TREE_READONLY_DECL_P (size))
9131 size = decl_constant_value (size);
9133 /* If this involves a template parameter, it will be a constant at
9134 instantiation time, but we don't know what the value is yet.
9135 Even if no template parameters are involved, we may an expression
9136 that is not a constant; we don't even simplify `1 + 2' when
9137 processing a template. */
9138 if (processing_template_decl)
9140 /* Resolve a qualified reference to an enumerator or static
9141 const data member of ours. */
9142 if (TREE_CODE (size) == SCOPE_REF
9143 && TREE_OPERAND (size, 0) == current_class_type)
9145 tree t = lookup_field (current_class_type,
9146 TREE_OPERAND (size, 1), 0, 0);
9151 return build_index_type (build_min (MINUS_EXPR, sizetype,
9152 size, integer_one_node));
9155 /* The array bound must be an integer type. */
9156 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9157 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9158 && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9161 cp_error ("size of array `%D' has non-integer type", name);
9163 cp_error ("size of array has non-integer type");
9164 size = integer_one_node;
9167 /* Normally, the array-bound will be a constant. */
9168 if (TREE_CONSTANT (size))
9170 /* Check to see if the array bound overflowed. Make that an
9171 error, no matter how generous we're being. */
9172 int old_flag_pedantic_errors = flag_pedantic_errors;
9173 int old_pedantic = pedantic;
9174 pedantic = flag_pedantic_errors = 1;
9175 constant_expression_warning (size);
9176 pedantic = old_pedantic;
9177 flag_pedantic_errors = old_flag_pedantic_errors;
9179 /* An array must have a positive number of elements. */
9180 if (INT_CST_LT (size, integer_zero_node))
9183 cp_error ("size of array `%D' is negative", name);
9185 cp_error ("size of array is negative");
9186 size = integer_one_node;
9188 /* Except that an extension we allow zero-sized arrays. We
9189 always allow them in system headers because glibc uses
9191 else if (integer_zerop (size) && pedantic && !in_system_header)
9194 cp_pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9196 cp_pedwarn ("ISO C++ forbids zero-size array");
9200 /* Compute the index of the largest element in the array. It is
9201 one less than the number of elements in the array. */
9203 = fold (build_binary_op (MINUS_EXPR,
9204 cp_convert (ssizetype, size),
9205 cp_convert (ssizetype,
9206 integer_one_node)));
9208 /* Check for variable-sized arrays. We allow such things as an
9209 extension, even though they are not allowed in ANSI/ISO C++. */
9210 if (!TREE_CONSTANT (itype))
9215 cp_pedwarn ("ISO C++ forbids variable-size array `%D'",
9218 cp_pedwarn ("ISO C++ forbids variable-size array");
9221 /* Create a variable-sized array index type. */
9222 itype = variable_size (itype);
9224 /* Make sure that there was no overflow when creating to a signed
9225 index type. (For example, on a 32-bit machine, an array with
9226 size 2^32 - 1 is too big.) */
9227 else if (TREE_OVERFLOW (itype))
9229 error ("overflow in array dimension");
9230 TREE_OVERFLOW (itype) = 0;
9233 /* Create and return the appropriate index type. */
9234 return build_index_type (itype);
9237 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9238 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9242 create_array_type_for_decl (name, type, size)
9247 tree itype = NULL_TREE;
9248 const char* error_msg;
9250 /* If things have already gone awry, bail now. */
9251 if (type == error_mark_node || size == error_mark_node)
9252 return error_mark_node;
9254 /* Assume that everything will go OK. */
9257 /* There are some types which cannot be array elements. */
9258 switch (TREE_CODE (type))
9261 error_msg = "array of void";
9265 error_msg = "array of functions";
9268 case REFERENCE_TYPE:
9269 error_msg = "array of references";
9273 error_msg = "array of data members";
9277 error_msg = "array of function members";
9284 /* If something went wrong, issue an error-message and return. */
9288 cp_error ("declaration of `%D' as %s", name, error_msg);
9290 cp_error ("creating %s", error_msg);
9292 return error_mark_node;
9297 The constant expressions that specify the bounds of the arrays
9298 can be omitted only for the first member of the sequence. */
9299 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9301 cp_error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9304 return error_mark_node;
9307 /* Figure out the index type for the array. */
9309 itype = compute_array_index_type (name, size);
9311 return build_cplus_array_type (type, itype);
9314 /* Check that it's OK to declare a function with the indicated TYPE.
9315 SFK indicates the kind of special function (if any) that this
9316 function is. CTYPE is the class of which this function is a
9317 member. OPTYPE is the type given in a conversion operator
9318 declaration. Returns the actual return type of the function; that
9319 may be different than TYPE if an error occurs, or for certain
9320 special functions. */
9323 check_special_function_return_type (sfk, type, ctype, optype)
9324 special_function_kind sfk;
9331 case sfk_constructor:
9333 cp_error ("return type specification for constructor invalid");
9335 /* In the old ABI, we return `this'; in the new ABI we don't
9337 type = flag_new_abi ? void_type_node : build_pointer_type (ctype);
9340 case sfk_destructor:
9342 cp_error ("return type specification for destructor invalid");
9343 type = void_type_node;
9346 case sfk_conversion:
9347 if (type && !same_type_p (type, optype))
9348 cp_error ("operator `%T' declared to return `%T'", optype, type);
9350 cp_pedwarn ("return type specified for `operator %T'", optype);
9355 my_friendly_abort (20000408);
9362 /* Given declspecs and a declarator,
9363 determine the name and type of the object declared
9364 and construct a ..._DECL node for it.
9365 (In one case we can return a ..._TYPE node instead.
9366 For invalid input we sometimes return 0.)
9368 DECLSPECS is a chain of tree_list nodes whose value fields
9369 are the storage classes and type specifiers.
9371 DECL_CONTEXT says which syntactic context this declaration is in:
9372 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9373 FUNCDEF for a function definition. Like NORMAL but a few different
9374 error messages in each case. Return value may be zero meaning
9375 this definition is too screwy to try to parse.
9376 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9377 handle member functions (which have FIELD context).
9378 Return value may be zero meaning this definition is too screwy to
9380 PARM for a parameter declaration (either within a function prototype
9381 or before a function body). Make a PARM_DECL, or return void_type_node.
9382 CATCHPARM for a parameter declaration before a catch clause.
9383 TYPENAME if for a typename (in a cast or sizeof).
9384 Don't make a DECL node; just return the ..._TYPE node.
9385 FIELD for a struct or union field; make a FIELD_DECL.
9386 BITFIELD for a field with specified width.
9387 INITIALIZED is 1 if the decl has an initializer.
9389 ATTRLIST is a TREE_LIST node with prefix attributes in TREE_VALUE and
9390 normal attributes in TREE_PURPOSE, or NULL_TREE.
9392 In the TYPENAME case, DECLARATOR is really an abstract declarator.
9393 It may also be so in the PARM case, for a prototype where the
9394 argument type is specified but not the name.
9396 This function is where the complicated C meanings of `static'
9397 and `extern' are interpreted.
9399 For C++, if there is any monkey business to do, the function which
9400 calls this one must do it, i.e., prepending instance variables,
9401 renaming overloaded function names, etc.
9403 Note that for this C++, it is an error to define a method within a class
9404 which does not belong to that class.
9406 Except in the case where SCOPE_REFs are implicitly known (such as
9407 methods within a class being redundantly qualified),
9408 declarations which involve SCOPE_REFs are returned as SCOPE_REFs
9409 (class_name::decl_name). The caller must also deal with this.
9411 If a constructor or destructor is seen, and the context is FIELD,
9412 then the type gains the attribute TREE_HAS_x. If such a declaration
9413 is erroneous, NULL_TREE is returned.
9415 QUALS is used only for FUNCDEF and MEMFUNCDEF cases. For a member
9416 function, these are the qualifiers to give to the `this' pointer. We
9417 apply TYPE_QUAL_RESTRICT to the this ptr, not the object.
9419 May return void_type_node if the declarator turned out to be a friend.
9420 See grokfield for details. */
9423 grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
9426 enum decl_context decl_context;
9430 RID_BIT_TYPE specbits;
9433 tree type = NULL_TREE;
9439 int virtualp, explicitp, friendp, inlinep, staticp;
9440 int explicit_int = 0;
9441 int explicit_char = 0;
9442 int defaulted_int = 0;
9443 tree typedef_decl = NULL_TREE;
9445 tree typedef_type = NULL_TREE;
9446 int funcdef_flag = 0;
9447 enum tree_code innermost_code = ERROR_MARK;
9450 /* See the code below that used this. */
9451 tree decl_machine_attr = NULL_TREE;
9453 /* Set this to error_mark_node for FIELD_DECLs we could not handle properly.
9454 All FIELD_DECLs we build here have `init' put into their DECL_INITIAL. */
9455 tree init = NULL_TREE;
9457 /* Keep track of what sort of function is being processed
9458 so that we can warn about default return values, or explicit
9459 return values which do not match prescribed defaults. */
9460 special_function_kind sfk = sfk_none;
9462 tree dname = NULL_TREE;
9463 tree ctype = current_class_type;
9464 tree ctor_return_type = NULL_TREE;
9465 enum overload_flags flags = NO_SPECIAL;
9466 tree quals = NULL_TREE;
9467 tree raises = NULL_TREE;
9468 int template_count = 0;
9469 tree in_namespace = NULL_TREE;
9473 RIDBIT_RESET_ALL (specbits);
9474 if (decl_context == FUNCDEF)
9475 funcdef_flag = 1, decl_context = NORMAL;
9476 else if (decl_context == MEMFUNCDEF)
9477 funcdef_flag = -1, decl_context = FIELD;
9478 else if (decl_context == BITFIELD)
9479 bitfield = 1, decl_context = FIELD;
9481 /* Look inside a declarator for the name being declared
9482 and get it as a string, for an error message. */
9484 tree *next = &declarator;
9488 while (next && *next)
9491 switch (TREE_CODE (decl))
9494 /* For attributes. */
9495 next = &TREE_VALUE (decl);
9500 next = &TREE_OPERAND (decl, 0);
9503 case BIT_NOT_EXPR: /* For C++ destructors! */
9505 tree name = TREE_OPERAND (decl, 0);
9506 tree rename = NULL_TREE;
9508 my_friendly_assert (flags == NO_SPECIAL, 152);
9510 sfk = sfk_destructor;
9511 if (TREE_CODE (name) == TYPE_DECL)
9512 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9513 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9514 if (ctype == NULL_TREE)
9516 if (current_class_type == NULL_TREE)
9518 error ("destructors must be member functions");
9523 tree t = constructor_name (current_class_name);
9530 tree t = constructor_name (ctype);
9537 cp_error ("destructor `%T' must match class name `%T'",
9539 TREE_OPERAND (decl, 0) = rename;
9545 case ADDR_EXPR: /* C++ reference declaration */
9550 innermost_code = TREE_CODE (decl);
9551 next = &TREE_OPERAND (decl, 0);
9555 if (parmlist_is_exprlist (CALL_DECLARATOR_PARMS (decl)))
9557 /* This is actually a variable declaration using
9558 constructor syntax. We need to call start_decl and
9559 cp_finish_decl so we can get the variable
9562 tree attributes, prefix_attributes;
9564 *next = TREE_OPERAND (decl, 0);
9565 init = CALL_DECLARATOR_PARMS (decl);
9569 attributes = TREE_PURPOSE (attrlist);
9570 prefix_attributes = TREE_VALUE (attrlist);
9574 attributes = NULL_TREE;
9575 prefix_attributes = NULL_TREE;
9578 decl = start_decl (declarator, declspecs, 1,
9579 attributes, prefix_attributes);
9580 decl_type_access_control (decl);
9583 /* Look for __unused__ attribute */
9584 if (TREE_USED (TREE_TYPE (decl)))
9585 TREE_USED (decl) = 1;
9586 finish_decl (decl, init, NULL_TREE);
9589 cp_error ("invalid declarator");
9592 innermost_code = TREE_CODE (decl);
9593 if (decl_context == FIELD && ctype == NULL_TREE)
9594 ctype = current_class_type;
9596 && TREE_OPERAND (decl, 0)
9597 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9598 && ((DECL_NAME (TREE_OPERAND (decl, 0))
9599 == constructor_name_full (ctype))
9600 || (DECL_NAME (TREE_OPERAND (decl, 0))
9601 == constructor_name (ctype)))))
9602 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9603 next = &TREE_OPERAND (decl, 0);
9605 if (ctype != NULL_TREE
9606 && decl != NULL_TREE && flags != DTOR_FLAG
9607 && decl == constructor_name (ctype))
9609 sfk = sfk_constructor;
9610 ctor_return_type = ctype;
9615 case TEMPLATE_ID_EXPR:
9617 tree fns = TREE_OPERAND (decl, 0);
9619 if (TREE_CODE (fns) == LOOKUP_EXPR)
9620 fns = TREE_OPERAND (fns, 0);
9623 if (TREE_CODE (dname) == COMPONENT_REF)
9624 dname = TREE_OPERAND (dname, 1);
9625 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9627 my_friendly_assert (is_overloaded_fn (dname),
9629 dname = DECL_NAME (get_first_fn (dname));
9634 case IDENTIFIER_NODE:
9635 if (TREE_CODE (decl) == IDENTIFIER_NODE)
9642 cp_error ("declarator-id missing; using reserved word `%D'",
9644 name = IDENTIFIER_POINTER (dname);
9646 if (! IDENTIFIER_OPNAME_P (dname)
9647 /* GNU/Linux headers use '__op'. Arrgh. */
9648 || (IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)))
9649 name = IDENTIFIER_POINTER (dname);
9652 if (IDENTIFIER_TYPENAME_P (dname))
9654 my_friendly_assert (flags == NO_SPECIAL, 154);
9655 flags = TYPENAME_FLAG;
9656 ctor_return_type = TREE_TYPE (dname);
9657 sfk = sfk_conversion;
9659 name = operator_name_string (dname);
9666 /* Perform error checking, and decide on a ctype. */
9667 tree cname = TREE_OPERAND (decl, 0);
9668 if (cname == NULL_TREE)
9670 else if (TREE_CODE (cname) == NAMESPACE_DECL)
9673 in_namespace = TREE_OPERAND (decl, 0);
9674 TREE_OPERAND (decl, 0) = NULL_TREE;
9676 else if (! is_aggr_type (cname, 1))
9677 TREE_OPERAND (decl, 0) = NULL_TREE;
9678 /* Must test TREE_OPERAND (decl, 1), in case user gives
9679 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9680 else if (TREE_OPERAND (decl, 1)
9681 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9683 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9684 || TREE_CODE (cname) == TEMPLATE_TEMPLATE_PARM)
9686 cp_error ("`%T::%D' is not a valid declarator", cname,
9687 TREE_OPERAND (decl, 1));
9688 cp_error (" perhaps you want `typename %T::%D' to make it a type",
9689 cname, TREE_OPERAND (decl, 1));
9690 return void_type_node;
9692 else if (ctype == NULL_TREE)
9694 else if (TREE_COMPLEXITY (decl) == current_class_depth)
9695 TREE_OPERAND (decl, 0) = ctype;
9698 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9700 cp_error ("type `%T' is not derived from type `%T'",
9702 TREE_OPERAND (decl, 0) = NULL_TREE;
9708 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9709 && ((DECL_NAME (TREE_OPERAND (decl, 1))
9710 == constructor_name_full (ctype))
9711 || (DECL_NAME (TREE_OPERAND (decl, 1))
9712 == constructor_name (ctype))))
9713 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9714 next = &TREE_OPERAND (decl, 1);
9718 if (TREE_CODE (decl) == IDENTIFIER_NODE
9719 && constructor_name (ctype) == decl)
9721 sfk = sfk_constructor;
9722 ctor_return_type = ctype;
9724 else if (TREE_CODE (decl) == BIT_NOT_EXPR
9725 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9726 && (constructor_name (ctype) == TREE_OPERAND (decl, 0)
9727 || constructor_name_full (ctype) == TREE_OPERAND (decl, 0)))
9729 sfk = sfk_destructor;
9730 ctor_return_type = ctype;
9732 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9733 next = &TREE_OPERAND (decl, 0);
9744 /* Parse error puts this typespec where
9745 a declarator should go. */
9746 cp_error ("`%T' specified as declarator-id", DECL_NAME (decl));
9747 if (TREE_TYPE (decl) == current_class_type)
9748 cp_error (" perhaps you want `%T' for a constructor",
9749 current_class_name);
9750 dname = DECL_NAME (decl);
9751 name = IDENTIFIER_POINTER (dname);
9753 /* Avoid giving two errors for this. */
9754 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9756 declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9762 cp_compiler_error ("`%D' as declarator", decl);
9763 return 0; /* We used to do a 155 abort here. */
9768 /* A function definition's declarator must have the form of
9769 a function declarator. */
9771 if (funcdef_flag && innermost_code != CALL_EXPR)
9774 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
9775 && innermost_code != CALL_EXPR
9776 && ! (ctype && declspecs == NULL_TREE))
9778 cp_error ("declaration of `%D' as non-function", dname);
9779 return void_type_node;
9782 /* Anything declared one level down from the top level
9783 must be one of the parameters of a function
9784 (because the body is at least two levels down). */
9786 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9787 by not allowing C++ class definitions to specify their parameters
9788 with xdecls (must be spec.d in the parmlist).
9790 Since we now wait to push a class scope until we are sure that
9791 we are in a legitimate method context, we must set oldcname
9792 explicitly (since current_class_name is not yet alive).
9794 We also want to avoid calling this a PARM if it is in a namespace. */
9796 if (decl_context == NORMAL && !toplevel_bindings_p ())
9798 struct binding_level *b = current_binding_level;
9799 current_binding_level = b->level_chain;
9800 if (current_binding_level != 0 && toplevel_bindings_p ())
9801 decl_context = PARM;
9802 current_binding_level = b;
9806 name = decl_context == PARM ? "parameter" : "type name";
9808 /* Look through the decl specs and record which ones appear.
9809 Some typespecs are defined as built-in typenames.
9810 Others, the ones that are modifiers of other types,
9811 are represented by bits in SPECBITS: set the bits for
9812 the modifiers that appear. Storage class keywords are also in SPECBITS.
9814 If there is a typedef name or a type, store the type in TYPE.
9815 This includes builtin typedefs such as `int'.
9817 Set EXPLICIT_INT if the type is `int' or `char' and did not
9818 come from a user typedef.
9820 Set LONGLONG if `long' is mentioned twice.
9822 For C++, constructors and destructors have their own fast treatment. */
9824 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
9829 /* Certain parse errors slip through. For example,
9830 `int class;' is not caught by the parser. Try
9831 weakly to recover here. */
9832 if (TREE_CODE (spec) != TREE_LIST)
9835 id = TREE_VALUE (spec);
9837 if (TREE_CODE (id) == IDENTIFIER_NODE)
9839 if (id == ridpointers[(int) RID_INT]
9840 || id == ridpointers[(int) RID_CHAR]
9841 || id == ridpointers[(int) RID_BOOL]
9842 || id == ridpointers[(int) RID_WCHAR])
9846 if (id == ridpointers[(int) RID_BOOL])
9847 error ("`bool' is now a keyword");
9849 cp_error ("extraneous `%T' ignored", id);
9853 if (id == ridpointers[(int) RID_INT])
9855 else if (id == ridpointers[(int) RID_CHAR])
9857 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
9861 /* C++ aggregate types. */
9862 if (IDENTIFIER_HAS_TYPE_VALUE (id))
9865 cp_error ("multiple declarations `%T' and `%T'", type, id);
9867 type = IDENTIFIER_TYPE_VALUE (id);
9871 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
9873 if (ridpointers[i] == id)
9875 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
9877 if (pedantic && ! in_system_header && warn_long_long)
9878 pedwarn ("ISO C++ does not support `long long'");
9880 error ("`long long long' is too long for GCC");
9884 else if (RIDBIT_SETP (i, specbits))
9885 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
9886 RIDBIT_SET (i, specbits);
9891 /* C++ aggregate types. */
9892 else if (TREE_CODE (id) == TYPE_DECL || TREE_CODE (id) == TEMPLATE_DECL)
9895 cp_error ("multiple declarations `%T' and `%T'", type,
9899 type = TREE_TYPE (id);
9900 TREE_VALUE (spec) = type;
9905 error ("two or more data types in declaration of `%s'", name);
9906 else if (TREE_CODE (id) == IDENTIFIER_NODE)
9908 register tree t = lookup_name (id, 1);
9909 if (!t || TREE_CODE (t) != TYPE_DECL)
9910 error ("`%s' fails to be a typedef or built in type",
9911 IDENTIFIER_POINTER (id));
9914 type = TREE_TYPE (t);
9916 /* See the code below that used this. */
9917 decl_machine_attr = DECL_MACHINE_ATTRIBUTES (id);
9922 else if (id != error_mark_node)
9923 /* Can't change CLASS nodes into RECORD nodes here! */
9929 typedef_type = type;
9931 /* No type at all: default to `int', and set DEFAULTED_INT
9932 because it was not a user-defined typedef. */
9934 if (type == NULL_TREE
9935 && (RIDBIT_SETP (RID_SIGNED, specbits)
9936 || RIDBIT_SETP (RID_UNSIGNED, specbits)
9937 || RIDBIT_SETP (RID_LONG, specbits)
9938 || RIDBIT_SETP (RID_SHORT, specbits)))
9940 /* These imply 'int'. */
9941 type = integer_type_node;
9945 if (sfk != sfk_none)
9946 type = check_special_function_return_type (sfk, type,
9949 else if (type == NULL_TREE)
9955 /* We handle `main' specially here, because 'main () { }' is so
9956 common. With no options, it is allowed. With -Wreturn-type,
9957 it is a warning. It is only an error with -pedantic-errors. */
9958 is_main = (funcdef_flag
9959 && MAIN_NAME_P (dname)
9960 && ctype == NULL_TREE
9961 && in_namespace == NULL_TREE
9962 && current_namespace == global_namespace);
9964 if (in_system_header || flag_ms_extensions)
9965 /* Allow it, sigh. */;
9966 else if (pedantic || ! is_main)
9967 cp_pedwarn ("ISO C++ forbids declaration of `%s' with no type",
9969 else if (warn_return_type)
9970 cp_warning ("ISO C++ forbids declaration of `%s' with no type",
9973 type = integer_type_node;
9978 /* Now process the modifiers that were specified
9979 and check for invalid combinations. */
9981 /* Long double is a special combination. */
9983 if (RIDBIT_SETP (RID_LONG, specbits)
9984 && TYPE_MAIN_VARIANT (type) == double_type_node)
9986 RIDBIT_RESET (RID_LONG, specbits);
9987 type = build_qualified_type (long_double_type_node,
9988 CP_TYPE_QUALS (type));
9991 /* Check all other uses of type modifiers. */
9993 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
9994 || RIDBIT_SETP (RID_SIGNED, specbits)
9995 || RIDBIT_SETP (RID_LONG, specbits)
9996 || RIDBIT_SETP (RID_SHORT, specbits))
10000 if (TREE_CODE (type) == REAL_TYPE)
10001 error ("short, signed or unsigned invalid for `%s'", name);
10002 else if (TREE_CODE (type) != INTEGER_TYPE)
10003 error ("long, short, signed or unsigned invalid for `%s'", name);
10004 else if (RIDBIT_SETP (RID_LONG, specbits)
10005 && RIDBIT_SETP (RID_SHORT, specbits))
10006 error ("long and short specified together for `%s'", name);
10007 else if ((RIDBIT_SETP (RID_LONG, specbits)
10008 || RIDBIT_SETP (RID_SHORT, specbits))
10010 error ("long or short specified with char for `%s'", name);
10011 else if ((RIDBIT_SETP (RID_LONG, specbits)
10012 || RIDBIT_SETP (RID_SHORT, specbits))
10013 && TREE_CODE (type) == REAL_TYPE)
10014 error ("long or short specified with floating type for `%s'", name);
10015 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10016 && RIDBIT_SETP (RID_UNSIGNED, specbits))
10017 error ("signed and unsigned given together for `%s'", name);
10021 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10023 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10025 if (flag_pedantic_errors)
10030 /* Discard the type modifiers if they are invalid. */
10033 RIDBIT_RESET (RID_UNSIGNED, specbits);
10034 RIDBIT_RESET (RID_SIGNED, specbits);
10035 RIDBIT_RESET (RID_LONG, specbits);
10036 RIDBIT_RESET (RID_SHORT, specbits);
10041 if (RIDBIT_SETP (RID_COMPLEX, specbits)
10042 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10044 error ("complex invalid for `%s'", name);
10045 RIDBIT_RESET (RID_COMPLEX, specbits);
10048 /* Decide whether an integer type is signed or not.
10049 Optionally treat bitfields as signed by default. */
10050 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10053 It is implementation-defined whether a plain (neither
10054 explicitly signed or unsigned) char, short, int, or long
10055 bit-field is signed or unsigned.
10057 Naturally, we extend this to long long as well. Note that
10058 this does not include wchar_t. */
10059 || (bitfield && !flag_signed_bitfields
10060 && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10061 /* A typedef for plain `int' without `signed' can be
10062 controlled just like plain `int', but a typedef for
10063 `signed int' cannot be so controlled. */
10065 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10066 && (TREE_CODE (type) == INTEGER_TYPE
10067 || TREE_CODE (type) == CHAR_TYPE)
10068 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10071 type = long_long_unsigned_type_node;
10072 else if (RIDBIT_SETP (RID_LONG, specbits))
10073 type = long_unsigned_type_node;
10074 else if (RIDBIT_SETP (RID_SHORT, specbits))
10075 type = short_unsigned_type_node;
10076 else if (type == char_type_node)
10077 type = unsigned_char_type_node;
10078 else if (typedef_decl)
10079 type = unsigned_type (type);
10081 type = unsigned_type_node;
10083 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10084 && type == char_type_node)
10085 type = signed_char_type_node;
10087 type = long_long_integer_type_node;
10088 else if (RIDBIT_SETP (RID_LONG, specbits))
10089 type = long_integer_type_node;
10090 else if (RIDBIT_SETP (RID_SHORT, specbits))
10091 type = short_integer_type_node;
10093 if (RIDBIT_SETP (RID_COMPLEX, specbits))
10095 /* If we just have "complex", it is equivalent to
10096 "complex double", but if any modifiers at all are specified it is
10097 the complex form of TYPE. E.g, "complex short" is
10098 "complex short int". */
10100 if (defaulted_int && ! longlong
10101 && ! (RIDBIT_SETP (RID_LONG, specbits)
10102 || RIDBIT_SETP (RID_SHORT, specbits)
10103 || RIDBIT_SETP (RID_SIGNED, specbits)
10104 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10105 type = complex_double_type_node;
10106 else if (type == integer_type_node)
10107 type = complex_integer_type_node;
10108 else if (type == float_type_node)
10109 type = complex_float_type_node;
10110 else if (type == double_type_node)
10111 type = complex_double_type_node;
10112 else if (type == long_double_type_node)
10113 type = complex_long_double_type_node;
10115 type = build_complex_type (type);
10118 if (sfk == sfk_conversion
10119 && (RIDBIT_SETP (RID_CONST, specbits)
10120 || RIDBIT_SETP (RID_VOLATILE, specbits)
10121 || RIDBIT_SETP (RID_RESTRICT, specbits)))
10122 cp_error ("qualifiers are not allowed on declaration of `operator %T'",
10125 /* Set CONSTP if this declaration is `const', whether by
10126 explicit specification or via a typedef.
10127 Likewise for VOLATILEP. */
10129 constp = !! RIDBIT_SETP (RID_CONST, specbits) + CP_TYPE_CONST_P (type);
10131 !! RIDBIT_SETP (RID_RESTRICT, specbits) + CP_TYPE_RESTRICT_P (type);
10133 !! RIDBIT_SETP (RID_VOLATILE, specbits) + CP_TYPE_VOLATILE_P (type);
10134 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10135 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10136 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10137 type = cp_build_qualified_type (type, type_quals);
10139 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10140 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10141 RIDBIT_RESET (RID_VIRTUAL, specbits);
10142 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10143 RIDBIT_RESET (RID_EXPLICIT, specbits);
10145 if (RIDBIT_SETP (RID_STATIC, specbits))
10146 staticp = 1 + (decl_context == FIELD);
10148 if (virtualp && staticp == 2)
10150 cp_error ("member `%D' cannot be declared both virtual and static",
10154 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10155 RIDBIT_RESET (RID_FRIEND, specbits);
10157 /* Warn if two storage classes are given. Default to `auto'. */
10159 if (RIDBIT_ANY_SET (specbits))
10161 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10162 if (RIDBIT_SETP (RID_EXTERN, specbits)) nclasses++;
10163 if (decl_context == PARM && nclasses > 0)
10164 error ("storage class specifiers invalid in parameter declarations");
10165 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10167 if (decl_context == PARM)
10168 error ("typedef declaration invalid in parameter declaration");
10171 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10172 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10175 /* Give error if `virtual' is used outside of class declaration. */
10177 && (current_class_name == NULL_TREE || decl_context != FIELD))
10179 error ("virtual outside class declaration");
10183 /* Static anonymous unions are dealt with here. */
10184 if (staticp && decl_context == TYPENAME
10185 && TREE_CODE (declspecs) == TREE_LIST
10186 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10187 decl_context = FIELD;
10189 /* Warn about storage classes that are invalid for certain
10190 kinds of declarations (parameters, typenames, etc.). */
10193 error ("multiple storage classes in declaration of `%s'", name);
10194 else if (decl_context != NORMAL && nclasses > 0)
10196 if ((decl_context == PARM || decl_context == CATCHPARM)
10197 && (RIDBIT_SETP (RID_REGISTER, specbits)
10198 || RIDBIT_SETP (RID_AUTO, specbits)))
10200 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10202 else if (decl_context == FIELD
10203 /* C++ allows static class elements */
10204 && RIDBIT_SETP (RID_STATIC, specbits))
10205 /* C++ also allows inlines and signed and unsigned elements,
10206 but in those cases we don't come in here. */
10210 if (decl_context == FIELD)
10212 tree tmp = NULL_TREE;
10213 register int op = 0;
10217 /* Avoid trying to get an operand off an identifier node. */
10218 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10221 tmp = TREE_OPERAND (declarator, 0);
10222 op = IDENTIFIER_OPNAME_P (tmp);
10224 error ("storage class specified for %s `%s'",
10225 op ? "member operator" : "field",
10226 op ? operator_name_string (tmp) : name);
10230 if (decl_context == PARM || decl_context == CATCHPARM)
10231 error ("storage class specified for parameter `%s'", name);
10233 error ("storage class specified for typename");
10235 RIDBIT_RESET (RID_REGISTER, specbits);
10236 RIDBIT_RESET (RID_AUTO, specbits);
10237 RIDBIT_RESET (RID_EXTERN, specbits);
10240 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10242 if (toplevel_bindings_p ())
10244 /* It's common practice (and completely valid) to have a const
10245 be initialized and declared extern. */
10246 if (!(type_quals & TYPE_QUAL_CONST))
10247 warning ("`%s' initialized and declared `extern'", name);
10250 error ("`%s' has both `extern' and initializer", name);
10252 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10253 && ! toplevel_bindings_p ())
10254 error ("nested function `%s' declared `extern'", name);
10255 else if (toplevel_bindings_p ())
10257 if (RIDBIT_SETP (RID_AUTO, specbits))
10258 error ("top-level declaration of `%s' specifies `auto'", name);
10261 if (nclasses > 0 && friendp)
10262 error ("storage class specifiers invalid in friend function declarations");
10264 /* Now figure out the structure of the declarator proper.
10265 Descend through it, creating more complex types, until we reach
10266 the declared identifier (or NULL_TREE, in an absolute declarator). */
10268 inner_attrs = NULL_TREE;
10271 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10272 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10274 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10275 an INDIRECT_REF (for *...),
10276 a CALL_EXPR (for ...(...)),
10277 an identifier (for the name being declared)
10278 or a null pointer (for the place in an absolute declarator
10279 where the name was omitted).
10280 For the last two cases, we have just exited the loop.
10282 For C++ it could also be
10283 a SCOPE_REF (for class :: ...). In this case, we have converted
10284 sensible names to types, and those are the values we use to
10285 qualify the member name.
10286 an ADDR_EXPR (for &...),
10287 a BIT_NOT_EXPR (for destructors)
10289 At this point, TYPE is the type of elements of an array,
10290 or for a function to return, or for a pointer to point to.
10291 After this sequence of ifs, TYPE is the type of the
10292 array or function or pointer, and DECLARATOR has had its
10293 outermost layer removed. */
10295 if (type == error_mark_node)
10297 if (TREE_CODE (declarator) == SCOPE_REF)
10298 declarator = TREE_OPERAND (declarator, 1);
10300 declarator = TREE_OPERAND (declarator, 0);
10303 if (quals != NULL_TREE
10304 && (declarator == NULL_TREE
10305 || TREE_CODE (declarator) != SCOPE_REF))
10307 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10308 ctype = TYPE_METHOD_BASETYPE (type);
10309 if (ctype != NULL_TREE)
10311 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10312 grok_method_quals (ctype, dummy, quals);
10313 type = TREE_TYPE (dummy);
10314 ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type)));
10319 /* See the comment for the TREE_LIST case, below. */
10322 else if (inner_attrs)
10324 decl_attributes (type, inner_attrs, NULL_TREE);
10325 inner_attrs = NULL_TREE;
10328 switch (TREE_CODE (declarator))
10332 /* We encode a declarator with embedded attributes using
10333 a TREE_LIST. The attributes apply to the declarator
10334 directly inside them, so we have to skip an iteration
10335 before applying them to the type. If the declarator just
10336 inside is the declarator-id, we apply the attrs to the
10338 inner_attrs = TREE_PURPOSE (declarator);
10340 declarator = TREE_VALUE (declarator);
10346 register tree size;
10348 size = TREE_OPERAND (declarator, 1);
10350 /* VC++ spells a zero-sized array with []. */
10351 if (size == NULL_TREE && decl_context == FIELD && ! staticp
10352 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10353 size = integer_zero_node;
10355 declarator = TREE_OPERAND (declarator, 0);
10357 type = create_array_type_for_decl (dname, type, size);
10366 tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10367 tree inner_decl = TREE_OPERAND (declarator, 0);
10369 /* Declaring a function type.
10370 Make sure we have a valid type for the function to return. */
10372 /* We now know that the TYPE_QUALS don't apply to the
10373 decl, but to its return type. */
10374 type_quals = TYPE_UNQUALIFIED;
10376 /* Warn about some types functions can't return. */
10378 if (TREE_CODE (type) == FUNCTION_TYPE)
10380 error ("`%s' declared as function returning a function", name);
10381 type = integer_type_node;
10383 if (TREE_CODE (type) == ARRAY_TYPE)
10385 error ("`%s' declared as function returning an array", name);
10386 type = integer_type_node;
10389 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10390 inner_decl = TREE_OPERAND (inner_decl, 1);
10392 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10393 inner_decl = dname;
10395 /* Pick up type qualifiers which should be applied to `this'. */
10396 quals = CALL_DECLARATOR_QUALS (declarator);
10398 /* Pick up the exception specifications. */
10399 raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10401 /* Say it's a definition only for the CALL_EXPR
10402 closest to the identifier. */
10405 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10406 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10407 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10409 if (ctype == NULL_TREE
10410 && decl_context == FIELD
10412 && (friendp == 0 || dname == current_class_name))
10413 ctype = current_class_type;
10415 if (ctype && sfk == sfk_conversion)
10416 TYPE_HAS_CONVERSION (ctype) = 1;
10417 if (ctype && constructor_name (ctype) == dname)
10419 /* We are within a class's scope. If our declarator name
10420 is the same as the class name, and we are defining
10421 a function, then it is a constructor/destructor, and
10422 therefore returns a void type. */
10424 if (flags == DTOR_FLAG)
10426 /* ISO C++ 12.4/2. A destructor may not be
10427 declared const or volatile. A destructor may
10430 error ("destructor cannot be static member function");
10433 cp_error ("destructors may not be `%s'",
10434 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10437 if (decl_context == FIELD)
10439 if (! member_function_or_else (ctype,
10440 current_class_type,
10442 return void_type_node;
10445 else /* It's a constructor. */
10447 if (explicitp == 1)
10449 /* ISO C++ 12.1. A constructor may not be
10450 declared const or volatile. A constructor may
10451 not be virtual. A constructor may not be
10454 error ("constructor cannot be static member function");
10457 pedwarn ("constructors cannot be declared virtual");
10462 cp_error ("constructors may not be `%s'",
10463 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10467 RID_BIT_TYPE tmp_bits;
10468 bcopy ((void*)&specbits, (void*)&tmp_bits, sizeof (RID_BIT_TYPE));
10469 RIDBIT_RESET (RID_INLINE, tmp_bits);
10470 RIDBIT_RESET (RID_STATIC, tmp_bits);
10471 if (RIDBIT_ANY_SET (tmp_bits))
10472 error ("return value type specifier for constructor ignored");
10474 if (decl_context == FIELD)
10476 if (! member_function_or_else (ctype,
10477 current_class_type,
10479 return void_type_node;
10480 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10481 if (sfk != sfk_constructor)
10485 if (decl_context == FIELD)
10491 error ("can't initialize friend function `%s'", name);
10494 /* Cannot be both friend and virtual. */
10495 error ("virtual functions cannot be friends");
10496 RIDBIT_RESET (RID_FRIEND, specbits);
10499 if (decl_context == NORMAL)
10500 error ("friend declaration not in class definition");
10501 if (current_function_decl && funcdef_flag)
10502 cp_error ("can't define friend function `%s' in a local class definition",
10506 /* Construct the function type and go to the next
10507 inner layer of declarator. */
10509 declarator = TREE_OPERAND (declarator, 0);
10511 /* FIXME: This is where default args should be fully
10514 arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0);
10516 if (declarator && flags == DTOR_FLAG)
10518 /* A destructor declared in the body of a class will
10519 be represented as a BIT_NOT_EXPR. But, we just
10520 want the underlying IDENTIFIER. */
10521 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10522 declarator = TREE_OPERAND (declarator, 0);
10524 if (strict_prototype == 0 && arg_types == NULL_TREE)
10525 arg_types = void_list_node;
10526 else if (arg_types == NULL_TREE
10527 || arg_types != void_list_node)
10529 cp_error ("destructors may not have parameters");
10530 arg_types = void_list_node;
10531 last_function_parms = NULL_TREE;
10535 /* ANSI says that `const int foo ();'
10536 does not make the function foo const. */
10537 type = build_function_type (type, arg_types);
10541 for (t = arg_types; t; t = TREE_CHAIN (t))
10542 if (TREE_PURPOSE (t)
10543 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
10545 add_defarg_fn (type);
10554 /* Filter out pointers-to-references and references-to-references.
10555 We can get these if a TYPE_DECL is used. */
10557 if (TREE_CODE (type) == REFERENCE_TYPE)
10559 error ("cannot declare %s to references",
10560 TREE_CODE (declarator) == ADDR_EXPR
10561 ? "references" : "pointers");
10562 declarator = TREE_OPERAND (declarator, 0);
10566 if (TREE_CODE (type) == OFFSET_TYPE
10567 && (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE
10568 || TREE_CODE (TREE_TYPE (type)) == REFERENCE_TYPE))
10570 cp_error ("cannot declare pointer to `%#T' member",
10572 type = TREE_TYPE (type);
10575 /* Merge any constancy or volatility into the target type
10576 for the pointer. */
10578 /* We now know that the TYPE_QUALS don't apply to the decl,
10579 but to the target of the pointer. */
10580 type_quals = TYPE_UNQUALIFIED;
10582 if (TREE_CODE (declarator) == ADDR_EXPR)
10584 if (TREE_CODE (type) == VOID_TYPE)
10585 error ("invalid type: `void &'");
10587 type = build_reference_type (type);
10589 else if (TREE_CODE (type) == METHOD_TYPE)
10590 type = build_ptrmemfunc_type (build_pointer_type (type));
10592 type = build_pointer_type (type);
10594 /* Process a list of type modifier keywords (such as
10595 const or volatile) that were given inside the `*' or `&'. */
10597 if (TREE_TYPE (declarator))
10599 register tree typemodlist;
10605 for (typemodlist = TREE_TYPE (declarator); typemodlist;
10606 typemodlist = TREE_CHAIN (typemodlist))
10608 tree qualifier = TREE_VALUE (typemodlist);
10610 if (qualifier == ridpointers[(int) RID_CONST])
10612 else if (qualifier == ridpointers[(int) RID_VOLATILE])
10614 else if (qualifier == ridpointers[(int) RID_RESTRICT])
10619 error ("invalid type modifier within pointer declarator");
10623 pedwarn ("duplicate `const'");
10625 pedwarn ("duplicate `volatile'");
10627 pedwarn ("duplicate `restrict'");
10629 type_quals = ((constp ? TYPE_QUAL_CONST : 0)
10630 | (restrictp ? TYPE_QUAL_RESTRICT : 0)
10631 | (volatilep ? TYPE_QUAL_VOLATILE : 0));
10632 if (TREE_CODE (declarator) == ADDR_EXPR
10633 && (constp || volatilep))
10636 pedwarn ("discarding `const' applied to a reference");
10638 pedwarn ("discarding `volatile' applied to a reference");
10639 type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
10641 type = cp_build_qualified_type (type, type_quals);
10643 declarator = TREE_OPERAND (declarator, 0);
10649 /* We have converted type names to NULL_TREE if the
10650 name was bogus, or to a _TYPE node, if not.
10652 The variable CTYPE holds the type we will ultimately
10653 resolve to. The code here just needs to build
10654 up appropriate member types. */
10655 tree sname = TREE_OPERAND (declarator, 1);
10658 /* Destructors can have their visibilities changed as well. */
10659 if (TREE_CODE (sname) == BIT_NOT_EXPR)
10660 sname = TREE_OPERAND (sname, 0);
10662 if (TREE_COMPLEXITY (declarator) == 0)
10663 /* This needs to be here, in case we are called
10664 multiple times. */ ;
10665 else if (TREE_COMPLEXITY (declarator) == -1)
10666 /* Namespace member. */
10667 pop_decl_namespace ();
10668 else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
10669 /* Don't fall out into global scope. Hides real bug? --eichin */ ;
10670 else if (! IS_AGGR_TYPE_CODE
10671 (TREE_CODE (TREE_OPERAND (declarator, 0))))
10673 else if (TREE_COMPLEXITY (declarator) == current_class_depth)
10675 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq
10676 that refer to ctype. They couldn't be resolved earlier
10677 because we hadn't pushed into the class yet.
10678 Example: resolve 'B<T>::type' in
10679 'B<typename B<T>::type> B<T>::f () { }'. */
10680 if (current_template_parms
10681 && uses_template_parms (type)
10682 && uses_template_parms (current_class_type))
10684 tree args = current_template_args ();
10685 type = tsubst (type, args, /*complain=*/1, NULL_TREE);
10688 /* This pop_nested_class corresponds to the
10689 push_nested_class used to push into class scope for
10690 parsing the argument list of a function decl, in
10692 pop_nested_class ();
10693 TREE_COMPLEXITY (declarator) = current_class_depth;
10696 my_friendly_abort (16);
10698 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10700 /* We had a reference to a global decl, or
10701 perhaps we were given a non-aggregate typedef,
10702 in which case we cleared this out, and should just
10703 keep going as though it wasn't there. */
10704 declarator = sname;
10707 ctype = TREE_OPERAND (declarator, 0);
10710 while (t != NULL_TREE && CLASS_TYPE_P (t))
10712 /* You're supposed to have one `template <...>'
10713 for every template class, but you don't need one
10714 for a full specialization. For example:
10716 template <class T> struct S{};
10717 template <> struct S<int> { void f(); };
10718 void S<int>::f () {}
10720 is correct; there shouldn't be a `template <>' for
10721 the definition of `S<int>::f'. */
10722 if (CLASSTYPE_TEMPLATE_INFO (t)
10723 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10724 || uses_template_parms (CLASSTYPE_TI_ARGS (t))))
10725 template_count += 1;
10727 t = TYPE_MAIN_DECL (t);
10728 if (DECL_LANG_SPECIFIC (t))
10729 t = DECL_CONTEXT (t);
10734 if (sname == NULL_TREE)
10737 if (TREE_CODE (sname) == IDENTIFIER_NODE)
10739 /* This is the `standard' use of the scoping operator:
10740 basetype :: member . */
10742 if (ctype == current_class_type)
10748 Is this ill-formed? */
10751 cp_pedwarn ("extra qualification `%T::' on member `%s' ignored",
10754 else if (TREE_CODE (type) == FUNCTION_TYPE)
10756 if (current_class_type == NULL_TREE
10758 type = build_cplus_method_type (ctype, TREE_TYPE (type),
10759 TYPE_ARG_TYPES (type));
10762 cp_error ("cannot declare member function `%T::%s' within `%T'",
10763 ctype, name, current_class_type);
10764 return void_type_node;
10767 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10768 || COMPLETE_TYPE_P (complete_type (ctype)))
10770 /* Have to move this code elsewhere in this function.
10771 this code is used for i.e., typedef int A::M; M *pm;
10773 It is? How? jason 10/2/94 */
10775 if (current_class_type)
10777 cp_error ("cannot declare member `%T::%s' within `%T'",
10778 ctype, name, current_class_type);
10779 return void_type_node;
10781 type = build_offset_type (ctype, type);
10783 else if (uses_template_parms (ctype))
10785 if (TREE_CODE (type) == FUNCTION_TYPE)
10787 = build_cplus_method_type (ctype, TREE_TYPE (type),
10788 TYPE_ARG_TYPES (type));
10792 cp_error ("structure `%T' not yet defined", ctype);
10793 return error_mark_node;
10796 declarator = sname;
10798 else if (TREE_CODE (sname) == SCOPE_REF)
10799 my_friendly_abort (17);
10803 declarator = TREE_OPERAND (declarator, 1);
10804 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
10805 /* In this case, we will deal with it later. */
10809 if (TREE_CODE (type) == FUNCTION_TYPE)
10810 type = build_cplus_method_type (ctype, TREE_TYPE (type),
10811 TYPE_ARG_TYPES (type));
10813 type = build_offset_type (ctype, type);
10820 declarator = TREE_OPERAND (declarator, 0);
10825 case ENUMERAL_TYPE:
10826 declarator = NULL_TREE;
10830 declarator = NULL_TREE;
10834 my_friendly_abort (158);
10838 /* See the comment for the TREE_LIST case, above. */
10841 if (! ignore_attrs)
10842 decl_attributes (type, inner_attrs, NULL_TREE);
10844 TREE_VALUE (attrlist) = chainon (inner_attrs, TREE_VALUE (attrlist));
10846 attrlist = build_decl_list (NULL_TREE, inner_attrs);
10849 /* Now TYPE has the actual type. */
10851 if (explicitp == 1 || (explicitp && friendp))
10853 /* [dcl.fct.spec] The explicit specifier shall only be used in
10854 declarations of constructors within a class definition. */
10855 error ("only declarations of constructors can be `explicit'");
10859 if (RIDBIT_SETP (RID_MUTABLE, specbits))
10861 if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
10863 error ("non-member `%s' cannot be declared `mutable'", name);
10864 RIDBIT_RESET (RID_MUTABLE, specbits);
10866 else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
10868 error ("non-object member `%s' cannot be declared `mutable'", name);
10869 RIDBIT_RESET (RID_MUTABLE, specbits);
10871 else if (TREE_CODE (type) == FUNCTION_TYPE
10872 || TREE_CODE (type) == METHOD_TYPE)
10874 error ("function `%s' cannot be declared `mutable'", name);
10875 RIDBIT_RESET (RID_MUTABLE, specbits);
10879 error ("static `%s' cannot be declared `mutable'", name);
10880 RIDBIT_RESET (RID_MUTABLE, specbits);
10882 else if (type_quals & TYPE_QUAL_CONST)
10884 error ("const `%s' cannot be declared `mutable'", name);
10885 RIDBIT_RESET (RID_MUTABLE, specbits);
10889 if (declarator == NULL_TREE
10890 || TREE_CODE (declarator) == IDENTIFIER_NODE
10891 || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
10892 && (TREE_CODE (type) == FUNCTION_TYPE
10893 || TREE_CODE (type) == METHOD_TYPE)))
10895 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
10897 cp_error ("template-id `%D' used as a declarator", declarator);
10898 declarator = dname;
10901 /* Unexpected declarator format. */
10902 my_friendly_abort (990210);
10904 /* If this is declaring a typedef name, return a TYPE_DECL. */
10906 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
10910 /* Note that the grammar rejects storage classes
10911 in typenames, fields or parameters. */
10912 if (current_lang_name == lang_name_java)
10913 TYPE_FOR_JAVA (type) = 1;
10915 if (decl_context == FIELD)
10917 if (declarator == constructor_name (current_class_type))
10918 cp_pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
10920 decl = build_lang_decl (TYPE_DECL, declarator, type);
10924 /* Make sure this typedef lives as long as its type,
10925 since it might be used as a template parameter. */
10926 if (processing_template_decl)
10927 decl = build_lang_decl (TYPE_DECL, declarator, type);
10929 decl = build_decl (TYPE_DECL, declarator, type);
10932 /* If the user declares "typedef struct {...} foo" then the
10933 struct will have an anonymous name. Fill that name in now.
10934 Nothing can refer to it, so nothing needs know about the name
10936 if (type != error_mark_node
10938 && TYPE_NAME (type)
10939 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10940 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))
10941 && CP_TYPE_QUALS (type) == TYPE_UNQUALIFIED)
10943 tree oldname = TYPE_NAME (type);
10946 /* Replace the anonymous name with the real name everywhere. */
10947 lookup_tag_reverse (type, declarator);
10948 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10949 if (TYPE_NAME (t) == oldname)
10950 TYPE_NAME (t) = decl;
10952 if (TYPE_LANG_SPECIFIC (type))
10953 TYPE_WAS_ANONYMOUS (type) = 1;
10955 /* If this is a typedef within a template class, the nested
10956 type is a (non-primary) template. The name for the
10957 template needs updating as well. */
10958 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10959 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10960 = TYPE_IDENTIFIER (type);
10962 /* XXX Temporarily set the scope.
10963 When returning, start_decl expects it as NULL_TREE,
10964 and will then then set it using pushdecl. */
10965 my_friendly_assert (DECL_CONTEXT (decl) == NULL_TREE, 980404);
10966 if (current_class_type)
10967 DECL_CONTEXT (decl) = current_class_type;
10969 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10971 DECL_ASSEMBLER_NAME (decl) = DECL_NAME (decl);
10972 DECL_ASSEMBLER_NAME (decl)
10973 = get_identifier (build_overload_name (type, 1, 1));
10974 DECL_CONTEXT (decl) = NULL_TREE;
10976 /* FIXME remangle member functions; member functions of a
10977 type with external linkage have external linkage. */
10980 if (TREE_CODE (type) == OFFSET_TYPE || TREE_CODE (type) == METHOD_TYPE)
10982 cp_error_at ("typedef name may not be class-qualified", decl);
10987 if (ctype == NULL_TREE)
10989 if (TREE_CODE (type) != METHOD_TYPE)
10990 cp_error_at ("invalid type qualifier for non-member function type", decl);
10992 ctype = TYPE_METHOD_BASETYPE (type);
10994 if (ctype != NULL_TREE)
10995 grok_method_quals (ctype, decl, quals);
10998 if (RIDBIT_SETP (RID_SIGNED, specbits)
10999 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11000 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11002 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11003 inlinep, friendp, raises != NULL_TREE);
11006 error ("typedef declaration includes an initializer");
11011 /* Detect the case of an array type of unspecified size
11012 which came, as such, direct from a typedef name.
11013 We must copy the type, so that each identifier gets
11014 a distinct type, so that each identifier's size can be
11015 controlled separately by its own initializer. */
11017 if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
11018 && TYPE_DOMAIN (type) == NULL_TREE)
11020 type = build_cplus_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
11023 /* If this is a type name (such as, in a cast or sizeof),
11024 compute the type and return it now. */
11026 if (decl_context == TYPENAME)
11028 /* Note that the grammar rejects storage classes
11029 in typenames, fields or parameters. */
11030 if (type_quals != TYPE_UNQUALIFIED)
11031 type_quals = TYPE_UNQUALIFIED;
11033 /* Special case: "friend class foo" looks like a TYPENAME context. */
11036 if (type_quals != TYPE_UNQUALIFIED)
11038 cp_error ("type qualifiers specified for friend class declaration");
11039 type_quals = TYPE_UNQUALIFIED;
11043 cp_error ("`inline' specified for friend class declaration");
11047 /* Only try to do this stuff if we didn't already give up. */
11048 if (type != integer_type_node)
11050 /* A friendly class? */
11051 if (current_class_type)
11052 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11054 error ("trying to make class `%s' a friend of global scope",
11055 TYPE_NAME_STRING (type));
11056 type = void_type_node;
11061 if (ctype == NULL_TREE)
11063 if (TREE_CODE (type) != METHOD_TYPE)
11064 cp_error ("invalid qualifiers on non-member function type");
11066 ctype = TYPE_METHOD_BASETYPE (type);
11070 tree dummy = build_decl (TYPE_DECL, declarator, type);
11071 grok_method_quals (ctype, dummy, quals);
11072 type = TREE_TYPE (dummy);
11078 else if (declarator == NULL_TREE && decl_context != PARM
11079 && decl_context != CATCHPARM
11080 && TREE_CODE (type) != UNION_TYPE
11083 cp_error ("abstract declarator `%T' used as declaration", type);
11084 declarator = make_anon_name ();
11087 /* `void' at top level (not within pointer)
11088 is allowed only in typedefs or type names.
11089 We don't complain about parms either, but that is because
11090 a better error message can be made later. */
11092 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11095 error ("unnamed variable or field declared void");
11096 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11098 if (IDENTIFIER_OPNAME_P (declarator))
11099 my_friendly_abort (356);
11101 error ("variable or field `%s' declared void", name);
11104 error ("variable or field declared void");
11105 type = integer_type_node;
11108 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11109 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11111 if (decl_context == PARM || decl_context == CATCHPARM)
11113 if (ctype || in_namespace)
11114 error ("cannot use `::' in parameter declaration");
11116 /* A parameter declared as an array of T is really a pointer to T.
11117 One declared as a function is really a pointer to a function.
11118 One declared as a member is really a pointer to member. */
11120 if (TREE_CODE (type) == ARRAY_TYPE)
11122 /* Transfer const-ness of array into that of type pointed to. */
11123 type = build_pointer_type (TREE_TYPE (type));
11124 type_quals = TYPE_UNQUALIFIED;
11126 else if (TREE_CODE (type) == FUNCTION_TYPE)
11127 type = build_pointer_type (type);
11128 else if (TREE_CODE (type) == OFFSET_TYPE)
11129 type = build_pointer_type (type);
11130 else if (TREE_CODE (type) == VOID_TYPE && declarator)
11132 error ("declaration of `%s' as void", name);
11138 register tree decl;
11140 if (decl_context == PARM)
11142 decl = build_decl (PARM_DECL, declarator, type);
11144 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11145 inlinep, friendp, raises != NULL_TREE);
11147 /* Compute the type actually passed in the parmlist,
11148 for the case where there is no prototype.
11149 (For example, shorts and chars are passed as ints.)
11150 When there is a prototype, this is overridden later. */
11152 DECL_ARG_TYPE (decl) = type_promotes_to (type);
11154 else if (decl_context == FIELD)
11156 if (type == error_mark_node)
11158 /* Happens when declaring arrays of sizes which
11159 are error_mark_node, for example. */
11162 else if (in_namespace && !friendp)
11164 /* Something like struct S { int N::j; }; */
11165 cp_error ("invalid use of `::'");
11168 else if (TREE_CODE (type) == FUNCTION_TYPE)
11171 tree function_context;
11173 /* We catch the others as conflicts with the builtin
11175 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11177 cp_error ("function `%D' cannot be declared friend",
11184 if (ctype == NULL_TREE)
11185 ctype = current_class_type;
11187 if (ctype == NULL_TREE)
11189 cp_error ("can't make `%D' into a method -- not in a class",
11191 return void_type_node;
11194 /* ``A union may [ ... ] not [ have ] virtual functions.''
11196 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11198 cp_error ("function `%D' declared virtual inside a union",
11200 return void_type_node;
11203 if (declarator == ansi_opname[(int) NEW_EXPR]
11204 || declarator == ansi_opname[(int) VEC_NEW_EXPR]
11205 || declarator == ansi_opname[(int) DELETE_EXPR]
11206 || declarator == ansi_opname[(int) VEC_DELETE_EXPR])
11210 cp_error ("`%D' cannot be declared virtual, since it is always static",
11215 else if (staticp < 2)
11216 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11217 TYPE_ARG_TYPES (type));
11220 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11221 function_context = (ctype != NULL_TREE) ?
11222 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11223 publicp = (! friendp || ! staticp)
11224 && function_context == NULL_TREE;
11225 decl = grokfndecl (ctype, type,
11226 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11227 ? declarator : dname,
11229 virtualp, flags, quals, raises,
11230 friendp ? -1 : 0, friendp, publicp, inlinep,
11231 funcdef_flag, template_count, in_namespace);
11232 if (decl == NULL_TREE)
11235 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11236 /* The decl and setting of decl_machine_attr is also turned off. */
11237 decl = build_decl_attribute_variant (decl, decl_machine_attr);
11240 /* [class.conv.ctor]
11242 A constructor declared without the function-specifier
11243 explicit that can be called with a single parameter
11244 specifies a conversion from the type of its first
11245 parameter to the type of its class. Such a constructor
11246 is called a converting constructor. */
11247 if (explicitp == 2)
11248 DECL_NONCONVERTING_P (decl) = 1;
11249 else if (DECL_CONSTRUCTOR_P (decl))
11251 /* The constructor can be called with exactly one
11252 parameter if there is at least one parameter, and
11253 any subsequent parameters have default arguments.
11254 We don't look at the first parameter, which is
11255 really just the `this' parameter for the new
11258 TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (decl)));
11260 /* Skip the `in_chrg' argument too, if present. */
11261 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
11262 arg_types = TREE_CHAIN (arg_types);
11264 if (arg_types == void_list_node
11266 && TREE_CHAIN (arg_types)
11267 && TREE_CHAIN (arg_types) != void_list_node
11268 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11269 DECL_NONCONVERTING_P (decl) = 1;
11272 else if (TREE_CODE (type) == METHOD_TYPE)
11274 /* We only get here for friend declarations of
11275 members of other classes. */
11276 /* All method decls are public, so tell grokfndecl to set
11277 TREE_PUBLIC, also. */
11278 decl = grokfndecl (ctype, type, declarator, declarator,
11279 virtualp, flags, quals, raises,
11280 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11281 template_count, in_namespace);
11282 if (decl == NULL_TREE)
11285 else if (!staticp && ! processing_template_decl
11286 && !COMPLETE_TYPE_P (complete_type (type))
11287 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11290 cp_error ("field `%D' has incomplete type", declarator);
11292 cp_error ("name `%T' has incomplete type", type);
11294 /* If we're instantiating a template, tell them which
11295 instantiation made the field's type be incomplete. */
11296 if (current_class_type
11297 && TYPE_NAME (current_class_type)
11298 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11299 && declspecs && TREE_VALUE (declspecs)
11300 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11301 cp_error (" in instantiation of template `%T'",
11302 current_class_type);
11304 type = error_mark_node;
11311 error ("`%s' is neither function nor member function; cannot be declared friend",
11312 IDENTIFIER_POINTER (declarator));
11320 /* Friends are treated specially. */
11321 if (ctype == current_class_type)
11322 warning ("member functions are implicitly friends of their class");
11325 tree t = NULL_TREE;
11326 if (decl && DECL_NAME (decl))
11328 if (template_class_depth (current_class_type) == 0)
11331 = check_explicit_specialization
11333 template_count, 2 * (funcdef_flag != 0) + 4);
11334 if (decl == error_mark_node)
11335 return error_mark_node;
11338 t = do_friend (ctype, declarator, decl,
11339 last_function_parms, attrlist, flags, quals,
11342 if (t && funcdef_flag)
11345 return void_type_node;
11349 /* Structure field. It may not be a function, except for C++ */
11351 if (decl == NULL_TREE)
11357 /* An attempt is being made to initialize a non-static
11358 member. But, from [class.mem]:
11360 4 A member-declarator can contain a
11361 constant-initializer only if it declares a static
11362 member (_class.static_) of integral or enumeration
11363 type, see _class.static.data_.
11365 This used to be relatively common practice, but
11366 the rest of the compiler does not correctly
11367 handle the initialization unless the member is
11368 static so we make it static below. */
11369 cp_pedwarn ("ISO C++ forbids initialization of member `%D'",
11371 cp_pedwarn ("making `%D' static", declarator);
11375 if (uses_template_parms (type))
11376 /* We'll check at instantiation time. */
11378 else if (check_static_variable_definition (declarator,
11380 /* If we just return the declaration, crashes
11381 will sometimes occur. We therefore return
11382 void_type_node, as if this was a friend
11383 declaration, to cause callers to completely
11384 ignore this declaration. */
11385 return void_type_node;
11388 /* 9.2p13 [class.mem] */
11389 if (declarator == constructor_name (current_class_type)
11390 /* Divergence from the standard: In extern "C", we
11391 allow non-static data members here, because C does
11392 and /usr/include/netinet/in.h uses that. */
11393 && (staticp || ! in_system_header))
11394 cp_pedwarn ("ISO C++ forbids data member `%D' with same name as enclosing class",
11399 /* C++ allows static class members. All other work
11400 for this is done by grokfield. */
11401 decl = build_lang_decl (VAR_DECL, declarator, type);
11402 TREE_STATIC (decl) = 1;
11403 /* In class context, 'static' means public access. */
11404 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11408 decl = build_lang_decl (FIELD_DECL, declarator, type);
11409 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11411 DECL_MUTABLE_P (decl) = 1;
11412 RIDBIT_RESET (RID_MUTABLE, specbits);
11416 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11417 inlinep, friendp, raises != NULL_TREE);
11420 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11422 tree original_name;
11428 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11429 original_name = dname;
11431 original_name = declarator;
11433 if (RIDBIT_SETP (RID_AUTO, specbits))
11434 error ("storage class `auto' invalid for function `%s'", name);
11435 else if (RIDBIT_SETP (RID_REGISTER, specbits))
11436 error ("storage class `register' invalid for function `%s'", name);
11438 /* Function declaration not at top level.
11439 Storage classes other than `extern' are not allowed
11440 and `extern' makes no difference. */
11441 if (! toplevel_bindings_p ()
11442 && (RIDBIT_SETP (RID_STATIC, specbits)
11443 || RIDBIT_SETP (RID_INLINE, specbits))
11446 if (RIDBIT_SETP (RID_STATIC, specbits))
11447 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11449 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11452 if (ctype == NULL_TREE)
11456 error ("virtual non-class function `%s'", name);
11460 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11461 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11462 TYPE_ARG_TYPES (type));
11464 /* Record presence of `static'. */
11465 publicp = (ctype != NULL_TREE
11466 || RIDBIT_SETP (RID_EXTERN, specbits)
11467 || !RIDBIT_SETP (RID_STATIC, specbits));
11469 decl = grokfndecl (ctype, type, original_name, declarator,
11470 virtualp, flags, quals, raises,
11472 publicp, inlinep, funcdef_flag,
11473 template_count, in_namespace);
11474 if (decl == NULL_TREE)
11479 int illegal_static = 0;
11481 /* Don't allow a static member function in a class, and forbid
11482 declaring main to be static. */
11483 if (TREE_CODE (type) == METHOD_TYPE)
11485 cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11486 illegal_static = 1;
11488 else if (current_function_decl)
11490 /* FIXME need arm citation */
11491 error ("cannot declare static function inside another function");
11492 illegal_static = 1;
11495 if (illegal_static)
11498 RIDBIT_RESET (RID_STATIC, specbits);
11504 /* It's a variable. */
11506 /* An uninitialized decl with `extern' is a reference. */
11507 decl = grokvardecl (type, declarator, &specbits,
11509 (type_quals & TYPE_QUAL_CONST) != 0,
11511 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11512 inlinep, friendp, raises != NULL_TREE);
11516 DECL_CONTEXT (decl) = ctype;
11519 cp_pedwarn ("static member `%D' re-declared as static", decl);
11521 RIDBIT_RESET (RID_STATIC, specbits);
11523 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11525 cp_error ("static member `%D' declared `register'", decl);
11526 RIDBIT_RESET (RID_REGISTER, specbits);
11528 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11530 cp_pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11532 RIDBIT_RESET (RID_EXTERN, specbits);
11537 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11539 /* Record `register' declaration for warnings on &
11540 and in case doing stupid register allocation. */
11542 if (RIDBIT_SETP (RID_REGISTER, specbits))
11543 DECL_REGISTER (decl) = 1;
11545 if (RIDBIT_SETP (RID_EXTERN, specbits))
11546 DECL_THIS_EXTERN (decl) = 1;
11548 if (RIDBIT_SETP (RID_STATIC, specbits))
11549 DECL_THIS_STATIC (decl) = 1;
11551 /* Record constancy and volatility. There's no need to do this
11552 when processing a template; we'll do this for the instantiated
11553 declaration based on the type of DECL. */
11554 if (!processing_template_decl)
11555 c_apply_type_quals_to_decl (type_quals, decl);
11561 /* Tell if a parmlist/exprlist looks like an exprlist or a parmlist.
11562 An empty exprlist is a parmlist. An exprlist which
11563 contains only identifiers at the global level
11564 is a parmlist. Otherwise, it is an exprlist. */
11567 parmlist_is_exprlist (exprs)
11570 if (exprs == NULL_TREE || TREE_PARMLIST (exprs))
11573 if (toplevel_bindings_p ())
11575 /* At the global level, if these are all identifiers,
11576 then it is a parmlist. */
11579 if (TREE_CODE (TREE_VALUE (exprs)) != IDENTIFIER_NODE)
11581 exprs = TREE_CHAIN (exprs);
11588 /* Subroutine of start_function. Ensure that each of the parameter
11589 types (as listed in PARMS) is complete, as is required for a
11590 function definition. */
11593 require_complete_types_for_parms (parms)
11596 for (; parms; parms = TREE_CHAIN (parms))
11598 tree type = TREE_TYPE (parms);
11600 /* Try to complete the TYPE. */
11601 type = complete_type (type);
11603 if (type == error_mark_node)
11606 if (!COMPLETE_TYPE_P (type))
11608 if (DECL_NAME (parms))
11609 error ("parameter `%s' has incomplete type",
11610 IDENTIFIER_POINTER (DECL_NAME (parms)));
11612 error ("parameter has incomplete type");
11613 TREE_TYPE (parms) = error_mark_node;
11616 layout_decl (parms, 0);
11620 /* Returns non-zero if T is a local variable. */
11623 local_variable_p (t)
11626 if ((TREE_CODE (t) == VAR_DECL
11627 /* A VAR_DECL with a context that is a _TYPE is a static data
11629 && !TYPE_P (CP_DECL_CONTEXT (t))
11630 /* Any other non-local variable must be at namespace scope. */
11631 && !DECL_NAMESPACE_SCOPE_P (t))
11632 || (TREE_CODE (t) == PARM_DECL))
11638 /* Returns non-zero if T is an automatic local variable or a label.
11639 (These are the declarations that need to be remapped when the code
11640 containing them is duplicated.) */
11643 nonstatic_local_decl_p (t)
11646 return ((local_variable_p (t) && !TREE_STATIC (t))
11647 || TREE_CODE (t) == LABEL_DECL
11648 || TREE_CODE (t) == RESULT_DECL);
11651 /* Like local_variable_p, but suitable for use as a tree-walking
11655 local_variable_p_walkfn (tp, walk_subtrees, data)
11657 int *walk_subtrees ATTRIBUTE_UNUSED;
11658 void *data ATTRIBUTE_UNUSED;
11660 return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11661 ? *tp : NULL_TREE);
11664 /* Check that ARG, which is a default-argument expression for a
11665 parameter DECL, is legal. Returns ARG, or ERROR_MARK_NODE, if
11666 something goes wrong. DECL may also be a _TYPE node, rather than a
11667 DECL, if there is no DECL available. */
11670 check_default_argument (decl, arg)
11677 if (TREE_CODE (arg) == DEFAULT_ARG)
11678 /* We get a DEFAULT_ARG when looking at an in-class declaration
11679 with a default argument. Ignore the argument for now; we'll
11680 deal with it after the class is complete. */
11683 if (processing_template_decl || uses_template_parms (arg))
11684 /* We don't do anything checking until instantiation-time. Note
11685 that there may be uninstantiated arguments even for an
11686 instantiated function, since default arguments are not
11687 instantiated until they are needed. */
11696 decl_type = TREE_TYPE (decl);
11698 if (arg == error_mark_node
11699 || decl == error_mark_node
11700 || TREE_TYPE (arg) == error_mark_node
11701 || decl_type == error_mark_node)
11702 /* Something already went wrong. There's no need to check
11704 return error_mark_node;
11706 /* [dcl.fct.default]
11708 A default argument expression is implicitly converted to the
11710 if (!TREE_TYPE (arg)
11711 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11714 cp_error ("default argument for `%#D' has type `%T'",
11715 decl, TREE_TYPE (arg));
11717 cp_error ("default argument for parameter of type `%T' has type `%T'",
11718 decl_type, TREE_TYPE (arg));
11720 return error_mark_node;
11723 /* [dcl.fct.default]
11725 Local variables shall not be used in default argument
11728 The keyword `this' shall not be used in a default argument of a
11729 member function. */
11730 var = walk_tree (&arg, local_variable_p_walkfn, NULL);
11733 cp_error ("default argument `%E' uses local variable `%D'",
11735 return error_mark_node;
11742 /* Decode the list of parameter types for a function type.
11743 Given the list of things declared inside the parens,
11744 return a list of types.
11746 The list we receive can have three kinds of elements:
11747 an IDENTIFIER_NODE for names given without types,
11748 a TREE_LIST node for arguments given as typespecs or names with typespecs,
11749 or void_type_node, to mark the end of an argument list
11750 when additional arguments are not permitted (... was not used).
11752 FUNCDEF_FLAG is nonzero for a function definition, 0 for
11753 a mere declaration. A nonempty identifier-list gets an error message
11754 when FUNCDEF_FLAG is zero.
11755 If FUNCDEF_FLAG is 1, then parameter types must be complete.
11756 If FUNCDEF_FLAG is -1, then parameter types may be incomplete.
11758 If all elements of the input list contain types,
11759 we return a list of the types.
11760 If all elements contain no type (except perhaps a void_type_node
11761 at the end), we return a null list.
11762 If some have types and some do not, it is an error, and we
11763 return a null list.
11765 Also set last_function_parms to either
11766 a list of names (IDENTIFIER_NODEs) or a chain of PARM_DECLs.
11767 A list of names is converted to a chain of PARM_DECLs
11768 by store_parm_decls so that ultimately it is always a chain of decls.
11770 Note that in C++, parameters can take default values. These default
11771 values are in the TREE_PURPOSE field of the TREE_LIST. It is
11772 an error to specify default values which are followed by parameters
11773 that have no default values, or an ELLIPSES. For simplicities sake,
11774 only parameters which are specified with their types can take on
11778 grokparms (first_parm, funcdef_flag)
11782 tree result = NULL_TREE;
11783 tree decls = NULL_TREE;
11785 if (first_parm != NULL_TREE
11786 && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
11788 if (! funcdef_flag)
11789 pedwarn ("parameter names (without types) in function declaration");
11790 last_function_parms = first_parm;
11793 else if (first_parm != NULL_TREE
11794 && TREE_CODE (TREE_VALUE (first_parm)) != TREE_LIST
11795 && TREE_CODE (TREE_VALUE (first_parm)) != VOID_TYPE)
11796 my_friendly_abort (145);
11799 /* Types were specified. This is a list of declarators
11800 each represented as a TREE_LIST node. */
11801 register tree parm, chain;
11802 int any_init = 0, any_error = 0;
11804 if (first_parm != NULL_TREE)
11806 tree last_result = NULL_TREE;
11807 tree last_decl = NULL_TREE;
11809 for (parm = first_parm; parm != NULL_TREE; parm = chain)
11811 tree type = NULL_TREE, list_node = parm;
11812 register tree decl = TREE_VALUE (parm);
11813 tree init = TREE_PURPOSE (parm);
11815 chain = TREE_CHAIN (parm);
11816 /* @@ weak defense against parse errors. */
11817 if (TREE_CODE (decl) != VOID_TYPE
11818 && TREE_CODE (decl) != TREE_LIST)
11820 /* Give various messages as the need arises. */
11821 if (TREE_CODE (decl) == STRING_CST)
11822 cp_error ("invalid string constant `%E'", decl);
11823 else if (TREE_CODE (decl) == INTEGER_CST)
11824 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11828 if (TREE_CODE (decl) != VOID_TYPE)
11830 decl = grokdeclarator (TREE_VALUE (decl),
11831 TREE_PURPOSE (decl),
11832 PARM, init != NULL_TREE,
11834 if (! decl || TREE_TYPE (decl) == error_mark_node)
11837 /* Top-level qualifiers on the parameters are
11838 ignored for function types. */
11839 type = TYPE_MAIN_VARIANT (TREE_TYPE (decl));
11841 if (TREE_CODE (type) == VOID_TYPE)
11842 decl = void_type_node;
11843 else if (TREE_CODE (type) == METHOD_TYPE)
11845 if (DECL_NAME (decl))
11846 /* Cannot use the decl here because
11847 we don't have DECL_CONTEXT set up yet. */
11848 cp_error ("parameter `%D' invalidly declared method type",
11851 error ("parameter invalidly declared method type");
11852 type = build_pointer_type (type);
11853 TREE_TYPE (decl) = type;
11855 else if (TREE_CODE (type) == OFFSET_TYPE)
11857 if (DECL_NAME (decl))
11858 cp_error ("parameter `%D' invalidly declared offset type",
11861 error ("parameter invalidly declared offset type");
11862 type = build_pointer_type (type);
11863 TREE_TYPE (decl) = type;
11865 else if (abstract_virtuals_error (decl, type))
11866 any_error = 1; /* Seems like a good idea. */
11867 else if (POINTER_TYPE_P (type))
11870 while (POINTER_TYPE_P (t)
11871 || (TREE_CODE (t) == ARRAY_TYPE
11872 && TYPE_DOMAIN (t) != NULL_TREE))
11874 if (TREE_CODE (t) == ARRAY_TYPE)
11875 cp_error ("parameter type `%T' includes %s to array of unknown bound",
11877 TYPE_PTR_P (type) ? "pointer" : "reference");
11881 if (TREE_CODE (decl) == VOID_TYPE)
11883 if (result == NULL_TREE)
11885 result = void_list_node;
11886 last_result = result;
11890 TREE_CHAIN (last_result) = void_list_node;
11891 last_result = void_list_node;
11894 && (chain != void_list_node || TREE_CHAIN (chain)))
11895 error ("`void' in parameter list must be entire list");
11899 /* Since there is a prototype, args are passed in their own types. */
11900 DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
11901 if (PROMOTE_PROTOTYPES
11902 && (TREE_CODE (type) == INTEGER_TYPE
11903 || TREE_CODE (type) == ENUMERAL_TYPE)
11904 && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
11905 DECL_ARG_TYPE (decl) = integer_type_node;
11906 if (!any_error && init)
11909 init = check_default_argument (decl, init);
11914 if (decls == NULL_TREE)
11921 TREE_CHAIN (last_decl) = decl;
11924 list_node = tree_cons (init, type, NULL_TREE);
11925 if (result == NULL_TREE)
11927 result = list_node;
11928 last_result = result;
11932 TREE_CHAIN (last_result) = list_node;
11933 last_result = list_node;
11937 TREE_CHAIN (last_result) = NULL_TREE;
11938 /* If there are no parameters, and the function does not end
11939 with `...', then last_decl will be NULL_TREE. */
11940 if (last_decl != NULL_TREE)
11941 TREE_CHAIN (last_decl) = NULL_TREE;
11945 last_function_parms = decls;
11950 /* Called from the parser to update an element of TYPE_ARG_TYPES for some
11951 FUNCTION_TYPE with the newly parsed version of its default argument, which
11952 was previously digested as text. See snarf_defarg et al in lex.c. */
11955 replace_defarg (arg, init)
11958 if (! processing_template_decl
11959 && ! can_convert_arg (TREE_VALUE (arg), TREE_TYPE (init), init))
11960 cp_pedwarn ("invalid type `%T' for default argument to `%T'",
11961 TREE_TYPE (init), TREE_VALUE (arg));
11962 TREE_PURPOSE (arg) = init;
11965 /* D is a constructor or overloaded `operator='. Returns non-zero if
11966 D's arguments allow it to be a copy constructor, or copy assignment
11975 if (!DECL_FUNCTION_MEMBER_P (d))
11978 t = FUNCTION_ARG_CHAIN (d);
11979 if (DECL_CONSTRUCTOR_P (d) && DECL_HAS_IN_CHARGE_PARM_P (d))
11980 t = TREE_CHAIN (t);
11981 if (t && TREE_CODE (TREE_VALUE (t)) == REFERENCE_TYPE
11982 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (t)))
11983 == DECL_CONTEXT (d))
11984 && (TREE_CHAIN (t) == NULL_TREE
11985 || TREE_CHAIN (t) == void_list_node
11986 || TREE_PURPOSE (TREE_CHAIN (t))))
11991 /* These memoizing functions keep track of special properties which
11992 a class may have. `grok_ctor_properties' notices whether a class
11993 has a constructor of the form X(X&), and also complains
11994 if the class has a constructor of the form X(X).
11995 `grok_op_properties' takes notice of the various forms of
11996 operator= which are defined, as well as what sorts of type conversion
11997 may apply. Both functions take a FUNCTION_DECL as an argument. */
12000 grok_ctor_properties (ctype, decl)
12003 tree parmtypes = FUNCTION_ARG_CHAIN (decl);
12004 tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
12006 /* When a type has virtual baseclasses, a magical first int argument is
12007 added to any ctor so we can tell if the class has been initialized
12008 yet. This could screw things up in this function, so we deliberately
12009 ignore the leading int if we're in that situation. */
12010 if (DECL_HAS_IN_CHARGE_PARM_P (decl))
12012 my_friendly_assert (parmtypes
12013 && TREE_VALUE (parmtypes) == integer_type_node,
12015 parmtypes = TREE_CHAIN (parmtypes);
12016 parmtype = TREE_VALUE (parmtypes);
12021 A non-template constructor for class X is a copy constructor if
12022 its first parameter is of type X&, const X&, volatile X& or const
12023 volatile X&, and either there are no other parameters or else all
12024 other parameters have default arguments. */
12025 if (TREE_CODE (parmtype) == REFERENCE_TYPE
12026 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == ctype
12027 && (TREE_CHAIN (parmtypes) == NULL_TREE
12028 || TREE_CHAIN (parmtypes) == void_list_node
12029 || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12030 && !(DECL_TEMPLATE_INSTANTIATION (decl)
12031 && is_member_template (DECL_TI_TEMPLATE (decl))))
12033 TYPE_HAS_INIT_REF (ctype) = 1;
12034 if (CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12035 TYPE_HAS_CONST_INIT_REF (ctype) = 1;
12039 A declaration of a constructor for a class X is ill-formed if its
12040 first parameter is of type (optionally cv-qualified) X and either
12041 there are no other parameters or else all other parameters have
12044 We *don't* complain about member template instantiations that
12045 have this form, though; they can occur as we try to decide what
12046 constructor to use during overload resolution. Since overload
12047 resolution will never prefer such a constructor to the
12048 non-template copy constructor (which is either explicitly or
12049 implicitly defined), there's no need to worry about their
12050 existence. Theoretically, they should never even be
12051 instantiated, but that's hard to forestall. */
12052 else if (TYPE_MAIN_VARIANT (parmtype) == ctype
12053 && (TREE_CHAIN (parmtypes) == NULL_TREE
12054 || TREE_CHAIN (parmtypes) == void_list_node
12055 || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
12056 && !(DECL_TEMPLATE_INSTANTIATION (decl)
12057 && is_member_template (DECL_TI_TEMPLATE (decl))))
12059 cp_error ("invalid constructor; you probably meant `%T (const %T&)'",
12061 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12064 else if (TREE_CODE (parmtype) == VOID_TYPE
12065 || TREE_PURPOSE (parmtypes) != NULL_TREE)
12066 TYPE_HAS_DEFAULT_CONSTRUCTOR (ctype) = 1;
12071 /* An operator with this name can be either unary or binary. */
12077 return (name == ansi_opname [(int) INDIRECT_REF]
12078 || name == ansi_opname [(int) ADDR_EXPR]
12079 || name == ansi_opname [(int) NEGATE_EXPR]
12080 || name == ansi_opname[(int) POSTINCREMENT_EXPR]
12081 || name == ansi_opname[(int) POSTDECREMENT_EXPR]
12082 || name == ansi_opname [(int) CONVERT_EXPR]);
12085 /* An operator with this name can only be unary. */
12091 return (name == ansi_opname [(int) TRUTH_NOT_EXPR]
12092 || name == ansi_opname [(int) BIT_NOT_EXPR]
12093 || name == ansi_opname [(int) COMPONENT_REF]
12094 || IDENTIFIER_TYPENAME_P (name));
12097 /* Do a little sanity-checking on how they declared their operator. */
12100 grok_op_properties (decl, virtualp, friendp)
12102 int virtualp, friendp;
12104 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12105 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12106 tree name = DECL_NAME (decl);
12108 if (current_class_type == NULL_TREE)
12115 A user-declared copy assignment operator X::operator= is a
12116 non-static non-template member function of class X with
12117 exactly one parameter of type X, X&, const X&, volatile X& or
12118 const volatile X&. */
12119 if (name == ansi_opname[(int) MODIFY_EXPR]
12120 && !(DECL_TEMPLATE_INSTANTIATION (decl)
12121 && is_member_template (DECL_TI_TEMPLATE (decl))))
12123 else if (name == ansi_opname[(int) CALL_EXPR])
12124 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12125 else if (name == ansi_opname[(int) ARRAY_REF])
12126 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12127 else if (name == ansi_opname[(int) COMPONENT_REF]
12128 || name == ansi_opname[(int) MEMBER_REF])
12129 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12130 else if (name == ansi_opname[(int) NEW_EXPR])
12131 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12132 else if (name == ansi_opname[(int) DELETE_EXPR])
12133 TYPE_GETS_DELETE (current_class_type) |= 1;
12134 else if (name == ansi_opname[(int) VEC_NEW_EXPR])
12135 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12136 else if (name == ansi_opname[(int) VEC_DELETE_EXPR])
12137 TYPE_GETS_DELETE (current_class_type) |= 2;
12140 if (name == ansi_opname[(int) NEW_EXPR]
12141 || name == ansi_opname[(int) VEC_NEW_EXPR])
12143 /* When the compiler encounters the definition of A::operator new, it
12144 doesn't look at the class declaration to find out if it's static. */
12146 revert_static_member_fn (decl);
12148 /* Take care of function decl if we had syntax errors. */
12149 if (argtypes == NULL_TREE)
12151 = build_function_type (ptr_type_node,
12152 hash_tree_chain (integer_type_node,
12155 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12157 else if (name == ansi_opname[(int) DELETE_EXPR]
12158 || name == ansi_opname[(int) VEC_DELETE_EXPR])
12161 revert_static_member_fn (decl);
12163 if (argtypes == NULL_TREE)
12165 = build_function_type (void_type_node,
12166 hash_tree_chain (ptr_type_node,
12169 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12173 /* An operator function must either be a non-static member function
12174 or have at least one parameter of a class, a reference to a class,
12175 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12176 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12178 if (IDENTIFIER_TYPENAME_P (name)
12179 || name == ansi_opname[(int) CALL_EXPR]
12180 || name == ansi_opname[(int) MODIFY_EXPR]
12181 || name == ansi_opname[(int) COMPONENT_REF]
12182 || name == ansi_opname[(int) ARRAY_REF])
12183 cp_error ("`%D' must be a nonstatic member function", decl);
12188 if (DECL_STATIC_FUNCTION_P (decl))
12189 cp_error ("`%D' must be either a non-static member function or a non-member function", decl);
12192 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12194 tree arg = TREE_VALUE (p);
12195 if (TREE_CODE (arg) == REFERENCE_TYPE)
12196 arg = TREE_TYPE (arg);
12198 /* This lets bad template code slip through. */
12199 if (IS_AGGR_TYPE (arg)
12200 || TREE_CODE (arg) == ENUMERAL_TYPE
12201 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12202 || TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM)
12206 ("`%D' must have an argument of class or enumerated type",
12213 if (name == ansi_opname[(int) CALL_EXPR])
12214 return; /* No restrictions on args. */
12216 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12218 tree t = TREE_TYPE (name);
12221 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12222 const char *what = 0;
12225 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12227 if (TREE_CODE (t) == VOID_TYPE)
12229 else if (t == current_class_type)
12230 what = "the same type";
12231 /* Don't force t to be complete here. */
12232 else if (IS_AGGR_TYPE (t)
12233 && COMPLETE_TYPE_P (t)
12234 && DERIVED_FROM_P (t, current_class_type))
12235 what = "a base class";
12238 warning ("conversion to %s%s will never use a type conversion operator",
12239 ref ? "a reference to " : "", what);
12243 if (name == ansi_opname[(int) MODIFY_EXPR])
12247 if (list_length (argtypes) != 3 && methodp)
12249 cp_error ("`%D' must take exactly one argument", decl);
12252 parmtype = TREE_VALUE (TREE_CHAIN (argtypes));
12254 if (copy_assignment_arg_p (parmtype, virtualp)
12257 TYPE_HAS_ASSIGN_REF (current_class_type) = 1;
12258 if (TREE_CODE (parmtype) != REFERENCE_TYPE
12259 || CP_TYPE_CONST_P (TREE_TYPE (parmtype)))
12260 TYPE_HAS_CONST_ASSIGN_REF (current_class_type) = 1;
12263 else if (name == ansi_opname[(int) COND_EXPR])
12266 cp_error ("ISO C++ prohibits overloading operator ?:");
12268 else if (ambi_op_p (name))
12270 if (list_length (argtypes) == 2)
12272 else if (list_length (argtypes) == 3)
12274 if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
12275 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12276 && ! processing_template_decl
12277 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12280 cp_error ("postfix `%D' must take `int' as its argument",
12284 ("postfix `%D' must take `int' as its second argument",
12291 cp_error ("`%D' must take either zero or one argument", decl);
12293 cp_error ("`%D' must take either one or two arguments", decl);
12296 /* More Effective C++ rule 6. */
12298 && (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12299 || name == ansi_opname[(int) POSTDECREMENT_EXPR]))
12301 tree arg = TREE_VALUE (argtypes);
12302 tree ret = TREE_TYPE (TREE_TYPE (decl));
12303 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12304 arg = TREE_TYPE (arg);
12305 arg = TYPE_MAIN_VARIANT (arg);
12306 if (list_length (argtypes) == 2)
12308 if (TREE_CODE (ret) != REFERENCE_TYPE
12309 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12311 cp_warning ("prefix `%D' should return `%T'", decl,
12312 build_reference_type (arg));
12316 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12317 cp_warning ("postfix `%D' should return `%T'", decl, arg);
12321 else if (unary_op_p (name))
12323 if (list_length (argtypes) != 2)
12326 cp_error ("`%D' must take `void'", decl);
12328 cp_error ("`%D' must take exactly one argument", decl);
12331 else /* if (binary_op_p (name)) */
12333 if (list_length (argtypes) != 3)
12336 cp_error ("`%D' must take exactly one argument", decl);
12338 cp_error ("`%D' must take exactly two arguments", decl);
12341 /* More Effective C++ rule 7. */
12343 && (name == ansi_opname [TRUTH_ANDIF_EXPR]
12344 || name == ansi_opname [TRUTH_ORIF_EXPR]
12345 || name == ansi_opname [COMPOUND_EXPR]))
12346 cp_warning ("user-defined `%D' always evaluates both arguments",
12350 /* Effective C++ rule 23. */
12352 && list_length (argtypes) == 3
12353 && (name == ansi_opname [PLUS_EXPR]
12354 || name == ansi_opname [MINUS_EXPR]
12355 || name == ansi_opname [TRUNC_DIV_EXPR]
12356 || name == ansi_opname [MULT_EXPR])
12357 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12358 cp_warning ("`%D' should return by value", decl);
12362 for (; argtypes != void_list_node ; argtypes = TREE_CHAIN (argtypes))
12363 if (TREE_PURPOSE (argtypes))
12365 TREE_PURPOSE (argtypes) = NULL_TREE;
12366 if (name == ansi_opname[(int) POSTINCREMENT_EXPR]
12367 || name == ansi_opname[(int) POSTDECREMENT_EXPR])
12370 cp_pedwarn ("`%D' cannot have default arguments", decl);
12373 cp_error ("`%D' cannot have default arguments", decl);
12378 static const char *
12380 enum tag_types code;
12393 my_friendly_abort (981122);
12397 /* Get the struct, enum or union (CODE says which) with tag NAME.
12398 Define the tag as a forward-reference if it is not defined.
12400 C++: If a class derivation is given, process it here, and report
12401 an error if multiple derivation declarations are not identical.
12403 If this is a definition, come in through xref_tag and only look in
12404 the current frame for the name (since C++ allows new names in any
12408 xref_tag (code_type_node, name, globalize)
12409 tree code_type_node;
12413 enum tag_types tag_code;
12414 enum tree_code code;
12415 register tree ref, t;
12416 struct binding_level *b = current_binding_level;
12418 tree attributes = NULL_TREE;
12419 tree context = NULL_TREE;
12421 /* If we are called from the parser, code_type_node will sometimes be a
12422 TREE_LIST. This indicates that the user wrote
12423 "class __attribute__ ((foo)) bar". Extract the attributes so we can
12425 if (TREE_CODE (code_type_node) == TREE_LIST)
12427 attributes = TREE_PURPOSE (code_type_node);
12428 code_type_node = TREE_VALUE (code_type_node);
12431 tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12436 code = RECORD_TYPE;
12442 code = ENUMERAL_TYPE;
12445 my_friendly_abort (18);
12448 /* If a cross reference is requested, look up the type
12449 already defined for this tag and return it. */
12453 name = TYPE_IDENTIFIER (t);
12457 t = IDENTIFIER_TYPE_VALUE (name);
12459 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12460 && TREE_CODE (t) != TEMPLATE_TEMPLATE_PARM)
12465 /* If we know we are defining this tag, only look it up in
12466 this scope and don't try to find it as a type. */
12467 ref = lookup_tag (code, name, b, 1);
12473 /* [dcl.type.elab] If the identifier resolves to a
12474 typedef-name or a template type-parameter, the
12475 elaborated-type-specifier is ill-formed. */
12476 if (t != TYPE_MAIN_VARIANT (t)
12477 || (CLASS_TYPE_P (t) && TYPE_WAS_ANONYMOUS (t)))
12478 cp_pedwarn ("using typedef-name `%D' after `%s'",
12479 TYPE_NAME (t), tag_name (tag_code));
12480 else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12481 cp_error ("using template type parameter `%T' after `%s'",
12482 t, tag_name (tag_code));
12487 ref = lookup_tag (code, name, b, 0);
12491 /* Try finding it as a type declaration. If that wins,
12493 ref = lookup_name (name, 1);
12495 if (ref != NULL_TREE
12496 && processing_template_decl
12497 && DECL_CLASS_TEMPLATE_P (ref)
12498 && template_class_depth (current_class_type) == 0)
12499 /* Since GLOBALIZE is true, we're declaring a global
12500 template, so we want this type. */
12501 ref = DECL_TEMPLATE_RESULT (ref);
12503 if (ref && TREE_CODE (ref) == TYPE_DECL
12504 && TREE_CODE (TREE_TYPE (ref)) == code)
12505 ref = TREE_TYPE (ref);
12510 if (ref && current_class_type
12511 && template_class_depth (current_class_type)
12512 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12514 /* Since GLOBALIZE is non-zero, we are not looking at a
12515 definition of this tag. Since, in addition, we are currently
12516 processing a (member) template declaration of a template
12517 class, we must be very careful; consider:
12524 { template <class V>
12525 friend struct S1; };
12527 Here, the S2::S1 declaration should not be confused with the
12528 outer declaration. In particular, the inner version should
12529 have a template parameter of level 2, not level 1. This
12530 would be particularly important if the member declaration
12533 template <class V = U> friend struct S1;
12535 say, when we should tsubst into `U' when instantiating
12536 S2. On the other hand, when presented with:
12546 we must find the inner binding eventually. We
12547 accomplish this by making sure that the new type we
12548 create to represent this declaration has the right
12550 context = TYPE_CONTEXT (ref);
12557 /* If no such tag is yet defined, create a forward-reference node
12558 and record it as the "definition".
12559 When a real declaration of this type is found,
12560 the forward-reference will be altered into a real type. */
12561 if (code == ENUMERAL_TYPE)
12563 cp_error ("use of enum `%#D' without previous declaration", name);
12565 ref = make_node (ENUMERAL_TYPE);
12567 /* Give the type a default layout like unsigned int
12568 to avoid crashing if it does not get defined. */
12569 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12570 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12571 TREE_UNSIGNED (ref) = 1;
12572 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12573 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12574 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12576 /* Enable us to recognize when a type is created in class context.
12577 To do nested classes correctly, this should probably be cleared
12578 out when we leave this classes scope. Currently this in only
12579 done in `start_enum'. */
12581 pushtag (name, ref, globalize);
12585 struct binding_level *old_b = class_binding_level;
12587 ref = make_aggr_type (code);
12588 TYPE_CONTEXT (ref) = context;
12590 #ifdef NONNESTED_CLASSES
12591 /* Class types don't nest the way enums do. */
12592 class_binding_level = (struct binding_level *)0;
12594 pushtag (name, ref, globalize);
12595 class_binding_level = old_b;
12600 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12601 redeclare_class_template (ref, current_template_parms);
12604 /* Until the type is defined, tentatively accept whatever
12605 structure tag the user hands us. */
12606 if (!COMPLETE_TYPE_P (ref)
12607 && ref != current_class_type
12608 /* Have to check this, in case we have contradictory tag info. */
12609 && IS_AGGR_TYPE_CODE (TREE_CODE (ref)))
12611 if (tag_code == class_type)
12612 CLASSTYPE_DECLARED_CLASS (ref) = 1;
12613 else if (tag_code == record_type)
12614 CLASSTYPE_DECLARED_CLASS (ref) = 0;
12617 TREE_TYPE (ref) = attributes;
12623 xref_tag_from_type (old, id, globalize)
12627 tree code_type_node;
12629 if (TREE_CODE (old) == RECORD_TYPE)
12630 code_type_node = (CLASSTYPE_DECLARED_CLASS (old)
12631 ? class_type_node : record_type_node);
12633 code_type_node = union_type_node;
12635 if (id == NULL_TREE)
12636 id = TYPE_IDENTIFIER (old);
12638 return xref_tag (code_type_node, id, globalize);
12641 /* REF is a type (named NAME), for which we have just seen some
12642 baseclasses. BINFO is a list of those baseclasses; the
12643 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12644 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12645 struct, or union. */
12648 xref_basetypes (code_type_node, name, ref, binfo)
12649 tree code_type_node;
12653 /* In the declaration `A : X, Y, ... Z' we mark all the types
12654 (A, X, Y, ..., Z) so we can check for duplicates. */
12659 enum tag_types tag_code = (enum tag_types) tree_low_cst (code_type_node, 1);
12661 if (tag_code == union_type)
12663 cp_error ("derived union `%T' invalid", ref);
12667 len = list_length (binfo);
12669 /* First, make sure that any templates in base-classes are
12670 instantiated. This ensures that if we call ourselves recursively
12671 we do not get confused about which classes are marked and which
12673 for (base = binfo; base; base = TREE_CHAIN (base))
12674 complete_type (TREE_VALUE (base));
12676 SET_CLASSTYPE_MARKED (ref);
12677 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos = make_tree_vec (len);
12679 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12681 /* The base of a derived struct is public by default. */
12683 = (TREE_PURPOSE (binfo) == access_public_node
12684 || TREE_PURPOSE (binfo) == access_public_virtual_node
12685 || (tag_code != class_type
12686 && (TREE_PURPOSE (binfo) == access_default_node
12687 || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12689 = (TREE_PURPOSE (binfo) == access_protected_node
12690 || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12692 = (TREE_PURPOSE (binfo) == access_private_virtual_node
12693 || TREE_PURPOSE (binfo) == access_protected_virtual_node
12694 || TREE_PURPOSE (binfo) == access_public_virtual_node
12695 || TREE_PURPOSE (binfo) == access_default_virtual_node);
12696 tree basetype = TREE_VALUE (binfo);
12699 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12700 basetype = TREE_TYPE (basetype);
12702 || (TREE_CODE (basetype) != RECORD_TYPE
12703 && TREE_CODE (basetype) != TYPENAME_TYPE
12704 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12705 && TREE_CODE (basetype) != TEMPLATE_TEMPLATE_PARM))
12707 cp_error ("base type `%T' fails to be a struct or class type",
12708 TREE_VALUE (binfo));
12712 GNU_xref_hier (name, basetype, via_public, via_virtual, 0);
12714 /* This code replaces similar code in layout_basetypes.
12715 We put the complete_type first for implicit `typename'. */
12716 if (!COMPLETE_TYPE_P (basetype)
12717 && ! (current_template_parms && uses_template_parms (basetype)))
12719 cp_error ("base class `%T' has incomplete type", basetype);
12724 if (CLASSTYPE_MARKED (basetype))
12726 if (basetype == ref)
12727 cp_error ("recursive type `%T' undefined", basetype);
12729 cp_error ("duplicate base type `%T' invalid", basetype);
12733 if (TYPE_FOR_JAVA (basetype)
12734 && (current_lang_stack
12735 == &VARRAY_TREE (current_lang_base, 0)))
12736 TYPE_FOR_JAVA (ref) = 1;
12738 /* Note that the BINFO records which describe individual
12739 inheritances are *not* shared in the lattice! They
12740 cannot be shared because a given baseclass may be
12741 inherited with different `accessibility' by different
12742 derived classes. (Each BINFO record describing an
12743 individual inheritance contains flags which say what
12744 the `accessibility' of that particular inheritance is.) */
12747 = make_binfo (size_zero_node, basetype,
12748 CLASS_TYPE_P (basetype)
12749 ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12750 CLASS_TYPE_P (basetype)
12751 ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12753 TREE_VEC_ELT (binfos, i) = base_binfo;
12754 TREE_VIA_PUBLIC (base_binfo) = via_public;
12755 TREE_VIA_PROTECTED (base_binfo) = via_protected;
12756 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12757 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12759 /* We need to unshare the binfos now so that lookups during class
12760 definition work. */
12761 unshare_base_binfos (base_binfo);
12763 SET_CLASSTYPE_MARKED (basetype);
12765 /* We are free to modify these bits because they are meaningless
12766 at top level, and BASETYPE is a top-level type. */
12767 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12769 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12770 /* Converting to a virtual base class requires looking
12771 up the offset of the virtual base. */
12772 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12775 if (CLASS_TYPE_P (basetype))
12777 TYPE_HAS_NEW_OPERATOR (ref)
12778 |= TYPE_HAS_NEW_OPERATOR (basetype);
12779 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12780 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12781 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12782 /* If the base-class uses multiple inheritance, so do we. */
12783 TYPE_USES_MULTIPLE_INHERITANCE (ref)
12784 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12785 /* Likewise, if converting to a base of the base may require
12786 code, then we may need to generate code to convert to a
12788 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12789 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12796 TREE_VEC_LENGTH (binfos) = i;
12798 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12802 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12803 /* If there is more than one non-empty they cannot be at the same
12805 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12808 /* Unmark all the types. */
12810 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
12811 CLEAR_CLASSTYPE_MARKED (ref);
12813 /* Now that we know all the base-classes, set up the list of virtual
12815 get_vbase_types (ref);
12819 /* Begin compiling the definition of an enumeration type.
12820 NAME is its name (or null if anonymous).
12821 Returns the type object, as yet incomplete.
12822 Also records info about it so that build_enumerator
12823 may be used to declare the individual values as they are read. */
12829 register tree enumtype = NULL_TREE;
12830 struct binding_level *b = current_binding_level;
12832 /* If this is the real definition for a previous forward reference,
12833 fill in the contents in the same object that used to be the
12834 forward reference. */
12836 if (name != NULL_TREE)
12837 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
12839 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12841 cp_error ("multiple definition of `%#T'", enumtype);
12842 cp_error_at ("previous definition here", enumtype);
12843 /* Clear out TYPE_VALUES, and start again. */
12844 TYPE_VALUES (enumtype) = NULL_TREE;
12848 enumtype = make_node (ENUMERAL_TYPE);
12849 pushtag (name, enumtype, 0);
12852 if (current_class_type)
12853 TREE_ADDRESSABLE (b->tags) = 1;
12855 GNU_xref_decl (current_function_decl, enumtype);
12859 /* After processing and defining all the values of an enumeration type,
12860 install their decls in the enumeration type and finish it off.
12861 ENUMTYPE is the type object and VALUES a list of name-value pairs.
12862 Returns ENUMTYPE. */
12865 finish_enum (enumtype)
12868 register tree minnode = NULL_TREE, maxnode = NULL_TREE;
12869 /* Calculate the maximum value of any enumerator in this type. */
12871 tree values = TYPE_VALUES (enumtype);
12876 for (pair = values; pair; pair = TREE_CHAIN (pair))
12881 /* The TREE_VALUE is a CONST_DECL for this enumeration
12883 decl = TREE_VALUE (pair);
12887 Following the closing brace of an enum-specifier, each
12888 enumerator has the type of its enumeration. Prior to the
12889 closing brace, the type of each enumerator is the type of
12890 its initializing value. */
12891 TREE_TYPE (decl) = enumtype;
12893 /* The DECL_INITIAL will be NULL if we are processing a
12894 template declaration and this enumeration constant had no
12895 explicit initializer. */
12896 value = DECL_INITIAL (decl);
12897 if (value && !processing_template_decl)
12899 /* Set the TREE_TYPE for the VALUE as well. That's so
12900 that when we call decl_constant_value we get an
12901 entity of the right type (but with the constant
12902 value). Since we shouldn't ever call
12903 decl_constant_value on a template type, there's no
12904 reason to do that when processing_template_decl.
12905 And, if the expression is something like a
12906 TEMPLATE_PARM_INDEX or a CAST_EXPR doing so will
12907 wreak havoc on the intended type of the expression.
12909 Of course, there's also no point in trying to compute
12910 minimum or maximum values if we're in a template. */
12911 TREE_TYPE (value) = enumtype;
12914 minnode = maxnode = value;
12915 else if (tree_int_cst_lt (maxnode, value))
12917 else if (tree_int_cst_lt (value, minnode))
12921 if (processing_template_decl)
12922 /* If this is just a template, leave the CONST_DECL
12923 alone. That way tsubst_copy will find CONST_DECLs for
12924 CONST_DECLs, and not INTEGER_CSTs. */
12927 /* In the list we're building up, we want the enumeration
12928 values, not the CONST_DECLs. */
12929 TREE_VALUE (pair) = value;
12933 maxnode = minnode = integer_zero_node;
12935 TYPE_VALUES (enumtype) = nreverse (values);
12937 if (processing_template_decl)
12939 tree scope = current_scope ();
12940 if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12941 add_tree (build_min (TAG_DEFN, enumtype));
12945 int unsignedp = tree_int_cst_sgn (minnode) >= 0;
12946 int lowprec = min_precision (minnode, unsignedp);
12947 int highprec = min_precision (maxnode, unsignedp);
12948 int precision = MAX (lowprec, highprec);
12951 TYPE_SIZE (enumtype) = NULL_TREE;
12953 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
12955 TYPE_PRECISION (enumtype) = precision;
12957 fixup_unsigned_type (enumtype);
12959 fixup_signed_type (enumtype);
12961 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
12962 /* Use the width of the narrowest normal C type which is wide
12964 TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size
12967 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
12969 TYPE_SIZE (enumtype) = 0;
12970 layout_type (enumtype);
12972 /* Fix up all variant types of this enum type. */
12973 for (tem = TYPE_MAIN_VARIANT (enumtype); tem;
12974 tem = TYPE_NEXT_VARIANT (tem))
12976 TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
12977 TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
12978 TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
12979 TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
12980 TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
12981 TYPE_MODE (tem) = TYPE_MODE (enumtype);
12982 TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
12983 TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
12984 TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype);
12987 /* Finish debugging output for this type. */
12988 rest_of_type_compilation (enumtype, namespace_bindings_p ());
12994 /* Build and install a CONST_DECL for an enumeration constant of the
12995 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12996 Assignment of sequential values by default is handled here. */
12999 build_enumerator (name, value, enumtype)
13009 /* Remove no-op casts from the value. */
13011 STRIP_TYPE_NOPS (value);
13013 if (! processing_template_decl)
13015 /* Validate and default VALUE. */
13016 if (value != NULL_TREE)
13018 if (TREE_READONLY_DECL_P (value))
13019 value = decl_constant_value (value);
13021 if (TREE_CODE (value) == INTEGER_CST)
13023 value = default_conversion (value);
13024 constant_expression_warning (value);
13028 cp_error ("enumerator value for `%D' not integer constant", name);
13033 /* Default based on previous value. */
13034 if (value == NULL_TREE && ! processing_template_decl)
13038 if (TYPE_VALUES (enumtype))
13040 /* The next value is the previous value ... */
13041 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13042 /* ... plus one. */
13043 value = build_binary_op (PLUS_EXPR,
13047 if (tree_int_cst_lt (value, prev_value))
13048 cp_error ("overflow in enumeration values at `%D'", name);
13051 value = integer_zero_node;
13054 /* Remove no-op casts from the value. */
13056 STRIP_TYPE_NOPS (value);
13058 /* To fix MAX_VAL enum consts. (bkoz) */
13059 TREE_TYPE (value) = integer_type_node;
13063 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13064 Even in other cases, we will later (in finish_enum) be setting
13065 the type of VALUE. But, we don't need to make a copy if this
13066 VALUE is one of the enumeration constants for this same
13067 enumeration type. */
13068 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13069 if (TREE_VALUE (values) == value)
13071 /* If we didn't break out of the loop, then we do need a copy. */
13072 if (!values && value)
13073 value = copy_node (value);
13075 /* C++ associates enums with global, function, or class declarations. */
13076 context = current_scope ();
13078 /* Build the actual enumeration constant. Note that the enumeration
13079 constants have the type of their initializers until the
13080 enumeration is complete:
13084 Following the closing brace of an enum-specifier, each enumer-
13085 ator has the type of its enumeration. Prior to the closing
13086 brace, the type of each enumerator is the type of its
13087 initializing value.
13089 In finish_enum we will reset the type. Of course, if we're
13090 processing a template, there may be no value. */
13091 type = value ? TREE_TYPE (value) : NULL_TREE;
13093 if (context && context == current_class_type)
13094 /* This enum declaration is local to the class. We need the full
13095 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13096 decl = build_lang_decl (CONST_DECL, name, type);
13098 /* It's a global enum, or it's local to a function. (Note local to
13099 a function could mean local to a class method. */
13100 decl = build_decl (CONST_DECL, name, type);
13102 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13103 DECL_INITIAL (decl) = value;
13104 TREE_READONLY (decl) = 1;
13106 if (context && context == current_class_type)
13107 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13108 on the TYPE_FIELDS list for `S'. (That's so that you can say
13109 things like `S::i' later.) */
13110 finish_member_declaration (decl);
13114 GNU_xref_decl (current_function_decl, decl);
13117 /* Add this enumeration constant to the list for this type. */
13118 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13122 static int function_depth;
13124 /* We're defining DECL. Make sure that it's type is OK. */
13127 check_function_type (decl)
13130 tree fntype = TREE_TYPE (decl);
13131 tree return_type = complete_type (TREE_TYPE (fntype));
13133 /* In a function definition, arg types must be complete. */
13134 require_complete_types_for_parms (current_function_parms);
13136 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13138 cp_error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13140 /* Make it return void instead, but don't change the
13141 type of the DECL_RESULT, in case we have a named return value. */
13142 if (TREE_CODE (fntype) == METHOD_TYPE)
13144 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13146 = build_cplus_method_type (ctype,
13148 FUNCTION_ARG_CHAIN (decl));
13152 = build_function_type (void_type_node,
13153 TYPE_ARG_TYPES (TREE_TYPE (decl)));
13155 = build_exception_variant (fntype,
13156 TYPE_RAISES_EXCEPTIONS (fntype));
13159 abstract_virtuals_error (decl, TREE_TYPE (fntype));
13162 /* Create the FUNCTION_DECL for a function definition.
13163 DECLSPECS and DECLARATOR are the parts of the declaration;
13164 they describe the function's name and the type it returns,
13165 but twisted together in a fashion that parallels the syntax of C.
13167 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13168 DECLARATOR is really the DECL for the function we are about to
13169 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13170 indicating that the function is an inline defined in-class, and
13171 SF_EXPAND indicating that we should generate RTL for this
13174 This function creates a binding context for the function body
13175 as well as setting up the FUNCTION_DECL in current_function_decl.
13177 Returns 1 on success. If the DECLARATOR is not suitable for a function
13178 (it defines a datum instead), we return 0, which tells
13179 yyparse to report a parse error.
13181 For C++, we must first check whether that datum makes any sense.
13182 For example, "class A local_a(1,2);" means that variable local_a
13183 is an aggregate of type A, which should have a constructor
13184 applied to it with the argument list [1, 2]. */
13187 start_function (declspecs, declarator, attrs, flags)
13188 tree declspecs, declarator, attrs;
13192 tree ctype = NULL_TREE;
13195 extern int have_extern_spec;
13196 extern int used_extern_spec;
13197 int doing_friend = 0;
13198 struct binding_level *bl;
13200 /* Sanity check. */
13201 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13202 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13204 /* This should only be done once on the top most decl. */
13205 if (have_extern_spec && !used_extern_spec)
13207 declspecs = decl_tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13208 used_extern_spec = 1;
13211 if (flags & SF_PRE_PARSED)
13213 decl1 = declarator;
13215 fntype = TREE_TYPE (decl1);
13216 if (TREE_CODE (fntype) == METHOD_TYPE)
13217 ctype = TYPE_METHOD_BASETYPE (fntype);
13219 /* ISO C++ 11.4/5. A friend function defined in a class is in
13220 the (lexical) scope of the class in which it is defined. */
13221 if (!ctype && DECL_FRIEND_P (decl1))
13223 ctype = DECL_FRIEND_CONTEXT (decl1);
13225 /* CTYPE could be null here if we're dealing with a template;
13226 for example, `inline friend float foo()' inside a template
13227 will have no CTYPE set. */
13228 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13234 last_function_parms = DECL_ARGUMENTS (decl1);
13235 last_function_parm_tags = NULL_TREE;
13239 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL_TREE);
13240 /* If the declarator is not suitable for a function definition,
13241 cause a syntax error. */
13242 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) return 0;
13244 fntype = TREE_TYPE (decl1);
13246 restype = TREE_TYPE (fntype);
13247 if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13249 cp_error ("semicolon missing after declaration of `%#T'", restype);
13250 shadow_tag (build_tree_list (NULL_TREE, restype));
13251 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13252 if (TREE_CODE (fntype) == FUNCTION_TYPE)
13253 fntype = build_function_type (integer_type_node,
13254 TYPE_ARG_TYPES (fntype));
13256 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13258 TYPE_ARG_TYPES (fntype));
13259 TREE_TYPE (decl1) = fntype;
13262 if (TREE_CODE (fntype) == METHOD_TYPE)
13263 ctype = TYPE_METHOD_BASETYPE (fntype);
13264 else if (DECL_MAIN_P (decl1))
13266 /* If this doesn't return integer_type, complain. */
13267 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13269 if (pedantic || warn_return_type)
13270 pedwarn ("return type for `main' changed to `int'");
13271 TREE_TYPE (decl1) = fntype = default_function_type;
13276 /* Sometimes we don't notice that a function is a static member, and
13277 build a METHOD_TYPE for it. Fix that up now. */
13278 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13279 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13281 revert_static_member_fn (decl1);
13282 last_function_parms = TREE_CHAIN (last_function_parms);
13286 /* Warn if function was previously implicitly declared
13287 (but not if we warned then). */
13288 if (! warn_implicit
13289 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13290 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13292 /* Set up current_class_type, and enter the scope of the class, if
13295 push_nested_class (ctype, 1);
13296 else if (DECL_STATIC_FUNCTION_P (decl1))
13297 push_nested_class (DECL_CONTEXT (decl1), 2);
13299 /* Now that we have entered the scope of the class, we must restore
13300 the bindings for any template parameters surrounding DECL1, if it
13301 is an inline member template. (Order is important; consider the
13302 case where a template parameter has the same name as a field of
13303 the class.) It is not until after this point that
13304 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13305 if (flags & SF_INCLASS_INLINE)
13306 maybe_begin_member_template_processing (decl1);
13308 /* Effective C++ rule 15. See also c_expand_return. */
13310 && DECL_NAME (decl1) == ansi_opname[(int) MODIFY_EXPR]
13311 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13312 cp_warning ("`operator=' should return a reference to `*this'");
13314 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13315 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13316 if (!DECL_INITIAL (decl1))
13317 DECL_INITIAL (decl1) = error_mark_node;
13319 #ifdef SET_DEFAULT_DECL_ATTRIBUTES
13320 SET_DEFAULT_DECL_ATTRIBUTES (decl1, attrs);
13323 /* This function exists in static storage.
13324 (This does not mean `static' in the C sense!) */
13325 TREE_STATIC (decl1) = 1;
13327 /* We must call push_template_decl after current_class_type is set
13328 up. (If we are processing inline definitions after exiting a
13329 class scope, current_class_type will be NULL_TREE until set above
13330 by push_nested_class.) */
13331 if (processing_template_decl)
13332 decl1 = push_template_decl (decl1);
13334 /* We are now in the scope of the function being defined. */
13335 current_function_decl = decl1;
13337 /* Save the parm names or decls from this function's declarator
13338 where store_parm_decls will find them. */
13339 current_function_parms = last_function_parms;
13340 current_function_parm_tags = last_function_parm_tags;
13342 /* Make sure the parameter and return types are reasonable. When
13343 you declare a function, these types can be incomplete, but they
13344 must be complete when you define the function. */
13345 if (! processing_template_decl)
13346 check_function_type (decl1);
13348 /* Build the return declaration for the function. */
13349 restype = TREE_TYPE (fntype);
13350 if (!processing_template_decl)
13352 if (!DECL_RESULT (decl1))
13354 DECL_RESULT (decl1)
13355 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13356 c_apply_type_quals_to_decl (CP_TYPE_QUALS (restype),
13357 DECL_RESULT (decl1));
13361 /* Just use `void'. Nobody will ever look at this anyhow. */
13362 DECL_RESULT (decl1) = build_decl (RESULT_DECL, 0, void_type_node);
13364 /* Initialize RTL machinery. We cannot do this until
13365 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13366 even when processing a template; this is how we get
13367 CFUN set up, and our per-function variables initialized. */
13368 bl = current_binding_level;
13369 init_function_start (decl1, input_filename, lineno);
13370 current_binding_level = bl;
13371 expanding_p = (flags & SF_EXPAND) != 0;
13373 /* Even though we're inside a function body, we still don't want to
13374 call expand_expr to calculate the size of a variable-sized array.
13375 We haven't necessarily assigned RTL to all variables yet, so it's
13376 not safe to try to expand expressions involving them. */
13377 immediate_size_expand = 0;
13378 cfun->x_dont_save_pending_sizes_p = 1;
13380 /* If we're building a statement-tree, start the tree now. */
13381 if (processing_template_decl || !expanding_p)
13382 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13384 /* Let the user know we're compiling this function. */
13385 if (processing_template_decl || !building_stmt_tree ())
13386 announce_function (decl1);
13388 /* Record the decl so that the function name is defined.
13389 If we already have a decl for this name, and it is a FUNCTION_DECL,
13390 use the old decl. */
13391 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13393 /* A specialization is not used to guide overload resolution. */
13394 if ((flag_guiding_decls
13395 || !DECL_TEMPLATE_SPECIALIZATION (decl1))
13396 && ! DECL_FUNCTION_MEMBER_P (decl1))
13397 decl1 = pushdecl (decl1);
13400 /* We need to set the DECL_CONTEXT. */
13401 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13402 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13403 /* And make sure we have enough default args. */
13404 check_default_args (decl1);
13406 fntype = TREE_TYPE (decl1);
13409 /* Reset these in case the call to pushdecl changed them. */
13410 current_function_decl = decl1;
13411 cfun->decl = decl1;
13413 /* Initialize the per-function data. */
13414 if (!DECL_PENDING_INLINE_P (decl1) && DECL_SAVED_FUNCTION_DATA (decl1))
13416 /* If we already parsed this function, and we're just expanding it
13417 now, restore saved state. */
13418 struct binding_level *bl = current_binding_level;
13419 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (decl1);
13420 current_binding_level = bl;
13422 /* This function is being processed in whole-function mode; we
13423 already did semantic analysis. */
13424 cfun->x_whole_function_mode_p = 1;
13426 /* If we decided that we didn't want to inline this function,
13427 make sure the back-end knows that. */
13428 if (!current_function_cannot_inline)
13429 current_function_cannot_inline = cp_function_chain->cannot_inline;
13431 /* We don't need the saved data anymore. */
13432 free (DECL_SAVED_FUNCTION_DATA (decl1));
13433 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13435 else if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13437 /* We know that this was set up by `grokclassfn'. We do not
13438 wait until `store_parm_decls', since evil parse errors may
13439 never get us to that point. Here we keep the consistency
13440 between `current_class_type' and `current_class_ptr'. */
13441 tree t = DECL_ARGUMENTS (decl1);
13443 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13445 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13448 cp_function_chain->x_current_class_ref
13449 = build_indirect_ref (t, NULL_PTR);
13450 cp_function_chain->x_current_class_ptr = t;
13452 /* Constructors and destructors need to know whether they're "in
13453 charge" of initializing virtual base classes. */
13454 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13455 current_in_charge_parm = TREE_CHAIN (t);
13458 if (DECL_INTERFACE_KNOWN (decl1))
13460 tree ctx = decl_function_context (decl1);
13462 if (DECL_NOT_REALLY_EXTERN (decl1))
13463 DECL_EXTERNAL (decl1) = 0;
13465 if (ctx != NULL_TREE && DECL_THIS_INLINE (ctx)
13466 && TREE_PUBLIC (ctx))
13467 /* This is a function in a local class in an extern inline
13469 comdat_linkage (decl1);
13471 /* If this function belongs to an interface, it is public.
13472 If it belongs to someone else's interface, it is also external.
13473 This only affects inlines and template instantiations. */
13474 else if (interface_unknown == 0
13475 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13476 || flag_alt_external_templates))
13478 if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
13479 || processing_template_decl)
13481 DECL_EXTERNAL (decl1)
13483 || (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines
13484 && !DECL_VINDEX (decl1)));
13486 /* For WIN32 we also want to put these in linkonce sections. */
13487 maybe_make_one_only (decl1);
13490 DECL_EXTERNAL (decl1) = 0;
13491 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13492 DECL_INTERFACE_KNOWN (decl1) = 1;
13494 else if (interface_unknown && interface_only
13495 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13496 || flag_alt_external_templates))
13498 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13499 interface, we will have interface_only set but not
13500 interface_known. In that case, we don't want to use the normal
13501 heuristics because someone will supply a #pragma implementation
13502 elsewhere, and deducing it here would produce a conflict. */
13503 comdat_linkage (decl1);
13504 DECL_EXTERNAL (decl1) = 0;
13505 DECL_INTERFACE_KNOWN (decl1) = 1;
13506 DECL_DEFER_OUTPUT (decl1) = 1;
13510 /* This is a definition, not a reference.
13511 So clear DECL_EXTERNAL. */
13512 DECL_EXTERNAL (decl1) = 0;
13514 if ((DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1))
13515 && ! DECL_INTERFACE_KNOWN (decl1)
13516 /* Don't try to defer nested functions for now. */
13517 && ! decl_function_context (decl1))
13518 DECL_DEFER_OUTPUT (decl1) = 1;
13520 DECL_INTERFACE_KNOWN (decl1) = 1;
13523 if (doing_semantic_analysis_p ())
13526 current_binding_level->parm_flag = 1;
13530 cplus_decl_attributes (decl1, NULL_TREE, attrs);
13532 if (!building_stmt_tree ())
13534 GNU_xref_function (decl1, current_function_parms);
13535 make_function_rtl (decl1);
13538 /* Promote the value to int before returning it. */
13539 if (C_PROMOTING_INTEGER_TYPE_P (restype))
13540 restype = type_promotes_to (restype);
13542 /* If this fcn was already referenced via a block-scope `extern' decl
13543 (or an implicit decl), propagate certain information about the usage. */
13544 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
13545 TREE_ADDRESSABLE (decl1) = 1;
13547 if (DECL_RESULT (decl1) == NULL_TREE)
13549 DECL_RESULT (decl1)
13550 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13551 TREE_READONLY (DECL_RESULT (decl1)) = CP_TYPE_CONST_P (restype);
13552 TREE_THIS_VOLATILE (DECL_RESULT (decl1)) = CP_TYPE_VOLATILE_P (restype);
13557 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
13558 && DECL_LANGUAGE (decl1) == lang_cplusplus)
13560 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13561 DECL_CONTEXT (dtor_label) = current_function_decl;
13563 /* Under the old ABI we return `this' from constructors, so we make
13564 ordinary `return' statements in constructors jump to CTOR_LABEL;
13565 from there we return `this'. Under the new ABI, we don't bother
13566 with any of this. By not setting CTOR_LABEL the remainder of the
13567 machinery is automatically disabled. */
13568 else if (!flag_new_abi && DECL_CONSTRUCTOR_P (decl1))
13570 ctor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13571 DECL_CONTEXT (ctor_label) = current_function_decl;
13577 /* Called after store_parm_decls for a function-try-block. */
13580 expand_start_early_try_stmts ()
13582 expand_start_try_stmts ();
13585 /* Store the parameter declarations into the current function declaration.
13586 This is called after parsing the parameter declarations, before
13587 digesting the body of the function.
13589 Also install to binding contour return value identifier, if any. */
13592 store_parm_decls ()
13594 register tree fndecl = current_function_decl;
13595 register tree parm;
13596 int parms_have_cleanups = 0;
13597 tree cleanups = NULL_TREE;
13599 /* This is a list of types declared among parms in a prototype. */
13600 tree parmtags = current_function_parm_tags;
13602 /* This is a chain of any other decls that came in among the parm
13603 declarations. If a parm is declared with enum {foo, bar} x;
13604 then CONST_DECLs for foo and bar are put here. */
13605 tree nonparms = NULL_TREE;
13607 /* Create a binding level for the parms. */
13608 if (!building_stmt_tree ())
13609 expand_start_bindings (2);
13611 if (current_function_parms)
13613 /* This case is when the function was defined with an ANSI prototype.
13614 The parms already have decls, so we need not do anything here
13615 except record them as in effect
13616 and complain if any redundant old-style parm decls were written. */
13618 tree specparms = current_function_parms;
13621 if (doing_semantic_analysis_p ())
13623 /* Must clear this because it might contain TYPE_DECLs declared
13625 storedecls (NULL_TREE);
13627 /* If we're doing semantic analysis, then we'll call pushdecl
13628 for each of these. We must do them in reverse order so that
13629 they end in the correct forward order. */
13630 specparms = nreverse (specparms);
13633 for (parm = specparms; parm; parm = next)
13635 next = TREE_CHAIN (parm);
13636 if (TREE_CODE (parm) == PARM_DECL)
13638 tree type = TREE_TYPE (parm);
13640 if (doing_semantic_analysis_p ())
13644 if (DECL_NAME (parm) == NULL_TREE
13645 || TREE_CODE (parm) != VOID_TYPE)
13648 cp_error ("parameter `%D' declared void", parm);
13650 cleanup = (processing_template_decl
13652 : maybe_build_cleanup (parm));
13655 cleanups = tree_cons (parm, cleanup, cleanups);
13657 else if (type != error_mark_node
13658 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13659 parms_have_cleanups = 1;
13663 /* If we find an enum constant or a type tag,
13664 put it aside for the moment. */
13665 TREE_CHAIN (parm) = NULL_TREE;
13666 nonparms = chainon (nonparms, parm);
13670 if (doing_semantic_analysis_p ())
13672 /* Get the decls in their original chain order
13673 and record in the function. This is all and only the
13674 PARM_DECLs that were pushed into scope by the loop above. */
13675 DECL_ARGUMENTS (fndecl) = getdecls ();
13676 storetags (chainon (parmtags, gettags ()));
13680 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13682 /* Now store the final chain of decls for the arguments
13683 as the decl-chain of the current lexical scope.
13684 Put the enumerators in as well, at the front so that
13685 DECL_ARGUMENTS is not modified. */
13686 if (doing_semantic_analysis_p ())
13687 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13689 /* Initialize the RTL code for the function. */
13690 DECL_SAVED_INSNS (fndecl) = 0;
13691 if (! building_stmt_tree ())
13692 expand_function_start (fndecl, parms_have_cleanups);
13694 current_function_parms_stored = 1;
13696 /* If this function is `main', emit a call to `__main'
13697 to run global initializers, etc. */
13698 if (DECL_MAIN_P (fndecl) && !building_stmt_tree ())
13699 expand_main_function ();
13701 /* Now that we have initialized the parms, we can start their
13702 cleanups. We cannot do this before, since expand_decl_cleanup
13703 should not be called before the parm can be used. */
13706 finish_decl_cleanup (TREE_PURPOSE (cleanups),
13707 TREE_VALUE (cleanups));
13708 cleanups = TREE_CHAIN (cleanups);
13711 /* Create a binding contour which can be used to catch
13712 cleanup-generated temporaries. Also, if the return value needs or
13713 has initialization, deal with that now. */
13714 if (parms_have_cleanups)
13717 if (!building_stmt_tree ())
13718 expand_start_bindings (2);
13721 /* Do the starting of the exception specifications, if we have any. */
13722 if (flag_exceptions && !processing_template_decl
13723 && flag_enforce_eh_specs
13724 && building_stmt_tree ()
13725 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13726 current_eh_spec_try_block = expand_start_eh_spec ();
13729 /* Bind a name and initialization to the return value of
13730 the current function. */
13733 store_return_init (decl)
13736 /* If this named return value comes in a register, put it in a
13737 pseudo-register. */
13738 if (DECL_REGISTER (decl))
13740 original_result_rtx = DECL_RTL (decl);
13741 /* Note that the mode of the old DECL_RTL may be wider than the
13742 mode of DECL_RESULT, depending on the calling conventions for
13743 the processor. For example, on the Alpha, a 32-bit integer
13744 is returned in a DImode register -- the DECL_RESULT has
13745 SImode but the DECL_RTL for the DECL_RESULT has DImode. So,
13746 here, we use the mode the back-end has already assigned for
13747 the return value. */
13748 DECL_RTL (decl) = gen_reg_rtx (GET_MODE (original_result_rtx));
13753 /* We have finished doing semantic analysis on DECL, but have not yet
13754 generated RTL for its body. Save away our current state, so that
13755 when we want to generate RTL later we know what to do. */
13758 save_function_data (decl)
13761 struct language_function *f;
13763 /* Save the language-specific per-function data so that we can
13764 get it back when we really expand this function. */
13765 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13769 f = ((struct language_function *)
13770 xmalloc (sizeof (struct language_function)));
13771 bcopy ((char *) cp_function_chain, (char *) f,
13772 sizeof (struct language_function));
13773 DECL_SAVED_FUNCTION_DATA (decl) = f;
13775 /* Clear out the bits we don't need. */
13776 f->x_base_init_list = NULL_TREE;
13777 f->x_member_init_list = NULL_TREE;
13778 f->x_stmt_tree.x_last_stmt = NULL_TREE;
13779 f->x_stmt_tree.x_last_expr_type = NULL_TREE;
13780 f->x_result_rtx = NULL_RTX;
13781 f->x_named_label_uses = NULL;
13782 f->bindings = NULL;
13784 /* When we get back here again, we will be expanding. */
13785 f->x_expanding_p = 1;
13787 /* If we've already decided that we cannot inline this function, we
13788 must remember that fact when we actually go to expand the
13790 f->cannot_inline = current_function_cannot_inline;
13793 /* At the end of every constructor we generate to code to return
13794 `this'. Do that now. */
13797 finish_constructor_body ()
13799 /* Any return from a constructor will end up here. */
13801 add_tree (build_min_nt (LABEL_STMT, ctor_label));
13803 /* Clear CTOR_LABEL so that finish_return_stmt knows to really
13804 generate the return, rather than a goto to CTOR_LABEL. */
13805 ctor_label = NULL_TREE;
13806 /* In check_return_expr we translate an empty return from a
13807 constructor to a return of `this'. */
13808 finish_return_stmt (NULL_TREE);
13809 /* Mark the end of the constructor. */
13810 add_tree (build_min_nt (CTOR_STMT));
13813 /* At the end of every destructor we generate code to restore virtual
13814 function tables to the values desired by base classes and to call
13815 to base class destructors. Do that now. */
13818 finish_destructor_body ()
13820 tree compound_stmt;
13825 /* Create a block to contain all the extra code. */
13826 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13828 /* Any return from a destructor will end up here. */
13829 add_tree (build_min_nt (LABEL_STMT, dtor_label));
13831 /* Generate the code to call destructor on base class. If this
13832 destructor belongs to a class with virtual functions, then set
13833 the virtual function table pointer to represent the type of our
13836 /* This side-effect makes call to `build_delete' generate the code
13837 we have to have at the end of this destructor. `build_delete'
13838 will set the flag again. */
13839 TYPE_HAS_DESTRUCTOR (current_class_type) = 0;
13841 exprstmt = build_delete (current_class_type,
13844 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
13847 if (exprstmt != error_mark_node
13848 && (TREE_CODE (exprstmt) != NOP_EXPR
13849 || TREE_OPERAND (exprstmt, 0) != integer_zero_node
13850 || TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)))
13852 if (exprstmt != void_zero_node)
13853 /* Don't call `expand_expr_stmt' if we're not going to do
13854 anything, since -Wall will give a diagnostic. */
13855 finish_expr_stmt (exprstmt);
13857 /* Run destructors for all virtual baseclasses. */
13858 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
13860 tree vbases = nreverse (copy_list (CLASSTYPE_VBASECLASSES (current_class_type)));
13861 tree if_stmt = begin_if_stmt ();
13862 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13863 current_in_charge_parm,
13869 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (vbases)))
13871 tree vb = get_vbase
13872 (BINFO_TYPE (vbases),
13873 TYPE_BINFO (current_class_type));
13875 (build_scoped_method_call
13876 (current_class_ref, vb, complete_dtor_identifier,
13879 vbases = TREE_CHAIN (vbases);
13882 finish_then_clause (if_stmt);
13887 virtual_size = c_sizeof (current_class_type);
13889 /* At the end, call delete if that's what's requested. */
13891 /* FDIS sez: At the point of definition of a virtual destructor
13892 (including an implicit definition), non-placement operator delete
13893 shall be looked up in the scope of the destructor's class and if
13894 found shall be accessible and unambiguous.
13896 This is somewhat unclear, but I take it to mean that if the class
13897 only defines placement deletes we don't do anything here. So we
13898 pass LOOKUP_SPECULATIVELY; delete_sanity will complain for us if
13899 they ever try to delete one of these. */
13900 exprstmt = build_op_delete_call
13901 (DELETE_EXPR, current_class_ptr, virtual_size,
13902 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13904 if_stmt = begin_if_stmt ();
13905 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13906 current_in_charge_parm,
13909 finish_expr_stmt (exprstmt);
13910 finish_then_clause (if_stmt);
13913 /* Close the block we started above. */
13914 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13917 /* Finish up a function declaration and compile that function
13918 all the way to assembler language output. The free the storage
13919 for the function definition.
13921 FLAGS is a bitwise or of the following values:
13923 An extra call to poplevel (and expand_end_bindings) must be
13924 made to take care of the binding contour for the base
13925 initializers. This is only relevant for constructors.
13927 We just finished processing the body of an in-class inline
13928 function definition. (This processing will have taken place
13929 after the class definition is complete.) */
13932 finish_function (flags)
13935 register tree fndecl = current_function_decl;
13936 tree fntype, ctype = NULL_TREE;
13937 /* Label to use if this function is supposed to return a value. */
13938 tree no_return_label = NULL_TREE;
13939 int call_poplevel = (flags & 1) != 0;
13940 int inclass_inline = (flags & 2) != 0;
13943 int current_line = lineno;
13945 /* When we get some parse errors, we can end up without a
13946 current_function_decl, so cope. */
13947 if (fndecl == NULL_TREE)
13948 return error_mark_node;
13950 nested = function_depth > 1;
13951 fntype = TREE_TYPE (fndecl);
13953 /* TREE_READONLY (fndecl) = 1;
13954 This caused &foo to be of type ptr-to-const-function
13955 which then got a warning when stored in a ptr-to-function variable. */
13957 /* This happens on strange parse errors. */
13958 if (! current_function_parms_stored)
13961 store_parm_decls ();
13964 /* For a cloned function, we've already got all the code we need;
13965 there's no need to add any extra bits. */
13966 if (building_stmt_tree () && DECL_CLONED_FUNCTION_P (fndecl))
13968 else if (building_stmt_tree ())
13970 if (DECL_CONSTRUCTOR_P (fndecl))
13972 finish_constructor_body ();
13976 else if (DECL_DESTRUCTOR_P (fndecl) && !processing_template_decl)
13977 finish_destructor_body ();
13978 else if (DECL_MAIN_P (fndecl))
13980 /* Make it so that `main' always returns 0 by default. */
13982 finish_return_stmt (integer_one_node);
13984 finish_return_stmt (integer_zero_node);
13988 /* Finish dealing with exception specifiers. */
13989 if (flag_exceptions && !processing_template_decl
13990 && flag_enforce_eh_specs
13991 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13992 expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS
13993 (TREE_TYPE (current_function_decl)),
13994 current_eh_spec_try_block);
13999 if (write_symbols != NO_DEBUG /*&& TREE_CODE (fntype) != METHOD_TYPE*/)
14001 /* Keep this code around in case we later want to control debug info
14002 based on whether a type is "used". (jason 1999-11-11) */
14004 tree ttype = target_type (fntype);
14007 if (IS_AGGR_TYPE (ttype))
14008 /* Let debugger know it should output info for this type. */
14009 note_debug_info_needed (ttype);
14011 for (parmdecl = DECL_ARGUMENTS (fndecl); parmdecl; parmdecl = TREE_CHAIN (parmdecl))
14013 ttype = target_type (TREE_TYPE (parmdecl));
14014 if (IS_AGGR_TYPE (ttype))
14015 /* Let debugger know it should output info for this type. */
14016 note_debug_info_needed (ttype);
14021 /* Clean house because we will need to reorder insns here. */
14022 do_pending_stack_adjust ();
14026 else if (DECL_CONSTRUCTOR_P (fndecl))
14031 else if (return_label != NULL_RTX
14032 && flag_this_is_variable <= 0
14033 && current_function_return_value == NULL_TREE
14034 && ! DECL_NAME (DECL_RESULT (current_function_decl)))
14035 no_return_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
14037 if (flag_exceptions)
14038 expand_exception_blocks ();
14040 /* If this function is supposed to return a value, ensure that
14041 we do not fall into the cleanups by mistake. The end of our
14042 function will look like this:
14044 user code (may have return stmt somewhere)
14045 goto no_return_label
14050 NOTE_INSN_FUNCTION_END
14054 If the user omits a return stmt in the USER CODE section, we
14055 will have a control path which reaches NOTE_INSN_FUNCTION_END.
14056 Otherwise, we won't. */
14057 if (no_return_label)
14059 DECL_CONTEXT (no_return_label) = fndecl;
14060 DECL_INITIAL (no_return_label) = error_mark_node;
14061 DECL_SOURCE_FILE (no_return_label) = input_filename;
14062 DECL_SOURCE_LINE (no_return_label) = current_line;
14063 expand_goto (no_return_label);
14068 /* Remove the binding contour which is used
14069 to catch cleanup-generated temporaries. */
14070 expand_end_bindings (0, 0, 0);
14071 poplevel (0, 0, 0);
14073 /* Emit label at beginning of cleanup code for parameters. */
14074 emit_label (cleanup_label);
14077 /* Get return value into register if that's where it's supposed
14079 if (original_result_rtx)
14080 fixup_result_decl (DECL_RESULT (fndecl), original_result_rtx);
14082 /* Finish building code that will trigger warnings if users forget
14083 to make their functions return values. */
14084 if (no_return_label || cleanup_label)
14085 emit_jump (return_label);
14086 if (no_return_label)
14088 /* We don't need to call `expand_*_return' here because we
14089 don't need any cleanups here--this path of code is only
14090 for error checking purposes. */
14091 expand_label (no_return_label);
14094 /* We hard-wired immediate_size_expand to zero in
14095 start_function. Expand_function_end will decrement this
14096 variable. So, we set the variable to one here, so that after
14097 the decrement it will remain zero. */
14098 immediate_size_expand = 1;
14100 /* Generate rtl for function exit. */
14101 expand_function_end (input_filename, current_line, 1);
14104 /* We have to save this value here in case
14105 maybe_end_member_template_processing decides to pop all the
14106 template parameters. */
14107 expand_p = !building_stmt_tree ();
14109 /* If we're saving up tree structure, tie off the function now. */
14111 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14113 /* This must come after expand_function_end because cleanups might
14114 have declarations (from inline functions) that need to go into
14115 this function's blocks. */
14116 if (doing_semantic_analysis_p ())
14118 if (current_binding_level->parm_flag != 1)
14119 my_friendly_abort (122);
14120 poplevel (1, 0, 1);
14123 /* Remember that we were in class scope. */
14124 if (current_class_name)
14125 ctype = current_class_type;
14127 /* Must mark the RESULT_DECL as being in this function. */
14128 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14130 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14131 to the FUNCTION_DECL node itself. */
14132 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14134 /* Save away current state, if appropriate. */
14135 if (!expanding_p && !processing_template_decl)
14136 save_function_data (fndecl);
14138 /* If this function calls `setjmp' it cannot be inlined. When
14139 `longjmp' is called it is not guaranteed to restore the value of
14140 local variables that have been modified since the call to
14141 `setjmp'. So, if were to inline this function into some caller
14142 `c', then when we `longjmp', we might not restore all variables
14143 in `c'. (It might seem, at first blush, that there's no way for
14144 this function to modify local variables in `c', but their
14145 addresses may have been stored somewhere accessible to this
14147 if (!expanding_p && !processing_template_decl && calls_setjmp_p (fndecl))
14148 DECL_UNINLINABLE (fndecl) = 1;
14155 /* So we can tell if jump_optimize sets it to 1. */
14158 /* Before we call rest_of_compilation (which will pop the
14159 CURRENT_FUNCTION), we must save these values. */
14160 returns_null = current_function_returns_null;
14161 returns_value = current_function_returns_value;
14163 /* If this is a nested function (like a template instantiation
14164 that we're compiling in the midst of compiling something
14165 else), push a new GC context. That will keep local variables
14166 on the stack from being collected while we're doing the
14167 compilation of this function. */
14168 if (function_depth > 1)
14169 ggc_push_context ();
14171 /* Run the optimizers and output the assembler code for this
14173 if (DECL_ARTIFICIAL (fndecl))
14175 /* Do we really *want* to inline this synthesized method? */
14177 int save_fif = flag_inline_functions;
14178 flag_inline_functions = 1;
14180 /* Turn off DECL_INLINE for the moment so function_cannot_inline_p
14181 will check our size. */
14182 DECL_INLINE (fndecl) = 0;
14184 rest_of_compilation (fndecl);
14185 flag_inline_functions = save_fif;
14188 rest_of_compilation (fndecl);
14190 /* Undo the call to ggc_push_context above. */
14191 if (function_depth > 1)
14192 ggc_pop_context ();
14194 if (DECL_SAVED_INSNS (fndecl) && ! TREE_ASM_WRITTEN (fndecl))
14196 /* Set DECL_EXTERNAL so that assemble_external will be called as
14197 necessary. We'll clear it again in finish_file. */
14198 if (! DECL_EXTERNAL (fndecl))
14199 DECL_NOT_REALLY_EXTERN (fndecl) = 1;
14200 DECL_EXTERNAL (fndecl) = 1;
14205 /* Keep this code around in case we later want to control debug info
14206 based on whether a type is "used". (jason 1999-11-11) */
14208 if (ctype && TREE_ASM_WRITTEN (fndecl))
14209 note_debug_info_needed (ctype);
14212 returns_null |= can_reach_end;
14214 /* Since we don't normally go through c_expand_return for constructors,
14215 this normally gets the wrong value.
14216 Also, named return values have their return codes emitted after
14217 NOTE_INSN_FUNCTION_END, confusing jump.c. */
14218 if (DECL_CONSTRUCTOR_P (fndecl)
14219 || DECL_NAME (DECL_RESULT (fndecl)) != NULL_TREE)
14222 if (TREE_THIS_VOLATILE (fndecl) && returns_null)
14223 cp_warning ("`noreturn' function `%D' does return", fndecl);
14224 else if ((warn_return_type || pedantic)
14226 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE)
14228 /* If this function returns non-void and control can drop through,
14230 cp_warning ("control reaches end of non-void function `%D'", fndecl);
14232 /* With just -W, complain only if function returns both with
14233 and without a value. */
14234 else if (extra_warnings && returns_value && returns_null)
14235 warning ("this function may return with or without a value");
14239 /* Clear out memory we no longer need. */
14240 free_after_parsing (cfun);
14241 /* Since we never call rest_of_compilation, we never clear
14242 CFUN. Do so explicitly. */
14243 free_after_compilation (cfun);
14247 /* If this is a in-class inline definition, we may have to pop the
14248 bindings for the template parameters that we added in
14249 maybe_begin_member_template_processing when start_function was
14251 if (inclass_inline)
14252 maybe_end_member_template_processing ();
14254 /* Leave the scope of the class. */
14256 pop_nested_class ();
14260 if (!DECL_SAVED_INSNS (fndecl) && !DECL_SAVED_FUNCTION_DATA (fndecl)
14261 && !(flag_inline_trees && DECL_INLINE (fndecl)))
14265 /* Stop pointing to the local nodes about to be freed. */
14266 /* But DECL_INITIAL must remain nonzero so we know this
14267 was an actual function definition. */
14268 DECL_INITIAL (fndecl) = error_mark_node;
14269 for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t))
14270 DECL_RTL (t) = DECL_INCOMING_RTL (t) = NULL_RTX;
14273 if (DECL_STATIC_CONSTRUCTOR (fndecl))
14274 static_ctors = tree_cons (NULL_TREE, fndecl, static_ctors);
14275 if (DECL_STATIC_DESTRUCTOR (fndecl))
14276 static_dtors = tree_cons (NULL_TREE, fndecl, static_dtors);
14281 /* Let the error reporting routines know that we're outside a
14282 function. For a nested function, this value is used in
14283 pop_cp_function_context and then reset via pop_function_context. */
14284 current_function_decl = NULL_TREE;
14285 /* We don't really care about obstacks, but the middle-end
14286 sometimes cares on what obstck things are located. */
14287 permanent_allocation (1);
14293 /* Create the FUNCTION_DECL for a function definition.
14294 DECLSPECS and DECLARATOR are the parts of the declaration;
14295 they describe the return type and the name of the function,
14296 but twisted together in a fashion that parallels the syntax of C.
14298 This function creates a binding context for the function body
14299 as well as setting up the FUNCTION_DECL in current_function_decl.
14301 Returns a FUNCTION_DECL on success.
14303 If the DECLARATOR is not suitable for a function (it defines a datum
14304 instead), we return 0, which tells yyparse to report a parse error.
14306 May return void_type_node indicating that this method is actually
14307 a friend. See grokfield for more details.
14309 Came here with a `.pushlevel' .
14311 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14312 CHANGES TO CODE IN `grokfield'. */
14315 start_method (declspecs, declarator, attrlist)
14316 tree declarator, declspecs, attrlist;
14318 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14321 /* Something too ugly to handle. */
14322 if (fndecl == NULL_TREE)
14325 /* Pass friends other than inline friend functions back. */
14326 if (fndecl == void_type_node)
14329 if (TREE_CODE (fndecl) != FUNCTION_DECL)
14330 /* Not a function, tell parser to report parse error. */
14333 if (DECL_IN_AGGR_P (fndecl))
14335 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14337 if (DECL_CONTEXT (fndecl)
14338 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14339 cp_error ("`%D' is already defined in class %s", fndecl,
14340 TYPE_NAME_STRING (DECL_CONTEXT (fndecl)));
14342 return void_type_node;
14345 check_template_shadow (fndecl);
14347 DECL_THIS_INLINE (fndecl) = 1;
14349 if (flag_default_inline)
14350 DECL_INLINE (fndecl) = 1;
14352 /* We process method specializations in finish_struct_1. */
14353 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14354 fndecl = push_template_decl (fndecl);
14356 if (! DECL_FRIEND_P (fndecl))
14358 if (TREE_CHAIN (fndecl))
14360 fndecl = copy_node (fndecl);
14361 TREE_CHAIN (fndecl) = NULL_TREE;
14364 if (DECL_CONSTRUCTOR_P (fndecl))
14366 if (! grok_ctor_properties (current_class_type, fndecl))
14367 return void_type_node;
14369 else if (IDENTIFIER_OPNAME_P (DECL_NAME (fndecl)))
14370 grok_op_properties (fndecl, DECL_VIRTUAL_P (fndecl), 0);
14373 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14375 /* Make a place for the parms */
14377 current_binding_level->parm_flag = 1;
14379 DECL_IN_AGGR_P (fndecl) = 1;
14383 /* Go through the motions of finishing a function definition.
14384 We don't compile this method until after the whole class has
14387 FINISH_METHOD must return something that looks as though it
14388 came from GROKFIELD (since we are defining a method, after all).
14390 This is called after parsing the body of the function definition.
14391 STMTS is the chain of statements that makes up the function body.
14393 DECL is the ..._DECL that `start_method' provided. */
14396 finish_method (decl)
14399 register tree fndecl = decl;
14402 register tree link;
14404 if (decl == void_type_node)
14407 old_initial = DECL_INITIAL (fndecl);
14409 /* Undo the level for the parms (from start_method).
14410 This is like poplevel, but it causes nothing to be
14411 saved. Saving information here confuses symbol-table
14412 output routines. Besides, this information will
14413 be correctly output when this method is actually
14416 /* Clear out the meanings of the local variables of this level;
14417 also record in each decl which block it belongs to. */
14419 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14421 if (DECL_NAME (link) != NULL_TREE)
14422 pop_binding (DECL_NAME (link), link);
14423 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14424 DECL_CONTEXT (link) = NULL_TREE;
14427 GNU_xref_end_scope ((HOST_WIDE_INT) current_binding_level,
14428 (HOST_WIDE_INT) current_binding_level->level_chain,
14429 current_binding_level->parm_flag,
14430 current_binding_level->keep);
14432 poplevel (0, 0, 0);
14434 DECL_INITIAL (fndecl) = old_initial;
14436 /* We used to check if the context of FNDECL was different from
14437 current_class_type as another way to get inside here. This didn't work
14438 for String.cc in libg++. */
14439 if (DECL_FRIEND_P (fndecl))
14441 CLASSTYPE_INLINE_FRIENDS (current_class_type)
14442 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14443 decl = void_type_node;
14449 /* Called when a new struct TYPE is defined.
14450 If this structure or union completes the type of any previous
14451 variable declaration, lay it out and output its rtl. */
14454 hack_incomplete_structures (type)
14458 struct binding_level *level;
14460 if (!type) /* Don't do this for class templates. */
14463 if (namespace_bindings_p ())
14466 list = &namespace_scope_incomplete;
14470 level = innermost_nonclass_level ();
14471 list = &level->incomplete;
14478 tree decl = TREE_VALUE (*list);
14479 if ((decl && TREE_TYPE (decl) == type)
14480 || (TREE_TYPE (decl)
14481 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14482 && TREE_TYPE (TREE_TYPE (decl)) == type))
14484 int toplevel = toplevel_bindings_p ();
14485 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
14486 && TREE_TYPE (TREE_TYPE (decl)) == type)
14487 layout_type (TREE_TYPE (decl));
14488 layout_decl (decl, 0);
14489 rest_of_decl_compilation (decl, NULL_PTR, toplevel, 0);
14493 expand_decl (decl);
14494 cleanup = maybe_build_cleanup (decl);
14495 expand_decl_init (decl);
14496 if (! expand_decl_cleanup (decl, cleanup))
14497 cp_error ("parser lost in parsing declaration of `%D'",
14500 *list = TREE_CHAIN (*list);
14503 list = &TREE_CHAIN (*list);
14506 /* Keep looking through artificial binding levels generated
14507 for local variables. */
14508 if (level && level->keep == 2)
14510 level = level->level_chain;
14511 list = &level->incomplete;
14518 /* If DECL is of a type which needs a cleanup, build that cleanup here.
14519 See build_delete for information about AUTO_DELETE. */
14522 maybe_build_cleanup_1 (decl, auto_delete)
14523 tree decl, auto_delete;
14525 tree type = TREE_TYPE (decl);
14526 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14528 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14531 if (TREE_CODE (type) == ARRAY_TYPE)
14535 mark_addressable (decl);
14536 rval = build_unary_op (ADDR_EXPR, decl, 0);
14539 /* Optimize for space over speed here. */
14540 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14541 || flag_expensive_optimizations)
14542 flags |= LOOKUP_NONVIRTUAL;
14544 rval = build_delete (TREE_TYPE (rval), rval, auto_delete, flags, 0);
14546 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14547 && ! TYPE_HAS_DESTRUCTOR (type))
14548 rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14549 build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14556 /* If DECL is of a type which needs a cleanup, build that cleanup
14557 here. The cleanup does not free the storage with a call a delete. */
14560 maybe_build_cleanup (decl)
14563 return maybe_build_cleanup_1 (decl, integer_two_node);
14566 /* Expand a C++ expression at the statement level.
14567 This is needed to ferret out nodes which have UNKNOWN_TYPE.
14568 The C++ type checker should get all of these out when
14569 expressions are combined with other, type-providing, expressions,
14570 leaving only orphan expressions, such as:
14572 &class::bar; / / takes its address, but does nothing with it. */
14575 cplus_expand_expr_stmt (exp)
14579 /* We should do this eventually, but right now this causes regex.o from
14580 libg++ to miscompile, and tString to core dump. */
14581 exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp);
14584 /* If we don't do this, we end up down inside expand_expr
14585 trying to do TYPE_MODE on the ERROR_MARK, and really
14586 go outside the bounds of the type. */
14587 if (exp != error_mark_node)
14588 expand_expr_stmt (exp);
14591 /* When a stmt has been parsed, this function is called. */
14596 /* Always assume this statement was not an expression statement. If
14597 it actually was an expression statement, its our callers
14598 responsibility to fix this up. */
14599 last_expr_type = NULL_TREE;
14602 /* DECL was originally constructed as a non-static member function,
14603 but turned out to be static. Update it accordingly. */
14606 revert_static_member_fn (decl)
14610 tree function = TREE_TYPE (decl);
14611 tree args = TYPE_ARG_TYPES (function);
14613 if (CP_TYPE_QUALS (TREE_TYPE (TREE_VALUE (args)))
14614 != TYPE_UNQUALIFIED)
14615 cp_error ("static member function `%#D' declared with type qualifiers",
14618 args = TREE_CHAIN (args);
14619 tmp = build_function_type (TREE_TYPE (function), args);
14620 tmp = build_qualified_type (tmp, CP_TYPE_QUALS (function));
14621 tmp = build_exception_variant (tmp,
14622 TYPE_RAISES_EXCEPTIONS (function));
14623 TREE_TYPE (decl) = tmp;
14624 if (DECL_ARGUMENTS (decl))
14625 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14626 DECL_STATIC_FUNCTION_P (decl) = 1;
14629 /* Initialize the variables used during compilation of a C++
14633 push_cp_function_context (f)
14634 struct function *f;
14636 struct language_function *p
14637 = ((struct language_function *)
14638 xcalloc (1, sizeof (struct language_function)));
14641 /* It takes an explicit call to expand_body to generate RTL for a
14645 /* Whenever we start a new function, we destroy temporaries in the
14647 stmts_are_full_exprs_p = 1;
14650 /* Free the language-specific parts of F, now that we've finished
14651 compiling the function. */
14654 pop_cp_function_context (f)
14655 struct function *f;
14658 free (f->language);
14662 /* Mark P for GC. */
14665 mark_lang_function (p)
14666 struct language_function *p;
14671 ggc_mark_tree (p->x_named_labels);
14672 ggc_mark_tree (p->x_ctor_label);
14673 ggc_mark_tree (p->x_dtor_label);
14674 ggc_mark_tree (p->x_base_init_list);
14675 ggc_mark_tree (p->x_member_init_list);
14676 ggc_mark_tree (p->x_current_class_ptr);
14677 ggc_mark_tree (p->x_current_class_ref);
14678 ggc_mark_tree (p->x_eh_spec_try_block);
14679 ggc_mark_tree (p->x_scope_stmt_stack);
14681 ggc_mark_rtx (p->x_result_rtx);
14683 mark_stmt_tree (&p->x_stmt_tree);
14684 mark_binding_level (&p->bindings);
14687 /* Mark the language-specific data in F for GC. */
14690 mark_cp_function_context (f)
14691 struct function *f;
14693 mark_lang_function (f->language);
14697 lang_mark_false_label_stack (l)
14698 struct label_node *l;
14700 /* C++ doesn't use false_label_stack. It better be NULL. */
14701 my_friendly_assert (l == NULL, 19990904);
14708 enum tree_code code = TREE_CODE (t);
14709 if (code == IDENTIFIER_NODE)
14711 struct lang_identifier *li = (struct lang_identifier *) t;
14712 struct lang_id2 *li2 = li->x;
14713 ggc_mark_tree (li->namespace_bindings);
14714 ggc_mark_tree (li->bindings);
14715 ggc_mark_tree (li->class_value);
14716 ggc_mark_tree (li->class_template_info);
14720 ggc_mark_tree (li2->label_value);
14721 ggc_mark_tree (li2->implicit_decl);
14722 ggc_mark_tree (li2->error_locus);
14725 else if (code == CPLUS_BINDING)
14727 if (BINDING_HAS_LEVEL_P (t))
14728 mark_binding_level (&BINDING_LEVEL (t));
14730 ggc_mark_tree (BINDING_SCOPE (t));
14731 ggc_mark_tree (BINDING_VALUE (t));
14733 else if (code == OVERLOAD)
14734 ggc_mark_tree (OVL_FUNCTION (t));
14735 else if (code == TEMPLATE_PARM_INDEX)
14736 ggc_mark_tree (TEMPLATE_PARM_DECL (t));
14737 else if (TREE_CODE_CLASS (code) == 'd')
14739 struct lang_decl *ld = DECL_LANG_SPECIFIC (t);
14744 if (!DECL_GLOBAL_CTOR_P (t) && !DECL_GLOBAL_DTOR_P (t))
14745 ggc_mark_tree (ld->decl_flags.u2.access);
14746 ggc_mark_tree (ld->decl_flags.context);
14747 if (TREE_CODE (t) != NAMESPACE_DECL)
14748 ggc_mark_tree (ld->decl_flags.u.template_info);
14750 mark_binding_level (&NAMESPACE_LEVEL (t));
14751 if (CAN_HAVE_FULL_LANG_DECL_P (t))
14753 ggc_mark_tree (ld->befriending_classes);
14754 ggc_mark_tree (ld->saved_tree);
14755 ggc_mark_tree (ld->cloned_function);
14756 if (TREE_CODE (t) == TYPE_DECL)
14757 ggc_mark_tree (ld->u.sorted_fields);
14758 else if (TREE_CODE (t) == FUNCTION_DECL
14759 && !DECL_PENDING_INLINE_P (t))
14760 mark_lang_function (DECL_SAVED_FUNCTION_DATA (t));
14764 else if (TREE_CODE_CLASS (code) == 't')
14766 struct lang_type *lt = TYPE_LANG_SPECIFIC (t);
14768 if (lt && !(TREE_CODE (t) == POINTER_TYPE
14769 && TREE_CODE (TREE_TYPE (t)) == METHOD_TYPE))
14772 ggc_mark_tree (lt->vfields);
14773 ggc_mark_tree (lt->vbases);
14774 ggc_mark_tree (lt->tags);
14775 ggc_mark_tree (lt->search_slot);
14776 ggc_mark_tree (lt->size);
14777 ggc_mark_tree (lt->pure_virtuals);
14778 ggc_mark_tree (lt->friend_classes);
14779 ggc_mark_tree (lt->rtti);
14780 ggc_mark_tree (lt->methods);
14781 ggc_mark_tree (lt->template_info);
14782 ggc_mark_tree (lt->befriending_classes);
14785 /* In the case of pointer-to-member function types, the
14786 TYPE_LANG_SPECIFIC is really just a tree. */
14787 ggc_mark_tree ((tree) lt);