1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC 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 GCC 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 GCC; 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. */
33 #include "coretypes.h"
40 #include "tree-inline.h"
51 #include "diagnostic.h"
55 static tree grokparms (tree);
56 static const char *redeclaration_error_message (tree, tree);
58 static void push_binding_level (struct cp_binding_level *, int,
60 static void pop_binding_level (void);
61 static void suspend_binding_level (void);
62 static void resume_binding_level (struct cp_binding_level *);
63 static struct cp_binding_level *make_binding_level (void);
64 static void declare_namespace_level (void);
65 static int decl_jump_unsafe (tree);
66 static void storedecls (tree);
67 static void require_complete_types_for_parms (tree);
68 static int ambi_op_p (enum tree_code);
69 static int unary_op_p (enum tree_code);
70 static cxx_saved_binding *store_bindings (tree, cxx_saved_binding *);
71 static tree lookup_tag_reverse (tree, tree);
72 static void push_local_name (tree);
73 static void warn_extern_redeclared_static (tree, tree);
74 static tree grok_reference_init (tree, tree, tree);
75 static tree grokfndecl (tree, tree, tree, tree, int,
76 enum overload_flags, tree,
77 tree, int, int, int, int, int, int, tree);
78 static tree grokvardecl (tree, tree, RID_BIT_TYPE *, int, int, tree);
79 static tree follow_tag_typedef (tree);
80 static tree lookup_tag (enum tree_code, tree,
81 struct cp_binding_level *, int);
82 static void set_identifier_type_value_with_scope
83 (tree, tree, struct cp_binding_level *);
84 static void record_unknown_type (tree, const char *);
85 static tree builtin_function_1 (const char *, tree, tree, int,
86 enum built_in_class, const char *,
88 static tree build_library_fn_1 (tree, enum tree_code, tree);
89 static int member_function_or_else (tree, tree, enum overload_flags);
90 static void bad_specifiers (tree, const char *, int, int, int, int,
92 static tree maybe_process_template_type_declaration
93 (tree, int, struct cp_binding_level*);
94 static void check_for_uninitialized_const_var (tree);
95 static hashval_t typename_hash (const void *);
96 static int typename_compare (const void *, const void *);
97 static void push_binding (tree, tree, struct cp_binding_level*);
98 static int add_binding (tree, tree);
99 static void pop_binding (tree, tree);
100 static tree local_variable_p_walkfn (tree *, int *, void *);
101 static tree find_binding (tree, tree);
102 static tree select_decl (tree, int);
103 static int lookup_flags (int, int);
104 static tree qualify_lookup (tree, int);
105 static tree record_builtin_java_type (const char *, int);
106 static const char *tag_name (enum tag_types code);
107 static void find_class_binding_level (void);
108 static struct cp_binding_level *innermost_nonclass_level (void);
109 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
110 static int walk_globals_r (tree, void*);
111 static int walk_vtables_r (tree, void*);
112 static void add_decl_to_level (tree, struct cp_binding_level *);
113 static tree make_label_decl (tree, int);
114 static void use_label (tree);
115 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
117 static void check_previous_goto (struct named_label_use_list *);
118 static void check_switch_goto (struct cp_binding_level *);
119 static void check_previous_gotos (tree);
120 static void pop_label (tree, tree);
121 static void pop_labels (tree);
122 static void maybe_deduce_size_from_array_init (tree, tree);
123 static void layout_var_decl (tree);
124 static void maybe_commonize_var (tree);
125 static tree check_initializer (tree, tree, int);
126 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
127 static void save_function_data (tree);
128 static void check_function_type (tree, tree);
129 static void begin_constructor_body (void);
130 static void finish_constructor_body (void);
131 static void begin_destructor_body (void);
132 static void finish_destructor_body (void);
133 static tree create_array_type_for_decl (tree, tree, tree);
134 static tree get_atexit_node (void);
135 static tree get_dso_handle_node (void);
136 static tree start_cleanup_fn (void);
137 static void end_cleanup_fn (void);
138 static tree cp_make_fname_decl (tree, int);
139 static void initialize_predefined_identifiers (void);
140 static tree check_special_function_return_type
141 (special_function_kind, tree, tree);
142 static tree push_cp_library_fn (enum tree_code, tree);
143 static tree build_cp_library_fn (tree, enum tree_code, tree);
144 static void store_parm_decls (tree);
145 static int cp_missing_noreturn_ok_p (tree);
146 static void initialize_local_var (tree, tree);
147 static void expand_static_init (tree, tree);
148 static tree next_initializable_field (tree);
149 static tree reshape_init (tree, tree *);
150 static tree build_typename_type (tree, tree, tree);
152 #if defined (DEBUG_BINDING_LEVELS)
153 static void indent (void);
156 /* Erroneous argument lists can use this *IFF* they do not modify it. */
157 tree error_mark_list;
159 /* The following symbols are subsumed in the cp_global_trees array, and
160 listed here individually for documentation purposes.
163 tree wchar_decl_node;
165 tree vtable_entry_type;
166 tree delta_type_node;
167 tree __t_desc_type_node;
168 tree ti_desc_type_node;
169 tree bltn_desc_type_node, ptr_desc_type_node;
170 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
171 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
172 tree ptm_desc_type_node;
173 tree base_desc_type_node;
175 tree class_type_node, record_type_node, union_type_node, enum_type_node;
176 tree unknown_type_node;
178 Array type `vtable_entry_type[]'
181 tree vtbl_ptr_type_node;
188 A FUNCTION_DECL which can call `abort'. Not necessarily the
189 one that the user will declare, but sufficient to be called
190 by routines that want to abort the program.
194 The FUNCTION_DECL for the default `::operator delete'.
196 tree global_delete_fndecl;
199 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
204 tree cp_global_trees[CPTI_MAX];
206 /* Indicates that there is a type value in some namespace, although
207 that is not necessarily in scope at the moment. */
209 static GTY(()) tree global_type_node;
211 /* Used only for jumps to as-yet undefined labels, since jumps to
212 defined labels can have their validity checked immediately. */
214 struct named_label_use_list GTY(())
216 struct cp_binding_level *binding_level;
219 const char *filename_o_goto;
221 struct named_label_use_list *next;
224 #define named_label_uses cp_function_chain->x_named_label_uses
226 #define local_names cp_function_chain->x_local_names
228 /* A list of objects which have constructors or destructors
229 which reside in the global scope. The decl is stored in
230 the TREE_VALUE slot and the initializer is stored
231 in the TREE_PURPOSE slot. */
232 tree static_aggregates;
236 /* A node for the integer constants 2, and 3. */
238 tree integer_two_node, integer_three_node;
240 /* Similar, for last_function_parm_tags. */
241 tree last_function_parms;
243 /* A list of all LABEL_DECLs in the function that have names. Here so
244 we can clear out their names' definitions at the end of the
245 function, and so we can check the validity of jumps to these labels. */
247 struct named_label_list GTY(())
249 struct cp_binding_level *binding_level;
254 struct named_label_list *next;
255 unsigned int in_try_scope : 1;
256 unsigned int in_catch_scope : 1;
259 #define named_labels cp_function_chain->x_named_labels
261 /* The name of the anonymous namespace, throughout this translation
263 tree anonymous_namespace_name;
265 /* The number of function bodies which we are currently processing.
266 (Zero if we are at namespace scope, one inside the body of a
267 function, two inside the body of a function in a local class, etc.) */
270 /* States indicating how grokdeclarator() should handle declspecs marked
271 with __attribute__((deprecated)). An object declared as
272 __attribute__((deprecated)) suppresses warnings of uses of other
275 enum deprecated_states {
280 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
282 /* Set by add_implicitly_declared_members() to keep those members from
283 being flagged as deprecated or reported as using deprecated
285 int adding_implicit_members = 0;
287 /* True if a declaration with an `extern' linkage specifier is being
289 bool have_extern_spec;
292 /* For each binding contour we allocate a binding_level structure
293 which records the names defined in that contour.
296 1) one for each function definition,
297 where internal declarations of the parameters appear.
298 2) one for each compound statement,
299 to record its declarations.
301 The current meaning of a name can be found by searching the levels
302 from the current one out to the global one.
304 Off to the side, may be the class_binding_level. This exists only
305 to catch class-local declarations. It is otherwise nonexistent.
307 Also there may be binding levels that catch cleanups that must be
308 run when exceptions occur. Thus, to see whether a name is bound in
309 the current scope, it is not enough to look in the
310 CURRENT_BINDING_LEVEL. You should use lookup_name_current_level
313 /* Note that the information in the `names' component of the global contour
314 is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
316 struct cp_binding_level GTY(())
318 /* A chain of _DECL nodes for all variables, constants, functions,
319 and typedef types. These are in the reverse of the order
320 supplied. There may be OVERLOADs on this list, too, but they
321 are wrapped in TREE_LISTs; the TREE_VALUE is the OVERLOAD. */
324 /* Count of elements in names chain. */
327 /* A chain of NAMESPACE_DECL nodes. */
330 /* An array of static functions and variables (for namespaces only) */
331 varray_type static_decls;
333 /* A chain of VTABLE_DECL nodes. */
336 /* A list of structure, union and enum definitions, for looking up
338 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
339 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
340 or ENUMERAL_TYPE node.
342 C++: the TREE_VALUE nodes can be simple types for
343 component_bindings. */
346 /* A list of USING_DECL nodes. */
349 /* A list of used namespaces. PURPOSE is the namespace,
350 VALUE the common ancestor with this binding_level's namespace. */
351 tree using_directives;
353 /* If this binding level is the binding level for a class, then
354 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
355 is the name of an entity bound in the class. The TREE_TYPE is
356 the DECL bound by this name in the class. */
359 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
360 is used for all binding levels. In addition the TREE_VALUE is the
361 IDENTIFIER_TYPE_VALUE before we entered the class. */
364 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
365 label in this scope. The TREE_PURPOSE is the previous value of
366 the IDENTIFIER_LABEL VALUE. */
367 tree shadowed_labels;
369 /* For each level (except not the global one),
370 a chain of BLOCK nodes for all the levels
371 that were entered and exited one level down. */
374 /* The _TYPE node for this level, if parm_flag == 2. */
377 /* The binding level which this one is contained in (inherits from). */
378 struct cp_binding_level *level_chain;
380 /* List of VAR_DECLS saved from a previous for statement.
381 These would be dead in ISO-conforming code, but might
382 be referenced in ARM-era code. These are stored in a
383 TREE_LIST; the TREE_VALUE is the actual declaration. */
384 tree dead_vars_from_for;
386 /* 1 for the level that holds the parameters of a function.
387 2 for the level that holds a class declaration. */
388 unsigned parm_flag : 2;
390 /* 1 means make a BLOCK for this level regardless of all else.
391 2 for temporary binding contours created by the compiler. */
394 /* Nonzero if this level "doesn't exist" for tags. */
395 unsigned tag_transparent : 1;
397 /* Nonzero if this level can safely have additional
398 cleanup-needing variables added to it. */
399 unsigned more_cleanups_ok : 1;
400 unsigned have_cleanups : 1;
402 /* Nonzero if this scope is for storing the decls for template
403 parameters and generic decls; these decls will be discarded and
404 replaced with a TEMPLATE_DECL. */
405 unsigned template_parms_p : 1;
407 /* Nonzero if this scope corresponds to the `<>' in a
408 `template <>' clause. Whenever this flag is set,
409 TEMPLATE_PARMS_P will be set as well. */
410 unsigned template_spec_p : 1;
412 /* This is set for a namespace binding level. */
413 unsigned namespace_p : 1;
415 /* True if this level is that of a for-statement where we need to
416 worry about ambiguous (ARM or ISO) scope rules. */
417 unsigned is_for_scope : 1;
419 /* True if this level corresponds to a TRY block. Currently this
420 information is only available while building the tree structure. */
421 unsigned is_try_scope : 1;
423 /* True if this level corresponds to a CATCH block. Currently this
424 information is only available while building the tree structure. */
425 unsigned is_catch_scope : 1;
427 /* Three bits left for this word. */
429 /* Binding depth at which this level began. */
430 unsigned binding_depth;
433 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
435 /* The binding level currently in effect. */
437 #define current_binding_level \
438 (cfun && cp_function_chain->bindings \
439 ? cp_function_chain->bindings \
440 : scope_chain->bindings)
442 /* The binding level of the current class, if any. */
444 #define class_binding_level scope_chain->class_bindings
446 /* A chain of binding_level structures awaiting reuse. */
448 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
450 /* The outermost binding level, for names of file scope.
451 This is created when the compiler is started and exists
452 through the entire run. */
454 static GTY(()) struct cp_binding_level *global_binding_level;
456 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
458 static int keep_next_level_flag;
460 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
461 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
462 time the VAR_DECL was declared, the type was incomplete. */
464 static GTY(()) tree incomplete_vars;
466 #if defined(DEBUG_BINDING_LEVELS)
467 static int binding_depth = 0;
468 static int is_class_level = 0;
475 for (i = 0; i < binding_depth*2; i++)
478 #endif /* defined(DEBUG_BINDING_LEVELS) */
480 static tree pushdecl_with_scope (tree, struct cp_binding_level *);
483 push_binding_level (struct cp_binding_level *newlevel,
487 /* Add this level to the front of the chain (stack) of levels that
489 memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
490 newlevel->level_chain = current_binding_level;
491 current_binding_level = newlevel;
492 newlevel->tag_transparent = tag_transparent;
493 newlevel->more_cleanups_ok = 1;
495 newlevel->keep = keep;
496 #if defined(DEBUG_BINDING_LEVELS)
497 newlevel->binding_depth = binding_depth;
499 fprintf (stderr, "push %s level 0x%08x line %d\n",
500 (is_class_level) ? "class" : "block", newlevel, lineno);
503 #endif /* defined(DEBUG_BINDING_LEVELS) */
506 /* Find the innermost enclosing class scope, and reset
507 CLASS_BINDING_LEVEL appropriately. */
510 find_class_binding_level (void)
512 struct cp_binding_level *level = current_binding_level;
514 while (level && level->parm_flag != 2)
515 level = level->level_chain;
516 if (level && level->parm_flag == 2)
517 class_binding_level = level;
519 class_binding_level = 0;
523 pop_binding_level (void)
525 if (global_binding_level)
527 /* Cannot pop a level, if there are none left to pop. */
528 if (current_binding_level == global_binding_level)
531 /* Pop the current level, and free the structure for reuse. */
532 #if defined(DEBUG_BINDING_LEVELS)
535 fprintf (stderr, "pop %s level 0x%08x line %d\n",
536 (is_class_level) ? "class" : "block",
537 current_binding_level, lineno);
538 if (is_class_level != (current_binding_level == class_binding_level))
541 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
544 #endif /* defined(DEBUG_BINDING_LEVELS) */
546 register struct cp_binding_level *level = current_binding_level;
547 current_binding_level = current_binding_level->level_chain;
548 level->level_chain = free_binding_level;
549 #if 0 /* defined(DEBUG_BINDING_LEVELS) */
550 if (level->binding_depth != binding_depth)
552 #endif /* defined(DEBUG_BINDING_LEVELS) */
553 free_binding_level = level;
554 find_class_binding_level ();
559 suspend_binding_level (void)
561 if (class_binding_level)
562 current_binding_level = class_binding_level;
564 if (global_binding_level)
566 /* Cannot suspend a level, if there are none left to suspend. */
567 if (current_binding_level == global_binding_level)
570 /* Suspend the current level. */
571 #if defined(DEBUG_BINDING_LEVELS)
574 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
575 (is_class_level) ? "class" : "block",
576 current_binding_level, lineno);
577 if (is_class_level != (current_binding_level == class_binding_level))
580 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
583 #endif /* defined(DEBUG_BINDING_LEVELS) */
584 current_binding_level = current_binding_level->level_chain;
585 find_class_binding_level ();
589 resume_binding_level (struct cp_binding_level* b)
591 /* Resuming binding levels is meant only for namespaces,
592 and those cannot nest into classes. */
593 my_friendly_assert(!class_binding_level, 386);
594 /* Also, resuming a non-directly nested namespace is a no-no. */
595 my_friendly_assert(b->level_chain == current_binding_level, 386);
596 current_binding_level = b;
597 #if defined(DEBUG_BINDING_LEVELS)
598 b->binding_depth = binding_depth;
600 fprintf (stderr, "resume %s level 0x%08x line %d\n",
601 (is_class_level) ? "class" : "block", b, lineno);
604 #endif /* defined(DEBUG_BINDING_LEVELS) */
607 /* Create a new `struct cp_binding_level'. */
610 struct cp_binding_level *
611 make_binding_level (void)
614 return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
617 /* Nonzero if we are currently in the global binding level. */
620 global_bindings_p (void)
622 return current_binding_level == global_binding_level;
625 /* Return the innermost binding level that is not for a class scope. */
627 static struct cp_binding_level *
628 innermost_nonclass_level (void)
630 struct cp_binding_level *b;
632 b = current_binding_level;
633 while (b->parm_flag == 2)
639 /* Nonzero if we are currently in a toplevel binding level. This
640 means either the global binding level or a namespace in a toplevel
641 binding level. Since there are no non-toplevel namespace levels,
642 this really means any namespace or template parameter level. We
643 also include a class whose context is toplevel. */
646 toplevel_bindings_p (void)
648 struct cp_binding_level *b = innermost_nonclass_level ();
650 return b->namespace_p || b->template_parms_p;
653 /* Nonzero if this is a namespace scope, or if we are defining a class
654 which is itself at namespace scope, or whose enclosing class is
655 such a class, etc. */
658 namespace_bindings_p (void)
660 struct cp_binding_level *b = innermost_nonclass_level ();
662 return b->namespace_p;
665 /* If KEEP is nonzero, make a BLOCK node for the next binding level,
666 unconditionally. Otherwise, use the normal logic to decide whether
667 or not to create a BLOCK. */
670 keep_next_level (int keep)
672 keep_next_level_flag = keep;
675 /* Nonzero if the current level needs to have a BLOCK made. */
680 return (current_binding_level->blocks != NULL_TREE
681 || current_binding_level->keep
682 || current_binding_level->names != NULL_TREE
683 || (current_binding_level->tags != NULL_TREE
684 && !current_binding_level->tag_transparent));
688 declare_namespace_level (void)
690 current_binding_level->namespace_p = 1;
693 /* Returns nonzero if this scope was created to store template
697 template_parm_scope_p (void)
699 return current_binding_level->template_parms_p;
702 /* Returns the kind of template specialization we are currently
703 processing, given that it's declaration contained N_CLASS_SCOPES
704 explicit scope qualifications. */
707 current_tmpl_spec_kind (int n_class_scopes)
709 int n_template_parm_scopes = 0;
710 int seen_specialization_p = 0;
711 int innermost_specialization_p = 0;
712 struct cp_binding_level *b;
714 /* Scan through the template parameter scopes. */
715 for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
717 /* If we see a specialization scope inside a parameter scope,
718 then something is wrong. That corresponds to a declaration
721 template <class T> template <> ...
723 which is always invalid since [temp.expl.spec] forbids the
724 specialization of a class member template if the enclosing
725 class templates are not explicitly specialized as well. */
726 if (b->template_spec_p)
728 if (n_template_parm_scopes == 0)
729 innermost_specialization_p = 1;
731 seen_specialization_p = 1;
733 else if (seen_specialization_p == 1)
734 return tsk_invalid_member_spec;
736 ++n_template_parm_scopes;
739 /* Handle explicit instantiations. */
740 if (processing_explicit_instantiation)
742 if (n_template_parm_scopes != 0)
743 /* We've seen a template parameter list during an explicit
744 instantiation. For example:
746 template <class T> template void f(int);
748 This is erroneous. */
749 return tsk_invalid_expl_inst;
751 return tsk_expl_inst;
754 if (n_template_parm_scopes < n_class_scopes)
755 /* We've not seen enough template headers to match all the
756 specialized classes present. For example:
758 template <class T> void R<T>::S<T>::f(int);
760 This is invalid; there needs to be one set of template
761 parameters for each class. */
762 return tsk_insufficient_parms;
763 else if (n_template_parm_scopes == n_class_scopes)
764 /* We're processing a non-template declaration (even though it may
765 be a member of a template class.) For example:
767 template <class T> void S<T>::f(int);
769 The `class T' maches the `S<T>', leaving no template headers
770 corresponding to the `f'. */
772 else if (n_template_parm_scopes > n_class_scopes + 1)
773 /* We've got too many template headers. For example:
775 template <> template <class T> void f (T);
777 There need to be more enclosing classes. */
778 return tsk_excessive_parms;
780 /* This must be a template. It's of the form:
782 template <class T> template <class U> void S<T>::f(U);
784 This is a specialization if the innermost level was a
785 specialization; otherwise it's just a definition of the
787 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
791 set_class_shadows (tree shadows)
793 class_binding_level->class_shadowed = shadows;
796 /* Enter a new binding level.
797 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
798 not for that of tags. */
801 pushlevel (int tag_transparent)
803 struct cp_binding_level *newlevel;
805 if (cfun && !doing_semantic_analysis_p ())
808 /* Reuse or create a struct for this binding level. */
809 #if defined(DEBUG_BINDING_LEVELS)
811 #else /* !defined(DEBUG_BINDING_LEVELS) */
812 if (free_binding_level)
813 #endif /* !defined(DEBUG_BINDING_LEVELS) */
815 newlevel = free_binding_level;
816 free_binding_level = free_binding_level->level_chain;
819 newlevel = make_binding_level ();
821 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
822 keep_next_level_flag = 0;
825 /* We're defining an object of type TYPE. If it needs a cleanup, but
826 we're not allowed to add any more objects with cleanups to the current
827 scope, create a new binding level. */
830 maybe_push_cleanup_level (tree type)
832 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
833 && current_binding_level->more_cleanups_ok == 0)
838 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
842 /* Enter a new scope. The KIND indicates what kind of scope is being
846 begin_scope (scope_kind sk)
856 current_binding_level->is_try_scope = 1;
860 current_binding_level->is_catch_scope = 1;
864 current_binding_level->is_for_scope = 1;
867 case sk_template_spec:
868 current_binding_level->template_spec_p = 1;
871 case sk_template_parms:
872 current_binding_level->template_parms_p = 1;
880 /* Exit the current scope. */
888 /* For a binding between a name and an entity at a block scope,
889 this is the `struct cp_binding_level' for the block. */
890 #define BINDING_LEVEL(NODE) \
891 (((struct tree_binding*)(NODE))->scope.level)
893 /* A free list of CPLUS_BINDING nodes, connected by their
896 static GTY((deletable (""))) tree free_bindings;
898 /* Make DECL the innermost binding for ID. The LEVEL is the binding
899 level at which this declaration is being bound. */
902 push_binding (tree id,
904 struct cp_binding_level* level)
910 binding = free_bindings;
911 free_bindings = TREE_CHAIN (binding);
914 binding = make_node (CPLUS_BINDING);
916 /* Now, fill in the binding information. */
917 BINDING_VALUE (binding) = decl;
918 BINDING_TYPE (binding) = NULL_TREE;
919 BINDING_LEVEL (binding) = level;
920 INHERITED_VALUE_BINDING_P (binding) = 0;
921 LOCAL_BINDING_P (binding) = (level != class_binding_level);
922 BINDING_HAS_LEVEL_P (binding) = 1;
924 /* And put it on the front of the list of bindings for ID. */
925 TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
926 IDENTIFIER_BINDING (id) = binding;
929 /* ID is already bound in the current scope. But, DECL is an
930 additional binding for ID in the same scope. This is the `struct
931 stat' hack whereby a non-typedef class-name or enum-name can be
932 bound at the same level as some other kind of entity. It's the
933 responsibility of the caller to check that inserting this name is
934 valid here. Returns nonzero if the new binding was successful. */
936 add_binding (tree id, tree decl)
938 tree binding = IDENTIFIER_BINDING (id);
941 timevar_push (TV_NAME_LOOKUP);
942 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
943 /* The new name is the type name. */
944 BINDING_TYPE (binding) = decl;
945 else if (!BINDING_VALUE (binding))
946 /* This situation arises when push_class_level_binding moves an
947 inherited type-binding out of the way to make room for a new
949 BINDING_VALUE (binding) = decl;
950 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
951 && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
953 /* The old binding was a type name. It was placed in
954 BINDING_VALUE because it was thought, at the point it was
955 declared, to be the only entity with such a name. Move the
956 type name into the type slot; it is now hidden by the new
958 BINDING_TYPE (binding) = BINDING_VALUE (binding);
959 BINDING_VALUE (binding) = decl;
960 INHERITED_VALUE_BINDING_P (binding) = 0;
962 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
963 && TREE_CODE (decl) == TYPE_DECL
964 && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
965 && (same_type_p (TREE_TYPE (decl),
966 TREE_TYPE (BINDING_VALUE (binding)))
967 /* If either type involves template parameters, we must
968 wait until instantiation. */
969 || uses_template_parms (TREE_TYPE (decl))
970 || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
971 /* We have two typedef-names, both naming the same type to have
972 the same name. This is OK because of:
976 In a given scope, a typedef specifier can be used to redefine
977 the name of any type declared in that scope to refer to the
978 type to which it already refers. */
980 /* There can be two block-scope declarations of the same variable,
981 so long as they are `extern' declarations. */
982 else if (TREE_CODE (decl) == VAR_DECL
983 && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
984 && DECL_EXTERNAL (decl)
985 && DECL_EXTERNAL (BINDING_VALUE (binding)))
987 duplicate_decls (decl, BINDING_VALUE (binding));
992 error ("declaration of `%#D'", decl);
993 cp_error_at ("conflicts with previous declaration `%#D'",
994 BINDING_VALUE (binding));
998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
1001 /* Add DECL to the list of things declared in B. */
1004 add_decl_to_level (tree decl,
1005 struct cp_binding_level* b)
1007 if (TREE_CODE (decl) == NAMESPACE_DECL
1008 && !DECL_NAMESPACE_ALIAS (decl))
1010 TREE_CHAIN (decl) = b->namespaces;
1011 b->namespaces = decl;
1013 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
1015 TREE_CHAIN (decl) = b->vtables;
1020 /* We build up the list in reverse order, and reverse it later if
1022 TREE_CHAIN (decl) = b->names;
1026 /* If appropriate, add decl to separate list of statics */
1028 if ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
1029 || (TREE_CODE (decl) == FUNCTION_DECL
1030 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
1031 VARRAY_PUSH_TREE (b->static_decls, decl);
1035 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1036 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1037 doesn't really belong to this binding level, that it got here
1038 through a using-declaration. */
1041 push_local_binding (tree id, tree decl, int flags)
1043 struct cp_binding_level *b;
1045 /* Skip over any local classes. This makes sense if we call
1046 push_local_binding with a friend decl of a local class. */
1047 b = current_binding_level;
1048 while (b->parm_flag == 2)
1051 if (lookup_name_current_level (id))
1053 /* Supplement the existing binding. */
1054 if (!add_binding (id, decl))
1055 /* It didn't work. Something else must be bound at this
1056 level. Do not add DECL to the list of things to pop
1061 /* Create a new binding. */
1062 push_binding (id, decl, b);
1064 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1065 /* We must put the OVERLOAD into a TREE_LIST since the
1066 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1067 decls that got here through a using-declaration. */
1068 decl = build_tree_list (NULL_TREE, decl);
1070 /* And put DECL on the list of things declared by the current
1072 add_decl_to_level (decl, b);
1075 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1076 binding was successful. */
1079 push_class_binding (tree id, tree decl)
1082 tree binding = IDENTIFIER_BINDING (id);
1085 timevar_push (TV_NAME_LOOKUP);
1086 /* Note that we declared this value so that we can issue an error if
1087 this is an invalid redeclaration of a name already used for some
1089 note_name_declared_in_class (id, decl);
1091 if (binding && BINDING_LEVEL (binding) == class_binding_level)
1092 /* Supplement the existing binding. */
1093 result = add_binding (id, decl);
1095 /* Create a new binding. */
1096 push_binding (id, decl, class_binding_level);
1098 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1099 class-level declaration. Note that we do not use DECL here
1100 because of the possibility of the `struct stat' hack; if DECL is
1101 a class-name or enum-name we might prefer a field-name, or some
1103 IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1105 /* If this is a binding from a base class, mark it as such. */
1106 binding = IDENTIFIER_BINDING (id);
1107 if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1109 if (TREE_CODE (decl) == OVERLOAD)
1110 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1113 my_friendly_assert (DECL_P (decl), 0);
1114 context = context_for_name_lookup (decl);
1117 if (is_properly_derived_from (current_class_type, context))
1118 INHERITED_VALUE_BINDING_P (binding) = 1;
1120 INHERITED_VALUE_BINDING_P (binding) = 0;
1122 else if (BINDING_VALUE (binding) == decl)
1123 /* We only encounter a TREE_LIST when push_class_decls detects an
1124 ambiguity. Such an ambiguity can be overridden by a definition
1126 INHERITED_VALUE_BINDING_P (binding) = 1;
1128 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
1131 /* Remove the binding for DECL which should be the innermost binding
1135 pop_binding (tree id, tree decl)
1139 if (id == NULL_TREE)
1140 /* It's easiest to write the loops that call this function without
1141 checking whether or not the entities involved have names. We
1142 get here for such an entity. */
1145 /* Get the innermost binding for ID. */
1146 binding = IDENTIFIER_BINDING (id);
1148 /* The name should be bound. */
1149 my_friendly_assert (binding != NULL_TREE, 0);
1151 /* The DECL will be either the ordinary binding or the type
1152 binding for this identifier. Remove that binding. */
1153 if (BINDING_VALUE (binding) == decl)
1154 BINDING_VALUE (binding) = NULL_TREE;
1155 else if (BINDING_TYPE (binding) == decl)
1156 BINDING_TYPE (binding) = NULL_TREE;
1160 if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1162 /* We're completely done with the innermost binding for this
1163 identifier. Unhook it from the list of bindings. */
1164 IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1166 /* Add it to the free list. */
1167 TREE_CHAIN (binding) = free_bindings;
1168 free_bindings = binding;
1170 /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1172 BINDING_LEVEL (binding) = NULL;
1176 /* When a label goes out of scope, check to see if that label was used
1177 in a valid manner, and issue any appropriate warnings or errors. */
1180 pop_label (tree label, tree old_value)
1182 if (!processing_template_decl && doing_semantic_analysis_p ())
1184 if (DECL_INITIAL (label) == NULL_TREE)
1186 cp_error_at ("label `%D' used but not defined", label);
1187 /* Avoid crashing later. */
1188 define_label (input_filename, 1, DECL_NAME (label));
1190 else if (warn_unused_label && !TREE_USED (label))
1191 cp_warning_at ("label `%D' defined but not used", label);
1194 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1197 /* At the end of a function, all labels declared within the function
1198 go out of scope. BLOCK is the top-level block for the
1202 pop_labels (tree block)
1204 struct named_label_list *link;
1206 /* Clear out the definitions of all label names, since their scopes
1208 for (link = named_labels; link; link = link->next)
1210 pop_label (link->label_decl, link->old_value);
1211 /* Put the labels into the "variables" of the top-level block,
1212 so debugger can see them. */
1213 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1214 BLOCK_VARS (block) = link->label_decl;
1217 named_labels = NULL;
1220 /* Exit a binding level.
1221 Pop the level off, and restore the state of the identifier-decl mappings
1222 that were in effect when this level was entered.
1224 If KEEP == 1, this level had explicit declarations, so
1225 and create a "block" (a BLOCK node) for the level
1226 to record its declarations and subblocks for symbol table output.
1228 If FUNCTIONBODY is nonzero, this level is the body of a function,
1229 so create a block as if KEEP were set and also clear out all
1232 If REVERSE is nonzero, reverse the order of decls before putting
1233 them into the BLOCK. */
1236 poplevel (int keep, int reverse, int functionbody)
1239 /* The chain of decls was accumulated in reverse order.
1240 Put it into forward order, just for cleanliness. */
1242 int tmp = functionbody;
1243 int real_functionbody;
1246 tree block = NULL_TREE;
1248 int leaving_for_scope;
1250 timevar_push (TV_NAME_LOOKUP);
1251 if (cfun && !doing_semantic_analysis_p ())
1252 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1254 my_friendly_assert (current_binding_level->parm_flag != 2,
1257 real_functionbody = (current_binding_level->keep == 2
1258 ? ((functionbody = 0), tmp) : functionbody);
1259 tags = functionbody >= 0 ? current_binding_level->tags : 0;
1260 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1262 my_friendly_assert (!current_binding_level->class_shadowed,
1265 /* We used to use KEEP == 2 to indicate that the new block should go
1266 at the beginning of the list of blocks at this binding level,
1267 rather than the end. This hack is no longer used. */
1268 my_friendly_assert (keep == 0 || keep == 1, 0);
1270 if (current_binding_level->keep == 1)
1273 /* Any uses of undefined labels, and any defined labels, now operate
1274 under constraints of next binding contour. */
1275 if (cfun && !functionbody)
1277 struct cp_binding_level *level_chain;
1278 level_chain = current_binding_level->level_chain;
1281 struct named_label_use_list *uses;
1282 struct named_label_list *labels;
1283 for (labels = named_labels; labels; labels = labels->next)
1284 if (labels->binding_level == current_binding_level)
1287 if (current_binding_level->is_try_scope)
1288 labels->in_try_scope = 1;
1289 if (current_binding_level->is_catch_scope)
1290 labels->in_catch_scope = 1;
1291 for (decl = labels->names_in_scope; decl;
1292 decl = TREE_CHAIN (decl))
1293 if (decl_jump_unsafe (decl))
1294 labels->bad_decls = tree_cons (NULL_TREE, decl,
1296 labels->binding_level = level_chain;
1297 labels->names_in_scope = level_chain->names;
1300 for (uses = named_label_uses; uses; uses = uses->next)
1301 if (uses->binding_level == current_binding_level)
1303 uses->binding_level = level_chain;
1304 uses->names_in_scope = level_chain->names;
1309 /* Get the decls in the order they were written.
1310 Usually current_binding_level->names is in reverse order.
1311 But parameter decls were previously put in forward order. */
1314 current_binding_level->names
1315 = decls = nreverse (current_binding_level->names);
1317 decls = current_binding_level->names;
1319 /* Output any nested inline functions within this block
1320 if they weren't already output. */
1321 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1322 if (TREE_CODE (decl) == FUNCTION_DECL
1323 && ! TREE_ASM_WRITTEN (decl)
1324 && DECL_INITIAL (decl) != NULL_TREE
1325 && TREE_ADDRESSABLE (decl)
1326 && decl_function_context (decl) == current_function_decl)
1328 /* If this decl was copied from a file-scope decl
1329 on account of a block-scope extern decl,
1330 propagate TREE_ADDRESSABLE to the file-scope decl. */
1331 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1332 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1335 push_function_context ();
1336 output_inline_function (decl);
1337 pop_function_context ();
1341 /* When not in function-at-a-time mode, expand_end_bindings will
1342 warn about unused variables. But, in function-at-a-time mode
1343 expand_end_bindings is not passed the list of variables in the
1344 current scope, and therefore no warning is emitted. So, we
1345 explicitly warn here. */
1346 if (!processing_template_decl)
1347 warn_about_unused_variables (getdecls ());
1349 /* If there were any declarations or structure tags in that level,
1350 or if this level is a function body,
1351 create a BLOCK to record them for the life of this function. */
1353 if (keep == 1 || functionbody)
1354 block = make_node (BLOCK);
1355 if (block != NULL_TREE)
1357 BLOCK_VARS (block) = decls;
1358 BLOCK_SUBBLOCKS (block) = subblocks;
1361 /* In each subblock, record that this is its superior. */
1363 for (link = subblocks; link; link = TREE_CHAIN (link))
1364 BLOCK_SUPERCONTEXT (link) = block;
1366 /* We still support the old for-scope rules, whereby the variables
1367 in a for-init statement were in scope after the for-statement
1368 ended. We only use the new rules if flag_new_for_scope is
1371 = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1373 /* Remove declarations for all the DECLs in this level. */
1374 for (link = decls; link; link = TREE_CHAIN (link))
1376 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1377 && DECL_NAME (link))
1380 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1384 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1386 ns_binding = NULL_TREE;
1389 && (BINDING_LEVEL (outer_binding)
1390 == current_binding_level->level_chain))
1391 /* We have something like:
1396 and we are leaving the `for' scope. There's no reason to
1397 keep the binding of the inner `i' in this case. */
1398 pop_binding (DECL_NAME (link), link);
1399 else if ((outer_binding
1400 && (TREE_CODE (BINDING_VALUE (outer_binding))
1403 && TREE_CODE (ns_binding) == TYPE_DECL))
1404 /* Here, we have something like:
1412 We must pop the for-scope binding so we know what's a
1413 type and what isn't. */
1414 pop_binding (DECL_NAME (link), link);
1417 /* Mark this VAR_DECL as dead so that we can tell we left it
1418 there only for backward compatibility. */
1419 DECL_DEAD_FOR_LOCAL (link) = 1;
1421 /* Keep track of what should of have happenned when we
1422 popped the binding. */
1423 if (outer_binding && BINDING_VALUE (outer_binding))
1424 DECL_SHADOWED_FOR_VAR (link)
1425 = BINDING_VALUE (outer_binding);
1427 /* Add it to the list of dead variables in the next
1428 outermost binding to that we can remove these when we
1429 leave that binding. */
1430 current_binding_level->level_chain->dead_vars_from_for
1431 = tree_cons (NULL_TREE, link,
1432 current_binding_level->level_chain->
1433 dead_vars_from_for);
1435 /* Although we don't pop the CPLUS_BINDING, we do clear
1436 its BINDING_LEVEL since the level is going away now. */
1437 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1443 /* Remove the binding. */
1445 if (TREE_CODE (decl) == TREE_LIST)
1446 decl = TREE_VALUE (decl);
1448 pop_binding (DECL_NAME (decl), decl);
1449 else if (TREE_CODE (decl) == OVERLOAD)
1450 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1456 /* Remove declarations for any `for' variables from inner scopes
1457 that we kept around. */
1458 for (link = current_binding_level->dead_vars_from_for;
1459 link; link = TREE_CHAIN (link))
1460 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1462 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1463 for (link = current_binding_level->type_shadowed;
1464 link; link = TREE_CHAIN (link))
1465 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1467 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1468 for (link = current_binding_level->shadowed_labels;
1470 link = TREE_CHAIN (link))
1471 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1473 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1474 list if a `using' declaration put them there. The debugging
1475 back-ends won't understand OVERLOAD, so we remove them here.
1476 Because the BLOCK_VARS are (temporarily) shared with
1477 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1478 popped all the bindings. */
1483 for (d = &BLOCK_VARS (block); *d; )
1485 if (TREE_CODE (*d) == TREE_LIST)
1486 *d = TREE_CHAIN (*d);
1488 d = &TREE_CHAIN (*d);
1492 /* If the level being exited is the top level of a function,
1493 check over all the labels. */
1496 /* Since this is the top level block of a function, the vars are
1497 the function's parameters. Don't leave them in the BLOCK
1498 because they are found in the FUNCTION_DECL instead. */
1499 BLOCK_VARS (block) = 0;
1503 tmp = current_binding_level->keep;
1505 pop_binding_level ();
1507 DECL_INITIAL (current_function_decl) = block;
1509 current_binding_level->blocks
1510 = chainon (current_binding_level->blocks, block);
1512 /* If we did not make a block for the level just exited,
1513 any blocks made for inner levels
1514 (since they cannot be recorded as subblocks in that level)
1515 must be carried forward so they will later become subblocks
1516 of something else. */
1518 current_binding_level->blocks
1519 = chainon (current_binding_level->blocks, subblocks);
1521 /* Each and every BLOCK node created here in `poplevel' is important
1522 (e.g. for proper debugging information) so if we created one
1523 earlier, mark it as "used". */
1525 TREE_USED (block) = 1;
1527 /* Take care of compiler's internal binding structures. */
1533 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1536 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1537 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1540 block = poplevel (keep, reverse, functionbody);
1543 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
1546 /* Delete the node BLOCK from the current binding level.
1547 This is used for the block inside a stmt expr ({...})
1548 so that the block can be reinserted where appropriate. */
1551 delete_block (tree block)
1554 if (current_binding_level->blocks == block)
1555 current_binding_level->blocks = TREE_CHAIN (block);
1556 for (t = current_binding_level->blocks; t;)
1558 if (TREE_CHAIN (t) == block)
1559 TREE_CHAIN (t) = TREE_CHAIN (block);
1563 TREE_CHAIN (block) = NULL_TREE;
1564 /* Clear TREE_USED which is always set by poplevel.
1565 The flag is set again if insert_block is called. */
1566 TREE_USED (block) = 0;
1569 /* Insert BLOCK at the end of the list of subblocks of the
1570 current binding level. This is used when a BIND_EXPR is expanded,
1571 to handle the BLOCK node inside the BIND_EXPR. */
1574 insert_block (tree block)
1576 TREE_USED (block) = 1;
1577 current_binding_level->blocks
1578 = chainon (current_binding_level->blocks, block);
1581 /* Set the BLOCK node for the innermost scope
1582 (the one we are currently in). */
1585 set_block (tree block ATTRIBUTE_UNUSED )
1587 /* The RTL expansion machinery requires us to provide this callback,
1588 but it is not applicable in function-at-a-time mode. */
1589 my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1592 /* Do a pushlevel for class declarations. */
1595 pushlevel_class (void)
1597 register struct cp_binding_level *newlevel;
1599 /* Reuse or create a struct for this binding level. */
1600 #if defined(DEBUG_BINDING_LEVELS)
1602 #else /* !defined(DEBUG_BINDING_LEVELS) */
1603 if (free_binding_level)
1604 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1606 newlevel = free_binding_level;
1607 free_binding_level = free_binding_level->level_chain;
1610 newlevel = make_binding_level ();
1612 #if defined(DEBUG_BINDING_LEVELS)
1614 #endif /* defined(DEBUG_BINDING_LEVELS) */
1616 push_binding_level (newlevel, 0, 0);
1618 class_binding_level = current_binding_level;
1619 class_binding_level->parm_flag = 2;
1620 class_binding_level->this_class = current_class_type;
1623 /* ...and a poplevel for class declarations. */
1626 poplevel_class (void)
1628 register struct cp_binding_level *level = class_binding_level;
1631 timevar_push (TV_NAME_LOOKUP);
1632 my_friendly_assert (level != 0, 354);
1634 /* If we're leaving a toplevel class, don't bother to do the setting
1635 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1636 shouldn't even be used when current_class_type isn't set, and second,
1637 if we don't touch it here, we're able to use the cache effect if the
1638 next time we're entering a class scope, it is the same class. */
1639 if (current_class_depth != 1)
1641 struct cp_binding_level* b;
1643 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1644 for (shadowed = level->class_shadowed;
1646 shadowed = TREE_CHAIN (shadowed))
1647 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1649 /* Find the next enclosing class, and recreate
1650 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1651 b = level->level_chain;
1652 while (b && b->parm_flag != 2)
1656 for (shadowed = b->class_shadowed;
1658 shadowed = TREE_CHAIN (shadowed))
1662 t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1663 while (t && BINDING_LEVEL (t) != b)
1667 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1668 = BINDING_VALUE (t);
1672 /* Remember to save what IDENTIFIER's were bound in this scope so we
1673 can recover from cache misses. */
1675 previous_class_type = current_class_type;
1676 previous_class_values = class_binding_level->class_shadowed;
1678 for (shadowed = level->type_shadowed;
1680 shadowed = TREE_CHAIN (shadowed))
1681 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1683 /* Remove the bindings for all of the class-level declarations. */
1684 for (shadowed = level->class_shadowed;
1686 shadowed = TREE_CHAIN (shadowed))
1687 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1689 /* Now, pop out of the binding level which we created up in the
1690 `pushlevel_class' routine. */
1691 #if defined(DEBUG_BINDING_LEVELS)
1693 #endif /* defined(DEBUG_BINDING_LEVELS) */
1695 pop_binding_level ();
1696 timevar_pop (TV_NAME_LOOKUP);
1699 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1700 for any names in enclosing classes. */
1703 clear_identifier_class_values (void)
1707 if (!class_binding_level)
1710 for (t = class_binding_level->class_shadowed;
1713 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1716 /* Returns nonzero if T is a virtual function table. */
1719 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
1721 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1724 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
1728 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
1730 return (TREE_CODE (t) == TYPE_DECL
1731 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1732 && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1735 /* Return the declarations that are members of the namespace NS. */
1738 cp_namespace_decls (tree ns)
1740 return NAMESPACE_LEVEL (ns)->names;
1743 struct walk_globals_data {
1744 walk_globals_pred p;
1749 /* Walk the vtable declarations in NAMESPACE. Whenever one is found
1750 for which P returns nonzero, call F with its address. If any call
1751 to F returns a nonzero value, return a nonzero value. */
1754 walk_vtables_r (tree namespace, void* data)
1756 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1757 walk_globals_fn f = wgd->f;
1758 void *d = wgd->data;
1759 tree decl = NAMESPACE_LEVEL (namespace)->vtables;
1762 for (; decl ; decl = TREE_CHAIN (decl))
1763 result |= (*f) (&decl, d);
1768 /* Walk the vtable declarations. Whenever one is found for which P
1769 returns nonzero, call F with its address. If any call to F
1770 returns a nonzero value, return a nonzero value. */
1772 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
1774 struct walk_globals_data wgd;
1779 return walk_namespaces (walk_vtables_r, &wgd);
1782 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1783 itself, calling F for each. The DATA is passed to F as well. */
1786 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
1789 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
1791 result |= (*f) (namespace, data);
1793 for (; current; current = TREE_CHAIN (current))
1794 result |= walk_namespaces_r (current, f, data);
1799 /* Walk all the namespaces, calling F for each. The DATA is passed to
1803 walk_namespaces (walk_namespaces_fn f, void* data)
1805 return walk_namespaces_r (global_namespace, f, data);
1808 /* Walk the global declarations in NAMESPACE. Whenever one is found
1809 for which P returns nonzero, call F with its address. If any call
1810 to F returns a nonzero value, return a nonzero value. */
1813 walk_globals_r (tree namespace, void* data)
1815 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1816 walk_globals_pred p = wgd->p;
1817 walk_globals_fn f = wgd->f;
1818 void *d = wgd->data;
1822 t = &NAMESPACE_LEVEL (namespace)->names;
1829 result |= (*f) (t, d);
1831 /* If F changed *T, then *T still points at the next item to
1834 t = &TREE_CHAIN (*t);
1840 /* Walk the global declarations. Whenever one is found for which P
1841 returns true, call F with its address. If any call to F
1842 returns true, return true. */
1845 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
1847 struct walk_globals_data wgd;
1852 return walk_namespaces (walk_globals_r, &wgd);
1855 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1856 DATA is non-NULL, this is the last time we will call
1857 wrapup_global_declarations for this NAMESPACE. */
1860 wrapup_globals_for_namespace (tree namespace, void* data)
1862 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
1863 varray_type statics = level->static_decls;
1864 tree *vec = &VARRAY_TREE (statics, 0);
1865 int len = VARRAY_ACTIVE_SIZE (statics);
1866 int last_time = (data != 0);
1870 check_global_declarations (vec, len);
1874 /* Write out any globals that need to be output. */
1875 return wrapup_global_declarations (vec, len);
1879 /* For debugging. */
1880 static int no_print_functions = 0;
1881 static int no_print_builtins = 0;
1884 print_binding_level (struct cp_binding_level* lvl)
1888 fprintf (stderr, " blocks=");
1889 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1890 if (lvl->tag_transparent)
1891 fprintf (stderr, " tag-transparent");
1892 if (lvl->more_cleanups_ok)
1893 fprintf (stderr, " more-cleanups-ok");
1894 if (lvl->have_cleanups)
1895 fprintf (stderr, " have-cleanups");
1896 fprintf (stderr, "\n");
1899 fprintf (stderr, " names:\t");
1900 /* We can probably fit 3 names to a line? */
1901 for (t = lvl->names; t; t = TREE_CHAIN (t))
1903 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1905 if (no_print_builtins
1906 && (TREE_CODE (t) == TYPE_DECL)
1907 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1910 /* Function decls tend to have longer names. */
1911 if (TREE_CODE (t) == FUNCTION_DECL)
1918 fprintf (stderr, "\n\t");
1921 print_node_brief (stderr, "", t, 0);
1922 if (t == error_mark_node)
1926 fprintf (stderr, "\n");
1930 fprintf (stderr, " tags:\t");
1932 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1934 if (TREE_PURPOSE (t) == NULL_TREE)
1936 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1943 fprintf (stderr, "\n\t");
1946 if (TREE_PURPOSE (t) == NULL_TREE)
1948 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1949 fprintf (stderr, ">");
1951 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1952 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1955 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1956 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1957 fprintf (stderr, ">");
1961 fprintf (stderr, "\n");
1963 if (lvl->class_shadowed)
1965 fprintf (stderr, " class-shadowed:");
1966 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1968 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1970 fprintf (stderr, "\n");
1972 if (lvl->type_shadowed)
1974 fprintf (stderr, " type-shadowed:");
1975 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1977 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1979 fprintf (stderr, "\n");
1984 print_other_binding_stack (struct cp_binding_level *stack)
1986 struct cp_binding_level *level;
1987 for (level = stack; level != global_binding_level; level = level->level_chain)
1989 fprintf (stderr, "binding level ");
1990 fprintf (stderr, HOST_PTR_PRINTF, level);
1991 fprintf (stderr, "\n");
1992 print_binding_level (level);
1997 print_binding_stack (void)
1999 struct cp_binding_level *b;
2000 fprintf (stderr, "current_binding_level=");
2001 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2002 fprintf (stderr, "\nclass_binding_level=");
2003 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2004 fprintf (stderr, "\nglobal_binding_level=");
2005 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2006 fprintf (stderr, "\n");
2007 if (class_binding_level)
2009 for (b = class_binding_level; b; b = b->level_chain)
2010 if (b == current_binding_level)
2013 b = class_binding_level;
2015 b = current_binding_level;
2018 b = current_binding_level;
2019 print_other_binding_stack (b);
2020 fprintf (stderr, "global:\n");
2021 print_binding_level (global_binding_level);
2024 /* Namespace binding access routines: The namespace_bindings field of
2025 the identifier is polymorphic, with three possible values:
2026 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2027 indicating the BINDING_VALUE of global_namespace. */
2029 /* Check whether the a binding for the name to scope is known.
2030 Assumes that the bindings of the name are already a list
2031 of bindings. Returns the binding found, or NULL_TREE. */
2034 find_binding (tree name, tree scope)
2036 tree iter, prev = NULL_TREE;
2038 timevar_push (TV_NAME_LOOKUP);
2039 scope = ORIGINAL_NAMESPACE (scope);
2041 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2042 iter = TREE_CHAIN (iter))
2044 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2045 if (BINDING_SCOPE (iter) == scope)
2047 /* Move binding found to the front of the list, so
2048 subsequent lookups will find it faster. */
2051 TREE_CHAIN (prev) = TREE_CHAIN (iter);
2052 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2053 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2055 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, iter);
2059 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2062 /* Always returns a binding for name in scope. If the
2063 namespace_bindings is not a list, convert it to one first.
2064 If no binding is found, make a new one. */
2067 binding_for_name (tree name, tree scope)
2069 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2072 scope = ORIGINAL_NAMESPACE (scope);
2074 if (b && TREE_CODE (b) != CPLUS_BINDING)
2076 /* Get rid of optimization for global scope. */
2077 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2078 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2079 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2081 if (b && (result = find_binding (name, scope)))
2083 /* Not found, make a new one. */
2084 result = make_node (CPLUS_BINDING);
2085 TREE_CHAIN (result) = b;
2086 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2087 BINDING_SCOPE (result) = scope;
2088 BINDING_TYPE (result) = NULL_TREE;
2089 BINDING_VALUE (result) = NULL_TREE;
2093 /* Return the binding value for name in scope, considering that
2094 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2097 namespace_binding (tree name, tree scope)
2099 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2102 if (scope == NULL_TREE)
2103 scope = global_namespace;
2104 if (TREE_CODE (b) != CPLUS_BINDING)
2105 return (scope == global_namespace) ? b : NULL_TREE;
2106 name = find_binding (name,scope);
2107 if (name == NULL_TREE)
2109 return BINDING_VALUE (name);
2112 /* Set the binding value for name in scope. If modifying the binding
2113 of global_namespace is attempted, try to optimize it. */
2116 set_namespace_binding (tree name, tree scope, tree val)
2120 timevar_push (TV_NAME_LOOKUP);
2121 if (scope == NULL_TREE)
2122 scope = global_namespace;
2124 if (scope == global_namespace)
2126 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2127 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2129 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2130 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
2133 b = binding_for_name (name, scope);
2134 BINDING_VALUE (b) = val;
2135 timevar_pop (TV_NAME_LOOKUP);
2138 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2139 select a name that is unique to this compilation unit. */
2142 push_namespace (tree name)
2146 int implicit_use = 0;
2149 timevar_push (TV_NAME_LOOKUP);
2151 if (!global_namespace)
2153 /* This must be ::. */
2154 my_friendly_assert (name == get_identifier ("::"), 377);
2159 /* The name of anonymous namespace is unique for the translation
2161 if (!anonymous_namespace_name)
2162 anonymous_namespace_name = get_file_function_name ('N');
2163 name = anonymous_namespace_name;
2164 d = IDENTIFIER_NAMESPACE_VALUE (name);
2166 /* Reopening anonymous namespace. */
2172 /* Check whether this is an extended namespace definition. */
2173 d = IDENTIFIER_NAMESPACE_VALUE (name);
2174 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2177 if (DECL_NAMESPACE_ALIAS (d))
2179 error ("namespace alias `%D' not allowed here, assuming `%D'",
2180 d, DECL_NAMESPACE_ALIAS (d));
2181 d = DECL_NAMESPACE_ALIAS (d);
2188 /* Make a new namespace, binding the name to it. */
2189 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2190 /* The global namespace is not pushed, and the global binding
2191 level is set elsewhere. */
2194 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2197 declare_namespace_level ();
2198 NAMESPACE_LEVEL (d) = current_binding_level;
2199 VARRAY_TREE_INIT (current_binding_level->static_decls,
2200 name != std_identifier ? 10 : 200,
2201 "Static declarations");
2205 resume_binding_level (NAMESPACE_LEVEL (d));
2208 do_using_directive (d);
2209 /* Enter the name space. */
2210 current_namespace = d;
2212 timevar_pop (TV_NAME_LOOKUP);
2215 /* Pop from the scope of the current namespace. */
2218 pop_namespace (void)
2220 my_friendly_assert (current_namespace != global_namespace, 20010801);
2221 current_namespace = CP_DECL_CONTEXT (current_namespace);
2222 /* The binding level is not popped, as it might be re-opened later. */
2223 suspend_binding_level ();
2226 /* Push into the scope of the namespace NS, even if it is deeply
2227 nested within another namespace. */
2230 push_nested_namespace (tree ns)
2232 if (ns == global_namespace)
2233 push_to_top_level ();
2236 push_nested_namespace (CP_DECL_CONTEXT (ns));
2237 push_namespace (DECL_NAME (ns));
2241 /* Pop back from the scope of the namespace NS, which was previously
2242 entered with push_nested_namespace. */
2245 pop_nested_namespace (tree ns)
2247 timevar_push (TV_NAME_LOOKUP);
2248 while (ns != global_namespace)
2251 ns = CP_DECL_CONTEXT (ns);
2254 pop_from_top_level ();
2255 timevar_pop (TV_NAME_LOOKUP);
2259 /* Allocate storage for saving a C++ binding. */
2260 #define cxx_saved_binding_make() \
2261 (ggc_alloc (sizeof (cxx_saved_binding)))
2263 struct cxx_saved_binding GTY(())
2265 /* Link that chains saved C++ bindings for a given name into a stack. */
2266 cxx_saved_binding *previous;
2267 /* The name of the current binding. */
2269 /* The binding we're saving. */
2272 tree real_type_value;
2275 /* Subroutines for reverting temporarily to top-level for instantiation
2276 of templates and such. We actually need to clear out the class- and
2277 local-value slots of all identifiers, so that only the global values
2278 are at all visible. Simply setting current_binding_level to the global
2279 scope isn't enough, because more binding levels may be pushed. */
2280 struct saved_scope *scope_chain;
2282 static cxx_saved_binding *
2283 store_bindings (tree names, cxx_saved_binding *old_bindings)
2286 cxx_saved_binding *search_bindings = old_bindings;
2288 timevar_push (TV_NAME_LOOKUP);
2289 for (t = names; t; t = TREE_CHAIN (t))
2292 cxx_saved_binding *saved;
2293 cxx_saved_binding *t1;
2295 if (TREE_CODE (t) == TREE_LIST)
2296 id = TREE_PURPOSE (t);
2301 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2302 we have no IDENTIFIER_BINDING if we have left the class
2303 scope, but cached the class-level declarations. */
2304 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2307 for (t1 = search_bindings; t1; t1 = t1->previous)
2308 if (t1->identifier == id)
2311 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2312 saved = cxx_saved_binding_make ();
2313 saved->previous = old_bindings;
2314 saved->identifier = id;
2315 saved->binding = IDENTIFIER_BINDING (id);
2316 saved->class_value = IDENTIFIER_CLASS_VALUE (id);;
2317 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2318 IDENTIFIER_BINDING (id) = NULL_TREE;
2319 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2320 old_bindings = saved;
2324 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings);
2328 maybe_push_to_top_level (int pseudo)
2330 struct saved_scope *s;
2331 struct cp_binding_level *b;
2332 cxx_saved_binding *old_bindings;
2335 timevar_push (TV_NAME_LOOKUP);
2336 s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2338 b = scope_chain ? current_binding_level : 0;
2340 /* If we're in the middle of some function, save our state. */
2344 push_function_context_to (NULL_TREE);
2349 old_bindings = NULL;
2350 if (scope_chain && previous_class_type)
2351 old_bindings = store_bindings (previous_class_values, old_bindings);
2353 /* Have to include global_binding_level, because class-level decls
2354 aren't listed anywhere useful. */
2355 for (; b; b = b->level_chain)
2359 /* Template IDs are inserted into the global level. If they were
2360 inserted into namespace level, finish_file wouldn't find them
2361 when doing pending instantiations. Therefore, don't stop at
2362 namespace level, but continue until :: . */
2363 if (b == global_binding_level || (pseudo && b->template_parms_p))
2366 old_bindings = store_bindings (b->names, old_bindings);
2367 /* We also need to check class_shadowed to save class-level type
2368 bindings, since pushclass doesn't fill in b->names. */
2369 if (b->parm_flag == 2)
2370 old_bindings = store_bindings (b->class_shadowed, old_bindings);
2372 /* Unwind type-value slots back to top level. */
2373 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2374 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2376 s->prev = scope_chain;
2377 s->old_bindings = old_bindings;
2379 s->need_pop_function_context = need_pop;
2380 s->function_decl = current_function_decl;
2381 s->last_parms = last_function_parms;
2382 s->check_access = flag_access_control;
2385 current_function_decl = NULL_TREE;
2386 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2387 current_lang_name = lang_name_cplusplus;
2388 current_namespace = global_namespace;
2389 timevar_pop (TV_NAME_LOOKUP);
2393 push_to_top_level (void)
2395 maybe_push_to_top_level (0);
2399 pop_from_top_level (void)
2401 struct saved_scope *s = scope_chain;
2402 cxx_saved_binding *saved;
2404 timevar_push (TV_NAME_LOOKUP);
2405 /* Clear out class-level bindings cache. */
2406 if (previous_class_type)
2407 invalidate_class_lookup_cache ();
2409 current_lang_base = 0;
2411 scope_chain = s->prev;
2412 for (saved = s->old_bindings; saved; saved = saved->previous)
2414 tree id = saved->identifier;
2416 IDENTIFIER_BINDING (id) = saved->binding;
2417 IDENTIFIER_CLASS_VALUE (id) = saved->class_value;
2418 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
2421 /* If we were in the middle of compiling a function, restore our
2423 if (s->need_pop_function_context)
2424 pop_function_context_from (NULL_TREE);
2425 current_function_decl = s->function_decl;
2426 last_function_parms = s->last_parms;
2427 timevar_pop (TV_NAME_LOOKUP);
2430 /* Push a definition of struct, union or enum tag "name".
2431 into binding_level "b". "type" should be the type node,
2432 We assume that the tag "name" is not already defined.
2434 Note that the definition may really be just a forward reference.
2435 In that case, the TYPE_SIZE will be a NULL_TREE.
2437 C++ gratuitously puts all these tags in the name space. */
2439 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2440 record the shadowed value for this binding contour. TYPE is
2441 the type that ID maps to. */
2444 set_identifier_type_value_with_scope (tree id,
2446 struct cp_binding_level* b)
2448 if (!b->namespace_p)
2450 /* Shadow the marker, not the real thing, so that the marker
2451 gets restored later. */
2452 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2454 = tree_cons (id, old_type_value, b->type_shadowed);
2458 tree binding = binding_for_name (id, current_namespace);
2459 BINDING_TYPE (binding) = type;
2460 /* Store marker instead of real type. */
2461 type = global_type_node;
2463 SET_IDENTIFIER_TYPE_VALUE (id, type);
2466 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2469 set_identifier_type_value (tree id, tree type)
2471 set_identifier_type_value_with_scope (id, type, current_binding_level);
2474 /* Return the type associated with id. */
2477 identifier_type_value (tree id)
2479 timevar_push (TV_NAME_LOOKUP);
2480 /* There is no type with that name, anywhere. */
2481 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2482 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2483 /* This is not the type marker, but the real thing. */
2484 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2485 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
2486 /* Have to search for it. It must be on the global level, now.
2487 Ask lookup_name not to return non-types. */
2488 id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
2490 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
2491 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2494 /* Pop off extraneous binding levels left over due to syntax errors.
2496 We don't pop past namespaces, as they might be valid. */
2499 pop_everything (void)
2501 #ifdef DEBUG_BINDING_LEVELS
2502 fprintf (stderr, "XXX entering pop_everything ()\n");
2504 while (!toplevel_bindings_p ())
2506 if (current_binding_level->parm_flag == 2)
2507 pop_nested_class ();
2511 #ifdef DEBUG_BINDING_LEVELS
2512 fprintf (stderr, "XXX leaving pop_everything ()\n");
2516 /* The type TYPE is being declared. If it is a class template, or a
2517 specialization of a class template, do any processing required and
2518 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
2519 being declared a friend. B is the binding level at which this TYPE
2522 Returns the TYPE_DECL for TYPE, which may have been altered by this
2526 maybe_process_template_type_declaration (tree type,
2528 struct cp_binding_level* b)
2530 tree decl = TYPE_NAME (type);
2532 if (processing_template_parmlist)
2533 /* You can't declare a new template type in a template parameter
2534 list. But, you can declare a non-template type:
2536 template <class A*> struct S;
2538 is a forward-declaration of `A'. */
2542 maybe_check_template_type (type);
2544 my_friendly_assert (IS_AGGR_TYPE (type)
2545 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2548 if (processing_template_decl)
2550 /* This may change after the call to
2551 push_template_decl_real, but we want the original value. */
2552 tree name = DECL_NAME (decl);
2554 decl = push_template_decl_real (decl, globalize);
2555 /* If the current binding level is the binding level for the
2556 template parameters (see the comment in
2557 begin_template_parm_list) and the enclosing level is a class
2558 scope, and we're not looking at a friend, push the
2559 declaration of the member class into the class scope. In the
2560 friend case, push_template_decl will already have put the
2561 friend into global scope, if appropriate. */
2562 if (TREE_CODE (type) != ENUMERAL_TYPE
2563 && !globalize && b->template_parms_p
2564 && b->level_chain->parm_flag == 2)
2566 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2567 /* Put this tag on the list of tags for the class, since
2568 that won't happen below because B is not the class
2569 binding level, but is instead the pseudo-global level. */
2570 b->level_chain->tags =
2571 tree_cons (name, type, b->level_chain->tags);
2572 if (!COMPLETE_TYPE_P (current_class_type))
2574 maybe_add_class_template_decl_list (current_class_type,
2575 type, /*friend_p=*/0);
2576 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2585 /* In C++, you don't have to write `struct S' to refer to `S'; you
2586 can just use `S'. We accomplish this by creating a TYPE_DECL as
2587 if the user had written `typedef struct S S'. Create and return
2588 the TYPE_DECL for TYPE. */
2591 create_implicit_typedef (tree name, tree type)
2595 decl = build_decl (TYPE_DECL, name, type);
2596 DECL_ARTIFICIAL (decl) = 1;
2597 /* There are other implicit type declarations, like the one *within*
2598 a class that allows you to write `S::S'. We must distinguish
2600 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2601 TYPE_NAME (type) = decl;
2606 /* Remember a local name for name-mangling purposes. */
2609 push_local_name (tree decl)
2614 timevar_push (TV_NAME_LOOKUP);
2616 VARRAY_TREE_INIT (local_names, 8, "local_names");
2618 name = DECL_NAME (decl);
2620 nelts = VARRAY_ACTIVE_SIZE (local_names);
2621 for (i = 0; i < nelts; i++)
2623 t = VARRAY_TREE (local_names, i);
2624 if (DECL_NAME (t) == name)
2626 if (!DECL_LANG_SPECIFIC (decl))
2627 retrofit_lang_decl (decl);
2628 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2629 if (DECL_LANG_SPECIFIC (t))
2630 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2632 DECL_DISCRIMINATOR (decl) = 1;
2634 VARRAY_TREE (local_names, i) = decl;
2635 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
2639 VARRAY_PUSH_TREE (local_names, decl);
2640 timevar_pop (TV_NAME_LOOKUP);
2643 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2644 Normally put it into the inner-most non-tag-transparent scope,
2645 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2646 The latter is needed for implicit declarations. */
2649 pushtag (tree name, tree type, int globalize)
2651 register struct cp_binding_level *b;
2653 timevar_push (TV_NAME_LOOKUP);
2654 b = current_binding_level;
2655 while (b->tag_transparent
2656 || (b->parm_flag == 2
2658 /* We may be defining a new type in the initializer
2659 of a static member variable. We allow this when
2660 not pedantic, and it is particularly useful for
2661 type punning via an anonymous union. */
2662 || COMPLETE_TYPE_P (b->this_class))))
2665 b->tags = tree_cons (name, type, b->tags);
2669 /* Do C++ gratuitous typedefing. */
2670 if (IDENTIFIER_TYPE_VALUE (name) != type)
2672 register tree d = NULL_TREE;
2674 tree context = TYPE_CONTEXT (type);
2678 tree cs = current_scope ();
2682 else if (cs != NULL_TREE && TYPE_P (cs))
2683 /* When declaring a friend class of a local class, we want
2684 to inject the newly named class into the scope
2685 containing the local class, not the namespace scope. */
2686 context = decl_function_context (get_type_decl (cs));
2689 context = current_namespace;
2691 if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2692 || b->parm_flag == 2)
2695 if (current_lang_name == lang_name_java)
2696 TYPE_FOR_JAVA (type) = 1;
2698 d = create_implicit_typedef (name, type);
2699 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2701 set_identifier_type_value_with_scope (name, type, b);
2703 d = maybe_process_template_type_declaration (type,
2706 if (b->parm_flag == 2)
2708 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2709 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2710 class. But if it's a member template class, we
2711 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2713 finish_member_declaration (d);
2715 pushdecl_class_level (d);
2718 d = pushdecl_with_scope (d, b);
2720 /* FIXME what if it gets a name from typedef? */
2721 if (ANON_AGGRNAME_P (name))
2722 DECL_IGNORED_P (d) = 1;
2724 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2726 /* If this is a local class, keep track of it. We need this
2727 information for name-mangling, and so that it is possible to find
2728 all function definitions in a translation unit in a convenient
2729 way. (It's otherwise tricky to find a member function definition
2730 it's only pointed to from within a local class.) */
2731 if (TYPE_CONTEXT (type)
2732 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2733 && !processing_template_decl)
2734 VARRAY_PUSH_TREE (local_classes, type);
2736 if (b->parm_flag == 2)
2738 if (!COMPLETE_TYPE_P (current_class_type))
2740 maybe_add_class_template_decl_list (current_class_type,
2741 type, /*friend_p=*/0);
2742 CLASSTYPE_TAGS (current_class_type) = b->tags;
2747 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2748 /* Use the canonical TYPE_DECL for this node. */
2749 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2752 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2753 will be the tagged type we just added to the current
2754 binding level. This fake NULL-named TYPE_DECL node helps
2755 dwarfout.c to know when it needs to output a
2756 representation of a tagged type, and it also gives us a
2757 convenient place to record the "scope start" address for
2760 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2761 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2763 timevar_pop (TV_NAME_LOOKUP);
2766 /* Counter used to create anonymous type names. */
2768 static GTY(()) int anon_cnt;
2770 /* Return an IDENTIFIER which can be used as a name for
2771 anonymous structs and unions. */
2774 make_anon_name (void)
2778 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2779 return get_identifier (buf);
2782 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2783 This keeps dbxout from getting confused. */
2786 clear_anon_tags (void)
2788 register struct cp_binding_level *b;
2790 static int last_cnt = 0;
2792 /* Fast out if no new anon names were declared. */
2793 if (last_cnt == anon_cnt)
2796 b = current_binding_level;
2797 while (b->tag_transparent)
2802 /* A NULL purpose means we have already processed all tags
2803 from here to the end of the list. */
2804 if (TREE_PURPOSE (tags) == NULL_TREE)
2806 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2807 TREE_PURPOSE (tags) = NULL_TREE;
2808 tags = TREE_CHAIN (tags);
2810 last_cnt = anon_cnt;
2813 /* Subroutine of duplicate_decls: return truthvalue of whether
2814 or not types of these decls match.
2816 For C++, we must compare the parameter list so that `int' can match
2817 `int&' in a parameter position, but `int&' is not confused with
2821 decls_match (tree newdecl, tree olddecl)
2825 if (newdecl == olddecl)
2828 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2829 /* If the two DECLs are not even the same kind of thing, we're not
2830 interested in their types. */
2833 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2835 tree f1 = TREE_TYPE (newdecl);
2836 tree f2 = TREE_TYPE (olddecl);
2837 tree p1 = TYPE_ARG_TYPES (f1);
2838 tree p2 = TYPE_ARG_TYPES (f2);
2840 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2841 && ! (DECL_EXTERN_C_P (newdecl)
2842 && DECL_EXTERN_C_P (olddecl)))
2845 if (TREE_CODE (f1) != TREE_CODE (f2))
2848 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2850 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2851 && (DECL_BUILT_IN (olddecl)
2852 #ifndef NO_IMPLICIT_EXTERN_C
2853 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2854 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2858 types_match = self_promoting_args_p (p1);
2859 if (p1 == void_list_node)
2860 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2862 #ifndef NO_IMPLICIT_EXTERN_C
2863 else if (p1 == NULL_TREE
2864 && (DECL_EXTERN_C_P (olddecl)
2865 && DECL_IN_SYSTEM_HEADER (olddecl)
2866 && !DECL_CLASS_SCOPE_P (olddecl))
2867 && (DECL_EXTERN_C_P (newdecl)
2868 && DECL_IN_SYSTEM_HEADER (newdecl)
2869 && !DECL_CLASS_SCOPE_P (newdecl)))
2871 types_match = self_promoting_args_p (p2);
2872 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2876 types_match = compparms (p1, p2);
2881 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2883 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2884 DECL_TEMPLATE_PARMS (olddecl)))
2887 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2888 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2891 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2894 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2895 DECL_TEMPLATE_RESULT (newdecl));
2899 if (TREE_TYPE (newdecl) == error_mark_node)
2900 types_match = TREE_TYPE (olddecl) == error_mark_node;
2901 else if (TREE_TYPE (olddecl) == NULL_TREE)
2902 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2903 else if (TREE_TYPE (newdecl) == NULL_TREE)
2906 types_match = comptypes (TREE_TYPE (newdecl),
2907 TREE_TYPE (olddecl),
2908 COMPARE_REDECLARATION);
2914 /* If NEWDECL is `static' and an `extern' was seen previously,
2915 warn about it. OLDDECL is the previous declaration.
2917 Note that this does not apply to the C++ case of declaring
2918 a variable `extern const' and then later `const'.
2920 Don't complain about built-in functions, since they are beyond
2921 the user's control. */
2924 warn_extern_redeclared_static (tree newdecl, tree olddecl)
2926 static const char *const explicit_extern_static_warning
2927 = "`%D' was declared `extern' and later `static'";
2928 static const char *const implicit_extern_static_warning
2929 = "`%D' was declared implicitly `extern' and later `static'";
2933 if (TREE_CODE (newdecl) == TYPE_DECL
2934 || TREE_CODE (newdecl) == TEMPLATE_DECL
2935 || TREE_CODE (newdecl) == CONST_DECL)
2938 /* Don't get confused by static member functions; that's a different
2940 if (TREE_CODE (newdecl) == FUNCTION_DECL
2941 && DECL_STATIC_FUNCTION_P (newdecl))
2944 /* If the old declaration was `static', or the new one isn't, then
2945 then everything is OK. */
2946 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2949 /* It's OK to declare a builtin function as `static'. */
2950 if (TREE_CODE (olddecl) == FUNCTION_DECL
2951 && DECL_ARTIFICIAL (olddecl))
2954 name = DECL_ASSEMBLER_NAME (newdecl);
2955 pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2956 ? implicit_extern_static_warning
2957 : explicit_extern_static_warning, newdecl);
2958 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2961 /* Handle when a new declaration NEWDECL has the same name as an old
2962 one OLDDECL in the same binding contour. Prints an error message
2965 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2966 Otherwise, return 0. */
2969 duplicate_decls (tree newdecl, tree olddecl)
2971 unsigned olddecl_uid = DECL_UID (olddecl);
2972 int olddecl_friend = 0, types_match = 0;
2973 int new_defines_function = 0;
2975 if (newdecl == olddecl)
2978 types_match = decls_match (newdecl, olddecl);
2980 /* If either the type of the new decl or the type of the old decl is an
2981 error_mark_node, then that implies that we have already issued an
2982 error (earlier) for some bogus type specification, and in that case,
2983 it is rather pointless to harass the user with yet more error message
2984 about the same declaration, so just pretend the types match here. */
2985 if (TREE_TYPE (newdecl) == error_mark_node
2986 || TREE_TYPE (olddecl) == error_mark_node)
2989 if (DECL_P (olddecl)
2990 && TREE_CODE (newdecl) == FUNCTION_DECL
2991 && TREE_CODE (olddecl) == FUNCTION_DECL
2992 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
2994 if (DECL_DECLARED_INLINE_P (newdecl)
2995 && DECL_UNINLINABLE (newdecl)
2996 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2997 /* Already warned elsewhere. */;
2998 else if (DECL_DECLARED_INLINE_P (olddecl)
2999 && DECL_UNINLINABLE (olddecl)
3000 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3001 /* Already warned. */;
3002 else if (DECL_DECLARED_INLINE_P (newdecl)
3003 && DECL_UNINLINABLE (olddecl)
3004 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
3006 warning ("%Hfunction '%D' redeclared as inline",
3007 &DECL_SOURCE_LOCATION (newdecl), newdecl);
3008 warning ("%Hprevious declaration of '%D' with attribute noinline",
3009 &DECL_SOURCE_LOCATION (olddecl), olddecl);
3011 else if (DECL_DECLARED_INLINE_P (olddecl)
3012 && DECL_UNINLINABLE (newdecl)
3013 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
3015 warning ("%Hfunction '%D' redeclared with attribute noinline",
3016 &DECL_SOURCE_LOCATION (newdecl), newdecl);
3017 warning ("%Hprevious declaration of '%D' was inline",
3018 &DECL_SOURCE_LOCATION (olddecl), olddecl);
3022 /* Check for redeclaration and other discrepancies. */
3023 if (TREE_CODE (olddecl) == FUNCTION_DECL
3024 && DECL_ARTIFICIAL (olddecl))
3026 if (TREE_CODE (newdecl) != FUNCTION_DECL)
3028 /* Avoid warnings redeclaring anticipated built-ins. */
3029 if (DECL_ANTICIPATED (olddecl))
3032 /* If you declare a built-in or predefined function name as static,
3033 the old definition is overridden, but optionally warn this was a
3034 bad choice of name. */
3035 if (! TREE_PUBLIC (newdecl))
3038 warning ("shadowing %s function `%#D'",
3039 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3041 /* Discard the old built-in function. */
3044 /* If the built-in is not ansi, then programs can override
3045 it even globally without an error. */
3046 else if (! DECL_BUILT_IN (olddecl))
3047 warning ("library function `%#D' redeclared as non-function `%#D'",
3051 error ("declaration of `%#D'", newdecl);
3052 error ("conflicts with built-in declaration `%#D'",
3057 else if (!types_match)
3059 /* Avoid warnings redeclaring anticipated built-ins. */
3060 if (DECL_ANTICIPATED (olddecl))
3061 ; /* Do nothing yet. */
3062 else if ((DECL_EXTERN_C_P (newdecl)
3063 && DECL_EXTERN_C_P (olddecl))
3064 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3065 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3067 /* A near match; override the builtin. */
3069 if (TREE_PUBLIC (newdecl))
3071 warning ("new declaration `%#D'", newdecl);
3072 warning ("ambiguates built-in declaration `%#D'",
3075 else if (warn_shadow)
3076 warning ("shadowing %s function `%#D'",
3077 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3081 /* Discard the old built-in function. */
3084 /* Replace the old RTL to avoid problems with inlining. */
3085 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3088 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3090 /* If a builtin function is redeclared as `static', merge
3091 the declarations, but make the original one static. */
3092 DECL_THIS_STATIC (olddecl) = 1;
3093 TREE_PUBLIC (olddecl) = 0;
3095 /* Make the old declaration consistent with the new one so
3096 that all remnants of the builtin-ness of this function
3097 will be banished. */
3098 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3099 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3102 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3104 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3105 && TREE_CODE (newdecl) != TYPE_DECL
3106 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3107 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3108 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3109 && TREE_CODE (olddecl) != TYPE_DECL
3110 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3111 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3114 /* We do nothing special here, because C++ does such nasty
3115 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3116 get shadowed, and know that if we need to find a TYPE_DECL
3117 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3118 slot of the identifier. */
3122 if ((TREE_CODE (newdecl) == FUNCTION_DECL
3123 && DECL_FUNCTION_TEMPLATE_P (olddecl))
3124 || (TREE_CODE (olddecl) == FUNCTION_DECL
3125 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3128 error ("`%#D' redeclared as different kind of symbol", newdecl);
3129 if (TREE_CODE (olddecl) == TREE_LIST)
3130 olddecl = TREE_VALUE (olddecl);
3131 cp_error_at ("previous declaration of `%#D'", olddecl);
3133 /* New decl is completely inconsistent with the old one =>
3134 tell caller to replace the old one. */
3138 else if (!types_match)
3140 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3141 /* These are certainly not duplicate declarations; they're
3142 from different scopes. */
3145 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3147 /* The name of a class template may not be declared to refer to
3148 any other template, class, function, object, namespace, value,
3149 or type in the same scope. */
3150 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3151 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3153 error ("declaration of template `%#D'", newdecl);
3154 cp_error_at ("conflicts with previous declaration `%#D'",
3157 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3158 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3159 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3160 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3161 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3162 DECL_TEMPLATE_PARMS (olddecl))
3163 /* Template functions can be disambiguated by
3165 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
3166 TREE_TYPE (TREE_TYPE (olddecl))))
3168 error ("new declaration `%#D'", newdecl);
3169 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3173 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3175 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3177 error ("declaration of C function `%#D' conflicts with",
3179 cp_error_at ("previous declaration `%#D' here", olddecl);
3181 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3182 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3184 error ("new declaration `%#D'", newdecl);
3185 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3191 /* Already complained about this, so don't do so again. */
3192 else if (current_class_type == NULL_TREE
3193 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3195 error ("conflicting types for `%#D'", newdecl);
3196 cp_error_at ("previous declaration as `%#D'", olddecl);
3199 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3200 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3201 && (!DECL_TEMPLATE_INFO (newdecl)
3202 || (DECL_TI_TEMPLATE (newdecl)
3203 != DECL_TI_TEMPLATE (olddecl))))
3204 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3205 && (!DECL_TEMPLATE_INFO (olddecl)
3206 || (DECL_TI_TEMPLATE (olddecl)
3207 != DECL_TI_TEMPLATE (newdecl))))))
3208 /* It's OK to have a template specialization and a non-template
3209 with the same type, or to have specializations of two
3210 different templates with the same type. Note that if one is a
3211 specialization, and the other is an instantiation of the same
3212 template, that we do not exit at this point. That situation
3213 can occur if we instantiate a template class, and then
3214 specialize one of its methods. This situation is valid, but
3215 the declarations must be merged in the usual way. */
3217 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3218 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3219 && !DECL_USE_TEMPLATE (newdecl))
3220 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3221 && !DECL_USE_TEMPLATE (olddecl))))
3222 /* One of the declarations is a template instantiation, and the
3223 other is not a template at all. That's OK. */
3225 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3226 && DECL_NAMESPACE_ALIAS (newdecl)
3227 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3228 /* Redeclaration of namespace alias, ignore it. */
3232 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3235 error (errmsg, newdecl);
3236 if (DECL_NAME (olddecl) != NULL_TREE)
3237 cp_error_at ((DECL_INITIAL (olddecl)
3238 && namespace_bindings_p ())
3239 ? "`%#D' previously defined here"
3240 : "`%#D' previously declared here", olddecl);
3243 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3244 && DECL_INITIAL (olddecl) != NULL_TREE
3245 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3246 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3248 /* Prototype decl follows defn w/o prototype. */
3249 cp_warning_at ("prototype for `%#D'", newdecl);
3250 cp_warning_at ("follows non-prototype definition here", olddecl);
3252 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3253 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3255 /* extern "C" int foo ();
3256 int foo () { bar (); }
3258 if (current_lang_depth () == 0)
3259 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3262 cp_error_at ("previous declaration of `%#D' with %L linkage",
3263 olddecl, DECL_LANGUAGE (olddecl));
3264 error ("conflicts with new declaration with %L linkage",
3265 DECL_LANGUAGE (newdecl));
3269 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3271 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3273 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3274 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3277 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3278 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3280 for (; t1 && t1 != void_list_node;
3281 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3282 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3284 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3287 pedwarn ("default argument given for parameter %d of `%#D'",
3289 cp_pedwarn_at ("after previous specification in `%#D'",
3294 error ("default argument given for parameter %d of `%#D'",
3296 cp_error_at ("after previous specification in `%#D'",
3301 if (DECL_DECLARED_INLINE_P (newdecl)
3302 && ! DECL_DECLARED_INLINE_P (olddecl)
3303 && TREE_ADDRESSABLE (olddecl) && warn_inline)
3305 warning ("`%#D' was used before it was declared inline",
3307 cp_warning_at ("previous non-inline declaration here",
3313 /* Do not merge an implicit typedef with an explicit one. In:
3317 typedef class A A __attribute__ ((foo));
3319 the attribute should apply only to the typedef. */
3320 if (TREE_CODE (olddecl) == TYPE_DECL
3321 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3322 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3325 /* If new decl is `static' and an `extern' was seen previously,
3327 warn_extern_redeclared_static (newdecl, olddecl);
3329 /* We have committed to returning 1 at this point. */
3330 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3332 /* Now that functions must hold information normally held
3333 by field decls, there is extra work to do so that
3334 declaration information does not get destroyed during
3336 if (DECL_VINDEX (olddecl))
3337 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3338 if (DECL_CONTEXT (olddecl))
3339 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3340 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3341 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3342 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3343 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3344 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3345 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3346 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3347 SET_OVERLOADED_OPERATOR_CODE
3348 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3349 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3351 /* Optionally warn about more than one declaration for the same
3352 name, but don't warn about a function declaration followed by a
3354 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3355 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3356 /* Don't warn about extern decl followed by definition. */
3357 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3358 /* Don't warn about friends, let add_friend take care of it. */
3359 && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3361 warning ("redundant redeclaration of `%D' in same scope", newdecl);
3362 cp_warning_at ("previous declaration of `%D'", olddecl);
3366 /* Deal with C++: must preserve virtual function table size. */
3367 if (TREE_CODE (olddecl) == TYPE_DECL)
3369 register tree newtype = TREE_TYPE (newdecl);
3370 register tree oldtype = TREE_TYPE (olddecl);
3372 if (newtype != error_mark_node && oldtype != error_mark_node
3373 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3374 CLASSTYPE_FRIEND_CLASSES (newtype)
3375 = CLASSTYPE_FRIEND_CLASSES (oldtype);
3377 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3380 /* Copy all the DECL_... slots specified in the new decl
3381 except for any that we copy here from the old type. */
3382 DECL_ATTRIBUTES (newdecl)
3383 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3385 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3387 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3388 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3389 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3390 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3392 /* If the new declaration is a definition, update the file and
3393 line information on the declaration. */
3394 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3395 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3397 DECL_SOURCE_LOCATION (olddecl)
3398 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
3399 = DECL_SOURCE_LOCATION (newdecl);
3407 /* Automatically handles default parameters. */
3408 tree oldtype = TREE_TYPE (olddecl);
3411 /* Merge the data types specified in the two decls. */
3412 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3414 /* If merge_types produces a non-typedef type, just use the old type. */
3415 if (TREE_CODE (newdecl) == TYPE_DECL
3416 && newtype == DECL_ORIGINAL_TYPE (newdecl))
3419 if (TREE_CODE (newdecl) == VAR_DECL)
3421 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3422 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3425 /* Do this after calling `merge_types' so that default
3426 parameters don't confuse us. */
3427 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3428 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3429 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3431 TREE_TYPE (newdecl) = build_exception_variant (newtype,
3432 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3433 TREE_TYPE (olddecl) = build_exception_variant (newtype,
3434 TYPE_RAISES_EXCEPTIONS (oldtype));
3436 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3437 && DECL_SOURCE_LINE (olddecl) != 0
3439 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3440 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3442 error ("declaration of `%F' throws different exceptions",
3444 cp_error_at ("than previous declaration `%F'", olddecl);
3447 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3449 /* Lay the type out, unless already done. */
3450 if (! same_type_p (newtype, oldtype)
3451 && TREE_TYPE (newdecl) != error_mark_node
3452 && !(processing_template_decl && uses_template_parms (newdecl)))
3453 layout_type (TREE_TYPE (newdecl));
3455 if ((TREE_CODE (newdecl) == VAR_DECL
3456 || TREE_CODE (newdecl) == PARM_DECL
3457 || TREE_CODE (newdecl) == RESULT_DECL
3458 || TREE_CODE (newdecl) == FIELD_DECL
3459 || TREE_CODE (newdecl) == TYPE_DECL)
3460 && !(processing_template_decl && uses_template_parms (newdecl)))
3461 layout_decl (newdecl, 0);
3463 /* Merge the type qualifiers. */
3464 if (TREE_READONLY (newdecl))
3465 TREE_READONLY (olddecl) = 1;
3466 if (TREE_THIS_VOLATILE (newdecl))
3467 TREE_THIS_VOLATILE (olddecl) = 1;
3469 /* Merge the initialization information. */
3470 if (DECL_INITIAL (newdecl) == NULL_TREE
3471 && DECL_INITIAL (olddecl) != NULL_TREE)
3473 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3474 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
3475 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3476 && DECL_LANG_SPECIFIC (newdecl)
3477 && DECL_LANG_SPECIFIC (olddecl))
3478 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3481 /* Merge the section attribute.
3482 We want to issue an error if the sections conflict but that must be
3483 done later in decl_attributes since we are called before attributes
3485 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3486 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3488 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3490 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3491 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3492 DECL_NO_LIMIT_STACK (newdecl)
3493 |= DECL_NO_LIMIT_STACK (olddecl);
3494 /* Keep the old RTL. */
3495 COPY_DECL_RTL (olddecl, newdecl);
3497 else if (TREE_CODE (newdecl) == VAR_DECL
3498 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3500 /* Keep the old RTL. We cannot keep the old RTL if the old
3501 declaration was for an incomplete object and the new
3502 declaration is not since many attributes of the RTL will
3504 COPY_DECL_RTL (olddecl, newdecl);
3507 /* If cannot merge, then use the new type and qualifiers,
3508 and don't preserve the old rtl. */
3511 /* Clean out any memory we had of the old declaration. */
3512 tree oldstatic = value_member (olddecl, static_aggregates);
3514 TREE_VALUE (oldstatic) = error_mark_node;
3516 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3517 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3518 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3519 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3522 /* Merge the storage class information. */
3523 merge_weak (newdecl, olddecl);
3525 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3526 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3527 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3528 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3529 if (! DECL_EXTERNAL (olddecl))
3530 DECL_EXTERNAL (newdecl) = 0;
3532 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3534 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3535 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3536 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3537 DECL_TEMPLATE_INSTANTIATED (newdecl)
3538 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3539 /* Don't really know how much of the language-specific
3540 values we should copy from old to new. */
3541 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3542 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3543 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3544 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3545 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3546 DECL_INITIALIZED_IN_CLASS_P (newdecl)
3547 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3548 olddecl_friend = DECL_FRIEND_P (olddecl);
3550 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3551 if (TREE_CODE (newdecl) == FUNCTION_DECL
3552 || DECL_FUNCTION_TEMPLATE_P (newdecl))
3554 DECL_BEFRIENDING_CLASSES (newdecl)
3555 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3556 DECL_BEFRIENDING_CLASSES (olddecl));
3557 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
3561 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3563 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3564 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3566 /* If newdecl is not a specialization, then it is not a
3567 template-related function at all. And that means that we
3568 should have exited above, returning 0. */
3569 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3572 if (TREE_USED (olddecl))
3573 /* From [temp.expl.spec]:
3575 If a template, a member template or the member of a class
3576 template is explicitly specialized then that
3577 specialization shall be declared before the first use of
3578 that specialization that would cause an implicit
3579 instantiation to take place, in every translation unit in
3580 which such a use occurs. */
3581 error ("explicit specialization of %D after first use",
3584 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3586 /* [temp.expl.spec/14] We don't inline explicit specialization
3587 just because the primary template says so. */
3591 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3592 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3594 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3596 /* If either decl says `inline', this fn is inline, unless
3597 its definition was passed already. */
3598 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3599 DECL_INLINE (olddecl) = 1;
3600 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3602 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3603 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3606 /* Preserve abstractness on cloned [cd]tors. */
3607 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3611 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3612 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3613 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3615 if (! types_match || new_defines_function)
3617 /* These need to be copied so that the names are available.
3618 Note that if the types do match, we'll preserve inline
3619 info and other bits, but if not, we won't. */
3620 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3621 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3623 if (new_defines_function)
3624 /* If defining a function declared with other language
3625 linkage, use the previously declared language linkage. */
3626 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3627 else if (types_match)
3629 /* If redeclaring a builtin function, and not a definition,
3630 it stays built in. */
3631 if (DECL_BUILT_IN (olddecl))
3633 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3634 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3635 /* If we're keeping the built-in definition, keep the rtl,
3636 regardless of declaration matches. */
3637 SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3640 DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3642 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3643 /* Don't clear out the arguments if we're redefining a function. */
3644 if (DECL_ARGUMENTS (olddecl))
3645 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3648 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3649 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3651 /* Now preserve various other info from the definition. */
3652 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3653 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3654 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3655 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3657 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3661 function_size = sizeof (struct tree_decl);
3663 memcpy ((char *) olddecl + sizeof (struct tree_common),
3664 (char *) newdecl + sizeof (struct tree_common),
3665 function_size - sizeof (struct tree_common));
3667 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3669 /* If newdecl is a template instantiation, it is possible that
3670 the following sequence of events has occurred:
3672 o A friend function was declared in a class template. The
3673 class template was instantiated.
3675 o The instantiation of the friend declaration was
3676 recorded on the instantiation list, and is newdecl.
3678 o Later, however, instantiate_class_template called pushdecl
3679 on the newdecl to perform name injection. But, pushdecl in
3680 turn called duplicate_decls when it discovered that another
3681 declaration of a global function with the same name already
3684 o Here, in duplicate_decls, we decided to clobber newdecl.
3686 If we're going to do that, we'd better make sure that
3687 olddecl, and not newdecl, is on the list of
3688 instantiations so that if we try to do the instantiation
3689 again we won't get the clobbered declaration. */
3691 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3692 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3694 for (; decls; decls = TREE_CHAIN (decls))
3695 if (TREE_VALUE (decls) == newdecl)
3696 TREE_VALUE (decls) = olddecl;
3701 memcpy ((char *) olddecl + sizeof (struct tree_common),
3702 (char *) newdecl + sizeof (struct tree_common),
3703 sizeof (struct tree_decl) - sizeof (struct tree_common)
3704 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3707 DECL_UID (olddecl) = olddecl_uid;
3709 DECL_FRIEND_P (olddecl) = 1;
3711 /* NEWDECL contains the merged attribute lists.
3712 Update OLDDECL to be the same. */
3713 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3718 /* Record a decl-node X as belonging to the current lexical scope.
3719 Check for errors (such as an incompatible declaration for the same
3720 name already seen in the same scope).
3722 Returns either X or an old decl for the same name.
3723 If an old decl is returned, it may have been smashed
3724 to agree with what X says. */
3731 int need_new_binding;
3733 timevar_push (TV_NAME_LOOKUP);
3734 /* We shouldn't be calling pushdecl when we're generating RTL for a
3735 function that we already did semantic analysis on previously. */
3736 my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3739 need_new_binding = 1;
3741 if (DECL_TEMPLATE_PARM_P (x))
3742 /* Template parameters have no context; they are not X::T even
3743 when declared within a class or namespace. */
3747 if (current_function_decl && x != current_function_decl
3748 /* A local declaration for a function doesn't constitute
3750 && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3751 /* A local declaration for an `extern' variable is in the
3752 scope of the current namespace, not the current
3754 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3755 && !DECL_CONTEXT (x))
3756 DECL_CONTEXT (x) = current_function_decl;
3758 /* If this is the declaration for a namespace-scope function,
3759 but the declaration itself is in a local scope, mark the
3761 if (TREE_CODE (x) == FUNCTION_DECL
3762 && DECL_NAMESPACE_SCOPE_P (x)
3763 && current_function_decl
3764 && x != current_function_decl)
3765 DECL_LOCAL_FUNCTION_P (x) = 1;
3768 name = DECL_NAME (x);
3771 int different_binding_level = 0;
3773 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3774 name = TREE_OPERAND (name, 0);
3776 /* In case this decl was explicitly namespace-qualified, look it
3777 up in its namespace context. */
3778 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3779 && namespace_bindings_p ())
3780 t = namespace_binding (name, DECL_CONTEXT (x));
3782 t = lookup_name_current_level (name);
3784 /* [basic.link] If there is a visible declaration of an entity
3785 with linkage having the same name and type, ignoring entities
3786 declared outside the innermost enclosing namespace scope, the
3787 block scope declaration declares that same entity and
3788 receives the linkage of the previous declaration. */
3789 if (! t && current_function_decl && x != current_function_decl
3790 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3791 && DECL_EXTERNAL (x))
3793 /* Look in block scope. */
3794 t = IDENTIFIER_VALUE (name);
3795 /* Or in the innermost namespace. */
3797 t = namespace_binding (name, DECL_CONTEXT (x));
3798 /* Does it have linkage? Note that if this isn't a DECL, it's an
3799 OVERLOAD, which is OK. */
3800 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3803 different_binding_level = 1;
3806 /* If we are declaring a function, and the result of name-lookup
3807 was an OVERLOAD, look for an overloaded instance that is
3808 actually the same as the function we are declaring. (If
3809 there is one, we have to merge our declaration with the
3810 previous declaration.) */
3811 if (t && TREE_CODE (t) == OVERLOAD)
3815 if (TREE_CODE (x) == FUNCTION_DECL)
3816 for (match = t; match; match = OVL_NEXT (match))
3818 if (decls_match (OVL_CURRENT (match), x))
3822 /* Just choose one. */
3826 t = OVL_CURRENT (match);
3831 if (t == error_mark_node)
3833 /* error_mark_node is 0 for a while during initialization! */
3835 cp_error_at ("`%#D' used prior to declaration", x);
3837 else if (t != NULL_TREE)
3839 if (different_binding_level)
3841 if (decls_match (x, t))
3842 /* The standard only says that the local extern
3843 inherits linkage from the previous decl; in
3844 particular, default args are not shared. It would
3845 be nice to propagate inlining info, though. FIXME. */
3846 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3848 else if (TREE_CODE (t) == PARM_DECL)
3850 if (DECL_CONTEXT (t) == NULL_TREE)
3851 /* This is probaby caused by too many errors, but calling
3852 abort will say that if errors have occurred. */
3855 /* Check for duplicate params. */
3856 if (duplicate_decls (x, t))
3857 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3859 else if ((DECL_EXTERN_C_FUNCTION_P (x)
3860 || DECL_FUNCTION_TEMPLATE_P (x))
3861 && is_overloaded_fn (t))
3862 /* Don't do anything just yet. */;
3863 else if (t == wchar_decl_node)
3865 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3866 pedwarn ("redeclaration of `wchar_t' as `%T'",
3869 /* Throw away the redeclaration. */
3870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3872 else if (TREE_CODE (t) != TREE_CODE (x))
3874 if (duplicate_decls (x, t))
3875 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3877 else if (duplicate_decls (x, t))
3879 if (TREE_CODE (t) == TYPE_DECL)
3880 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3881 else if (TREE_CODE (t) == FUNCTION_DECL)
3882 check_default_args (t);
3884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3886 else if (DECL_MAIN_P (x))
3888 /* A redeclaration of main, but not a duplicate of the
3893 This function shall not be overloaded. */
3894 cp_error_at ("invalid redeclaration of `%D'", t);
3895 error ("as `%D'", x);
3896 /* We don't try to push this declaration since that
3898 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3902 check_template_shadow (x);
3904 /* If this is a function conjured up by the backend, massage it
3905 so it looks friendly. */
3906 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3908 retrofit_lang_decl (x);
3909 SET_DECL_LANGUAGE (x, lang_c);
3912 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3914 t = push_overloaded_decl (x, PUSH_LOCAL);
3916 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3917 if (!namespace_bindings_p ())
3918 /* We do not need to create a binding for this name;
3919 push_overloaded_decl will have already done so if
3921 need_new_binding = 0;
3923 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3925 t = push_overloaded_decl (x, PUSH_GLOBAL);
3927 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3928 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3931 /* If declaring a type as a typedef, copy the type (unless we're
3932 at line 0), and install this TYPE_DECL as the new type's typedef
3933 name. See the extensive comment in ../c-decl.c (pushdecl). */
3934 if (TREE_CODE (x) == TYPE_DECL)
3936 tree type = TREE_TYPE (x);
3937 if (DECL_SOURCE_LINE (x) == 0)
3939 if (TYPE_NAME (type) == 0)
3940 TYPE_NAME (type) = x;
3942 else if (type != error_mark_node && TYPE_NAME (type) != x
3943 /* We don't want to copy the type when all we're
3944 doing is making a TYPE_DECL for the purposes of
3946 && (!TYPE_NAME (type)
3947 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3949 DECL_ORIGINAL_TYPE (x) = type;
3950 type = build_type_copy (type);
3951 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3952 TYPE_NAME (type) = x;
3953 TREE_TYPE (x) = type;
3956 if (type != error_mark_node
3958 && TYPE_IDENTIFIER (type))
3959 set_identifier_type_value_with_scope (DECL_NAME (x), type,
3960 current_binding_level);
3964 /* Multiple external decls of the same identifier ought to match.
3966 We get warnings about inline functions where they are defined.
3967 We get warnings about other functions from push_overloaded_decl.
3969 Avoid duplicate warnings where they are used. */
3970 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3974 decl = IDENTIFIER_NAMESPACE_VALUE (name);
3975 if (decl && TREE_CODE (decl) == OVERLOAD)
3976 decl = OVL_FUNCTION (decl);
3978 if (decl && decl != error_mark_node
3979 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
3980 /* If different sort of thing, we already gave an error. */
3981 && TREE_CODE (decl) == TREE_CODE (x)
3982 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3984 pedwarn ("type mismatch with previous external decl", x);
3985 cp_pedwarn_at ("previous external decl of `%#D'", decl);
3989 /* This name is new in its binding level.
3990 Install the new declaration and return it. */
3991 if (namespace_bindings_p ())
3993 /* Install a global value. */
3995 /* If the first global decl has external linkage,
3996 warn if we later see static one. */
3997 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3998 TREE_PUBLIC (name) = 1;
4000 /* Bind the name for the entity. */
4001 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
4003 && (TREE_CODE (x) == TYPE_DECL
4004 || TREE_CODE (x) == VAR_DECL
4005 || TREE_CODE (x) == ALIAS_DECL
4006 || TREE_CODE (x) == NAMESPACE_DECL
4007 || TREE_CODE (x) == CONST_DECL
4008 || TREE_CODE (x) == TEMPLATE_DECL))
4009 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
4011 /* Don't forget if the function was used via an implicit decl. */
4012 if (IDENTIFIER_IMPLICIT_DECL (name)
4013 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
4016 /* Don't forget if its address was taken in that way. */
4017 if (IDENTIFIER_IMPLICIT_DECL (name)
4018 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
4019 TREE_ADDRESSABLE (x) = 1;
4021 /* Warn about mismatches against previous implicit decl. */
4022 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
4023 /* If this real decl matches the implicit, don't complain. */
4024 && ! (TREE_CODE (x) == FUNCTION_DECL
4025 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
4027 ("`%D' was previously implicitly declared to return `int'", x);
4029 /* If new decl is `static' and an `extern' was seen previously,
4031 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
4032 warn_extern_redeclared_static (x, t);
4036 /* Here to install a non-global value. */
4037 tree oldlocal = IDENTIFIER_VALUE (name);
4038 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
4040 if (need_new_binding)
4042 push_local_binding (name, x, 0);
4043 /* Because push_local_binding will hook X on to the
4044 current_binding_level's name list, we don't want to
4045 do that again below. */
4046 need_new_binding = 0;
4049 /* If this is a TYPE_DECL, push it into the type value slot. */
4050 if (TREE_CODE (x) == TYPE_DECL)
4051 set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4052 current_binding_level);
4054 /* Clear out any TYPE_DECL shadowed by a namespace so that
4055 we won't think this is a type. The C struct hack doesn't
4056 go through namespaces. */
4057 if (TREE_CODE (x) == NAMESPACE_DECL)
4058 set_identifier_type_value_with_scope (name, NULL_TREE,
4059 current_binding_level);
4066 && TREE_CODE (oldlocal) == VAR_DECL
4067 && DECL_DEAD_FOR_LOCAL (oldlocal))
4068 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4070 if (oldlocal == NULL_TREE)
4071 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4074 /* If this is an extern function declaration, see if we
4075 have a global definition or declaration for the function. */
4076 if (oldlocal == NULL_TREE
4077 && DECL_EXTERNAL (x)
4078 && oldglobal != NULL_TREE
4079 && TREE_CODE (x) == FUNCTION_DECL
4080 && TREE_CODE (oldglobal) == FUNCTION_DECL)
4082 /* We have one. Their types must agree. */
4083 if (decls_match (x, oldglobal))
4087 warning ("extern declaration of `%#D' doesn't match", x);
4088 cp_warning_at ("global declaration `%#D'", oldglobal);
4091 /* If we have a local external declaration,
4092 and no file-scope declaration has yet been seen,
4093 then if we later have a file-scope decl it must not be static. */
4094 if (oldlocal == NULL_TREE
4095 && oldglobal == NULL_TREE
4096 && DECL_EXTERNAL (x)
4098 TREE_PUBLIC (name) = 1;
4100 /* Warn if shadowing an argument at the top level of the body. */
4101 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4102 /* Inline decls shadow nothing. */
4103 && !DECL_FROM_INLINE (x)
4104 && TREE_CODE (oldlocal) == PARM_DECL)
4108 /* Don't complain if it's from an enclosing function. */
4109 if (DECL_CONTEXT (oldlocal) == current_function_decl
4110 && TREE_CODE (x) != PARM_DECL)
4112 /* Go to where the parms should be and see if we find
4114 struct cp_binding_level *b = current_binding_level->level_chain;
4116 /* Skip the ctor/dtor cleanup level. */
4120 if (b->parm_flag == 1)
4122 error ("declaration of `%#D' shadows a parameter",
4128 if (warn_shadow && !err)
4129 shadow_warning ("a parameter", name, oldlocal);
4132 /* Maybe warn if shadowing something else. */
4133 else if (warn_shadow && !DECL_EXTERNAL (x)
4134 /* No shadow warnings for internally generated vars. */
4135 && ! DECL_ARTIFICIAL (x)
4136 /* No shadow warnings for vars made for inlining. */
4137 && ! DECL_FROM_INLINE (x))
4139 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4140 && current_class_ptr
4141 && !TREE_STATIC (name))
4142 warning ("declaration of `%s' shadows a member of `this'",
4143 IDENTIFIER_POINTER (name));
4144 else if (oldlocal != NULL_TREE
4145 && TREE_CODE (oldlocal) == VAR_DECL)
4146 shadow_warning ("a previous local", name, oldlocal);
4147 else if (oldglobal != NULL_TREE
4148 && TREE_CODE (oldglobal) == VAR_DECL)
4149 /* XXX shadow warnings in outer-more namespaces */
4150 shadow_warning ("a global declaration", name, oldglobal);
4154 if (TREE_CODE (x) == FUNCTION_DECL)
4155 check_default_args (x);
4157 if (TREE_CODE (x) == VAR_DECL)
4158 maybe_register_incomplete_var (x);
4161 if (need_new_binding)
4162 add_decl_to_level (x,
4163 DECL_NAMESPACE_SCOPE_P (x)
4164 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4165 : current_binding_level);
4167 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
4170 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4171 caller to set DECL_CONTEXT properly. */
4174 pushdecl_with_scope (tree x, struct cp_binding_level* level)
4176 register struct cp_binding_level *b;
4177 tree function_decl = current_function_decl;
4179 timevar_push (TV_NAME_LOOKUP);
4180 current_function_decl = NULL_TREE;
4181 if (level->parm_flag == 2)
4183 b = class_binding_level;
4184 class_binding_level = level;
4185 pushdecl_class_level (x);
4186 class_binding_level = b;
4190 b = current_binding_level;
4191 current_binding_level = level;
4193 current_binding_level = b;
4195 current_function_decl = function_decl;
4196 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
4199 /* Like pushdecl, only it places X in the current namespace,
4203 pushdecl_namespace_level (tree x)
4205 register struct cp_binding_level *b = current_binding_level;
4208 timevar_push (TV_NAME_LOOKUP);
4209 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4211 /* Now, the type_shadowed stack may screw us. Munge it so it does
4213 if (TREE_CODE (x) == TYPE_DECL)
4215 tree name = DECL_NAME (x);
4217 tree *ptr = (tree *)0;
4218 for (; b != global_binding_level; b = b->level_chain)
4220 tree shadowed = b->type_shadowed;
4221 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4222 if (TREE_PURPOSE (shadowed) == name)
4224 ptr = &TREE_VALUE (shadowed);
4225 /* Can't break out of the loop here because sometimes
4226 a binding level will have duplicate bindings for
4227 PT names. It's gross, but I haven't time to fix it. */
4230 newval = TREE_TYPE (x);
4231 if (ptr == (tree *)0)
4233 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4234 up here if this is changed to an assertion. --KR */
4235 SET_IDENTIFIER_TYPE_VALUE (name, newval);
4242 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4245 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4249 pushdecl_top_level (tree x)
4251 timevar_push (TV_NAME_LOOKUP);
4252 push_to_top_level ();
4253 x = pushdecl_namespace_level (x);
4254 pop_from_top_level ();
4255 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
4258 /* Make the declaration of X appear in CLASS scope. */
4261 pushdecl_class_level (tree x)
4265 timevar_push (TV_NAME_LOOKUP);
4266 /* Get the name of X. */
4267 if (TREE_CODE (x) == OVERLOAD)
4268 name = DECL_NAME (get_first_fn (x));
4270 name = DECL_NAME (x);
4274 push_class_level_binding (name, x);
4275 if (TREE_CODE (x) == TYPE_DECL)
4276 set_identifier_type_value (name, TREE_TYPE (x));
4278 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4280 /* If X is an anonymous aggregate, all of its members are
4281 treated as if they were members of the class containing the
4282 aggregate, for naming purposes. */
4285 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
4286 pushdecl_class_level (f);
4288 timevar_pop (TV_NAME_LOOKUP);
4291 /* Enter DECL into the symbol table, if that's appropriate. Returns
4292 DECL, or a modified version thereof. */
4295 maybe_push_decl (tree decl)
4297 tree type = TREE_TYPE (decl);
4299 /* Add this decl to the current binding level, but not if it comes
4300 from another scope, e.g. a static member variable. TEM may equal
4301 DECL or it may be a previous decl of the same name. */
4302 if (decl == error_mark_node
4303 || (TREE_CODE (decl) != PARM_DECL
4304 && DECL_CONTEXT (decl) != NULL_TREE
4305 /* Definitions of namespace members outside their namespace are
4307 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4308 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4309 || TREE_CODE (type) == UNKNOWN_TYPE
4310 /* The declaration of a template specialization does not affect
4311 the functions available for overload resolution, so we do not
4313 || (TREE_CODE (decl) == FUNCTION_DECL
4314 && DECL_TEMPLATE_SPECIALIZATION (decl)))
4317 return pushdecl (decl);
4320 /* Make the declaration(s) of X appear in CLASS scope
4321 under the name NAME. */
4324 push_class_level_binding (tree name, tree x)
4327 timevar_push (TV_NAME_LOOKUP);
4328 /* The class_binding_level will be NULL if x is a template
4329 parameter name in a member template. */
4330 if (!class_binding_level)
4331 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
4333 /* Make sure that this new member does not have the same name
4334 as a template parameter. */
4335 if (TYPE_BEING_DEFINED (current_class_type))
4336 check_template_shadow (x);
4338 /* If this declaration shadows a declaration from an enclosing
4339 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4340 we leave this class. Record the shadowed declaration here. */
4341 binding = IDENTIFIER_BINDING (name);
4343 && ((TREE_CODE (x) == OVERLOAD
4344 && BINDING_VALUE (binding)
4345 && is_overloaded_fn (BINDING_VALUE (binding)))
4346 || INHERITED_VALUE_BINDING_P (binding)))
4351 /* If the old binding was from a base class, and was for a tag
4352 name, slide it over to make room for the new binding. The
4353 old binding is still visible if explicitly qualified with a
4355 if (INHERITED_VALUE_BINDING_P (binding)
4356 && BINDING_VALUE (binding)
4357 && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4358 && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4359 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4361 old_decl = BINDING_TYPE (binding);
4362 BINDING_TYPE (binding) = BINDING_VALUE (binding);
4363 BINDING_VALUE (binding) = NULL_TREE;
4364 INHERITED_VALUE_BINDING_P (binding) = 0;
4367 old_decl = BINDING_VALUE (binding);
4369 /* Find the previous binding of name on the class-shadowed
4370 list, and update it. */
4371 for (shadow = class_binding_level->class_shadowed;
4373 shadow = TREE_CHAIN (shadow))
4374 if (TREE_PURPOSE (shadow) == name
4375 && TREE_TYPE (shadow) == old_decl)
4377 BINDING_VALUE (binding) = x;
4378 INHERITED_VALUE_BINDING_P (binding) = 0;
4379 TREE_TYPE (shadow) = x;
4380 IDENTIFIER_CLASS_VALUE (name) = x;
4381 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
4385 /* If we didn't replace an existing binding, put the binding on the
4386 stack of bindings for the identifier, and update the shadowed list. */
4387 if (push_class_binding (name, x))
4389 class_binding_level->class_shadowed
4390 = tree_cons (name, NULL,
4391 class_binding_level->class_shadowed);
4392 /* Record the value we are binding NAME to so that we can know
4393 what to pop later. */
4394 TREE_TYPE (class_binding_level->class_shadowed) = x;
4396 timevar_pop (TV_NAME_LOOKUP);
4399 /* Insert another USING_DECL into the current binding level, returning
4400 this declaration. If this is a redeclaration, do nothing, and
4401 return NULL_TREE if this not in namespace scope (in namespace
4402 scope, a using decl might extend any previous bindings). */
4405 push_using_decl (tree scope, tree name)
4409 timevar_push (TV_NAME_LOOKUP);
4410 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4411 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4412 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4413 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4416 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4417 namespace_bindings_p () ? decl : NULL_TREE);
4418 decl = build_lang_decl (USING_DECL, name, void_type_node);
4419 DECL_INITIAL (decl) = scope;
4420 TREE_CHAIN (decl) = current_binding_level->usings;
4421 current_binding_level->usings = decl;
4422 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4425 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4426 changed (i.e. there was already a directive), or the fresh
4427 TREE_LIST otherwise. */
4430 push_using_directive (tree used)
4432 tree ud = current_binding_level->using_directives;
4433 tree iter, ancestor;
4435 timevar_push (TV_NAME_LOOKUP);
4436 /* Check if we already have this. */
4437 if (purpose_member (used, ud) != NULL_TREE)
4438 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4440 /* Recursively add all namespaces used. */
4441 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4442 push_using_directive (TREE_PURPOSE (iter));
4444 ancestor = namespace_ancestor (current_decl_namespace (), used);
4445 ud = current_binding_level->using_directives;
4446 ud = tree_cons (used, ancestor, ud);
4447 current_binding_level->using_directives = ud;
4448 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4451 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4452 other definitions already in place. We get around this by making
4453 the value of the identifier point to a list of all the things that
4454 want to be referenced by that name. It is then up to the users of
4455 that name to decide what to do with that list.
4457 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4458 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4460 FLAGS is a bitwise-or of the following values:
4461 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4463 PUSH_USING: DECL is being pushed as the result of a using
4466 The value returned may be a previous declaration if we guessed wrong
4467 about what language DECL should belong to (C or C++). Otherwise,
4468 it's always DECL (and never something that's not a _DECL). */
4471 push_overloaded_decl (tree decl, int flags)
4473 tree name = DECL_NAME (decl);
4476 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4478 timevar_push (TV_NAME_LOOKUP);
4480 old = namespace_binding (name, DECL_CONTEXT (decl));
4482 old = lookup_name_current_level (name);
4486 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4488 tree t = TREE_TYPE (old);
4489 if (IS_AGGR_TYPE (t) && warn_shadow
4490 && (! DECL_IN_SYSTEM_HEADER (decl)
4491 || ! DECL_IN_SYSTEM_HEADER (old)))
4492 warning ("`%#D' hides constructor for `%#T'", decl, t);
4495 else if (is_overloaded_fn (old))
4499 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4501 tree fn = OVL_CURRENT (tmp);
4503 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4504 && !(flags & PUSH_USING)
4505 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4506 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4507 error ("`%#D' conflicts with previous using declaration `%#D'",
4510 if (duplicate_decls (decl, fn))
4511 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
4514 else if (old == error_mark_node)
4515 /* Ignore the undefined symbol marker. */
4519 cp_error_at ("previous non-function declaration `%#D'", old);
4520 error ("conflicts with function declaration `%#D'", decl);
4521 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4525 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4527 if (old && TREE_CODE (old) != OVERLOAD)
4528 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4530 new_binding = ovl_cons (decl, old);
4531 if (flags & PUSH_USING)
4532 OVL_USED (new_binding) = 1;
4535 /* NAME is not ambiguous. */
4539 set_namespace_binding (name, current_namespace, new_binding);
4542 /* We only create an OVERLOAD if there was a previous binding at
4543 this level, or if decl is a template. In the former case, we
4544 need to remove the old binding and replace it with the new
4545 binding. We must also run through the NAMES on the binding
4546 level where the name was bound to update the chain. */
4548 if (TREE_CODE (new_binding) == OVERLOAD && old)
4552 for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4554 d = &TREE_CHAIN (*d))
4556 || (TREE_CODE (*d) == TREE_LIST
4557 && TREE_VALUE (*d) == old))
4559 if (TREE_CODE (*d) == TREE_LIST)
4560 /* Just replace the old binding with the new. */
4561 TREE_VALUE (*d) = new_binding;
4563 /* Build a TREE_LIST to wrap the OVERLOAD. */
4564 *d = tree_cons (NULL_TREE, new_binding,
4567 /* And update the CPLUS_BINDING node. */
4568 BINDING_VALUE (IDENTIFIER_BINDING (name))
4570 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4573 /* We should always find a previous binding in this case. */
4577 /* Install the new binding. */
4578 push_local_binding (name, new_binding, flags);
4581 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4584 /* Generate an implicit declaration for identifier FUNCTIONID
4585 as a function of type int (). Print a warning if appropriate. */
4588 implicitly_declare (tree functionid)
4592 /* We used to reuse an old implicit decl here,
4593 but this loses with inline functions because it can clobber
4594 the saved decl chains. */
4595 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4597 DECL_EXTERNAL (decl) = 1;
4598 TREE_PUBLIC (decl) = 1;
4600 /* ISO standard says implicit declarations are in the innermost block.
4601 So we record the decl in the standard fashion. */
4603 rest_of_decl_compilation (decl, NULL, 0, 0);
4606 /* Only one warning per identifier. */
4607 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4609 pedwarn ("implicit declaration of function `%#D'", decl);
4612 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4617 /* Return zero if the declaration NEWDECL is valid
4618 when the declaration OLDDECL (assumed to be for the same name)
4619 has already been seen.
4620 Otherwise return an error message format string with a %s
4621 where the identifier should go. */
4624 redeclaration_error_message (tree newdecl, tree olddecl)
4626 if (TREE_CODE (newdecl) == TYPE_DECL)
4628 /* Because C++ can put things into name space for free,
4629 constructs like "typedef struct foo { ... } foo"
4630 would look like an erroneous redeclaration. */
4631 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4634 return "redefinition of `%#D'";
4636 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4638 /* If this is a pure function, its olddecl will actually be
4639 the original initialization to `0' (which we force to call
4640 abort()). Don't complain about redefinition in this case. */
4641 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4644 /* If both functions come from different namespaces, this is not
4645 a redeclaration - this is a conflict with a used function. */
4646 if (DECL_NAMESPACE_SCOPE_P (olddecl)
4647 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4648 return "`%D' conflicts with used function";
4650 /* We'll complain about linkage mismatches in
4651 warn_extern_redeclared_static. */
4653 /* Defining the same name twice is no good. */
4654 if (DECL_INITIAL (olddecl) != NULL_TREE
4655 && DECL_INITIAL (newdecl) != NULL_TREE)
4657 if (DECL_NAME (olddecl) == NULL_TREE)
4658 return "`%#D' not declared in class";
4660 return "redefinition of `%#D'";
4664 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4666 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4667 && (DECL_TEMPLATE_RESULT (newdecl)
4668 != DECL_TEMPLATE_RESULT (olddecl))
4669 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4670 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4671 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4672 && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4673 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4674 return "redefinition of `%#D'";
4677 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4679 /* Objects declared at top level: */
4680 /* If at least one is a reference, it's ok. */
4681 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4683 /* Reject two definitions. */
4684 return "redefinition of `%#D'";
4688 /* Objects declared with block scope: */
4689 /* Reject two definitions, and reject a definition
4690 together with an external reference. */
4691 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4692 return "redeclaration of `%#D'";
4697 /* Create a new label, named ID. */
4700 make_label_decl (tree id, int local_p)
4704 decl = build_decl (LABEL_DECL, id, void_type_node);
4706 /* Make sure every label has an rtx. */
4709 DECL_CONTEXT (decl) = current_function_decl;
4710 DECL_MODE (decl) = VOIDmode;
4711 C_DECLARED_LABEL_FLAG (decl) = local_p;
4713 /* Say where one reference is to the label, for the sake of the
4714 error if it is not defined. */
4715 DECL_SOURCE_LINE (decl) = lineno;
4716 DECL_SOURCE_FILE (decl) = input_filename;
4718 /* Record the fact that this identifier is bound to this label. */
4719 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4724 /* Record this label on the list of used labels so that we can check
4725 at the end of the function to see whether or not the label was
4726 actually defined, and so we can check when the label is defined whether
4727 this use is valid. */
4730 use_label (tree decl)
4732 if (named_label_uses == NULL
4733 || named_label_uses->names_in_scope != current_binding_level->names
4734 || named_label_uses->label_decl != decl)
4736 struct named_label_use_list *new_ent;
4737 new_ent = ((struct named_label_use_list *)
4738 ggc_alloc (sizeof (struct named_label_use_list)));
4739 new_ent->label_decl = decl;
4740 new_ent->names_in_scope = current_binding_level->names;
4741 new_ent->binding_level = current_binding_level;
4742 new_ent->lineno_o_goto = lineno;
4743 new_ent->filename_o_goto = input_filename;
4744 new_ent->next = named_label_uses;
4745 named_label_uses = new_ent;
4749 /* Look for a label named ID in the current function. If one cannot
4750 be found, create one. (We keep track of used, but undefined,
4751 labels, and complain about them at the end of a function.) */
4754 lookup_label (tree id)
4757 struct named_label_list *ent;
4759 timevar_push (TV_NAME_LOOKUP);
4760 /* You can't use labels at global scope. */
4761 if (current_function_decl == NULL_TREE)
4763 error ("label `%s' referenced outside of any function",
4764 IDENTIFIER_POINTER (id));
4765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4768 /* See if we've already got this label. */
4769 decl = IDENTIFIER_LABEL_VALUE (id);
4770 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4771 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4773 /* Record this label on the list of labels used in this function.
4774 We do this before calling make_label_decl so that we get the
4775 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4776 ent = ((struct named_label_list *)
4777 ggc_alloc_cleared (sizeof (struct named_label_list)));
4778 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4779 ent->next = named_labels;
4782 /* We need a new label. */
4783 decl = make_label_decl (id, /*local_p=*/0);
4785 /* Now fill in the information we didn't have before. */
4786 ent->label_decl = decl;
4788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4791 /* Declare a local label named ID. */
4794 declare_local_label (tree id)
4798 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4799 this scope we can restore the old value of
4800 IDENTIFIER_TYPE_VALUE. */
4801 current_binding_level->shadowed_labels
4802 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4803 current_binding_level->shadowed_labels);
4804 /* Look for the label. */
4805 decl = make_label_decl (id, /*local_p=*/1);
4806 /* Now fill in the information we didn't have before. */
4807 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4812 /* Returns nonzero if it is ill-formed to jump past the declaration of
4813 DECL. Returns 2 if it's also a real problem. */
4816 decl_jump_unsafe (tree decl)
4818 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4821 if (DECL_INITIAL (decl) == NULL_TREE
4822 && pod_type_p (TREE_TYPE (decl)))
4825 /* This is really only important if we're crossing an initialization.
4826 The POD stuff is just pedantry; why should it matter if the class
4827 contains a field of pointer to member type? */
4828 if (DECL_INITIAL (decl)
4829 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4834 /* Check that a single previously seen jump to a newly defined label
4835 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4836 the jump context; NAMES are the names in scope in LEVEL at the jump
4837 context; FILE and LINE are the source position of the jump or 0. */
4840 check_previous_goto_1 (tree decl,
4841 struct cp_binding_level* level,
4848 struct cp_binding_level *b = current_binding_level;
4849 for (; b; b = b->level_chain)
4851 tree new_decls = b->names;
4852 tree old_decls = (b == level ? names : NULL_TREE);
4853 for (; new_decls != old_decls;
4854 new_decls = TREE_CHAIN (new_decls))
4856 int problem = decl_jump_unsafe (new_decls);
4863 pedwarn ("jump to label `%D'", decl);
4865 pedwarn ("jump to case label");
4868 pedwarn_with_file_and_line (file, line, " from here");
4873 cp_error_at (" crosses initialization of `%#D'",
4876 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4882 if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4887 pedwarn ("jump to label `%D'", decl);
4889 pedwarn ("jump to case label");
4892 pedwarn_with_file_and_line (file, line, " from here");
4895 if (b->is_try_scope)
4896 error (" enters try block");
4898 error (" enters catch block");
4905 check_previous_goto (struct named_label_use_list* use)
4907 check_previous_goto_1 (use->label_decl, use->binding_level,
4908 use->names_in_scope, use->filename_o_goto,
4909 use->lineno_o_goto);
4913 check_switch_goto (struct cp_binding_level* level)
4915 check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4918 /* Check that any previously seen jumps to a newly defined label DECL
4919 are OK. Called by define_label. */
4922 check_previous_gotos (tree decl)
4924 struct named_label_use_list **usep;
4926 if (! TREE_USED (decl))
4929 for (usep = &named_label_uses; *usep; )
4931 struct named_label_use_list *use = *usep;
4932 if (use->label_decl == decl)
4934 check_previous_goto (use);
4938 usep = &(use->next);
4942 /* Check that a new jump to a label DECL is OK. Called by
4943 finish_goto_stmt. */
4946 check_goto (tree decl)
4950 struct named_label_list *lab;
4952 /* We can't know where a computed goto is jumping. So we assume
4954 if (! DECL_P (decl))
4957 /* If the label hasn't been defined yet, defer checking. */
4958 if (! DECL_INITIAL (decl))
4964 for (lab = named_labels; lab; lab = lab->next)
4965 if (decl == lab->label_decl)
4968 /* If the label is not on named_labels it's a gcc local label, so
4969 it must be in an outer scope, so jumping to it is always OK. */
4973 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
4976 cp_pedwarn_at ("jump to label `%D'", decl);
4977 pedwarn (" from here");
4981 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
4983 tree b = TREE_VALUE (bad);
4984 int u = decl_jump_unsafe (b);
4986 if (u > 1 && DECL_ARTIFICIAL (b))
4987 /* Can't skip init of __exception_info. */
4988 cp_error_at (" enters catch block", b);
4990 cp_error_at (" skips initialization of `%#D'", b);
4992 cp_pedwarn_at (" enters scope of non-POD `%#D'", b);
4995 if (lab->in_try_scope)
4996 error (" enters try block");
4997 else if (lab->in_catch_scope)
4998 error (" enters catch block");
5001 /* Define a label, specifying the location in the source file.
5002 Return the LABEL_DECL node for the label, if the definition is valid.
5003 Otherwise return 0. */
5006 define_label (const char* filename, int line, tree name)
5008 tree decl = lookup_label (name);
5009 struct named_label_list *ent;
5010 register struct cp_binding_level *p;
5012 timevar_push (TV_NAME_LOOKUP);
5013 for (ent = named_labels; ent; ent = ent->next)
5014 if (ent->label_decl == decl)
5017 /* After labels, make any new cleanups in the function go into their
5018 own new (temporary) binding contour. */
5019 for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5020 p->more_cleanups_ok = 0;
5022 if (name == get_identifier ("wchar_t"))
5023 pedwarn ("label named wchar_t");
5025 if (DECL_INITIAL (decl) != NULL_TREE)
5027 error ("duplicate label `%D'", decl);
5028 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5032 /* Mark label as having been defined. */
5033 DECL_INITIAL (decl) = error_mark_node;
5034 /* Say where in the source. */
5035 DECL_SOURCE_FILE (decl) = filename;
5036 DECL_SOURCE_LINE (decl) = line;
5039 ent->names_in_scope = current_binding_level->names;
5040 ent->binding_level = current_binding_level;
5042 check_previous_gotos (decl);
5043 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5045 timevar_pop (TV_NAME_LOOKUP);
5050 struct cp_binding_level *level;
5051 struct cp_switch *next;
5052 /* The SWITCH_STMT being built. */
5054 /* A splay-tree mapping the low element of a case range to the high
5055 element, or NULL_TREE if there is no high element. Used to
5056 determine whether or not a new case label duplicates an old case
5057 label. We need a tree, rather than simply a hash table, because
5058 of the GNU case range extension. */
5062 /* A stack of the currently active switch statements. The innermost
5063 switch statement is on the top of the stack. There is no need to
5064 mark the stack for garbage collection because it is only active
5065 during the processing of the body of a function, and we never
5066 collect at that point. */
5068 static struct cp_switch *switch_stack;
5070 /* Called right after a switch-statement condition is parsed.
5071 SWITCH_STMT is the switch statement being parsed. */
5074 push_switch (tree switch_stmt)
5077 = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5078 p->level = current_binding_level;
5079 p->next = switch_stack;
5080 p->switch_stmt = switch_stmt;
5081 p->cases = splay_tree_new (case_compare, NULL, NULL);
5088 struct cp_switch *cs;
5091 splay_tree_delete (cs->cases);
5092 switch_stack = switch_stack->next;
5096 /* Note that we've seen a definition of a case label, and complain if this
5097 is a bad place for one. */
5100 finish_case_label (tree low_value, tree high_value)
5103 register struct cp_binding_level *p;
5108 error ("case label not within a switch statement");
5110 error ("case label `%E' not within a switch statement",
5113 error ("`default' label not within a switch statement");
5117 if (processing_template_decl)
5121 /* For templates, just add the case label; we'll do semantic
5122 analysis at instantiation-time. */
5123 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5124 return add_stmt (build_case_label (low_value, high_value, label));
5127 /* Find the condition on which this switch statement depends. */
5128 cond = SWITCH_COND (switch_stack->switch_stmt);
5129 if (cond && TREE_CODE (cond) == TREE_LIST)
5130 cond = TREE_VALUE (cond);
5132 r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5134 check_switch_goto (switch_stack->level);
5136 /* After labels, make any new cleanups in the function go into their
5137 own new (temporary) binding contour. */
5138 for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5139 p->more_cleanups_ok = 0;
5144 /* Return the list of declarations of the current level.
5145 Note that this list is in reverse order unless/until
5146 you nreverse it; and when you do nreverse it, you must
5147 store the result back using `storedecls' or you will lose. */
5152 return current_binding_level->names;
5155 /* Return the list of type-tags (for structs, etc) of the current level. */
5160 return current_binding_level->tags;
5163 /* Store the list of declarations of the current level.
5164 This is done for the parameter declarations of a function being defined,
5165 after they are modified in the light of any missing parameters. */
5168 storedecls (tree decls)
5170 current_binding_level->names = decls;
5173 /* Similarly, store the list of tags of the current level. */
5176 storetags (tree tags)
5178 current_binding_level->tags = tags;
5181 /* Return the type that should be used when TYPE's name is preceded
5182 by a tag such as 'struct' or 'union', or null if the name cannot
5183 be used in this way.
5185 For example, when processing the third line of:
5191 lookup of A will find the typedef. Given A's typedef, this function
5192 will return the type associated with "struct A". For the tag to be
5193 anything other than TYPE, TYPE must be a typedef whose original type
5194 has the same name and context as TYPE itself.
5196 It is not valid for a typedef of an anonymous type to be used with
5199 typedef struct { ... } B;
5202 Return null for this case. */
5205 follow_tag_typedef (tree type)
5209 original = original_type (type);
5210 if (! TYPE_NAME (original))
5212 if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5213 && (CP_DECL_CONTEXT (TYPE_NAME (original))
5214 == CP_DECL_CONTEXT (TYPE_NAME (type)))
5215 && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5221 /* Given NAME, an IDENTIFIER_NODE,
5222 return the structure (or union or enum) definition for that name.
5223 Searches binding levels from BINDING_LEVEL up to the global level.
5224 If THISLEVEL_ONLY is nonzero, searches only the specified context
5225 (but skips any tag-transparent contexts to find one that is
5226 meaningful for tags).
5227 FORM says which kind of type the caller wants;
5228 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5229 If the wrong kind of type is found, and it's not a template, an error is
5233 lookup_tag (enum tree_code form,
5235 struct cp_binding_level* binding_level,
5238 register struct cp_binding_level *level;
5239 /* Nonzero if, we should look past a template parameter level, even
5240 if THISLEVEL_ONLY. */
5241 int allow_template_parms_p = 1;
5243 timevar_push (TV_NAME_LOOKUP);
5244 for (level = binding_level; level; level = level->level_chain)
5247 if (ANON_AGGRNAME_P (name))
5248 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5250 /* There's no need for error checking here, because
5251 anon names are unique throughout the compilation. */
5252 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5253 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (tail));
5255 else if (level->namespace_p)
5256 /* Do namespace lookup. */
5257 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5259 tree old = binding_for_name (name, tail);
5261 /* If we just skipped past a template parameter level,
5262 even though THISLEVEL_ONLY, and we find a template
5263 class declaration, then we use the _TYPE node for the
5264 template. See the example below. */
5265 if (thislevel_only && !allow_template_parms_p
5266 && old && BINDING_VALUE (old)
5267 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5268 old = TREE_TYPE (BINDING_VALUE (old));
5270 old = BINDING_TYPE (old);
5274 /* We've found something at this binding level. If it is
5275 a typedef, extract the tag it refers to. Lookup fails
5276 if the typedef doesn't refer to a taggable type. */
5277 old = follow_tag_typedef (old);
5279 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5280 if (TREE_CODE (old) != form
5281 && (form == ENUMERAL_TYPE
5282 || TREE_CODE (old) == ENUMERAL_TYPE))
5284 error ("`%#D' redeclared as %C", old, form);
5285 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5287 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
5289 if (thislevel_only || tail == global_namespace)
5290 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5293 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5295 if (TREE_PURPOSE (tail) == name)
5297 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5300 && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5302 /* Definition isn't the kind we were looking for. */
5303 error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5304 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5306 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_VALUE (tail));
5309 if (thislevel_only && ! level->tag_transparent)
5311 if (level->template_parms_p && allow_template_parms_p)
5313 /* We must deal with cases like this:
5315 template <class T> struct S;
5316 template <class T> struct S {};
5318 When looking up `S', for the second declaration, we
5319 would like to find the first declaration. But, we
5320 are in the pseudo-global level created for the
5321 template parameters, rather than the (surrounding)
5322 namespace level. Thus, we keep going one more level,
5323 even though THISLEVEL_ONLY is nonzero. */
5324 allow_template_parms_p = 0;
5328 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5331 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5334 /* Given a type, find the tag that was defined for it and return the tag name.
5335 Otherwise return 0. However, the value can never be 0
5336 in the cases in which this is used.
5338 C++: If NAME is nonzero, this is the new name to install. This is
5339 done when replacing anonymous tags with real tag names. */
5342 lookup_tag_reverse (tree type, tree name)
5344 register struct cp_binding_level *level;
5346 timevar_push (TV_NAME_LOOKUP);
5347 for (level = current_binding_level; level; level = level->level_chain)
5350 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5352 if (TREE_VALUE (tail) == type)
5355 TREE_PURPOSE (tail) = name;
5356 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_PURPOSE (tail));
5360 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5363 /* Look up NAME in the NAMESPACE. */
5366 lookup_namespace_name (tree namespace, tree name)
5369 tree template_id = NULL_TREE;
5371 timevar_push (TV_NAME_LOOKUP);
5372 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5374 if (TREE_CODE (name) == NAMESPACE_DECL)
5375 /* This happens for A::B<int> when B is a namespace. */
5376 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
5377 else if (TREE_CODE (name) == TEMPLATE_DECL)
5379 /* This happens for A::B where B is a template, and there are no
5380 template arguments. */
5381 error ("invalid use of `%D'", name);
5382 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5385 namespace = ORIGINAL_NAMESPACE (namespace);
5387 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5390 name = TREE_OPERAND (name, 0);
5391 if (TREE_CODE (name) == OVERLOAD)
5392 name = DECL_NAME (OVL_CURRENT (name));
5393 else if (DECL_P (name))
5394 name = DECL_NAME (name);
5397 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5399 val = make_node (CPLUS_BINDING);
5400 if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5401 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5403 if (BINDING_VALUE (val))
5405 val = BINDING_VALUE (val);
5409 if (DECL_CLASS_TEMPLATE_P (val))
5410 val = lookup_template_class (val,
5411 TREE_OPERAND (template_id, 1),
5412 /*in_decl=*/NULL_TREE,
5413 /*context=*/NULL_TREE,
5414 /*entering_scope=*/0,
5415 tf_error | tf_warning);
5416 else if (DECL_FUNCTION_TEMPLATE_P (val)
5417 || TREE_CODE (val) == OVERLOAD)
5418 val = lookup_template_function (val,
5419 TREE_OPERAND (template_id, 1));
5422 error ("`%D::%D' is not a template",
5424 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5428 /* If we have a single function from a using decl, pull it out. */
5429 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5430 val = OVL_FUNCTION (val);
5432 /* Ignore built-in functions that haven't been prototyped yet. */
5433 if (!val || !DECL_P(val)
5434 || !DECL_LANG_SPECIFIC(val)
5435 || !DECL_ANTICIPATED (val))
5436 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5439 error ("`%D' undeclared in namespace `%D'", name, namespace);
5440 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5443 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5446 typename_hash (const void* k)
5451 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
5452 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
5457 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5460 typename_compare (const void * k1, const void * k2)
5469 d1 = TYPE_NAME (t1);
5470 d2 = TYPE_NAME (t2);
5472 return (DECL_NAME (d1) == DECL_NAME (d2)
5473 && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5474 && ((TREE_TYPE (t1) != NULL_TREE)
5475 == (TREE_TYPE (t2) != NULL_TREE))
5476 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5477 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5480 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5481 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5482 is non-NULL, this type is being created by the implicit typename
5483 extension, and BASE_TYPE is a type named `t' in some base class of
5484 `T' which depends on template parameters.
5486 Returns the new TYPENAME_TYPE. */
5488 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5491 build_typename_type (tree context, tree name, tree fullname)
5497 if (typename_htab == NULL)
5499 typename_htab = htab_create_ggc (61, &typename_hash,
5500 &typename_compare, NULL);
5503 /* Build the TYPENAME_TYPE. */
5504 t = make_aggr_type (TYPENAME_TYPE);
5505 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5506 TYPENAME_TYPE_FULLNAME (t) = fullname;
5508 /* Build the corresponding TYPE_DECL. */
5509 d = build_decl (TYPE_DECL, name, t);
5510 TYPE_NAME (TREE_TYPE (d)) = d;
5511 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5512 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5513 DECL_ARTIFICIAL (d) = 1;
5515 /* See if we already have this type. */
5516 e = htab_find_slot (typename_htab, t, INSERT);
5525 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5526 unless an error occurs, in which case error_mark_node is returned.
5527 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5528 set, we return that, rather than the _TYPE it corresponds to, in
5529 other cases we look through the type decl. If TF_ERROR is set,
5530 complain about errors, otherwise be quiet. */
5533 make_typename_type (tree context, tree name, tsubst_flags_t complain)
5539 if (!(TYPE_LANG_SPECIFIC (name)
5540 && (CLASSTYPE_IS_TEMPLATE (name)
5541 || CLASSTYPE_USE_TEMPLATE (name))))
5542 name = TYPE_IDENTIFIER (name);
5544 /* Create a TEMPLATE_ID_EXPR for the type. */
5545 name = build_nt (TEMPLATE_ID_EXPR,
5546 CLASSTYPE_TI_TEMPLATE (name),
5547 CLASSTYPE_TI_ARGS (name));
5549 else if (TREE_CODE (name) == TYPE_DECL)
5550 name = DECL_NAME (name);
5554 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5556 name = TREE_OPERAND (name, 0);
5557 if (TREE_CODE (name) == TEMPLATE_DECL)
5558 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5560 if (TREE_CODE (name) == TEMPLATE_DECL)
5562 error ("`%D' used without template parameters", name);
5563 return error_mark_node;
5565 if (TREE_CODE (name) != IDENTIFIER_NODE)
5568 if (TREE_CODE (context) == NAMESPACE_DECL)
5570 /* We can get here from typename_sub0 in the explicit_template_type
5571 expansion. Just fail. */
5572 if (complain & tf_error)
5573 error ("no class template named `%#T' in `%#T'",
5575 return error_mark_node;
5578 if (! uses_template_parms (context)
5579 || currently_open_class (context))
5581 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5583 tree tmpl = NULL_TREE;
5584 if (IS_AGGR_TYPE (context))
5585 tmpl = lookup_field (context, name, 0, false);
5586 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5588 if (complain & tf_error)
5589 error ("no class template named `%#T' in `%#T'",
5591 return error_mark_node;
5594 if (complain & tf_error)
5596 if (complain & tf_parsing)
5597 perform_or_defer_access_check (context, tmpl);
5599 enforce_access (context, tmpl);
5602 return lookup_template_class (tmpl,
5603 TREE_OPERAND (fullname, 1),
5605 /*entering_scope=*/0,
5606 tf_error | tf_warning);
5612 if (!IS_AGGR_TYPE (context))
5614 if (complain & tf_error)
5615 error ("no type named `%#T' in `%#T'", name, context);
5616 return error_mark_node;
5619 t = lookup_field (context, name, 0, true);
5622 if (TREE_CODE (t) != TYPE_DECL)
5624 if (complain & tf_error)
5625 error ("no type named `%#T' in `%#T'", name, context);
5626 return error_mark_node;
5629 if (complain & tf_error)
5631 if (complain & tf_parsing)
5632 perform_or_defer_access_check (context, t);
5634 enforce_access (context, t);
5637 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5645 /* If the CONTEXT is not a template type, then either the field is
5646 there now or its never going to be. */
5647 if (!uses_template_parms (context))
5649 if (complain & tf_error)
5650 error ("no type named `%#T' in `%#T'", name, context);
5651 return error_mark_node;
5654 return build_typename_type (context, name, fullname);
5657 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
5658 unless an error occurs, in which case error_mark_node is returned.
5659 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5660 corresponds to. If COMPLAIN zero, don't complain about any errors
5664 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
5670 name = TYPE_IDENTIFIER (name);
5671 else if (DECL_P (name))
5672 name = DECL_NAME (name);
5673 if (TREE_CODE (name) != IDENTIFIER_NODE)
5676 if (!uses_template_parms (context)
5677 || currently_open_class (context))
5679 tree tmpl = NULL_TREE;
5681 if (IS_AGGR_TYPE (context))
5682 tmpl = lookup_field (context, name, 0, false);
5684 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5686 if (complain & tf_error)
5687 error ("no class template named `%#T' in `%#T'", name, context);
5688 return error_mark_node;
5691 if (complain & tf_error)
5693 if (complain & tf_parsing)
5694 perform_or_defer_access_check (context, tmpl);
5696 enforce_access (context, tmpl);
5702 /* Build the UNBOUND_CLASS_TEMPLATE. */
5703 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5704 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5705 TREE_TYPE (t) = NULL_TREE;
5707 /* Build the corresponding TEMPLATE_DECL. */
5708 d = build_decl (TEMPLATE_DECL, name, t);
5709 TYPE_NAME (TREE_TYPE (d)) = d;
5710 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5711 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5712 DECL_ARTIFICIAL (d) = 1;
5717 /* Select the right _DECL from multiple choices. */
5720 select_decl (tree binding, int flags)
5723 val = BINDING_VALUE (binding);
5725 timevar_push (TV_NAME_LOOKUP);
5726 if (LOOKUP_NAMESPACES_ONLY (flags))
5728 /* We are not interested in types. */
5729 if (val && TREE_CODE (val) == NAMESPACE_DECL)
5730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5734 /* If we could have a type and
5735 we have nothing or we need a type and have none. */
5736 if (BINDING_TYPE (binding)
5737 && (!val || ((flags & LOOKUP_PREFER_TYPES)
5738 && TREE_CODE (val) != TYPE_DECL)))
5739 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5740 /* Don't return non-types if we really prefer types. */
5741 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
5742 && (TREE_CODE (val) != TEMPLATE_DECL
5743 || !DECL_CLASS_TEMPLATE_P (val)))
5746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5749 /* Unscoped lookup of a global: iterate over current namespaces,
5750 considering using-directives. If SPACESP is non-NULL, store a list
5751 of the namespaces we've considered in it. */
5754 unqualified_namespace_lookup (tree name, int flags, tree* spacesp)
5756 tree b = make_node (CPLUS_BINDING);
5757 tree initial = current_decl_namespace ();
5758 tree scope = initial;
5760 struct cp_binding_level *level;
5761 tree val = NULL_TREE;
5763 timevar_push (TV_NAME_LOOKUP);
5765 *spacesp = NULL_TREE;
5767 for (; !val; scope = CP_DECL_CONTEXT (scope))
5770 *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5771 val = binding_for_name (name, scope);
5773 /* Ignore anticipated built-in functions. */
5774 if (val && BINDING_VALUE (val)
5775 && DECL_P (BINDING_VALUE (val))
5776 && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5777 && DECL_ANTICIPATED (BINDING_VALUE (val)))
5779 BINDING_VALUE (b) = NULL_TREE;
5780 BINDING_TYPE (b) = NULL_TREE;
5784 /* Initialize binding for this context. */
5785 BINDING_VALUE (b) = BINDING_VALUE (val);
5786 BINDING_TYPE (b) = BINDING_TYPE (val);
5789 /* Add all _DECLs seen through local using-directives. */
5790 for (level = current_binding_level;
5791 !level->namespace_p;
5792 level = level->level_chain)
5793 if (!lookup_using_namespace (name, b, level->using_directives,
5794 scope, flags, spacesp))
5795 /* Give up because of error. */
5796 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5798 /* Add all _DECLs seen through global using-directives. */
5799 /* XXX local and global using lists should work equally. */
5803 if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5804 scope, flags, spacesp))
5805 /* Give up because of error. */
5806 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5807 if (siter == scope) break;
5808 siter = CP_DECL_CONTEXT (siter);
5811 val = select_decl (b, flags);
5812 if (scope == global_namespace)
5815 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
5818 /* Combine prefer_type and namespaces_only into flags. */
5821 lookup_flags (int prefer_type, int namespaces_only)
5823 if (namespaces_only)
5824 return LOOKUP_PREFER_NAMESPACES;
5825 if (prefer_type > 1)
5826 return LOOKUP_PREFER_TYPES;
5827 if (prefer_type > 0)
5828 return LOOKUP_PREFER_BOTH;
5832 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5833 ignore it or not. Subroutine of lookup_name_real. */
5836 qualify_lookup (tree val, int flags)
5838 if (val == NULL_TREE)
5840 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5842 if ((flags & LOOKUP_PREFER_TYPES) && TREE_CODE (val) == TYPE_DECL)
5844 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5849 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5850 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
5853 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5854 declaration found. */
5857 lookup_qualified_name (tree scope, tree name, bool is_type_p, int flags)
5859 if (TREE_CODE (scope) == NAMESPACE_DECL)
5863 val = make_node (CPLUS_BINDING);
5864 flags |= LOOKUP_COMPLAIN;
5866 flags |= LOOKUP_PREFER_TYPES;
5867 if (!qualified_lookup_using_namespace (name, scope, val, flags))
5869 return select_decl (val, flags);
5872 return lookup_member (scope, name, 0, is_type_p);
5875 /* Check to see whether or not DECL is a variable that would have been
5876 in scope under the ARM, but is not in scope under the ANSI/ISO
5877 standard. If so, issue an error message. If name lookup would
5878 work in both cases, but return a different result, this function
5879 returns the result of ANSI/ISO lookup. Otherwise, it returns
5883 check_for_out_of_scope_variable (tree decl)
5887 /* We only care about out of scope variables. */
5888 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
5891 shadowed = DECL_SHADOWED_FOR_VAR (decl);
5892 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
5893 && DECL_DEAD_FOR_LOCAL (shadowed))
5894 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
5896 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
5899 if (!DECL_ERROR_REPORTED (decl))
5901 warning ("name lookup of `%D' changed",
5903 cp_warning_at (" matches this `%D' under ISO standard rules",
5905 cp_warning_at (" matches this `%D' under old rules", decl);
5906 DECL_ERROR_REPORTED (decl) = 1;
5911 /* If we have already complained about this declaration, there's no
5912 need to do it again. */
5913 if (DECL_ERROR_REPORTED (decl))
5916 DECL_ERROR_REPORTED (decl) = 1;
5917 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5919 error ("name lookup of `%D' changed for new ISO `for' scoping",
5921 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl);
5922 return error_mark_node;
5926 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
5928 cp_pedwarn_at (" using obsolete binding at `%D'", decl);
5934 /* Look up NAME in the current binding level and its superiors in the
5935 namespace of variables, functions and typedefs. Return a ..._DECL
5936 node of some kind representing its definition if there is only one
5937 such declaration, or return a TREE_LIST with all the overloaded
5938 definitions if there are many, or return 0 if it is undefined.
5940 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5941 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5942 Otherwise we prefer non-TYPE_DECLs.
5944 If NONCLASS is nonzero, we don't look for the NAME in class scope,
5945 using IDENTIFIER_CLASS_VALUE. */
5948 lookup_name_real (tree name,
5951 int namespaces_only,
5955 tree val = NULL_TREE;
5957 timevar_push (TV_NAME_LOOKUP);
5958 /* Conversion operators are handled specially because ordinary
5959 unqualified name lookup will not find template conversion
5961 if (IDENTIFIER_TYPENAME_P (name))
5963 struct cp_binding_level *level;
5965 for (level = current_binding_level;
5966 level && !level->namespace_p;
5967 level = level->level_chain)
5972 /* A conversion operator can only be declared in a class
5974 if (level->parm_flag != 2)
5977 /* Lookup the conversion operator in the class. */
5978 class_type = level->this_class;
5979 operators = lookup_fnfields (class_type, name, /*protect=*/0);
5981 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
5984 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5987 flags |= lookup_flags (prefer_type, namespaces_only);
5989 /* First, look in non-namespace scopes. */
5991 if (current_class_type == NULL_TREE)
5994 for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5998 if (!LOCAL_BINDING_P (t) && nonclass)
5999 /* We're not looking for class-scoped bindings, so keep going. */
6002 /* If this is the kind of thing we're looking for, we're done. */
6003 if (qualify_lookup (BINDING_VALUE (t), flags))
6004 binding = BINDING_VALUE (t);
6005 else if ((flags & LOOKUP_PREFER_TYPES)
6006 && qualify_lookup (BINDING_TYPE (t), flags))
6007 binding = BINDING_TYPE (t);
6009 binding = NULL_TREE;
6018 /* Now lookup in namespace scopes. */
6021 t = unqualified_namespace_lookup (name, flags, 0);
6028 /* If we have a single function from a using decl, pull it out. */
6029 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
6030 val = OVL_FUNCTION (val);
6033 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
6037 lookup_name_nonclass (tree name)
6039 return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
6043 lookup_function_nonclass (tree name, tree args)
6045 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6049 lookup_name (tree name, int prefer_type)
6051 return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
6054 /* Similar to `lookup_name' but look only in the innermost non-class
6058 lookup_name_current_level (tree name)
6060 struct cp_binding_level *b;
6063 timevar_push (TV_NAME_LOOKUP);
6064 b = current_binding_level;
6065 while (b->parm_flag == 2)
6070 t = IDENTIFIER_NAMESPACE_VALUE (name);
6072 /* extern "C" function() */
6073 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6076 else if (IDENTIFIER_BINDING (name)
6077 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6081 if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6082 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
6091 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6094 /* Like lookup_name_current_level, but for types. */
6097 lookup_type_current_level (tree name)
6099 register tree t = NULL_TREE;
6101 timevar_push (TV_NAME_LOOKUP);
6102 my_friendly_assert (! current_binding_level->namespace_p, 980716);
6104 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6105 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6107 struct cp_binding_level *b = current_binding_level;
6110 if (purpose_member (name, b->type_shadowed))
6111 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
6112 REAL_IDENTIFIER_TYPE_VALUE (name));
6120 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
6124 /* Push the declarations of builtin types into the namespace.
6125 RID_INDEX is the index of the builtin type
6126 in the array RID_POINTERS. NAME is the name used when looking
6127 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6130 record_builtin_type (enum rid rid_index,
6134 tree rname = NULL_TREE, tname = NULL_TREE;
6135 tree tdecl = NULL_TREE;
6137 if ((int) rid_index < (int) RID_MAX)
6138 rname = ridpointers[(int) rid_index];
6140 tname = get_identifier (name);
6144 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6145 set_identifier_type_value (tname, NULL_TREE);
6146 if ((int) rid_index < (int) RID_MAX)
6147 /* Built-in types live in the global namespace. */
6148 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6150 if (rname != NULL_TREE)
6152 if (tname != NULL_TREE)
6154 set_identifier_type_value (rname, NULL_TREE);
6155 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6159 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6160 set_identifier_type_value (rname, NULL_TREE);
6165 /* Record one of the standard Java types.
6166 * Declare it as having the given NAME.
6167 * If SIZE > 0, it is the size of one of the integral types;
6168 * otherwise it is the negative of the size of one of the other types. */
6171 record_builtin_java_type (const char* name, int size)
6175 type = make_signed_type (size);
6176 else if (size > -32)
6177 { /* "__java_char" or ""__java_boolean". */
6178 type = make_unsigned_type (-size);
6179 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6182 { /* "__java_float" or ""__java_double". */
6183 type = make_node (REAL_TYPE);
6184 TYPE_PRECISION (type) = - size;
6187 record_builtin_type (RID_MAX, name, type);
6188 decl = TYPE_NAME (type);
6190 /* Suppress generate debug symbol entries for these types,
6191 since for normal C++ they are just clutter.
6192 However, push_lang_context undoes this if extern "Java" is seen. */
6193 DECL_IGNORED_P (decl) = 1;
6195 TYPE_FOR_JAVA (type) = 1;
6199 /* Push a type into the namespace so that the back-ends ignore it. */
6202 record_unknown_type (tree type, const char* name)
6204 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6205 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6206 DECL_IGNORED_P (decl) = 1;
6207 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6208 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6209 TYPE_ALIGN (type) = 1;
6210 TYPE_USER_ALIGN (type) = 0;
6211 TYPE_MODE (type) = TYPE_MODE (void_type_node);
6214 /* An string for which we should create an IDENTIFIER_NODE at
6217 typedef struct predefined_identifier
6219 /* The name of the identifier. */
6220 const char *const name;
6221 /* The place where the IDENTIFIER_NODE should be stored. */
6223 /* Nonzero if this is the name of a constructor or destructor. */
6224 const int ctor_or_dtor_p;
6225 } predefined_identifier;
6227 /* Create all the predefined identifiers. */
6230 initialize_predefined_identifiers (void)
6232 const predefined_identifier *pid;
6234 /* A table of identifiers to create at startup. */
6235 static const predefined_identifier predefined_identifiers[] = {
6236 { "C++", &lang_name_cplusplus, 0 },
6237 { "C", &lang_name_c, 0 },
6238 { "Java", &lang_name_java, 0 },
6239 { CTOR_NAME, &ctor_identifier, 1 },
6240 { "__base_ctor", &base_ctor_identifier, 1 },
6241 { "__comp_ctor", &complete_ctor_identifier, 1 },
6242 { DTOR_NAME, &dtor_identifier, 1 },
6243 { "__comp_dtor", &complete_dtor_identifier, 1 },
6244 { "__base_dtor", &base_dtor_identifier, 1 },
6245 { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6246 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6247 { "nelts", &nelts_identifier, 0 },
6248 { THIS_NAME, &this_identifier, 0 },
6249 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6250 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6251 { "_vptr", &vptr_identifier, 0 },
6252 { "__vtt_parm", &vtt_parm_identifier, 0 },
6253 { "std", &std_identifier, 0 },
6257 for (pid = predefined_identifiers; pid->name; ++pid)
6259 *pid->node = get_identifier (pid->name);
6260 if (pid->ctor_or_dtor_p)
6261 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6265 /* Create the predefined scalar types of C,
6266 and some nodes representing standard constants (0, 1, (void *)0).
6267 Initialize the global binding level.
6268 Make definitions for built-in primitive functions. */
6271 cxx_init_decl_processing (void)
6274 tree void_ftype_ptr;
6276 /* Create all the identifiers we need. */
6277 initialize_predefined_identifiers ();
6279 /* Fill in back-end hooks. */
6280 lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6282 /* Create the global variables. */
6283 push_to_top_level ();
6285 /* Enter the global namespace. */
6286 my_friendly_assert (global_namespace == NULL_TREE, 375);
6287 push_namespace (get_identifier ("::"));
6288 global_namespace = current_namespace;
6289 current_lang_name = NULL_TREE;
6291 /* Adjust various flags based on command-line settings. */
6292 if (! flag_permissive && ! pedantic)
6293 flag_pedantic_errors = 1;
6294 if (!flag_no_inline)
6296 flag_inline_trees = 1;
6299 if (flag_inline_functions)
6301 flag_inline_trees = 2;
6302 flag_inline_functions = 0;
6305 /* Force minimum function alignment if using the least significant
6306 bit of function pointers to store the virtual bit. */
6307 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6308 && force_align_functions_log < 1)
6309 force_align_functions_log = 1;
6312 current_lang_name = lang_name_c;
6314 current_function_decl = NULL_TREE;
6315 current_binding_level = NULL_BINDING_LEVEL;
6316 free_binding_level = NULL_BINDING_LEVEL;
6318 build_common_tree_nodes (flag_signed_char);
6320 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6321 TREE_TYPE (error_mark_list) = error_mark_node;
6323 /* Make the binding_level structure for global names. */
6325 global_binding_level = current_binding_level;
6326 /* The global level is the namespace level of ::. */
6327 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6328 declare_namespace_level ();
6330 VARRAY_TREE_INIT (global_binding_level->static_decls,
6332 "Static declarations");
6334 /* Create the `std' namespace. */
6335 push_namespace (std_identifier);
6336 std_node = current_namespace;
6339 c_common_nodes_and_builtins ();
6341 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6342 java_short_type_node = record_builtin_java_type ("__java_short", 16);
6343 java_int_type_node = record_builtin_java_type ("__java_int", 32);
6344 java_long_type_node = record_builtin_java_type ("__java_long", 64);
6345 java_float_type_node = record_builtin_java_type ("__java_float", -32);
6346 java_double_type_node = record_builtin_java_type ("__java_double", -64);
6347 java_char_type_node = record_builtin_java_type ("__java_char", -16);
6348 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6350 integer_two_node = build_int_2 (2, 0);
6351 TREE_TYPE (integer_two_node) = integer_type_node;
6352 integer_three_node = build_int_2 (3, 0);
6353 TREE_TYPE (integer_three_node) = integer_type_node;
6355 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6356 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6357 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6358 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6359 TYPE_PRECISION (boolean_type_node) = 1;
6360 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6361 boolean_false_node = build_int_2 (0, 0);
6362 TREE_TYPE (boolean_false_node) = boolean_type_node;
6363 boolean_true_node = build_int_2 (1, 0);
6364 TREE_TYPE (boolean_true_node) = boolean_type_node;
6366 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6369 record_builtin_type (RID_MAX, NULL, string_type_node);
6372 delta_type_node = ptrdiff_type_node;
6373 vtable_index_type = ptrdiff_type_node;
6375 vtt_parm_type = build_pointer_type (const_ptr_type_node);
6376 void_ftype = build_function_type (void_type_node, void_list_node);
6377 void_ftype_ptr = build_function_type (void_type_node,
6378 tree_cons (NULL_TREE,
6382 = build_exception_variant (void_ftype_ptr, empty_except_spec);
6384 /* C++ extensions */
6386 unknown_type_node = make_node (UNKNOWN_TYPE);
6387 record_unknown_type (unknown_type_node, "unknown type");
6389 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6390 TREE_TYPE (unknown_type_node) = unknown_type_node;
6392 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6394 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6395 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6398 /* Make sure we get a unique function type, so we can give
6399 its pointer type a name. (This wins for gdb.) */
6400 tree vfunc_type = make_node (FUNCTION_TYPE);
6401 TREE_TYPE (vfunc_type) = integer_type_node;
6402 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6403 layout_type (vfunc_type);
6405 vtable_entry_type = build_pointer_type (vfunc_type);
6407 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6410 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6411 layout_type (vtbl_type_node);
6412 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6413 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6414 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6415 layout_type (vtbl_ptr_type_node);
6416 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6418 push_namespace (get_identifier ("__cxxabiv1"));
6419 abi_node = current_namespace;
6422 global_type_node = make_node (LANG_TYPE);
6423 record_unknown_type (global_type_node, "global type");
6426 current_lang_name = lang_name_cplusplus;
6429 tree bad_alloc_type_node, newtype, deltype;
6430 tree ptr_ftype_sizetype;
6432 push_namespace (std_identifier);
6434 = xref_tag (class_type, get_identifier ("bad_alloc"),
6435 /*attributes=*/NULL_TREE, 1);
6438 = build_function_type (ptr_type_node,
6439 tree_cons (NULL_TREE,
6442 newtype = build_exception_variant
6443 (ptr_ftype_sizetype, add_exception_specifier
6444 (NULL_TREE, bad_alloc_type_node, -1));
6445 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6446 push_cp_library_fn (NEW_EXPR, newtype);
6447 push_cp_library_fn (VEC_NEW_EXPR, newtype);
6448 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6449 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6453 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6455 /* Perform other language dependent initializations. */
6456 init_class_processing ();
6457 init_search_processing ();
6458 init_rtti_processing ();
6460 if (flag_exceptions)
6461 init_exception_processing ();
6463 if (! supports_one_only ())
6466 make_fname_decl = cp_make_fname_decl;
6467 start_fname_decls ();
6469 /* Show we use EH for cleanups. */
6470 using_eh_for_cleanups ();
6472 /* Maintain consistency. Perhaps we should just complain if they
6473 say -fwritable-strings? */
6474 if (flag_writable_strings)
6475 flag_const_strings = 0;
6478 /* Generate an initializer for a function naming variable from
6479 NAME. NAME may be NULL, in which case we generate a special
6480 ERROR_MARK node which should be replaced later. */
6483 cp_fname_init (const char* name)
6485 tree domain = NULL_TREE;
6487 tree init = NULL_TREE;
6492 length = strlen (name);
6493 domain = build_index_type (size_int (length));
6494 init = build_string (length + 1, name);
6497 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6498 type = build_cplus_array_type (type, domain);
6501 TREE_TYPE (init) = type;
6503 /* We don't know the value until instantiation time. Make
6504 something which will be digested now, but replaced later. */
6505 init = build (ERROR_MARK, type);
6510 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6511 decl, NAME is the initialization string and TYPE_DEP indicates whether
6512 NAME depended on the type of the function. We make use of that to detect
6513 __PRETTY_FUNCTION__ inside a template fn. This is being done
6514 lazily at the point of first use, so we musn't push the decl now. */
6517 cp_make_fname_decl (tree id, int type_dep)
6519 const char *const name = (type_dep && processing_template_decl
6520 ? NULL : fname_as_string (type_dep));
6521 tree init = cp_fname_init (name);
6522 tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6524 /* As we're using pushdecl_with_scope, we must set the context. */
6525 DECL_CONTEXT (decl) = current_function_decl;
6526 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6528 TREE_STATIC (decl) = 1;
6529 TREE_READONLY (decl) = 1;
6530 DECL_ARTIFICIAL (decl) = 1;
6531 DECL_INITIAL (decl) = init;
6533 TREE_USED (decl) = 1;
6535 if (current_function_decl)
6537 struct cp_binding_level *b = current_binding_level;
6538 while (b->level_chain->parm_flag == 0)
6540 pushdecl_with_scope (decl, b);
6543 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6548 /* Make a definition for a builtin function named NAME in the current
6549 namespace, whose data type is TYPE and whose context is CONTEXT.
6550 TYPE should be a function type with argument types.
6552 CLASS and CODE tell later passes how to compile calls to this function.
6553 See tree.h for possible values.
6555 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6556 the name to be called if we can't opencode the function.
6557 If ATTRS is nonzero, use that for the function's attribute
6561 builtin_function_1 (const char* name,
6565 enum built_in_class class,
6566 const char* libname,
6569 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6570 DECL_BUILT_IN_CLASS (decl) = class;
6571 DECL_FUNCTION_CODE (decl) = code;
6572 DECL_CONTEXT (decl) = context;
6576 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6577 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6578 function in the namespace. */
6580 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6581 make_decl_rtl (decl, NULL);
6583 /* Warn if a function in the namespace for users
6584 is used without an occasion to consider it declared. */
6585 if (name[0] != '_' || name[1] != '_')
6586 DECL_ANTICIPATED (decl) = 1;
6588 /* Possibly apply some default attributes to this built-in function. */
6590 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6592 decl_attributes (&decl, NULL_TREE, 0);
6597 /* Entry point for the benefit of c_common_nodes_and_builtins.
6599 Make a defintion for a builtin function named NAME and whose data type
6600 is TYPE. TYPE should be a function type with argument types. This
6601 function places the anticipated declaration in the global namespace
6602 and additionally in the std namespace if appropriate.
6604 CLASS and CODE tell later passes how to compile calls to this function.
6605 See tree.h for possible values.
6607 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6608 the name to be called if we can't opencode the function.
6610 If ATTRS is nonzero, use that for the function's attribute
6614 builtin_function (const char* name,
6617 enum built_in_class class,
6618 const char* libname,
6621 /* All builtins that don't begin with an '_' should additionally
6622 go in the 'std' namespace. */
6625 push_namespace (std_identifier);
6626 builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6630 return builtin_function_1 (name, type, NULL_TREE, code,
6631 class, libname, attrs);
6634 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6635 function. Not called directly. */
6638 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
6640 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6641 DECL_EXTERNAL (fn) = 1;
6642 TREE_PUBLIC (fn) = 1;
6643 DECL_ARTIFICIAL (fn) = 1;
6644 TREE_NOTHROW (fn) = 1;
6645 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6646 SET_DECL_LANGUAGE (fn, lang_c);
6650 /* Returns the _DECL for a library function with C linkage.
6651 We assume that such functions never throw; if this is incorrect,
6652 callers should unset TREE_NOTHROW. */
6655 build_library_fn (tree name, tree type)
6657 return build_library_fn_1 (name, ERROR_MARK, type);
6660 /* Returns the _DECL for a library function with C++ linkage. */
6663 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
6665 tree fn = build_library_fn_1 (name, operator_code, type);
6666 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6667 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6668 SET_DECL_LANGUAGE (fn, lang_cplusplus);
6669 set_mangled_name_for_decl (fn);
6673 /* Like build_library_fn, but takes a C string instead of an
6677 build_library_fn_ptr (const char* name, tree 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 (const char* name, tree type)
6688 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6691 /* Like build_library_fn, but also pushes the function so that we will
6692 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6695 push_library_fn (tree name, tree type)
6697 tree fn = build_library_fn (name, type);
6698 pushdecl_top_level (fn);
6702 /* Like build_cp_library_fn, but also pushes the function so that it
6703 will be found by normal lookup. */
6706 push_cp_library_fn (enum tree_code operator_code, tree type)
6708 tree fn = build_cp_library_fn (ansi_opname (operator_code),
6715 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6719 push_void_library_fn (tree name, tree parmtypes)
6721 tree type = build_function_type (void_type_node, parmtypes);
6722 return push_library_fn (name, type);
6725 /* Like push_library_fn, but also note that this function throws
6726 and does not return. Used for __throw_foo and the like. */
6729 push_throw_library_fn (tree name, tree type)
6731 tree fn = push_library_fn (name, type);
6732 TREE_THIS_VOLATILE (fn) = 1;
6733 TREE_NOTHROW (fn) = 0;
6737 /* Apply default attributes to a function, if a system function with default
6741 cxx_insert_default_attributes (tree decl)
6743 if (!DECL_EXTERN_C_FUNCTION_P (decl))
6745 if (!TREE_PUBLIC (decl))
6747 c_common_insert_default_attributes (decl);
6750 /* When we call finish_struct for an anonymous union, we create
6751 default copy constructors and such. But, an anonymous union
6752 shouldn't have such things; this function undoes the damage to the
6753 anonymous union type T.
6755 (The reason that we create the synthesized methods is that we don't
6756 distinguish `union { int i; }' from `typedef union { int i; } U'.
6757 The first is an anonymous union; the second is just an ordinary
6761 fixup_anonymous_aggr (tree t)
6765 /* Wipe out memory of synthesized methods */
6766 TYPE_HAS_CONSTRUCTOR (t) = 0;
6767 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6768 TYPE_HAS_INIT_REF (t) = 0;
6769 TYPE_HAS_CONST_INIT_REF (t) = 0;
6770 TYPE_HAS_ASSIGN_REF (t) = 0;
6771 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6773 /* Splice the implicitly generated functions out of the TYPE_METHODS
6775 q = &TYPE_METHODS (t);
6778 if (DECL_ARTIFICIAL (*q))
6779 *q = TREE_CHAIN (*q);
6781 q = &TREE_CHAIN (*q);
6784 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6785 if (TYPE_METHODS (t))
6786 cp_error_at ("an anonymous union cannot have function members", t);
6788 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6789 assignment operators (because they cannot have these methods themselves).
6790 For anonymous unions this is already checked because they are not allowed
6791 in any union, otherwise we have to check it. */
6792 if (TREE_CODE (t) != UNION_TYPE)
6796 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6797 if (TREE_CODE (field) == FIELD_DECL)
6799 type = TREE_TYPE (field);
6800 if (CLASS_TYPE_P (type))
6802 if (TYPE_NEEDS_CONSTRUCTING (type))
6803 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6805 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6806 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6808 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6809 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6816 /* Make sure that a declaration with no declarator is well-formed, i.e.
6817 just declares a tagged type or anonymous union.
6819 Returns the type declared; or NULL_TREE if none. */
6822 check_tag_decl (tree declspecs)
6826 int saw_typedef = 0;
6827 tree ob_modifier = NULL_TREE;
6829 /* If a class, struct, or enum type is declared by the DECLSPECS
6830 (i.e, if a class-specifier, enum-specifier, or non-typename
6831 elaborated-type-specifier appears in the DECLSPECS),
6832 DECLARED_TYPE is set to the corresponding type. */
6833 tree declared_type = NULL_TREE;
6834 bool error_p = false;
6836 for (link = declspecs; link; link = TREE_CHAIN (link))
6838 tree value = TREE_VALUE (link);
6841 || TREE_CODE (value) == TYPE_DECL
6842 || (TREE_CODE (value) == IDENTIFIER_NODE
6843 && IDENTIFIER_GLOBAL_VALUE (value)
6844 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6848 if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6850 if (! in_system_header)
6851 pedwarn ("redeclaration of C++ built-in type `%T'", value);
6856 && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6857 || TREE_CODE (value) == ENUMERAL_TYPE))
6859 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6860 declared_type = value;
6863 else if (value == ridpointers[(int) RID_TYPEDEF])
6865 else if (value == ridpointers[(int) RID_FRIEND])
6867 if (current_class_type == NULL_TREE
6868 || current_scope () != current_class_type)
6869 ob_modifier = value;
6873 else if (value == ridpointers[(int) RID_STATIC]
6874 || value == ridpointers[(int) RID_EXTERN]
6875 || value == ridpointers[(int) RID_AUTO]
6876 || value == ridpointers[(int) RID_REGISTER]
6877 || value == ridpointers[(int) RID_INLINE]
6878 || value == ridpointers[(int) RID_VIRTUAL]
6879 || value == ridpointers[(int) RID_CONST]
6880 || value == ridpointers[(int) RID_VOLATILE]
6881 || value == ridpointers[(int) RID_EXPLICIT]
6882 || value == ridpointers[(int) RID_THREAD])
6883 ob_modifier = value;
6884 else if (value == error_mark_node)
6889 error ("multiple types in one declaration");
6891 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
6892 pedwarn ("declaration does not declare anything");
6893 /* Check for an anonymous union. */
6894 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
6895 && TYPE_ANONYMOUS_P (declared_type))
6897 /* 7/3 In a simple-declaration, the optional init-declarator-list
6898 can be omitted only when declaring a class (clause 9) or
6899 enumeration (7.2), that is, when the decl-specifier-seq contains
6900 either a class-specifier, an elaborated-type-specifier with
6901 a class-key (9.1), or an enum-specifier. In these cases and
6902 whenever a class-specifier or enum-specifier is present in the
6903 decl-specifier-seq, the identifiers in these specifiers are among
6904 the names being declared by the declaration (as class-name,
6905 enum-names, or enumerators, depending on the syntax). In such
6906 cases, and except for the declaration of an unnamed bit-field (9.6),
6907 the decl-specifier-seq shall introduce one or more names into the
6908 program, or shall redeclare a name introduced by a previous
6909 declaration. [Example:
6910 enum { }; // ill-formed
6911 typedef class { }; // ill-formed
6915 error ("missing type-name in typedef-declaration");
6918 /* Anonymous unions are objects, so they can have specifiers. */;
6919 SET_ANON_AGGR_TYPE_P (declared_type);
6921 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
6922 && !in_system_header)
6923 pedwarn ("ISO C++ prohibits anonymous structs");
6926 else if (ob_modifier)
6928 if (ob_modifier == ridpointers[(int) RID_INLINE]
6929 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6930 error ("`%D' can only be specified for functions", ob_modifier);
6931 else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6932 error ("`%D' can only be specified inside a class", ob_modifier);
6933 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6934 error ("`%D' can only be specified for constructors",
6937 error ("`%D' can only be specified for objects and functions",
6941 return declared_type;
6944 /* Called when a declaration is seen that contains no names to declare.
6945 If its type is a reference to a structure, union or enum inherited
6946 from a containing scope, shadow that tag name for the current scope
6947 with a forward reference.
6948 If its type defines a new named structure or union
6949 or defines an enum, it is valid but we need not do anything here.
6950 Otherwise, it is an error.
6952 C++: may have to grok the declspecs to learn about static,
6953 complain for anonymous unions.
6955 Returns the TYPE declared -- or NULL_TREE if none. */
6958 shadow_tag (tree declspecs)
6960 tree t = check_tag_decl (declspecs);
6965 maybe_process_partial_specialization (t);
6967 /* This is where the variables in an anonymous union are
6968 declared. An anonymous union declaration looks like:
6970 because there is no declarator after the union, the parser
6971 sends that declaration here. */
6972 if (ANON_AGGR_TYPE_P (t))
6974 fixup_anonymous_aggr (t);
6976 if (TYPE_FIELDS (t))
6978 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6980 finish_anon_union (decl);
6987 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6990 groktypename (tree typename)
6994 if (TREE_CODE (typename) != TREE_LIST)
6996 split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
6997 type = grokdeclarator (TREE_VALUE (typename), specs,
6998 TYPENAME, 0, &attrs);
7000 cplus_decl_attributes (&type, attrs, 0);
7004 /* Decode a declarator in an ordinary declaration or data definition.
7005 This is called as soon as the type information and variable name
7006 have been parsed, before parsing the initializer if any.
7007 Here we create the ..._DECL node, fill in its type,
7008 and put it on the list of decls for the current context.
7009 The ..._DECL node is returned as the value.
7011 Exception: for arrays where the length is not specified,
7012 the type is left null, to be filled in by `cp_finish_decl'.
7014 Function definitions do not come here; they go to start_function
7015 instead. However, external and forward declarations of functions
7016 do go through here. Structure field declarations are done by
7017 grokfield and not through here. */
7020 start_decl (tree declarator,
7024 tree prefix_attributes)
7027 register tree type, tem;
7030 /* This should only be done once on the top most decl. */
7031 if (have_extern_spec)
7033 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
7035 have_extern_spec = false;
7038 /* An object declared as __attribute__((deprecated)) suppresses
7039 warnings of uses of other deprecated items. */
7040 if (lookup_attribute ("deprecated", attributes))
7041 deprecated_state = DEPRECATED_SUPPRESS;
7043 attributes = chainon (attributes, prefix_attributes);
7045 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7048 deprecated_state = DEPRECATED_NORMAL;
7050 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7053 type = TREE_TYPE (decl);
7055 if (type == error_mark_node)
7058 context = DECL_CONTEXT (decl);
7060 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7061 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7063 /* When parsing the initializer, lookup should use the object's
7065 push_decl_namespace (context);
7068 /* We are only interested in class contexts, later. */
7069 if (context && TREE_CODE (context) == NAMESPACE_DECL)
7070 context = NULL_TREE;
7073 /* Is it valid for this decl to have an initializer at all?
7074 If not, set INITIALIZED to zero, which will indirectly
7075 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7076 switch (TREE_CODE (decl))
7079 error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7084 error ("function `%#D' is initialized like a variable", decl);
7094 if (! toplevel_bindings_p ()
7095 && DECL_EXTERNAL (decl))
7096 warning ("declaration of `%#D' has `extern' and is initialized",
7098 DECL_EXTERNAL (decl) = 0;
7099 if (toplevel_bindings_p ())
7100 TREE_STATIC (decl) = 1;
7102 /* Tell `pushdecl' this is an initialized decl
7103 even though we don't yet have the initializer expression.
7104 Also tell `cp_finish_decl' it may store the real initializer. */
7105 DECL_INITIAL (decl) = error_mark_node;
7108 /* Set attributes here so if duplicate decl, will have proper attributes. */
7109 cplus_decl_attributes (&decl, attributes, 0);
7111 /* If #pragma weak was used, mark the decl weak now. */
7112 if (current_binding_level == global_binding_level)
7113 maybe_apply_pragma_weak (decl);
7115 if (TREE_CODE (decl) == FUNCTION_DECL
7116 && DECL_DECLARED_INLINE_P (decl)
7117 && DECL_UNINLINABLE (decl)
7118 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7119 warning ("%Hinline function '%D' given attribute noinline",
7120 &DECL_SOURCE_LOCATION (decl), decl);
7122 if (context && COMPLETE_TYPE_P (complete_type (context)))
7124 push_nested_class (context);
7126 if (TREE_CODE (decl) == VAR_DECL)
7128 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
7129 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7130 error ("`%#D' is not a static member of `%#T'", decl, context);
7133 if (DECL_CONTEXT (field) != context)
7135 if (!same_type_p (DECL_CONTEXT (field), context))
7136 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7137 DECL_CONTEXT (field), DECL_NAME (decl),
7138 context, DECL_NAME (decl));
7139 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7141 /* Static data member are tricky; an in-class initialization
7142 still doesn't provide a definition, so the in-class
7143 declaration will have DECL_EXTERNAL set, but will have an
7144 initialization. Thus, duplicate_decls won't warn
7145 about this situation, and so we check here. */
7146 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7147 error ("duplicate initialization of %D", decl);
7148 if (duplicate_decls (decl, field))
7154 tree field = check_classfn (context, decl);
7155 if (field && duplicate_decls (decl, field))
7159 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7160 DECL_IN_AGGR_P (decl) = 0;
7161 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7162 || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7164 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7165 /* [temp.expl.spec] An explicit specialization of a static data
7166 member of a template is a definition if the declaration
7167 includes an initializer; otherwise, it is a declaration.
7169 We check for processing_specialization so this only applies
7170 to the new specialization syntax. */
7171 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7172 DECL_EXTERNAL (decl) = 1;
7175 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7176 pedwarn ("declaration of `%#D' outside of class is not definition",
7180 /* Enter this declaration into the symbol table. */
7181 tem = maybe_push_decl (decl);
7183 if (processing_template_decl)
7184 tem = push_template_decl (tem);
7186 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7187 /* Tell the back-end to use or not use .common as appropriate. If we say
7188 -fconserve-space, we want this to save .data space, at the expense of
7189 wrong semantics. If we say -fno-conserve-space, we want this to
7190 produce errors about redefs; to do this we force variables into the
7192 DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
7193 || !DECL_THREAD_LOCAL (tem))
7194 && (flag_conserve_space || ! TREE_PUBLIC (tem)));
7197 if (! processing_template_decl)
7204 start_decl_1 (tree decl)
7206 tree type = TREE_TYPE (decl);
7207 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7209 if (type == error_mark_node)
7212 maybe_push_cleanup_level (type);
7215 /* Is it valid for this decl to have an initializer at all?
7216 If not, set INITIALIZED to zero, which will indirectly
7217 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7219 /* Don't allow initializations for incomplete types except for
7220 arrays which might be completed by the initialization. */
7221 if (COMPLETE_TYPE_P (complete_type (type)))
7222 ; /* A complete type is ok. */
7223 else if (TREE_CODE (type) != ARRAY_TYPE)
7225 error ("variable `%#D' has initializer but incomplete type",
7228 type = TREE_TYPE (decl) = error_mark_node;
7230 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7232 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7233 error ("elements of array `%#D' have incomplete type", decl);
7234 /* else we already gave an error in start_decl. */
7240 && TREE_CODE (decl) != TYPE_DECL
7241 && TREE_CODE (decl) != TEMPLATE_DECL
7242 && type != error_mark_node
7243 && IS_AGGR_TYPE (type)
7244 && ! DECL_EXTERNAL (decl))
7246 if ((! processing_template_decl || ! uses_template_parms (type))
7247 && !COMPLETE_TYPE_P (complete_type (type)))
7249 error ("aggregate `%#D' has incomplete type and cannot be defined",
7251 /* Change the type so that assemble_variable will give
7252 DECL an rtl we can live with: (mem (const_int 0)). */
7253 type = TREE_TYPE (decl) = error_mark_node;
7257 /* If any base type in the hierarchy of TYPE needs a constructor,
7258 then we set initialized to 1. This way any nodes which are
7259 created for the purposes of initializing this aggregate
7260 will live as long as it does. This is necessary for global
7261 aggregates which do not have their initializers processed until
7262 the end of the file. */
7263 initialized = TYPE_NEEDS_CONSTRUCTING (type);
7268 DECL_INITIAL (decl) = NULL_TREE;
7271 /* Handle initialization of references.
7272 These three arguments are from `cp_finish_decl', and have the
7273 same meaning here that they do there.
7275 Quotes on semantics can be found in ARM 8.4.3. */
7278 grok_reference_init (tree decl, tree type, tree init)
7282 if (init == NULL_TREE)
7284 if ((DECL_LANG_SPECIFIC (decl) == 0
7285 || DECL_IN_AGGR_P (decl) == 0)
7286 && ! DECL_THIS_EXTERN (decl))
7287 error ("`%D' declared as reference but not initialized", decl);
7291 if (TREE_CODE (init) == CONSTRUCTOR)
7293 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7297 if (TREE_CODE (init) == TREE_LIST)
7298 init = build_compound_expr (init);
7300 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7301 init = convert_from_reference (init);
7303 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7304 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7306 /* Note: default conversion is only called in very special cases. */
7307 init = default_conversion (init);
7310 /* Convert INIT to the reference type TYPE. This may involve the
7311 creation of a temporary, whose lifetime must be the same as that
7312 of the reference. If so, a DECL_STMT for the temporary will be
7313 added just after the DECL_STMT for DECL. That's why we don't set
7314 DECL_INITIAL for local references (instead assigning to them
7315 explicitly); we need to allow the temporary to be initialized
7317 tmp = initialize_reference (type, init, decl);
7319 if (tmp == error_mark_node)
7321 else if (tmp == NULL_TREE)
7323 error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7327 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7330 DECL_INITIAL (decl) = tmp;
7335 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7336 array until we finish parsing the initializer. If that's the
7337 situation we're in, update DECL accordingly. */
7340 maybe_deduce_size_from_array_init (tree decl, tree init)
7342 tree type = TREE_TYPE (decl);
7344 if (TREE_CODE (type) == ARRAY_TYPE
7345 && TYPE_DOMAIN (type) == NULL_TREE
7346 && TREE_CODE (decl) != TYPE_DECL)
7348 /* do_default is really a C-ism to deal with tentative definitions.
7349 But let's leave it here to ease the eventual merge. */
7350 int do_default = !DECL_EXTERNAL (decl);
7351 tree initializer = init ? init : DECL_INITIAL (decl);
7352 int failure = complete_array_type (type, initializer, do_default);
7355 error ("initializer fails to determine size of `%D'", decl);
7360 error ("array size missing in `%D'", decl);
7361 /* If a `static' var's size isn't known, make it extern as
7362 well as static, so it does not get allocated. If it's not
7363 `static', then don't mark it extern; finish_incomplete_decl
7364 will give it a default size and it will get allocated. */
7365 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7366 DECL_EXTERNAL (decl) = 1;
7369 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7370 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7372 error ("zero-size array `%D'", decl);
7374 layout_decl (decl, 0);
7378 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7379 any appropriate error messages regarding the layout. */
7382 layout_var_decl (tree decl)
7384 tree type = TREE_TYPE (decl);
7386 tree ttype = target_type (type);
7389 /* If we haven't already layed out this declaration, do so now.
7390 Note that we must not call complete type for an external object
7391 because it's type might involve templates that we are not
7392 supposed to isntantiate yet. (And it's perfectly valid to say
7393 `extern X x' for some incomplete type `X'.) */
7394 if (!DECL_EXTERNAL (decl))
7395 complete_type (type);
7396 if (!DECL_SIZE (decl)
7397 && TREE_TYPE (decl) != error_mark_node
7398 && (COMPLETE_TYPE_P (type)
7399 || (TREE_CODE (type) == ARRAY_TYPE
7400 && !TYPE_DOMAIN (type)
7401 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
7402 layout_decl (decl, 0);
7404 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7406 /* An automatic variable with an incomplete type: that is an error.
7407 Don't talk about array types here, since we took care of that
7408 message in grokdeclarator. */
7409 error ("storage size of `%D' isn't known", decl);
7410 TREE_TYPE (decl) = error_mark_node;
7413 /* Keep this code around in case we later want to control debug info
7414 based on whether a type is "used". (jason 1999-11-11) */
7416 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7417 /* Let debugger know it should output info for this type. */
7418 note_debug_info_needed (ttype);
7420 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7421 note_debug_info_needed (DECL_CONTEXT (decl));
7424 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7425 && DECL_SIZE (decl) != NULL_TREE
7426 && ! TREE_CONSTANT (DECL_SIZE (decl)))
7428 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7429 constant_expression_warning (DECL_SIZE (decl));
7431 error ("storage size of `%D' isn't constant", decl);
7434 if (TREE_STATIC (decl)
7435 && !DECL_ARTIFICIAL (decl)
7436 && current_function_decl
7437 && DECL_CONTEXT (decl) == current_function_decl)
7438 push_local_name (decl);
7441 /* If a local static variable is declared in an inline function, or if
7442 we have a weak definition, we must endeavor to create only one
7443 instance of the variable at link-time. */
7446 maybe_commonize_var (tree decl)
7448 /* Static data in a function with comdat linkage also has comdat
7450 if (TREE_STATIC (decl)
7451 /* Don't mess with __FUNCTION__. */
7452 && ! DECL_ARTIFICIAL (decl)
7453 && current_function_decl
7454 && DECL_CONTEXT (decl) == current_function_decl
7455 && (DECL_DECLARED_INLINE_P (current_function_decl)
7456 || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7457 && TREE_PUBLIC (current_function_decl))
7459 /* If flag_weak, we don't need to mess with this, as we can just
7460 make the function weak, and let it refer to its unique local
7461 copy. This works because we don't allow the function to be
7465 if (DECL_INTERFACE_KNOWN (current_function_decl))
7467 TREE_PUBLIC (decl) = 1;
7468 DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7470 else if (DECL_INITIAL (decl) == NULL_TREE
7471 || DECL_INITIAL (decl) == error_mark_node)
7473 TREE_PUBLIC (decl) = 1;
7474 DECL_COMMON (decl) = 1;
7476 /* else we lose. We can only do this if we can use common,
7477 which we can't if it has been initialized. */
7479 if (!TREE_PUBLIC (decl))
7481 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7482 cp_warning_at (" you can work around this by removing the initializer", decl);
7486 comdat_linkage (decl);
7488 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7489 /* Set it up again; we might have set DECL_INITIAL since the last
7491 comdat_linkage (decl);
7494 /* Issue an error message if DECL is an uninitialized const variable. */
7497 check_for_uninitialized_const_var (tree decl)
7499 tree type = TREE_TYPE (decl);
7501 /* ``Unless explicitly declared extern, a const object does not have
7502 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7504 if (TREE_CODE (decl) == VAR_DECL
7505 && TREE_CODE (type) != REFERENCE_TYPE
7506 && CP_TYPE_CONST_P (type)
7507 && !TYPE_NEEDS_CONSTRUCTING (type)
7508 && !DECL_INITIAL (decl))
7509 error ("uninitialized const `%D'", decl);
7512 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
7513 returned is the next FIELD_DECL (possibly FIELD itself) that can be
7514 initialized. If there are no more such fields, the return value
7518 next_initializable_field (tree field)
7521 && (TREE_CODE (field) != FIELD_DECL
7522 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
7523 || DECL_ARTIFICIAL (field)))
7524 field = TREE_CHAIN (field);
7529 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7530 brace-enclosed aggregate initializer.
7532 *INITP is one of a list of initializers describing a brace-enclosed
7533 initializer for an entity of the indicated aggregate TYPE. It may
7534 not presently match the shape of the TYPE; for example:
7536 struct S { int a; int b; };
7537 struct S a[] = { 1, 2, 3, 4 };
7539 Here *INITP will point to TREE_LIST of four elements, rather than a
7540 list of two elements, each itself a list of two elements. This
7541 routine transforms INIT from the former form into the latter. The
7542 revised initializer is returned. */
7545 reshape_init (tree type, tree *initp)
7549 tree old_init_value;
7551 bool brace_enclosed_p;
7554 old_init_value = (TREE_CODE (*initp) == TREE_LIST
7555 ? TREE_VALUE (*initp) : old_init);
7557 /* For some parse errors, OLD_INIT_VALUE may be NULL. */
7558 if (!old_init_value)
7560 my_friendly_assert (TREE_CODE (old_init) == TREE_LIST, 20021202);
7561 TREE_VALUE (old_init) = error_mark_node;
7565 /* If the initializer is brace-enclosed, pull initializers from the
7566 enclosed elements. Advance past the brace-enclosed initializer
7568 if (TREE_CODE (old_init_value) == CONSTRUCTOR
7569 && TREE_HAS_CONSTRUCTOR (old_init_value))
7571 *initp = TREE_CHAIN (old_init);
7572 TREE_CHAIN (old_init) = NULL_TREE;
7573 inits = CONSTRUCTOR_ELTS (old_init_value);
7575 brace_enclosed_p = true;
7580 brace_enclosed_p = false;
7583 /* A non-aggregate type is always initialized with a single
7585 if (!CP_AGGREGATE_TYPE_P (type))
7587 *initp = TREE_CHAIN (old_init);
7588 TREE_CHAIN (old_init) = NULL_TREE;
7589 /* It is invalid to initialize a non-aggregate type with a
7590 brace-enclosed initializer. */
7591 if (brace_enclosed_p)
7593 error ("brace-enclosed initializer used to initialize `%T'",
7595 if (TREE_CODE (old_init) == TREE_LIST)
7596 TREE_VALUE (old_init) = error_mark_node;
7598 old_init = error_mark_node;
7606 All implicit type conversions (clause _conv_) are considered when
7607 initializing the aggregate member with an initializer from an
7608 initializer-list. If the initializer can initialize a member,
7609 the member is initialized. Otherwise, if the member is itself a
7610 non-empty subaggregate, brace elision is assumed and the
7611 initializer is considered for the initialization of the first
7612 member of the subaggregate. */
7613 if (CLASS_TYPE_P (type)
7614 && !brace_enclosed_p
7615 && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
7617 *initp = TREE_CHAIN (old_init);
7618 TREE_CHAIN (old_init) = NULL_TREE;
7622 if (TREE_CODE (old_init_value) == STRING_CST
7623 && TREE_CODE (type) == ARRAY_TYPE
7624 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
7626 /* [dcl.init.string]
7628 A char array (whether plain char, signed char, or unsigned char)
7629 can be initialized by a string-literal (optionally enclosed in
7630 braces); a wchar_t array can be initialized by a wide
7631 string-literal (optionally enclosed in braces). */
7632 new_init = old_init;
7633 /* Move past the initializer. */
7634 *initp = TREE_CHAIN (old_init);
7635 TREE_CHAIN (old_init) = NULL_TREE;
7639 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
7640 new_init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
7641 TREE_HAS_CONSTRUCTOR (new_init) = 1;
7643 if (CLASS_TYPE_P (type))
7647 field = next_initializable_field (TYPE_FIELDS (type));
7653 An initializer for an aggregate member that is an
7654 empty class shall have the form of an empty
7655 initializer-list {}. */
7656 if (!brace_enclosed_p)
7657 error ("initializer for `%T' must be brace-enclosed",
7662 /* Loop through the initializable fields, gathering
7664 /* FIXME support non-trivial labeled initializers. */
7665 while (*initp && field)
7669 field_init = reshape_init (TREE_TYPE (field), initp);
7670 TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
7671 CONSTRUCTOR_ELTS (new_init) = field_init;
7674 When a union is initialized with a brace-enclosed
7675 initializer, the braces shall only contain an
7676 initializer for the first member of the union. */
7677 if (TREE_CODE (type) == UNION_TYPE)
7679 field = next_initializable_field (TREE_CHAIN (field));
7683 else if (TREE_CODE (type) == ARRAY_TYPE)
7688 /* If the bound of the array is known, take no more initializers
7689 than are allowed. */
7690 max_index = (TYPE_DOMAIN (type)
7691 ? array_type_nelts (type) : NULL_TREE);
7692 /* Loop through the array elements, gathering initializers. */
7693 for (index = size_zero_node;
7694 *initp && (!max_index || !tree_int_cst_lt (max_index, index));
7695 index = size_binop (PLUS_EXPR, index, size_one_node))
7699 element_init = reshape_init (TREE_TYPE (type), initp);
7700 TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
7701 CONSTRUCTOR_ELTS (new_init) = element_init;
7702 if (TREE_PURPOSE (element_init))
7703 index = TREE_PURPOSE (element_init);
7709 /* The initializers were placed in reverse order in the
7711 CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
7713 if (TREE_CODE (old_init) == TREE_LIST)
7714 new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
7717 /* If this was a brace-enclosed initializer and all of the
7718 initializers were not used up, there is a problem. */
7719 if (brace_enclosed_p && *initp)
7720 error ("too many initializers for `%T'", type);
7725 /* Verify INIT (the initializer for DECL), and record the
7726 initialization in DECL_INITIAL, if appropriate.
7728 If the return value is non-NULL, it is an expression that must be
7729 evaluated dynamically to initialize DECL. */
7732 check_initializer (tree decl, tree init, int flags)
7734 tree type = TREE_TYPE (decl);
7736 /* If `start_decl' didn't like having an initialization, ignore it now. */
7737 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7740 /* If an initializer is present, DECL_INITIAL has been
7741 error_mark_node, to indicate that an as-of-yet unevaluated
7742 initialization will occur. From now on, DECL_INITIAL reflects
7743 the static initialization -- if any -- of DECL. */
7744 DECL_INITIAL (decl) = NULL_TREE;
7746 /* Things that are going to be initialized need to have complete
7748 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7750 if (type == error_mark_node)
7751 /* We will have already complained. */
7753 else if (init && COMPLETE_TYPE_P (type)
7754 && !TREE_CONSTANT (TYPE_SIZE (type)))
7756 error ("variable-sized object `%D' may not be initialized", decl);
7759 else if (TREE_CODE (type) == ARRAY_TYPE
7760 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7762 error ("elements of array `%#D' have incomplete type", decl);
7765 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7767 error ("`%D' has incomplete type", decl);
7768 TREE_TYPE (decl) = error_mark_node;
7772 if (TREE_CODE (decl) == CONST_DECL)
7774 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7776 DECL_INITIAL (decl) = init;
7778 my_friendly_assert (init != NULL_TREE, 149);
7781 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7782 init = grok_reference_init (decl, type, init);
7785 if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7787 /* [dcl.init] paragraph 13,
7788 If T is a scalar type, then a declaration of the form
7793 reshape_init will complain about the extra braces,
7794 and doesn't do anything useful in the case where TYPE is
7795 scalar, so just don't call it. */
7796 if (CP_AGGREGATE_TYPE_P (type))
7797 init = reshape_init (type, &init);
7799 if ((*targetm.vector_opaque_p) (type))
7801 error ("opaque vector types cannot be initialized");
7802 init = error_mark_node;
7806 /* If DECL has an array type without a specific bound, deduce the
7807 array size from the initializer. */
7808 maybe_deduce_size_from_array_init (decl, init);
7809 type = TREE_TYPE (decl);
7810 if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7811 TREE_TYPE (init) = type;
7813 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7815 if (TREE_CODE (type) == ARRAY_TYPE)
7816 goto initialize_aggr;
7817 else if (TREE_CODE (init) == CONSTRUCTOR
7818 && TREE_HAS_CONSTRUCTOR (init))
7820 if (TYPE_NON_AGGREGATE_CLASS (type))
7822 error ("`%D' must be initialized by constructor, not by `{...}'",
7824 init = error_mark_node;
7827 goto dont_use_constructor;
7831 int saved_stmts_are_full_exprs_p;
7834 saved_stmts_are_full_exprs_p = 0;
7835 if (building_stmt_tree ())
7837 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7838 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7840 init = build_aggr_init (decl, init, flags);
7841 if (building_stmt_tree ())
7842 current_stmt_tree ()->stmts_are_full_exprs_p =
7843 saved_stmts_are_full_exprs_p;
7849 dont_use_constructor:
7850 if (TREE_CODE (init) != TREE_VEC)
7851 init = store_init_value (decl, init);
7854 else if (DECL_EXTERNAL (decl))
7856 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7857 goto initialize_aggr;
7858 else if (IS_AGGR_TYPE (type))
7860 tree core_type = strip_array_types (type);
7862 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7863 error ("structure `%D' with uninitialized const members", decl);
7864 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7865 error ("structure `%D' with uninitialized reference members",
7868 check_for_uninitialized_const_var (decl);
7871 check_for_uninitialized_const_var (decl);
7873 if (init && init != error_mark_node)
7874 init = build (INIT_EXPR, type, decl, init);
7879 /* If DECL is not a local variable, give it RTL. */
7882 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
7884 int toplev = toplevel_bindings_p ();
7887 /* Handle non-variables up front. */
7888 if (TREE_CODE (decl) != VAR_DECL)
7890 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7894 /* If we see a class member here, it should be a static data
7896 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7898 my_friendly_assert (TREE_STATIC (decl), 19990828);
7899 /* An in-class declaration of a static data member should be
7900 external; it is only a declaration, and not a definition. */
7901 if (init == NULL_TREE)
7902 my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7905 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7908 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7909 /* The `register' keyword, when used together with an
7910 asm-specification, indicates that the variable should be
7911 placed in a particular register. */
7912 if (DECL_REGISTER (decl))
7913 DECL_C_HARD_REGISTER (decl) = 1;
7916 /* We don't create any RTL for local variables. */
7917 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7920 /* We defer emission of local statics until the corresponding
7921 DECL_STMT is expanded. */
7922 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7924 /* We try to defer namespace-scope static constants so that they are
7925 not emitted into the object file unnecessarily. */
7926 if (!DECL_VIRTUAL_P (decl)
7927 && TREE_READONLY (decl)
7928 && DECL_INITIAL (decl) != NULL_TREE
7929 && DECL_INITIAL (decl) != error_mark_node
7930 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7932 && !TREE_PUBLIC (decl))
7934 /* Fool with the linkage of static consts according to #pragma
7936 if (!interface_unknown && !TREE_PUBLIC (decl))
7938 TREE_PUBLIC (decl) = 1;
7939 DECL_EXTERNAL (decl) = interface_only;
7944 /* Likewise for template instantiations. */
7945 else if (DECL_COMDAT (decl))
7948 /* If we're deferring the variable, we only need to make RTL if
7949 there's an ASMSPEC. Otherwise, we'll lazily create it later when
7950 we need it. (There's no way to lazily create RTL for things that
7951 have assembly specs because the information about the specifier
7952 isn't stored in the tree, yet) */
7953 if (defer_p && asmspec)
7954 make_decl_rtl (decl, asmspec);
7955 /* If we're not deferring, go ahead and assemble the variable. */
7957 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7960 /* The old ARM scoping rules injected variables declared in the
7961 initialization statement of a for-statement into the surrounding
7962 scope. We support this usage, in order to be backward-compatible.
7963 DECL is a just-declared VAR_DECL; if necessary inject its
7964 declaration into the surrounding scope. */
7967 maybe_inject_for_scope_var (tree decl)
7969 timevar_push (TV_NAME_LOOKUP);
7970 if (!DECL_NAME (decl))
7971 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
7973 /* Declarations of __FUNCTION__ and its ilk appear magically when
7974 the variable is first used. If that happens to be inside a
7975 for-loop, we don't want to do anything special. */
7976 if (DECL_PRETTY_FUNCTION_P (decl))
7977 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
7979 if (current_binding_level->is_for_scope)
7981 struct cp_binding_level *outer
7982 = current_binding_level->level_chain;
7984 /* Check to see if the same name is already bound at the outer
7985 level, either because it was directly declared, or because a
7986 dead for-decl got preserved. In either case, the code would
7987 not have been valid under the ARM scope rules, so clear
7988 is_for_scope for the current_binding_level.
7990 Otherwise, we need to preserve the temp slot for decl to last
7991 into the outer binding level. */
7994 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7996 if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7997 && (TREE_CODE (BINDING_VALUE (outer_binding))
7999 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
8001 BINDING_VALUE (outer_binding)
8002 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
8003 current_binding_level->is_for_scope = 0;
8006 timevar_pop (TV_NAME_LOOKUP);
8009 /* Generate code to initialize DECL (a local variable). */
8012 initialize_local_var (tree decl, tree init)
8014 tree type = TREE_TYPE (decl);
8016 my_friendly_assert (TREE_CODE (decl) == VAR_DECL
8017 || TREE_CODE (decl) == RESULT_DECL,
8019 my_friendly_assert (!TREE_STATIC (decl), 20021010);
8021 if (DECL_SIZE (decl) == NULL_TREE)
8023 /* If we used it already as memory, it must stay in memory. */
8024 DECL_INITIAL (decl) = NULL_TREE;
8025 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
8028 if (DECL_SIZE (decl) && type != error_mark_node)
8032 /* Compute and store the initial value. */
8033 already_used = TREE_USED (decl) || TREE_USED (type);
8035 /* Perform the initialization. */
8038 int saved_stmts_are_full_exprs_p;
8040 my_friendly_assert (building_stmt_tree (), 20000906);
8041 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
8042 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
8043 finish_expr_stmt (init);
8044 current_stmt_tree ()->stmts_are_full_exprs_p =
8045 saved_stmts_are_full_exprs_p;
8048 /* Set this to 0 so we can tell whether an aggregate which was
8049 initialized was ever used. Don't do this if it has a
8050 destructor, so we don't complain about the 'resource
8051 allocation is initialization' idiom. Now set
8052 attribute((unused)) on types so decls of that type will be
8053 marked used. (see TREE_USED, above.) */
8054 if (TYPE_NEEDS_CONSTRUCTING (type)
8056 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8057 && DECL_NAME (decl))
8058 TREE_USED (decl) = 0;
8059 else if (already_used)
8060 TREE_USED (decl) = 1;
8063 /* Generate a cleanup, if necessary. */
8064 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8068 /* Compute the cleanup. */
8069 cleanup = cxx_maybe_build_cleanup (decl);
8071 /* Record the cleanup required for this declaration. */
8072 if (DECL_SIZE (decl) && cleanup)
8073 finish_decl_cleanup (decl, cleanup);
8077 /* Finish processing of a declaration;
8078 install its line number and initial value.
8079 If the length of an array type is not known before,
8080 it must be determined now, from the initial value, or it is an error.
8082 INIT holds the value of an initializer that should be allowed to escape
8085 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8086 if the (init) syntax was used. */
8089 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
8092 tree ttype = NULL_TREE;
8093 const char *asmspec = NULL;
8094 int was_readonly = 0;
8099 error ("assignment (not initialization) in declaration");
8103 /* If a name was specified, get the string. */
8104 if (current_binding_level == global_binding_level)
8105 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8107 asmspec = TREE_STRING_POINTER (asmspec_tree);
8109 if (init && TREE_CODE (init) == NAMESPACE_DECL)
8111 error ("cannot initialize `%D' to namespace `%D'",
8116 if (current_class_type
8117 && CP_DECL_CONTEXT (decl) == current_class_type
8118 && TYPE_BEING_DEFINED (current_class_type)
8119 && (DECL_INITIAL (decl) || init))
8120 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8122 if (TREE_CODE (decl) == VAR_DECL
8123 && DECL_CONTEXT (decl)
8124 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8125 && DECL_CONTEXT (decl) != current_namespace
8128 /* Leave the namespace of the object. */
8129 pop_decl_namespace ();
8132 type = TREE_TYPE (decl);
8134 if (type == error_mark_node)
8137 if (TYPE_HAS_MUTABLE_P (type))
8138 TREE_READONLY (decl) = 0;
8140 if (processing_template_decl)
8142 /* Add this declaration to the statement-tree. */
8143 if (at_function_scope_p ()
8144 && TREE_CODE (decl) != RESULT_DECL)
8145 add_decl_stmt (decl);
8147 if (init && DECL_INITIAL (decl))
8148 DECL_INITIAL (decl) = init;
8152 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8153 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8155 /* Take care of TYPE_DECLs up front. */
8156 if (TREE_CODE (decl) == TYPE_DECL)
8158 if (type != error_mark_node
8159 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8161 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8162 warning ("shadowing previous type declaration of `%#D'", decl);
8163 set_identifier_type_value (DECL_NAME (decl), type);
8164 CLASSTYPE_GOT_SEMICOLON (type) = 1;
8167 /* If we have installed this as the canonical typedef for this
8168 type, and that type has not been defined yet, delay emitting
8169 the debug information for it, as we will emit it later. */
8170 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8171 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8172 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8174 rest_of_decl_compilation (decl, NULL,
8175 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8179 if (TREE_CODE (decl) != FUNCTION_DECL)
8180 ttype = target_type (type);
8182 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8183 && TYPE_NEEDS_CONSTRUCTING (type))
8185 /* Currently, GNU C++ puts constants in text space, making them
8186 impossible to initialize. In the future, one would hope for
8187 an operating system which understood the difference between
8188 initialization and the running of a program. */
8190 TREE_READONLY (decl) = 0;
8193 if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8195 /* This must override the asm specifier which was placed by
8196 grokclassfn. Lay this out fresh. */
8197 SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8198 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8199 make_decl_rtl (decl, asmspec);
8201 else if (TREE_CODE (decl) == RESULT_DECL)
8202 init = check_initializer (decl, init, flags);
8203 else if (TREE_CODE (decl) == VAR_DECL)
8205 /* Only PODs can have thread-local storage. Other types may require
8206 various kinds of non-trivial initialization. */
8207 if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
8208 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
8209 decl, TREE_TYPE (decl));
8210 /* Convert the initializer to the type of DECL, if we have not
8211 already initialized DECL. */
8212 if (!DECL_INITIALIZED_P (decl)
8213 /* If !DECL_EXTERNAL then DECL is being defined. In the
8214 case of a static data member initialized inside the
8215 class-specifier, there can be an initializer even if DECL
8216 is *not* defined. */
8217 && (!DECL_EXTERNAL (decl) || init))
8219 init = check_initializer (decl, init, flags);
8220 /* Thread-local storage cannot be dynamically initialized. */
8221 if (DECL_THREAD_LOCAL (decl) && init)
8223 error ("`%D' is thread-local and so cannot be dynamically "
8224 "initialized", decl);
8231 The memory occupied by any object of static storage
8232 duration is zero-initialized at program startup before
8233 any other initialization takes place.
8235 We cannot create an appropriate initializer until after
8236 the type of DECL is finalized. If DECL_INITIAL is set,
8237 then the DECL is statically initialized, and any
8238 necessary zero-initialization has already been performed. */
8239 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
8240 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
8241 /*nelts=*/NULL_TREE,
8242 /*static_storage_p=*/true);
8243 /* Remember that the initialization for this variable has
8245 DECL_INITIALIZED_P (decl) = 1;
8247 /* If the variable has an array type, lay out the type, even if
8248 there is no initializer. It is valid to index through the
8249 array, and we must get TYPE_ALIGN set correctly on the array
8251 else if (TREE_CODE (type) == ARRAY_TYPE)
8255 /* Add this declaration to the statement-tree. This needs to happen
8256 after the call to check_initializer so that the DECL_STMT for a
8257 reference temp is added before the DECL_STMT for the reference itself. */
8258 if (building_stmt_tree ()
8259 && at_function_scope_p ()
8260 && TREE_CODE (decl) != RESULT_DECL)
8261 add_decl_stmt (decl);
8263 if (TREE_CODE (decl) == VAR_DECL)
8264 layout_var_decl (decl);
8266 /* Output the assembler code and/or RTL code for variables and functions,
8267 unless the type is an undefined structure or union.
8268 If not, it will get done when the type is completed. */
8269 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8270 || TREE_CODE (decl) == RESULT_DECL)
8272 if (TREE_CODE (decl) == VAR_DECL)
8273 maybe_commonize_var (decl);
8275 make_rtl_for_nonlocal_decl (decl, init, asmspec);
8277 if (TREE_CODE (type) == FUNCTION_TYPE
8278 || TREE_CODE (type) == METHOD_TYPE)
8279 abstract_virtuals_error (decl,
8280 strip_array_types (TREE_TYPE (type)));
8282 abstract_virtuals_error (decl, strip_array_types (type));
8284 if (TREE_CODE (decl) == FUNCTION_DECL
8285 || TREE_TYPE (decl) == error_mark_node)
8286 /* No initialization required. */
8288 else if (DECL_EXTERNAL (decl)
8289 && ! (DECL_LANG_SPECIFIC (decl)
8290 && DECL_NOT_REALLY_EXTERN (decl)))
8293 DECL_INITIAL (decl) = init;
8297 /* A variable definition. */
8298 if (DECL_FUNCTION_SCOPE_P (decl))
8300 /* This is a local declaration. */
8301 if (doing_semantic_analysis_p ())
8302 maybe_inject_for_scope_var (decl);
8303 /* Initialize the local variable. */
8304 if (processing_template_decl)
8306 if (init || DECL_INITIAL (decl) == error_mark_node)
8307 DECL_INITIAL (decl) = init;
8309 else if (!TREE_STATIC (decl))
8310 initialize_local_var (decl, init);
8313 if (TREE_STATIC (decl))
8314 expand_static_init (decl, init);
8318 /* Undo call to `pushclass' that was done in `start_decl'
8319 due to initialization of qualified member variable.
8320 I.e., Foo::x = 10; */
8322 tree context = CP_DECL_CONTEXT (decl);
8325 && (TREE_CODE (decl) == VAR_DECL
8326 /* We also have a pushclass done that we need to undo here
8327 if we're at top level and declare a method. */
8328 || TREE_CODE (decl) == FUNCTION_DECL)
8329 /* If size hasn't been set, we're still defining it,
8330 and therefore inside the class body; don't pop
8331 the binding level.. */
8332 && COMPLETE_TYPE_P (context)
8333 && context == current_class_type)
8334 pop_nested_class ();
8341 TREE_READONLY (decl) = 1;
8344 /* This is here for a midend callback from c-common.c */
8347 finish_decl (tree decl, tree init, tree asmspec_tree)
8349 cp_finish_decl (decl, init, asmspec_tree, 0);
8352 /* Returns a declaration for a VAR_DECL as if:
8354 extern "C" TYPE NAME;
8356 had been seen. Used to create compiler-generated global
8360 declare_global_var (tree name, tree type)
8364 push_to_top_level ();
8365 decl = build_decl (VAR_DECL, name, type);
8366 TREE_PUBLIC (decl) = 1;
8367 DECL_EXTERNAL (decl) = 1;
8368 DECL_ARTIFICIAL (decl) = 1;
8370 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8371 pop_from_top_level ();
8376 /* Returns a pointer to the `atexit' function. Note that if
8377 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8378 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8381 get_atexit_node (void)
8392 if (flag_use_cxa_atexit)
8394 /* The declaration for `__cxa_atexit' is:
8396 int __cxa_atexit (void (*)(void *), void *, void *)
8398 We build up the argument types and then then function type
8401 /* First, build the pointer-to-function type for the first
8403 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8404 fn_type = build_function_type (void_type_node, arg_types);
8405 fn_ptr_type = build_pointer_type (fn_type);
8406 /* Then, build the rest of the argument types. */
8407 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8408 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8409 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8410 /* And the final __cxa_atexit type. */
8411 fn_type = build_function_type (integer_type_node, arg_types);
8412 fn_ptr_type = build_pointer_type (fn_type);
8413 name = "__cxa_atexit";
8417 /* The declaration for `atexit' is:
8419 int atexit (void (*)());
8421 We build up the argument types and then then function type
8423 fn_type = build_function_type (void_type_node, void_list_node);
8424 fn_ptr_type = build_pointer_type (fn_type);
8425 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8426 /* Build the final atexit type. */
8427 fn_type = build_function_type (integer_type_node, arg_types);
8431 /* Now, build the function declaration. */
8432 push_lang_context (lang_name_c);
8433 atexit_fndecl = build_library_fn_ptr (name, fn_type);
8434 mark_used (atexit_fndecl);
8435 pop_lang_context ();
8436 atexit_node = default_conversion (atexit_fndecl);
8441 /* Returns the __dso_handle VAR_DECL. */
8444 get_dso_handle_node (void)
8446 if (dso_handle_node)
8447 return dso_handle_node;
8449 /* Declare the variable. */
8450 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8453 return dso_handle_node;
8456 /* Begin a new function with internal linkage whose job will be simply
8457 to destroy some particular variable. */
8460 start_cleanup_fn (void)
8462 static int counter = 0;
8463 int old_interface_only = interface_only;
8464 int old_interface_unknown = interface_unknown;
8470 push_to_top_level ();
8472 /* No need to mangle this. */
8473 push_lang_context (lang_name_c);
8476 interface_unknown = 1;
8478 /* Build the parameter-types. */
8479 parmtypes = void_list_node;
8480 /* Functions passed to __cxa_atexit take an additional parameter.
8481 We'll just ignore it. After we implement the new calling
8482 convention for destructors, we can eliminate the use of
8483 additional cleanup functions entirely in the -fnew-abi case. */
8484 if (flag_use_cxa_atexit)
8485 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8486 /* Build the function type itself. */
8487 fntype = build_function_type (void_type_node, parmtypes);
8488 /* Build the name of the function. */
8489 sprintf (name, "__tcf_%d", counter++);
8490 /* Build the function declaration. */
8491 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8492 /* It's a function with internal linkage, generated by the
8494 TREE_PUBLIC (fndecl) = 0;
8495 DECL_ARTIFICIAL (fndecl) = 1;
8496 /* Make the function `inline' so that it is only emitted if it is
8497 actually needed. It is unlikely that it will be inlined, since
8498 it is only called via a function pointer, but we avoid unnecessary
8499 emissions this way. */
8500 DECL_INLINE (fndecl) = 1;
8501 /* Build the parameter. */
8502 if (flag_use_cxa_atexit)
8506 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8507 DECL_CONTEXT (parmdecl) = fndecl;
8508 TREE_USED (parmdecl) = 1;
8509 DECL_ARGUMENTS (fndecl) = parmdecl;
8513 start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8515 interface_unknown = old_interface_unknown;
8516 interface_only = old_interface_only;
8518 pop_lang_context ();
8520 return current_function_decl;
8523 /* Finish the cleanup function begun by start_cleanup_fn. */
8526 end_cleanup_fn (void)
8528 expand_body (finish_function (0));
8530 pop_from_top_level ();
8533 /* Generate code to handle the destruction of DECL, an object with
8534 static storage duration. */
8537 register_dtor_fn (tree decl)
8543 int saved_flag_access_control;
8545 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8548 /* Call build_cleanup before we enter the anonymous function so that
8549 any access checks will be done relative to the current scope,
8550 rather than the scope of the anonymous function. */
8551 build_cleanup (decl);
8553 /* Now start the function. */
8554 cleanup = start_cleanup_fn ();
8556 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8557 to the original function, rather than the anonymous one. That
8558 will make the back-end think that nested functions are in use,
8559 which causes confusion. */
8560 saved_flag_access_control = flag_access_control;
8561 scope_chain->check_access = flag_access_control = 0;
8562 fcall = build_cleanup (decl);
8563 scope_chain->check_access = flag_access_control = saved_flag_access_control;
8565 /* Create the body of the anonymous function. */
8566 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8567 finish_expr_stmt (fcall);
8568 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8571 /* Call atexit with the cleanup function. */
8572 cxx_mark_addressable (cleanup);
8573 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8574 if (flag_use_cxa_atexit)
8576 args = tree_cons (NULL_TREE,
8577 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8579 args = tree_cons (NULL_TREE, null_pointer_node, args);
8580 args = tree_cons (NULL_TREE, cleanup, args);
8583 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8584 finish_expr_stmt (build_function_call (get_atexit_node (), args));
8587 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
8588 is its initializer. Generate code to handle the construction
8589 and destruction of DECL. */
8592 expand_static_init (tree decl, tree init)
8596 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
8597 my_friendly_assert (TREE_STATIC (decl), 20021010);
8599 /* Some variables require no initialization. */
8601 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8602 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8605 oldstatic = value_member (decl, static_aggregates);
8609 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8610 error ("multiple initializations given for `%D'", decl);
8612 else if (! toplevel_bindings_p ())
8614 /* Emit code to perform this initialization but once. */
8621 /* Emit code to perform this initialization but once. This code
8624 static int guard = 0;
8626 // Do initialization.
8628 // Register variable for destruction at end of program.
8631 Note that the `temp' variable is only set to 1 *after* the
8632 initialization is complete. This ensures that an exception,
8633 thrown during the construction, will cause the variable to
8634 reinitialized when we pass through this code again, as per:
8638 If the initialization exits by throwing an exception, the
8639 initialization is not complete, so it will be tried again
8640 the next time control enters the declaration.
8642 In theory, this process should be thread-safe, too; multiple
8643 threads should not be able to initialize the variable more
8644 than once. We don't yet attempt to ensure thread-safety. */
8646 /* Create the guard variable. */
8647 guard = get_guard (decl);
8649 /* Begin the conditional initialization. */
8650 if_stmt = begin_if_stmt ();
8651 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8652 then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8654 /* Do the initialization itself. */
8655 assignment = init ? init : NULL_TREE;
8657 /* Once the assignment is complete, set TEMP to 1. Since the
8658 construction of the static object is complete at this point,
8659 we want to make sure TEMP is set to 1 even if a temporary
8660 constructed during the initialization throws an exception
8661 when it is destroyed. So, we combine the initialization and
8662 the assignment to TEMP into a single expression, ensuring
8663 that when we call finish_expr_stmt the cleanups will not be
8664 run until after TEMP is set to 1. */
8665 guard_init = set_guard (guard);
8668 assignment = tree_cons (NULL_TREE, assignment,
8669 build_tree_list (NULL_TREE,
8671 assignment = build_compound_expr (assignment);
8674 assignment = guard_init;
8675 finish_expr_stmt (assignment);
8677 /* Use atexit to register a function for destroying this static
8679 register_dtor_fn (decl);
8681 finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8682 finish_then_clause (if_stmt);
8686 static_aggregates = tree_cons (init, decl, static_aggregates);
8689 /* Finish the declaration of a catch-parameter. */
8692 start_handler_parms (tree declspecs, tree declarator)
8697 decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8699 if (decl == NULL_TREE)
8700 error ("invalid catch parameter");
8709 /* Make TYPE a complete type based on INITIAL_VALUE.
8710 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8711 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8714 complete_array_type (tree type, tree initial_value, int do_default)
8716 register tree maxindex = NULL_TREE;
8721 /* An array of character type can be initialized from a
8722 brace-enclosed string constant. */
8723 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8724 && TREE_CODE (initial_value) == CONSTRUCTOR
8725 && CONSTRUCTOR_ELTS (initial_value)
8726 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8728 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8729 initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8731 /* Note MAXINDEX is really the maximum index, one less than the
8733 if (TREE_CODE (initial_value) == STRING_CST)
8736 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8737 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8740 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8742 tree elts = CONSTRUCTOR_ELTS (initial_value);
8744 maxindex = ssize_int (-1);
8745 for (; elts; elts = TREE_CHAIN (elts))
8747 if (TREE_PURPOSE (elts))
8748 maxindex = TREE_PURPOSE (elts);
8750 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8752 maxindex = copy_node (maxindex);
8756 /* Make an error message unless that happened already. */
8757 if (initial_value != error_mark_node)
8760 initial_value = NULL_TREE;
8762 /* Prevent further error messages. */
8763 maxindex = build_int_2 (0, 0);
8770 maxindex = build_int_2 (0, 0);
8779 domain = build_index_type (maxindex);
8780 TYPE_DOMAIN (type) = domain;
8782 if (! TREE_TYPE (maxindex))
8783 TREE_TYPE (maxindex) = domain;
8785 itype = TREE_TYPE (initial_value);
8788 if (itype && !TYPE_DOMAIN (itype))
8789 TYPE_DOMAIN (itype) = domain;
8790 /* The type of the main variant should never be used for arrays
8791 of different sizes. It should only ever be completed with the
8792 size of the array. */
8793 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8794 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8797 /* Lay out the type now that we can get the real answer. */
8804 /* Return zero if something is declared to be a member of type
8805 CTYPE when in the context of CUR_TYPE. STRING is the error
8806 message to print in that case. Otherwise, quietly return 1. */
8809 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
8811 if (ctype && ctype != cur_type)
8813 if (flags == DTOR_FLAG)
8814 error ("destructor for alien class `%T' cannot be a member",
8817 error ("constructor for alien class `%T' cannot be a member",
8824 /* Subroutine of `grokdeclarator'. */
8826 /* Generate errors possibly applicable for a given set of specifiers.
8827 This is for ARM $7.1.2. */
8830 bad_specifiers (tree object,
8839 error ("`%D' declared as a `virtual' %s", object, type);
8841 error ("`%D' declared as an `inline' %s", object, type);
8843 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8846 cp_error_at ("`%D' declared as a friend", object);
8848 && (TREE_CODE (object) == TYPE_DECL
8849 || (!TYPE_PTRFN_P (TREE_TYPE (object))
8850 && !TYPE_REFFN_P (TREE_TYPE (object))
8851 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8852 cp_error_at ("`%D' declared with an exception specification", object);
8855 /* CTYPE is class type, or null if non-class.
8856 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8858 DECLARATOR is the function's name.
8859 VIRTUALP is truthvalue of whether the function is virtual or not.
8860 FLAGS are to be passed through to `grokclassfn'.
8861 QUALS are qualifiers indicating whether the function is `const'
8863 RAISES is a list of exceptions that this function can raise.
8864 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8865 not look, and -1 if we should not call `grokclassfn' at all.
8867 Returns `NULL_TREE' if something goes wrong, after issuing
8868 applicable error messages. */
8871 grokfndecl (tree ctype,
8874 tree orig_declarator,
8876 enum overload_flags flags,
8888 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8889 int has_default_arg = 0;
8893 type = build_exception_variant (type, raises);
8895 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8896 /* Propagate volatile out from type to decl. */
8897 if (TYPE_VOLATILE (type))
8898 TREE_THIS_VOLATILE (decl) = 1;
8900 /* If this decl has namespace scope, set that up. */
8902 set_decl_namespace (decl, in_namespace, friendp);
8904 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8906 /* `main' and builtins have implicit 'C' linkage. */
8907 if ((MAIN_NAME_P (declarator)
8908 || (IDENTIFIER_LENGTH (declarator) > 10
8909 && IDENTIFIER_POINTER (declarator)[0] == '_'
8910 && IDENTIFIER_POINTER (declarator)[1] == '_'
8911 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8912 && current_lang_name == lang_name_cplusplus
8913 && ctype == NULL_TREE
8914 /* NULL_TREE means global namespace. */
8915 && DECL_CONTEXT (decl) == NULL_TREE)
8916 SET_DECL_LANGUAGE (decl, lang_c);
8918 /* Should probably propagate const out from type to decl I bet (mrs). */
8921 DECL_STATIC_FUNCTION_P (decl) = 1;
8922 DECL_CONTEXT (decl) = ctype;
8926 DECL_CONTEXT (decl) = ctype;
8928 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8930 if (processing_template_decl)
8931 error ("cannot declare `::main' to be a template");
8933 error ("cannot declare `::main' to be inline");
8935 error ("cannot declare `::main' to be static");
8936 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8938 error ("`main' must return `int'");
8943 /* Members of anonymous types and local classes have no linkage; make
8945 /* FIXME what if it gets a name from typedef? */
8946 if (ctype && (TYPE_ANONYMOUS_P (ctype)
8947 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8952 /* [basic.link]: A name with no linkage (notably, the name of a class
8953 or enumeration declared in a local scope) shall not be used to
8954 declare an entity with linkage.
8956 Only check this for public decls for now. */
8957 t = no_linkage_check (TREE_TYPE (decl));
8960 if (TYPE_ANONYMOUS_P (t))
8962 if (DECL_EXTERN_C_P (decl))
8963 /* Allow this; it's pretty common in C. */;
8966 pedwarn ("non-local function `%#D' uses anonymous type",
8968 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8970 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8975 pedwarn ("non-local function `%#D' uses local type `%T'",
8980 TREE_PUBLIC (decl) = publicp;
8983 DECL_INTERFACE_KNOWN (decl) = 1;
8984 DECL_NOT_REALLY_EXTERN (decl) = 1;
8987 DID_INLINE_FUNC (decl) = 0;
8988 /* If the declaration was declared inline, mark it as such. */
8990 DECL_DECLARED_INLINE_P (decl) = 1;
8991 /* We inline functions that are explicitly declared inline, or, when
8992 the user explicitly asks us to, all functions. */
8993 if (DECL_DECLARED_INLINE_P (decl))
8994 DECL_INLINE (decl) = 1;
8995 if (flag_inline_trees == 2 && !DECL_INLINE (decl))
8997 DID_INLINE_FUNC (decl) = 1;
8998 DECL_INLINE (decl) = 1;
9001 DECL_EXTERNAL (decl) = 1;
9002 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
9004 error ("%smember function `%D' cannot have `%T' method qualifier",
9005 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
9009 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
9010 grok_op_properties (decl, friendp);
9012 if (ctype && decl_function_context (decl))
9013 DECL_NO_STATIC_CHAIN (decl) = 1;
9015 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
9016 if (TREE_PURPOSE (t)
9017 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
9019 has_default_arg = 1;
9024 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
9028 ("defining explicit specialization `%D' in friend declaration",
9032 tree fns = TREE_OPERAND (orig_declarator, 0);
9033 tree args = TREE_OPERAND (orig_declarator, 1);
9035 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9037 /* Something like `template <class T> friend void f<T>()'. */
9038 error ("invalid use of template-id `%D' in declaration of primary template",
9044 /* A friend declaration of the form friend void f<>(). Record
9045 the information in the TEMPLATE_ID_EXPR. */
9046 SET_DECL_IMPLICIT_INSTANTIATION (decl);
9048 if (TREE_CODE (fns) == COMPONENT_REF)
9050 /* Due to bison parser ickiness, we will have already looked
9051 up an operator_name or PFUNCNAME within the current class
9052 (see template_id in parse.y). If the current class contains
9053 such a name, we'll get a COMPONENT_REF here. Undo that. */
9055 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9056 == current_class_type, 20001120);
9057 fns = TREE_OPERAND (fns, 1);
9059 my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9060 || TREE_CODE (fns) == LOOKUP_EXPR
9061 || TREE_CODE (fns) == OVERLOAD, 20001120);
9062 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9064 if (has_default_arg)
9066 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9073 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9081 /* Make the init_value nonzero so pushdecl knows this is not
9082 tentative. error_mark_node is replaced later with the BLOCK. */
9083 DECL_INITIAL (decl) = error_mark_node;
9085 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9086 TREE_NOTHROW (decl) = 1;
9088 /* Caller will do the rest of this. */
9092 if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
9093 DECL_CONSTRUCTOR_P (decl) = 1;
9095 /* Function gets the ugly name, field gets the nice one. This call
9096 may change the type of the function (because of default
9098 if (ctype != NULL_TREE)
9099 grokclassfn (ctype, decl, flags, quals);
9101 decl = check_explicit_specialization (orig_declarator, decl,
9103 2 * (funcdef_flag != 0) +
9104 4 * (friendp != 0));
9105 if (decl == error_mark_node)
9108 if (ctype != NULL_TREE
9109 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9114 old_decl = check_classfn (ctype, decl);
9116 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9117 /* Because grokfndecl is always supposed to return a
9118 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9119 here. We depend on our callers to figure out that its
9120 really a template that's being returned. */
9121 old_decl = DECL_TEMPLATE_RESULT (old_decl);
9123 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9124 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9126 /* Remove the `this' parm added by grokclassfn.
9127 XXX Isn't this done in start_function, too? */
9128 revert_static_member_fn (decl);
9129 last_function_parms = TREE_CHAIN (last_function_parms);
9131 if (old_decl && DECL_ARTIFICIAL (old_decl))
9132 error ("definition of implicitly-declared `%D'", old_decl);
9136 /* Since we've smashed OLD_DECL to its
9137 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9138 if (TREE_CODE (decl) == TEMPLATE_DECL)
9139 decl = DECL_TEMPLATE_RESULT (decl);
9141 /* Attempt to merge the declarations. This can fail, in
9142 the case of some invalid specialization declarations. */
9144 if (!duplicate_decls (decl, old_decl))
9145 error ("no `%#D' member function declared in class `%T'",
9152 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9155 if (ctype == NULL_TREE || check)
9159 DECL_VIRTUAL_P (decl) = 1;
9164 /* Create a VAR_DECL named NAME with the indicated TYPE.
9166 If SCOPE is non-NULL, it is the class type or namespace containing
9167 the variable. If SCOPE is NULL, the variable should is created in
9168 the innermost enclosings scope. */
9171 grokvardecl (tree type,
9173 RID_BIT_TYPE * specbits_in,
9179 RID_BIT_TYPE specbits;
9181 my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
9184 specbits = *specbits_in;
9186 /* Compute the scope in which to place the variable. */
9189 /* An explicit "extern" specifier indicates a namespace-scope
9191 if (RIDBIT_SETP (RID_EXTERN, specbits))
9192 scope = current_namespace;
9193 else if (!at_function_scope_p ())
9195 scope = current_scope ();
9197 scope = current_namespace;
9202 && (/* If the variable is a namespace-scope variable declared in a
9203 template, we need DECL_LANG_SPECIFIC. */
9204 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9205 /* Similarly for namespace-scope variables with language linkage
9207 || (TREE_CODE (scope) == NAMESPACE_DECL
9208 && current_lang_name != lang_name_cplusplus)
9209 /* Similarly for static data members. */
9211 decl = build_lang_decl (VAR_DECL, name, type);
9213 decl = build_decl (VAR_DECL, name, type);
9215 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9216 set_decl_namespace (decl, scope, 0);
9218 DECL_CONTEXT (decl) = scope;
9220 if (name && scope && current_lang_name != lang_name_c)
9221 /* We can't mangle lazily here because we don't have any
9222 way to recover whether or not a variable was `extern
9226 if (RIDBIT_SETP (RID_EXTERN, specbits))
9228 DECL_THIS_EXTERN (decl) = 1;
9229 DECL_EXTERNAL (decl) = !initialized;
9232 /* In class context, static means one per class,
9233 public access, and static storage. */
9234 if (DECL_CLASS_SCOPE_P (decl))
9236 TREE_PUBLIC (decl) = 1;
9237 TREE_STATIC (decl) = 1;
9238 DECL_EXTERNAL (decl) = 0;
9240 /* At top level, either `static' or no s.c. makes a definition
9241 (perhaps tentative), and absence of `static' makes it public. */
9242 else if (toplevel_bindings_p ())
9244 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9245 && (DECL_THIS_EXTERN (decl) || ! constp));
9246 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9248 /* Not at top level, only `static' makes a static definition. */
9251 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9252 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9255 if (RIDBIT_SETP (RID_THREAD, specbits))
9257 if (targetm.have_tls)
9258 DECL_THREAD_LOCAL (decl) = 1;
9260 /* A mere warning is sure to result in improper semantics
9261 at runtime. Don't bother to allow this to compile. */
9262 error ("thread-local storage not supported for this target");
9265 if (TREE_PUBLIC (decl))
9267 /* [basic.link]: A name with no linkage (notably, the name of a class
9268 or enumeration declared in a local scope) shall not be used to
9269 declare an entity with linkage.
9271 Only check this for public decls for now. */
9272 tree t = no_linkage_check (TREE_TYPE (decl));
9275 if (TYPE_ANONYMOUS_P (t))
9276 /* Ignore for now; `enum { foo } e' is pretty common. */;
9278 pedwarn ("non-local variable `%#D' uses local type `%T'",
9286 /* Create and return a canonical pointer to member function type, for
9287 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9290 build_ptrmemfunc_type (tree type)
9294 tree unqualified_variant = NULL_TREE;
9296 if (type == error_mark_node)
9299 /* If a canonical type already exists for this type, use it. We use
9300 this method instead of type_hash_canon, because it only does a
9301 simple equality check on the list of field members. */
9303 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9306 /* Make sure that we always have the unqualified pointer-to-member
9308 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9310 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9312 t = make_aggr_type (RECORD_TYPE);
9313 /* Let the front-end know this is a pointer to member function... */
9314 TYPE_PTRMEMFUNC_FLAG (t) = 1;
9315 /* ... and not really an aggregate. */
9316 SET_IS_AGGR_TYPE (t, 0);
9318 field = build_decl (FIELD_DECL, pfn_identifier, type);
9321 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
9322 TREE_CHAIN (field) = fields;
9325 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9327 /* Zap out the name so that the back-end will give us the debugging
9328 information for this anonymous RECORD_TYPE. */
9329 TYPE_NAME (t) = NULL_TREE;
9331 /* If this is not the unqualified form of this pointer-to-member
9332 type, set the TYPE_MAIN_VARIANT for this type to be the
9333 unqualified type. Since they are actually RECORD_TYPEs that are
9334 not variants of each other, we must do this manually. */
9335 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9337 t = build_qualified_type (t, cp_type_quals (type));
9338 TYPE_MAIN_VARIANT (t) = unqualified_variant;
9339 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9340 TYPE_NEXT_VARIANT (unqualified_variant) = t;
9343 /* Cache this pointer-to-member type so that we can find it again
9345 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9347 /* Seems to be wanted. */
9348 CLASSTYPE_GOT_SEMICOLON (t) = 1;
9353 /* Create and return a pointer to data member type. */
9356 build_ptrmem_type (tree class_type, tree member_type)
9358 return build_pointer_type (build_offset_type (class_type, member_type));
9361 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9362 Check to see that the definition is valid. Issue appropriate error
9363 messages. Return 1 if the definition is particularly bad, or 0
9367 check_static_variable_definition (tree decl, tree type)
9369 /* Motion 10 at San Diego: If a static const integral data member is
9370 initialized with an integral constant expression, the initializer
9371 may appear either in the declaration (within the class), or in
9372 the definition, but not both. If it appears in the class, the
9373 member is a member constant. The file-scope definition is always
9375 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9377 error ("invalid in-class initialization of static data member of non-integral type `%T'",
9379 /* If we just return the declaration, crashes will sometimes
9380 occur. We therefore return void_type_node, as if this was a
9381 friend declaration, to cause callers to completely ignore
9382 this declaration. */
9385 else if (!CP_TYPE_CONST_P (type))
9386 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9388 else if (pedantic && !INTEGRAL_TYPE_P (type))
9389 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9394 /* Given the SIZE (i.e., number of elements) in an array, compute an
9395 appropriate index type for the array. If non-NULL, NAME is the
9396 name of the thing being declared. */
9399 compute_array_index_type (tree name, tree size)
9403 /* If this involves a template parameter, it will be a constant at
9404 instantiation time, but we don't know what the value is yet.
9405 Even if no template parameters are involved, we may an expression
9406 that is not a constant; we don't even simplify `1 + 2' when
9407 processing a template. */
9408 if (processing_template_decl)
9410 /* Resolve a qualified reference to an enumerator or static
9411 const data member of ours. */
9412 if (TREE_CODE (size) == SCOPE_REF
9413 && TREE_OPERAND (size, 0) == current_class_type)
9415 tree t = lookup_field (current_class_type,
9416 TREE_OPERAND (size, 1), 0, false);
9421 return build_index_type (build_min (MINUS_EXPR, sizetype,
9422 size, integer_one_node));
9425 /* The size might be the result of a cast. */
9426 STRIP_TYPE_NOPS (size);
9428 /* It might be a const variable or enumeration constant. */
9429 size = decl_constant_value (size);
9431 /* The array bound must be an integer type. */
9432 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9433 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9434 && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9437 error ("size of array `%D' has non-integer type", name);
9439 error ("size of array has non-integer type");
9440 size = integer_one_node;
9443 /* Normally, the array-bound will be a constant. */
9444 if (TREE_CODE (size) == INTEGER_CST)
9446 /* Check to see if the array bound overflowed. Make that an
9447 error, no matter how generous we're being. */
9448 int old_flag_pedantic_errors = flag_pedantic_errors;
9449 int old_pedantic = pedantic;
9450 pedantic = flag_pedantic_errors = 1;
9451 constant_expression_warning (size);
9452 pedantic = old_pedantic;
9453 flag_pedantic_errors = old_flag_pedantic_errors;
9455 /* An array must have a positive number of elements. */
9456 if (INT_CST_LT (size, integer_zero_node))
9459 error ("size of array `%D' is negative", name);
9461 error ("size of array is negative");
9462 size = integer_one_node;
9464 /* Except that an extension we allow zero-sized arrays. We
9465 always allow them in system headers because glibc uses
9467 else if (integer_zerop (size) && pedantic && !in_system_header)
9470 pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9472 pedwarn ("ISO C++ forbids zero-size array");
9475 else if (TREE_CONSTANT (size))
9477 /* `(int) &fn' is not a valid array bound. */
9479 error ("size of array `%D' is not an integral constant-expression",
9482 error ("size of array is not an integral constant-expression");
9485 /* Compute the index of the largest element in the array. It is
9486 one less than the number of elements in the array. */
9488 = fold (cp_build_binary_op (MINUS_EXPR,
9489 cp_convert (ssizetype, size),
9490 cp_convert (ssizetype,
9491 integer_one_node)));
9493 /* Check for variable-sized arrays. We allow such things as an
9494 extension, even though they are not allowed in ANSI/ISO C++. */
9495 if (!TREE_CONSTANT (itype))
9500 pedwarn ("ISO C++ forbids variable-size array `%D'",
9503 pedwarn ("ISO C++ forbids variable-size array");
9506 /* Create a variable-sized array index type. */
9507 itype = variable_size (itype);
9509 /* Make sure that there was no overflow when creating to a signed
9510 index type. (For example, on a 32-bit machine, an array with
9511 size 2^32 - 1 is too big.) */
9512 else if (TREE_OVERFLOW (itype))
9514 error ("overflow in array dimension");
9515 TREE_OVERFLOW (itype) = 0;
9518 /* Create and return the appropriate index type. */
9519 return build_index_type (itype);
9522 /* Returns the scope (if any) in which the entity declared by
9523 DECLARATOR will be located. If the entity was declared with an
9524 unqualified name, NULL_TREE is returned. */
9527 get_scope_of_declarator (tree declarator)
9532 switch (TREE_CODE (declarator))
9538 /* For any of these, the main declarator is the first operand. */
9539 return get_scope_of_declarator (TREE_OPERAND
9543 /* For a pointer-to-member, continue descending. */
9544 if (TREE_CODE (TREE_OPERAND (declarator, 1))
9546 return get_scope_of_declarator (TREE_OPERAND
9548 /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in
9549 which the declaration occurs is the first operand. */
9550 return TREE_OPERAND (declarator, 0);
9553 /* Attributes to be applied. The declarator is TREE_VALUE. */
9554 return get_scope_of_declarator (TREE_VALUE (declarator));
9557 /* Otherwise, we have a declarator-id which is not a qualified
9558 name; the entity will be declared in the current scope. */
9563 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9564 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9568 create_array_type_for_decl (tree name, tree type, tree size)
9570 tree itype = NULL_TREE;
9571 const char* error_msg;
9573 /* If things have already gone awry, bail now. */
9574 if (type == error_mark_node || size == error_mark_node)
9575 return error_mark_node;
9577 /* Assume that everything will go OK. */
9580 /* There are some types which cannot be array elements. */
9581 switch (TREE_CODE (type))
9584 error_msg = "array of void";
9588 error_msg = "array of functions";
9591 case REFERENCE_TYPE:
9592 error_msg = "array of references";
9596 error_msg = "array of data members";
9600 error_msg = "array of function members";
9607 /* If something went wrong, issue an error-message and return. */
9611 error ("declaration of `%D' as %s", name, error_msg);
9613 error ("creating %s", error_msg);
9615 return error_mark_node;
9620 The constant expressions that specify the bounds of the arrays
9621 can be omitted only for the first member of the sequence. */
9622 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9625 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9628 error ("multidimensional array must have bounds for all dimensions except the first");
9630 return error_mark_node;
9633 /* Figure out the index type for the array. */
9635 itype = compute_array_index_type (name, size);
9637 return build_cplus_array_type (type, itype);
9640 /* Check that it's OK to declare a function with the indicated TYPE.
9641 SFK indicates the kind of special function (if any) that this
9642 function is. OPTYPE is the type given in a conversion operator
9643 declaration. Returns the actual return type of the function; that
9644 may be different than TYPE if an error occurs, or for certain
9645 special functions. */
9648 check_special_function_return_type (special_function_kind sfk,
9654 case sfk_constructor:
9656 error ("return type specification for constructor invalid");
9658 type = void_type_node;
9661 case sfk_destructor:
9663 error ("return type specification for destructor invalid");
9664 type = void_type_node;
9667 case sfk_conversion:
9668 if (type && !same_type_p (type, optype))
9669 error ("operator `%T' declared to return `%T'", optype, type);
9671 pedwarn ("return type specified for `operator %T'", optype);
9683 /* Given declspecs and a declarator (abstract or otherwise), determine
9684 the name and type of the object declared and construct a DECL node
9687 DECLSPECS is a chain of tree_list nodes whose value fields
9688 are the storage classes and type specifiers.
9690 DECL_CONTEXT says which syntactic context this declaration is in:
9691 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9692 FUNCDEF for a function definition. Like NORMAL but a few different
9693 error messages in each case. Return value may be zero meaning
9694 this definition is too screwy to try to parse.
9695 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9696 handle member functions (which have FIELD context).
9697 Return value may be zero meaning this definition is too screwy to
9699 PARM for a parameter declaration (either within a function prototype
9700 or before a function body). Make a PARM_DECL, or return void_type_node.
9701 CATCHPARM for a parameter declaration before a catch clause.
9702 TYPENAME if for a typename (in a cast or sizeof).
9703 Don't make a DECL node; just return the ..._TYPE node.
9704 FIELD for a struct or union field; make a FIELD_DECL.
9705 BITFIELD for a field with specified width.
9706 INITIALIZED is 1 if the decl has an initializer.
9708 ATTRLIST is a pointer to the list of attributes, which may be NULL
9709 if there are none; *ATTRLIST may be modified if attributes from inside
9710 the declarator should be applied to the declaration.
9712 When this function is called, scoping variables (such as
9713 CURRENT_CLASS_TYPE) should reflect the scope in which the
9714 declaration occurs, not the scope in which the new declaration will
9715 be placed. For example, on:
9719 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9720 should not be `S'. */
9723 grokdeclarator (tree declarator,
9725 enum decl_context decl_context,
9729 RID_BIT_TYPE specbits;
9732 tree type = NULL_TREE;
9735 int virtualp, explicitp, friendp, inlinep, staticp;
9736 int explicit_int = 0;
9737 int explicit_char = 0;
9738 int defaulted_int = 0;
9739 int extern_langp = 0;
9740 tree dependant_name = NULL_TREE;
9742 tree typedef_decl = NULL_TREE;
9744 tree typedef_type = NULL_TREE;
9745 int funcdef_flag = 0;
9746 enum tree_code innermost_code = ERROR_MARK;
9749 /* See the code below that used this. */
9750 tree decl_attr = NULL_TREE;
9753 /* Keep track of what sort of function is being processed
9754 so that we can warn about default return values, or explicit
9755 return values which do not match prescribed defaults. */
9756 special_function_kind sfk = sfk_none;
9758 tree dname = NULL_TREE;
9759 tree ctype = current_class_type;
9760 tree ctor_return_type = NULL_TREE;
9761 enum overload_flags flags = NO_SPECIAL;
9762 tree quals = NULL_TREE;
9763 tree raises = NULL_TREE;
9764 int template_count = 0;
9765 tree in_namespace = NULL_TREE;
9766 tree returned_attrs = NULL_TREE;
9767 tree scope = NULL_TREE;
9769 RIDBIT_RESET_ALL (specbits);
9770 if (decl_context == FUNCDEF)
9771 funcdef_flag = 1, decl_context = NORMAL;
9772 else if (decl_context == MEMFUNCDEF)
9773 funcdef_flag = -1, decl_context = FIELD;
9774 else if (decl_context == BITFIELD)
9775 bitfield = 1, decl_context = FIELD;
9777 /* Look inside a declarator for the name being declared
9778 and get it as a string, for an error message. */
9780 tree *next = &declarator;
9784 while (next && *next)
9787 switch (TREE_CODE (decl))
9790 /* For attributes. */
9791 next = &TREE_VALUE (decl);
9796 next = &TREE_OPERAND (decl, 0);
9799 case BIT_NOT_EXPR: /* For C++ destructors! */
9801 tree name = TREE_OPERAND (decl, 0);
9802 tree rename = NULL_TREE;
9804 my_friendly_assert (flags == NO_SPECIAL, 152);
9806 sfk = sfk_destructor;
9808 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9809 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9810 if (ctype == NULL_TREE)
9812 if (current_class_type == NULL_TREE)
9814 error ("destructors must be member functions");
9819 tree t = constructor_name (current_class_type);
9826 tree t = constructor_name (ctype);
9833 error ("destructor `%T' must match class name `%T'",
9835 TREE_OPERAND (decl, 0) = rename;
9841 case ADDR_EXPR: /* C++ reference declaration */
9846 innermost_code = TREE_CODE (decl);
9847 next = &TREE_OPERAND (decl, 0);
9851 innermost_code = TREE_CODE (decl);
9852 if (decl_context == FIELD && ctype == NULL_TREE)
9853 ctype = current_class_type;
9855 && TREE_OPERAND (decl, 0)
9856 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9857 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
9859 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9860 next = &TREE_OPERAND (decl, 0);
9862 if (ctype != NULL_TREE
9863 && decl != NULL_TREE && flags != DTOR_FLAG
9864 && constructor_name_p (decl, ctype))
9866 sfk = sfk_constructor;
9867 ctor_return_type = ctype;
9872 case TEMPLATE_ID_EXPR:
9874 tree fns = TREE_OPERAND (decl, 0);
9876 if (TREE_CODE (fns) == LOOKUP_EXPR)
9877 fns = TREE_OPERAND (fns, 0);
9880 if (TREE_CODE (dname) == COMPONENT_REF)
9881 dname = TREE_OPERAND (dname, 1);
9882 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9884 my_friendly_assert (is_overloaded_fn (dname),
9886 dname = DECL_NAME (get_first_fn (dname));
9891 case IDENTIFIER_NODE:
9892 if (TREE_CODE (decl) == IDENTIFIER_NODE)
9897 if (C_IS_RESERVED_WORD (dname))
9899 error ("declarator-id missing; using reserved word `%D'",
9901 name = IDENTIFIER_POINTER (dname);
9903 else if (!IDENTIFIER_TYPENAME_P (dname))
9904 name = IDENTIFIER_POINTER (dname);
9907 my_friendly_assert (flags == NO_SPECIAL, 154);
9908 flags = TYPENAME_FLAG;
9909 ctor_return_type = TREE_TYPE (dname);
9910 sfk = sfk_conversion;
9911 if (IDENTIFIER_GLOBAL_VALUE (dname)
9912 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9914 name = IDENTIFIER_POINTER (dname);
9916 name = "<invalid operator>";
9923 /* Perform error checking, and decide on a ctype. */
9924 tree cname = TREE_OPERAND (decl, 0);
9925 if (cname == NULL_TREE)
9927 else if (TREE_CODE (cname) == NAMESPACE_DECL)
9930 in_namespace = TREE_OPERAND (decl, 0);
9932 else if (! is_aggr_type (cname, 1))
9934 /* Must test TREE_OPERAND (decl, 1), in case user gives
9935 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9936 else if (TREE_OPERAND (decl, 1)
9937 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9939 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9940 || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9942 /* This might be declaring a member of a template
9943 parm to be a friend. */
9945 dependant_name = TREE_OPERAND (decl, 1);
9947 else if (ctype == NULL_TREE)
9949 else if (TREE_COMPLEXITY (decl) == current_class_depth)
9953 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9955 error ("type `%T' is not derived from type `%T'",
9963 /* It is valid to write:
9965 class C { void f(); };
9969 The standard is not clear about whether `typedef const C D' is
9970 legal; as of 2002-09-15 the committee is considering
9971 that question. EDG 3.0 allows that syntax.
9972 Therefore, we do as well. */
9974 ctype = TYPE_MAIN_VARIANT (ctype);
9975 /* Update the declarator so that when we process it
9976 again the correct type is present. */
9977 TREE_OPERAND (decl, 0) = ctype;
9979 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9980 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
9982 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9983 next = &TREE_OPERAND (decl, 1);
9987 if (TREE_CODE (decl) == IDENTIFIER_NODE
9988 && constructor_name_p (decl, ctype))
9990 sfk = sfk_constructor;
9991 ctor_return_type = ctype;
9993 else if (TREE_CODE (decl) == BIT_NOT_EXPR
9994 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9995 && constructor_name_p (TREE_OPERAND (decl, 0),
9998 sfk = sfk_destructor;
9999 ctor_return_type = ctype;
10001 TREE_OPERAND (decl, 0) = constructor_name (ctype);
10002 next = &TREE_OPERAND (decl, 0);
10013 /* Parse error puts this typespec where
10014 a declarator should go. */
10015 error ("`%T' specified as declarator-id", DECL_NAME (decl));
10016 if (TREE_TYPE (decl) == current_class_type)
10017 error (" perhaps you want `%T' for a constructor",
10018 current_class_name);
10019 dname = DECL_NAME (decl);
10020 name = IDENTIFIER_POINTER (dname);
10022 /* Avoid giving two errors for this. */
10023 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
10025 declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
10031 next = &BASELINK_FUNCTIONS (decl);
10034 case TEMPLATE_DECL:
10035 /* Sometimes, we see a template-name used as part of a
10036 decl-specifier like in
10037 std::allocator alloc;
10038 Handle that gracefully. */
10039 error ("invalid use of template-name '%E' in a declarator", decl);
10040 return error_mark_node;
10044 my_friendly_assert (0, 20020917);
10049 /* A function definition's declarator must have the form of
10050 a function declarator. */
10052 if (funcdef_flag && innermost_code != CALL_EXPR)
10055 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10056 && innermost_code != CALL_EXPR
10057 && ! (ctype && declspecs == NULL_TREE))
10059 error ("declaration of `%D' as non-function", dname);
10060 return void_type_node;
10063 /* Anything declared one level down from the top level
10064 must be one of the parameters of a function
10065 (because the body is at least two levels down). */
10067 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10068 by not allowing C++ class definitions to specify their parameters
10069 with xdecls (must be spec.d in the parmlist).
10071 Since we now wait to push a class scope until we are sure that
10072 we are in a legitimate method context, we must set oldcname
10073 explicitly (since current_class_name is not yet alive).
10075 We also want to avoid calling this a PARM if it is in a namespace. */
10077 if (decl_context == NORMAL && !toplevel_bindings_p ())
10079 struct cp_binding_level *b = current_binding_level;
10080 current_binding_level = b->level_chain;
10081 if (current_binding_level != 0 && toplevel_bindings_p ())
10082 decl_context = PARM;
10083 current_binding_level = b;
10087 name = decl_context == PARM ? "parameter" : "type name";
10089 /* Look through the decl specs and record which ones appear.
10090 Some typespecs are defined as built-in typenames.
10091 Others, the ones that are modifiers of other types,
10092 are represented by bits in SPECBITS: set the bits for
10093 the modifiers that appear. Storage class keywords are also in SPECBITS.
10095 If there is a typedef name or a type, store the type in TYPE.
10096 This includes builtin typedefs such as `int'.
10098 Set EXPLICIT_INT if the type is `int' or `char' and did not
10099 come from a user typedef.
10101 Set LONGLONG if `long' is mentioned twice.
10103 For C++, constructors and destructors have their own fast treatment. */
10105 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10110 /* Certain parse errors slip through. For example,
10111 `int class;' is not caught by the parser. Try
10112 weakly to recover here. */
10113 if (TREE_CODE (spec) != TREE_LIST)
10116 id = TREE_VALUE (spec);
10118 /* If the entire declaration is itself tagged as deprecated then
10119 suppress reports of deprecated items. */
10120 if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10122 if (deprecated_state != DEPRECATED_SUPPRESS)
10123 warn_deprecated_use (id);
10126 if (TREE_CODE (id) == IDENTIFIER_NODE)
10128 if (id == ridpointers[(int) RID_INT]
10129 || id == ridpointers[(int) RID_CHAR]
10130 || id == ridpointers[(int) RID_BOOL]
10131 || id == ridpointers[(int) RID_WCHAR])
10135 if (id == ridpointers[(int) RID_BOOL])
10136 error ("`bool' is now a keyword");
10138 error ("extraneous `%T' ignored", id);
10142 if (id == ridpointers[(int) RID_INT])
10144 else if (id == ridpointers[(int) RID_CHAR])
10146 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10150 /* C++ aggregate types. */
10151 if (IDENTIFIER_HAS_TYPE_VALUE (id))
10154 error ("multiple declarations `%T' and `%T'", type, id);
10156 type = IDENTIFIER_TYPE_VALUE (id);
10160 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10162 if (ridpointers[i] == id)
10164 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10166 if (pedantic && ! in_system_header && warn_long_long)
10167 pedwarn ("ISO C++ does not support `long long'");
10169 error ("`long long long' is too long for GCC");
10173 else if (RIDBIT_SETP (i, specbits))
10174 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10176 /* Diagnose "__thread extern" or "__thread static". */
10177 if (RIDBIT_SETP (RID_THREAD, specbits))
10179 if (i == (int)RID_EXTERN)
10180 error ("`__thread' before `extern'");
10181 else if (i == (int)RID_STATIC)
10182 error ("`__thread' before `static'");
10185 if (i == (int)RID_EXTERN
10186 && TREE_PURPOSE (spec) == error_mark_node)
10187 /* This extern was part of a language linkage. */
10190 RIDBIT_SET (i, specbits);
10195 else if (TREE_CODE (id) == TYPE_DECL)
10198 error ("multiple declarations `%T' and `%T'", type,
10202 type = TREE_TYPE (id);
10203 TREE_VALUE (spec) = type;
10209 error ("two or more data types in declaration of `%s'", name);
10210 else if (TREE_CODE (id) == IDENTIFIER_NODE)
10212 register tree t = lookup_name (id, 1);
10213 if (!t || TREE_CODE (t) != TYPE_DECL)
10214 error ("`%s' fails to be a typedef or built in type",
10215 IDENTIFIER_POINTER (id));
10218 type = TREE_TYPE (t);
10222 else if (id != error_mark_node)
10223 /* Can't change CLASS nodes into RECORD nodes here! */
10230 /* See the code below that used this. */
10232 decl_attr = DECL_ATTRIBUTES (typedef_decl);
10234 typedef_type = type;
10236 /* No type at all: default to `int', and set DEFAULTED_INT
10237 because it was not a user-defined typedef. */
10239 if (type == NULL_TREE
10240 && (RIDBIT_SETP (RID_SIGNED, specbits)
10241 || RIDBIT_SETP (RID_UNSIGNED, specbits)
10242 || RIDBIT_SETP (RID_LONG, specbits)
10243 || RIDBIT_SETP (RID_SHORT, specbits)))
10245 /* These imply 'int'. */
10246 type = integer_type_node;
10250 if (sfk != sfk_none)
10251 type = check_special_function_return_type (sfk, type,
10253 else if (type == NULL_TREE)
10259 /* We handle `main' specially here, because 'main () { }' is so
10260 common. With no options, it is allowed. With -Wreturn-type,
10261 it is a warning. It is only an error with -pedantic-errors. */
10262 is_main = (funcdef_flag
10263 && dname && MAIN_NAME_P (dname)
10264 && ctype == NULL_TREE
10265 && in_namespace == NULL_TREE
10266 && current_namespace == global_namespace);
10268 if (in_system_header || flag_ms_extensions)
10269 /* Allow it, sigh. */;
10270 else if (pedantic || ! is_main)
10271 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10273 else if (warn_return_type)
10274 warning ("ISO C++ forbids declaration of `%s' with no type",
10277 type = integer_type_node;
10282 /* Now process the modifiers that were specified
10283 and check for invalid combinations. */
10285 /* Long double is a special combination. */
10287 if (RIDBIT_SETP (RID_LONG, specbits)
10288 && TYPE_MAIN_VARIANT (type) == double_type_node)
10290 RIDBIT_RESET (RID_LONG, specbits);
10291 type = build_qualified_type (long_double_type_node,
10292 cp_type_quals (type));
10295 /* Check all other uses of type modifiers. */
10297 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10298 || RIDBIT_SETP (RID_SIGNED, specbits)
10299 || RIDBIT_SETP (RID_LONG, specbits)
10300 || RIDBIT_SETP (RID_SHORT, specbits))
10304 if (TREE_CODE (type) == REAL_TYPE)
10305 error ("short, signed or unsigned invalid for `%s'", name);
10306 else if (TREE_CODE (type) != INTEGER_TYPE)
10307 error ("long, short, signed or unsigned invalid for `%s'", name);
10308 else if (RIDBIT_SETP (RID_LONG, specbits)
10309 && RIDBIT_SETP (RID_SHORT, specbits))
10310 error ("long and short specified together for `%s'", name);
10311 else if ((RIDBIT_SETP (RID_LONG, specbits)
10312 || RIDBIT_SETP (RID_SHORT, specbits))
10314 error ("long or short specified with char for `%s'", name);
10315 else if ((RIDBIT_SETP (RID_LONG, specbits)
10316 || RIDBIT_SETP (RID_SHORT, specbits))
10317 && TREE_CODE (type) == REAL_TYPE)
10318 error ("long or short specified with floating type for `%s'", name);
10319 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10320 && RIDBIT_SETP (RID_UNSIGNED, specbits))
10321 error ("signed and unsigned given together for `%s'", name);
10325 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10327 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10329 if (flag_pedantic_errors)
10334 /* Discard the type modifiers if they are invalid. */
10337 RIDBIT_RESET (RID_UNSIGNED, specbits);
10338 RIDBIT_RESET (RID_SIGNED, specbits);
10339 RIDBIT_RESET (RID_LONG, specbits);
10340 RIDBIT_RESET (RID_SHORT, specbits);
10345 if (RIDBIT_SETP (RID_COMPLEX, specbits)
10346 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10348 error ("complex invalid for `%s'", name);
10349 RIDBIT_RESET (RID_COMPLEX, specbits);
10352 /* Decide whether an integer type is signed or not.
10353 Optionally treat bitfields as signed by default. */
10354 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10357 It is implementation-defined whether a plain (neither
10358 explicitly signed or unsigned) char, short, int, or long
10359 bit-field is signed or unsigned.
10361 Naturally, we extend this to long long as well. Note that
10362 this does not include wchar_t. */
10363 || (bitfield && !flag_signed_bitfields
10364 && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10365 /* A typedef for plain `int' without `signed' can be
10366 controlled just like plain `int', but a typedef for
10367 `signed int' cannot be so controlled. */
10369 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10370 && (TREE_CODE (type) == INTEGER_TYPE
10371 || TREE_CODE (type) == CHAR_TYPE)
10372 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10375 type = long_long_unsigned_type_node;
10376 else if (RIDBIT_SETP (RID_LONG, specbits))
10377 type = long_unsigned_type_node;
10378 else if (RIDBIT_SETP (RID_SHORT, specbits))
10379 type = short_unsigned_type_node;
10380 else if (type == char_type_node)
10381 type = unsigned_char_type_node;
10382 else if (typedef_decl)
10383 type = c_common_unsigned_type (type);
10385 type = unsigned_type_node;
10387 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10388 && type == char_type_node)
10389 type = signed_char_type_node;
10391 type = long_long_integer_type_node;
10392 else if (RIDBIT_SETP (RID_LONG, specbits))
10393 type = long_integer_type_node;
10394 else if (RIDBIT_SETP (RID_SHORT, specbits))
10395 type = short_integer_type_node;
10397 if (RIDBIT_SETP (RID_COMPLEX, specbits))
10399 /* If we just have "complex", it is equivalent to
10400 "complex double", but if any modifiers at all are specified it is
10401 the complex form of TYPE. E.g, "complex short" is
10402 "complex short int". */
10404 if (defaulted_int && ! longlong
10405 && ! (RIDBIT_SETP (RID_LONG, specbits)
10406 || RIDBIT_SETP (RID_SHORT, specbits)
10407 || RIDBIT_SETP (RID_SIGNED, specbits)
10408 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10409 type = complex_double_type_node;
10410 else if (type == integer_type_node)
10411 type = complex_integer_type_node;
10412 else if (type == float_type_node)
10413 type = complex_float_type_node;
10414 else if (type == double_type_node)
10415 type = complex_double_type_node;
10416 else if (type == long_double_type_node)
10417 type = complex_long_double_type_node;
10419 type = build_complex_type (type);
10422 type_quals = TYPE_UNQUALIFIED;
10423 if (RIDBIT_SETP (RID_CONST, specbits))
10424 type_quals |= TYPE_QUAL_CONST;
10425 if (RIDBIT_SETP (RID_VOLATILE, specbits))
10426 type_quals |= TYPE_QUAL_VOLATILE;
10427 if (RIDBIT_SETP (RID_RESTRICT, specbits))
10428 type_quals |= TYPE_QUAL_RESTRICT;
10429 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10430 error ("qualifiers are not allowed on declaration of `operator %T'",
10433 type_quals |= cp_type_quals (type);
10434 type = cp_build_qualified_type_real
10435 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10436 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10437 /* We might have ignored or rejected some of the qualifiers. */
10438 type_quals = cp_type_quals (type);
10441 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10442 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10443 RIDBIT_RESET (RID_VIRTUAL, specbits);
10444 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10445 RIDBIT_RESET (RID_EXPLICIT, specbits);
10447 if (RIDBIT_SETP (RID_STATIC, specbits))
10448 staticp = 1 + (decl_context == FIELD);
10450 if (virtualp && staticp == 2)
10452 error ("member `%D' cannot be declared both virtual and static",
10456 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10457 RIDBIT_RESET (RID_FRIEND, specbits);
10459 if (dependant_name && !friendp)
10461 error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10462 return void_type_node;
10465 /* Warn if two storage classes are given. Default to `auto'. */
10467 if (RIDBIT_ANY_SET (specbits))
10469 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10470 if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10471 if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10472 if (decl_context == PARM && nclasses > 0)
10473 error ("storage class specifiers invalid in parameter declarations");
10474 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10476 if (decl_context == PARM)
10477 error ("typedef declaration invalid in parameter declaration");
10480 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10481 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10482 if (!nclasses && !friendp && extern_langp)
10486 /* Give error if `virtual' is used outside of class declaration. */
10488 && (current_class_name == NULL_TREE || decl_context != FIELD))
10490 error ("virtual outside class declaration");
10494 /* Static anonymous unions are dealt with here. */
10495 if (staticp && decl_context == TYPENAME
10496 && TREE_CODE (declspecs) == TREE_LIST
10497 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10498 decl_context = FIELD;
10500 /* Warn about storage classes that are invalid for certain
10501 kinds of declarations (parameters, typenames, etc.). */
10503 /* "static __thread" and "extern __thread" are allowed. */
10505 && RIDBIT_SETP (RID_THREAD, specbits)
10506 && (RIDBIT_SETP (RID_EXTERN, specbits)
10507 || RIDBIT_SETP (RID_STATIC, specbits)))
10511 error ("multiple storage classes in declaration of `%s'", name);
10512 else if (decl_context != NORMAL && nclasses > 0)
10514 if ((decl_context == PARM || decl_context == CATCHPARM)
10515 && (RIDBIT_SETP (RID_REGISTER, specbits)
10516 || RIDBIT_SETP (RID_AUTO, specbits)))
10518 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10520 else if (decl_context == FIELD
10521 /* C++ allows static class elements */
10522 && RIDBIT_SETP (RID_STATIC, specbits))
10523 /* C++ also allows inlines and signed and unsigned elements,
10524 but in those cases we don't come in here. */
10528 if (decl_context == FIELD)
10530 tree tmp = NULL_TREE;
10531 register int op = 0;
10535 /* Avoid trying to get an operand off an identifier node. */
10536 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10539 tmp = TREE_OPERAND (declarator, 0);
10540 op = IDENTIFIER_OPNAME_P (tmp);
10541 if (IDENTIFIER_TYPENAME_P (tmp))
10543 if (IDENTIFIER_GLOBAL_VALUE (tmp)
10544 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10546 name = IDENTIFIER_POINTER (tmp);
10548 name = "<invalid operator>";
10551 error ("storage class specified for %s `%s'",
10552 op ? "member operator" : "field",
10557 if (decl_context == PARM || decl_context == CATCHPARM)
10558 error ("storage class specified for parameter `%s'", name);
10560 error ("storage class specified for typename");
10562 RIDBIT_RESET (RID_REGISTER, specbits);
10563 RIDBIT_RESET (RID_AUTO, specbits);
10564 RIDBIT_RESET (RID_EXTERN, specbits);
10565 RIDBIT_RESET (RID_THREAD, specbits);
10568 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10570 if (toplevel_bindings_p ())
10572 /* It's common practice (and completely valid) to have a const
10573 be initialized and declared extern. */
10574 if (!(type_quals & TYPE_QUAL_CONST))
10575 warning ("`%s' initialized and declared `extern'", name);
10578 error ("`%s' has both `extern' and initializer", name);
10580 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10581 && ! toplevel_bindings_p ())
10582 error ("nested function `%s' declared `extern'", name);
10583 else if (toplevel_bindings_p ())
10585 if (RIDBIT_SETP (RID_AUTO, specbits))
10586 error ("top-level declaration of `%s' specifies `auto'", name);
10588 else if (RIDBIT_SETP (RID_THREAD, specbits)
10589 && !RIDBIT_SETP (RID_EXTERN, specbits)
10590 && !RIDBIT_SETP (RID_STATIC, specbits))
10592 error ("function-scope `%s' implicitly auto and declared `__thread'",
10594 RIDBIT_RESET (RID_THREAD, specbits);
10597 if (nclasses > 0 && friendp)
10598 error ("storage class specifiers invalid in friend function declarations");
10600 scope = get_scope_of_declarator (declarator);
10602 /* Now figure out the structure of the declarator proper.
10603 Descend through it, creating more complex types, until we reach
10604 the declared identifier (or NULL_TREE, in an abstract declarator). */
10606 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10607 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10609 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10610 an INDIRECT_REF (for *...),
10611 a CALL_EXPR (for ...(...)),
10612 an identifier (for the name being declared)
10613 or a null pointer (for the place in an absolute declarator
10614 where the name was omitted).
10615 For the last two cases, we have just exited the loop.
10617 For C++ it could also be
10618 a SCOPE_REF (for class :: ...). In this case, we have converted
10619 sensible names to types, and those are the values we use to
10620 qualify the member name.
10621 an ADDR_EXPR (for &...),
10622 a BIT_NOT_EXPR (for destructors)
10624 At this point, TYPE is the type of elements of an array,
10625 or for a function to return, or for a pointer to point to.
10626 After this sequence of ifs, TYPE is the type of the
10627 array or function or pointer, and DECLARATOR has had its
10628 outermost layer removed. */
10630 if (type == error_mark_node)
10632 if (TREE_CODE (declarator) == SCOPE_REF)
10633 declarator = TREE_OPERAND (declarator, 1);
10635 declarator = TREE_OPERAND (declarator, 0);
10638 if (quals != NULL_TREE
10639 && (declarator == NULL_TREE
10640 || TREE_CODE (declarator) != SCOPE_REF))
10642 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10643 ctype = TYPE_METHOD_BASETYPE (type);
10644 if (ctype != NULL_TREE)
10646 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10647 grok_method_quals (ctype, dummy, quals);
10648 type = TREE_TYPE (dummy);
10653 switch (TREE_CODE (declarator))
10657 /* We encode a declarator with embedded attributes using
10659 tree attrs = TREE_PURPOSE (declarator);
10663 declarator = TREE_VALUE (declarator);
10664 inner_decl = declarator;
10665 while (inner_decl != NULL_TREE
10666 && TREE_CODE (inner_decl) == TREE_LIST)
10667 inner_decl = TREE_VALUE (inner_decl);
10669 if (inner_decl == NULL_TREE
10670 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10671 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10672 if (TREE_CODE (inner_decl) == CALL_EXPR)
10673 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10674 if (TREE_CODE (inner_decl) == ARRAY_REF)
10675 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10676 returned_attrs = decl_attributes (&type,
10677 chainon (returned_attrs, attrs),
10684 register tree size;
10686 size = TREE_OPERAND (declarator, 1);
10688 /* VC++ spells a zero-sized array with []. */
10689 if (size == NULL_TREE && decl_context == FIELD && ! staticp
10690 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10691 size = integer_zero_node;
10693 declarator = TREE_OPERAND (declarator, 0);
10695 type = create_array_type_for_decl (dname, type, size);
10705 tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10706 tree inner_decl = TREE_OPERAND (declarator, 0);
10708 /* Declaring a function type.
10709 Make sure we have a valid type for the function to return. */
10711 /* We now know that the TYPE_QUALS don't apply to the
10712 decl, but to its return type. */
10713 type_quals = TYPE_UNQUALIFIED;
10715 /* Warn about some types functions can't return. */
10717 if (TREE_CODE (type) == FUNCTION_TYPE)
10719 error ("`%s' declared as function returning a function", name);
10720 type = integer_type_node;
10722 if (TREE_CODE (type) == ARRAY_TYPE)
10724 error ("`%s' declared as function returning an array", name);
10725 type = integer_type_node;
10728 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10729 inner_decl = TREE_OPERAND (inner_decl, 1);
10731 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10732 inner_decl = dname;
10734 /* Pick up type qualifiers which should be applied to `this'. */
10735 quals = CALL_DECLARATOR_QUALS (declarator);
10737 /* Pick up the exception specifications. */
10738 raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10740 /* Say it's a definition only for the CALL_EXPR
10741 closest to the identifier. */
10744 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10745 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10746 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10748 if (ctype == NULL_TREE
10749 && decl_context == FIELD
10751 && (friendp == 0 || dname == current_class_name))
10752 ctype = current_class_type;
10754 if (ctype && sfk == sfk_conversion)
10755 TYPE_HAS_CONVERSION (ctype) = 1;
10756 if (ctype && constructor_name_p (dname, ctype))
10758 /* We are within a class's scope. If our declarator name
10759 is the same as the class name, and we are defining
10760 a function, then it is a constructor/destructor, and
10761 therefore returns a void type. */
10763 if (flags == DTOR_FLAG)
10765 /* ISO C++ 12.4/2. A destructor may not be
10766 declared const or volatile. A destructor may
10769 error ("destructor cannot be static member function");
10772 error ("destructors may not be `%s'",
10773 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10776 if (decl_context == FIELD)
10778 if (! member_function_or_else (ctype,
10779 current_class_type,
10781 return void_type_node;
10784 else /* It's a constructor. */
10786 if (explicitp == 1)
10788 /* ISO C++ 12.1. A constructor may not be
10789 declared const or volatile. A constructor may
10790 not be virtual. A constructor may not be
10793 error ("constructor cannot be static member function");
10796 pedwarn ("constructors cannot be declared virtual");
10801 error ("constructors may not be `%s'",
10802 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10806 RID_BIT_TYPE tmp_bits;
10807 memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10808 RIDBIT_RESET (RID_INLINE, tmp_bits);
10809 RIDBIT_RESET (RID_STATIC, tmp_bits);
10810 if (RIDBIT_ANY_SET (tmp_bits))
10811 error ("return value type specifier for constructor ignored");
10813 if (decl_context == FIELD)
10815 if (! member_function_or_else (ctype,
10816 current_class_type,
10818 return void_type_node;
10819 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10820 if (sfk != sfk_constructor)
10824 if (decl_context == FIELD)
10830 error ("can't initialize friend function `%s'", name);
10833 /* Cannot be both friend and virtual. */
10834 error ("virtual functions cannot be friends");
10835 RIDBIT_RESET (RID_FRIEND, specbits);
10838 if (decl_context == NORMAL)
10839 error ("friend declaration not in class definition");
10840 if (current_function_decl && funcdef_flag)
10841 error ("can't define friend function `%s' in a local class definition",
10845 /* Construct the function type and go to the next
10846 inner layer of declarator. */
10848 declarator = TREE_OPERAND (declarator, 0);
10850 /* FIXME: This is where default args should be fully
10853 arg_types = grokparms (inner_parms);
10855 if (declarator && flags == DTOR_FLAG)
10857 /* A destructor declared in the body of a class will
10858 be represented as a BIT_NOT_EXPR. But, we just
10859 want the underlying IDENTIFIER. */
10860 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10861 declarator = TREE_OPERAND (declarator, 0);
10863 if (arg_types != void_list_node)
10865 error ("destructors may not have parameters");
10866 arg_types = void_list_node;
10867 last_function_parms = NULL_TREE;
10871 /* ANSI says that `const int foo ();'
10872 does not make the function foo const. */
10873 type = build_function_type (type, arg_types);
10879 /* Filter out pointers-to-references and references-to-references.
10880 We can get these if a TYPE_DECL is used. */
10882 if (TREE_CODE (type) == REFERENCE_TYPE)
10884 error (TREE_CODE (declarator) == ADDR_EXPR
10885 ? "cannot declare reference to `%#T'"
10886 : "cannot declare pointer to `%#T'", type);
10887 type = TREE_TYPE (type);
10889 else if (VOID_TYPE_P (type)
10890 && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
10891 error (ctype ? "cannot declare pointer to `%#T' member"
10892 : "cannot declare reference to `%#T'", type);
10894 /* Merge any constancy or volatility into the target type
10895 for the pointer. */
10897 /* We now know that the TYPE_QUALS don't apply to the decl,
10898 but to the target of the pointer. */
10899 type_quals = TYPE_UNQUALIFIED;
10901 if (TREE_CODE (declarator) == ADDR_EXPR)
10903 if (!VOID_TYPE_P (type))
10904 type = build_reference_type (type);
10906 else if (TREE_CODE (type) == METHOD_TYPE)
10907 type = build_ptrmemfunc_type (build_pointer_type (type));
10909 type = build_ptrmem_type (ctype, type);
10911 type = build_pointer_type (type);
10913 /* Process a list of type modifier keywords (such as
10914 const or volatile) that were given inside the `*' or `&'. */
10916 if (TREE_TYPE (declarator))
10918 register tree typemodlist;
10924 for (typemodlist = TREE_TYPE (declarator); typemodlist;
10925 typemodlist = TREE_CHAIN (typemodlist))
10927 tree qualifier = TREE_VALUE (typemodlist);
10929 if (qualifier == ridpointers[(int) RID_CONST])
10932 type_quals |= TYPE_QUAL_CONST;
10934 else if (qualifier == ridpointers[(int) RID_VOLATILE])
10937 type_quals |= TYPE_QUAL_VOLATILE;
10939 else if (qualifier == ridpointers[(int) RID_RESTRICT])
10942 type_quals |= TYPE_QUAL_RESTRICT;
10947 error ("invalid type modifier within pointer declarator");
10951 pedwarn ("duplicate `const'");
10953 pedwarn ("duplicate `volatile'");
10955 pedwarn ("duplicate `restrict'");
10956 type = cp_build_qualified_type (type, type_quals);
10957 type_quals = cp_type_quals (type);
10959 declarator = TREE_OPERAND (declarator, 0);
10965 /* We have converted type names to NULL_TREE if the
10966 name was bogus, or to a _TYPE node, if not.
10968 The variable CTYPE holds the type we will ultimately
10969 resolve to. The code here just needs to build
10970 up appropriate member types. */
10971 tree sname = TREE_OPERAND (declarator, 1);
10974 /* Destructors can have their visibilities changed as well. */
10975 if (TREE_CODE (sname) == BIT_NOT_EXPR)
10976 sname = TREE_OPERAND (sname, 0);
10978 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10980 /* We had a reference to a global decl, or
10981 perhaps we were given a non-aggregate typedef,
10982 in which case we cleared this out, and should just
10983 keep going as though it wasn't there. */
10984 declarator = sname;
10987 ctype = TREE_OPERAND (declarator, 0);
10990 while (t != NULL_TREE && CLASS_TYPE_P (t))
10992 /* You're supposed to have one `template <...>'
10993 for every template class, but you don't need one
10994 for a full specialization. For example:
10996 template <class T> struct S{};
10997 template <> struct S<int> { void f(); };
10998 void S<int>::f () {}
11000 is correct; there shouldn't be a `template <>' for
11001 the definition of `S<int>::f'. */
11002 if (CLASSTYPE_TEMPLATE_INFO (t)
11003 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
11004 || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
11005 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
11006 template_count += 1;
11008 t = TYPE_MAIN_DECL (t);
11009 t = DECL_CONTEXT (t);
11012 if (sname == NULL_TREE)
11015 if (TREE_CODE (sname) == IDENTIFIER_NODE)
11017 /* This is the `standard' use of the scoping operator:
11018 basetype :: member . */
11020 if (ctype == current_class_type)
11026 Is this ill-formed? */
11029 pedwarn ("extra qualification `%T::' on member `%s' ignored",
11032 else if (TREE_CODE (type) == FUNCTION_TYPE)
11034 if (current_class_type == NULL_TREE || friendp)
11035 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11036 TYPE_ARG_TYPES (type));
11039 error ("cannot declare member function `%T::%s' within `%T'",
11040 ctype, name, current_class_type);
11041 return error_mark_node;
11044 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
11045 || COMPLETE_TYPE_P (complete_type (ctype)))
11047 /* Have to move this code elsewhere in this function.
11048 this code is used for i.e., typedef int A::M; M *pm;
11050 It is? How? jason 10/2/94 */
11052 if (current_class_type)
11054 error ("cannot declare member `%T::%s' within `%T'",
11055 ctype, name, current_class_type);
11056 return void_type_node;
11061 cxx_incomplete_type_error (NULL_TREE, ctype);
11062 return error_mark_node;
11065 declarator = sname;
11067 else if (TREE_CODE (sname) == SCOPE_REF)
11072 declarator = TREE_OPERAND (declarator, 1);
11073 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11074 /* In this case, we will deal with it later. */
11076 else if (TREE_CODE (type) == FUNCTION_TYPE)
11077 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11078 TYPE_ARG_TYPES (type));
11084 declarator = TREE_OPERAND (declarator, 0);
11088 declarator = BASELINK_FUNCTIONS (declarator);
11093 case ENUMERAL_TYPE:
11094 declarator = NULL_TREE;
11098 declarator = NULL_TREE;
11106 if (returned_attrs)
11109 *attrlist = chainon (returned_attrs, *attrlist);
11111 attrlist = &returned_attrs;
11114 /* Now TYPE has the actual type. */
11116 /* Did array size calculations overflow? */
11118 if (TREE_CODE (type) == ARRAY_TYPE
11119 && COMPLETE_TYPE_P (type)
11120 && TREE_OVERFLOW (TYPE_SIZE (type)))
11122 error ("size of array `%s' is too large", name);
11123 /* If we proceed with the array type as it is, we'll eventually
11124 crash in tree_low_cst(). */
11125 type = error_mark_node;
11128 if ((decl_context == FIELD || decl_context == PARM)
11129 && !processing_template_decl
11130 && variably_modified_type_p (type))
11132 if (decl_context == FIELD)
11133 error ("data member may not have variably modified type `%T'", type);
11135 error ("parameter may not have variably modified type `%T'", type);
11136 type = error_mark_node;
11139 if (explicitp == 1 || (explicitp && friendp))
11141 /* [dcl.fct.spec] The explicit specifier shall only be used in
11142 declarations of constructors within a class definition. */
11143 error ("only declarations of constructors can be `explicit'");
11147 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11149 if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11151 error ("non-member `%s' cannot be declared `mutable'", name);
11152 RIDBIT_RESET (RID_MUTABLE, specbits);
11154 else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11156 error ("non-object member `%s' cannot be declared `mutable'", name);
11157 RIDBIT_RESET (RID_MUTABLE, specbits);
11159 else if (TREE_CODE (type) == FUNCTION_TYPE
11160 || TREE_CODE (type) == METHOD_TYPE)
11162 error ("function `%s' cannot be declared `mutable'", name);
11163 RIDBIT_RESET (RID_MUTABLE, specbits);
11167 error ("static `%s' cannot be declared `mutable'", name);
11168 RIDBIT_RESET (RID_MUTABLE, specbits);
11170 else if (type_quals & TYPE_QUAL_CONST)
11172 error ("const `%s' cannot be declared `mutable'", name);
11173 RIDBIT_RESET (RID_MUTABLE, specbits);
11177 if (declarator == NULL_TREE
11178 || TREE_CODE (declarator) == IDENTIFIER_NODE
11179 || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11180 && (TREE_CODE (type) == FUNCTION_TYPE
11181 || TREE_CODE (type) == METHOD_TYPE)))
11183 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11185 error ("template-id `%D' used as a declarator", declarator);
11186 declarator = dname;
11189 /* Unexpected declarator format. */
11192 /* If this is declaring a typedef name, return a TYPE_DECL. */
11194 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11198 /* Note that the grammar rejects storage classes
11199 in typenames, fields or parameters. */
11200 if (current_lang_name == lang_name_java)
11201 TYPE_FOR_JAVA (type) = 1;
11203 if (decl_context == FIELD)
11205 if (constructor_name_p (declarator, current_class_type))
11206 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11208 decl = build_lang_decl (TYPE_DECL, declarator, type);
11212 decl = build_decl (TYPE_DECL, declarator, type);
11213 if (in_namespace || ctype)
11214 cp_error_at ("typedef name may not be a nested-name-specifier",
11216 if (!current_function_decl)
11217 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11220 /* If the user declares "typedef struct {...} foo" then the
11221 struct will have an anonymous name. Fill that name in now.
11222 Nothing can refer to it, so nothing needs know about the name
11224 if (type != error_mark_node
11226 && TYPE_NAME (type)
11227 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11228 && TYPE_ANONYMOUS_P (type)
11229 /* Don't do this if there are attributes. */
11230 && (!attrlist || !*attrlist)
11231 && cp_type_quals (type) == TYPE_UNQUALIFIED)
11233 tree oldname = TYPE_NAME (type);
11236 /* Replace the anonymous name with the real name everywhere. */
11237 lookup_tag_reverse (type, declarator);
11238 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11239 if (TYPE_NAME (t) == oldname)
11240 TYPE_NAME (t) = decl;
11242 if (TYPE_LANG_SPECIFIC (type))
11243 TYPE_WAS_ANONYMOUS (type) = 1;
11245 /* If this is a typedef within a template class, the nested
11246 type is a (non-primary) template. The name for the
11247 template needs updating as well. */
11248 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11249 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11250 = TYPE_IDENTIFIER (type);
11252 /* FIXME remangle member functions; member functions of a
11253 type with external linkage have external linkage. */
11258 if (ctype == NULL_TREE)
11260 if (TREE_CODE (type) != METHOD_TYPE)
11261 cp_error_at ("invalid type qualifier for non-member function type", decl);
11263 ctype = TYPE_METHOD_BASETYPE (type);
11265 if (ctype != NULL_TREE)
11266 grok_method_quals (ctype, decl, quals);
11269 if (RIDBIT_SETP (RID_SIGNED, specbits)
11270 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11271 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11273 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11274 inlinep, friendp, raises != NULL_TREE);
11279 /* Detect the case of an array type of unspecified size
11280 which came, as such, direct from a typedef name.
11281 We must copy the type, so that the array's domain can be
11282 individually set by the object's initializer. */
11284 if (type && typedef_type
11285 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11286 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11287 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11289 /* Detect where we're using a typedef of function type to declare a
11290 function. last_function_parms will not be set, so we must create
11293 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11295 tree decls = NULL_TREE;
11298 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11300 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11302 TREE_CHAIN (decl) = decls;
11306 last_function_parms = nreverse (decls);
11309 /* If this is a type name (such as, in a cast or sizeof),
11310 compute the type and return it now. */
11312 if (decl_context == TYPENAME)
11314 /* Note that the grammar rejects storage classes
11315 in typenames, fields or parameters. */
11316 if (type_quals != TYPE_UNQUALIFIED)
11317 type_quals = TYPE_UNQUALIFIED;
11319 /* Special case: "friend class foo" looks like a TYPENAME context. */
11322 if (type_quals != TYPE_UNQUALIFIED)
11324 error ("type qualifiers specified for friend class declaration");
11325 type_quals = TYPE_UNQUALIFIED;
11329 error ("`inline' specified for friend class declaration");
11335 /* Don't allow friend declaration without a class-key. */
11336 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11337 pedwarn ("template parameters cannot be friends");
11338 else if (TREE_CODE (type) == TYPENAME_TYPE)
11339 pedwarn ("friend declaration requires class-key, "
11340 "i.e. `friend class %T::%D'",
11341 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
11343 pedwarn ("friend declaration requires class-key, "
11344 "i.e. `friend %#T'",
11348 /* Only try to do this stuff if we didn't already give up. */
11349 if (type != integer_type_node)
11351 /* A friendly class? */
11352 if (current_class_type)
11353 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11355 error ("trying to make class `%T' a friend of global scope",
11358 type = void_type_node;
11363 if (ctype == NULL_TREE)
11365 if (TREE_CODE (type) != METHOD_TYPE)
11366 error ("invalid qualifiers on non-member function type");
11368 ctype = TYPE_METHOD_BASETYPE (type);
11372 tree dummy = build_decl (TYPE_DECL, declarator, type);
11373 grok_method_quals (ctype, dummy, quals);
11374 type = TREE_TYPE (dummy);
11380 else if (declarator == NULL_TREE && decl_context != PARM
11381 && decl_context != CATCHPARM
11382 && TREE_CODE (type) != UNION_TYPE
11385 error ("abstract declarator `%T' used as declaration", type);
11386 declarator = make_anon_name ();
11389 /* `void' at top level (not within pointer)
11390 is allowed only in typedefs or type names.
11391 We don't complain about parms either, but that is because
11392 a better error message can be made later. */
11394 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11397 error ("unnamed variable or field declared void");
11398 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11400 if (IDENTIFIER_OPNAME_P (declarator))
11403 error ("variable or field `%s' declared void", name);
11406 error ("variable or field declared void");
11407 type = integer_type_node;
11410 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11411 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11413 if (decl_context == PARM || decl_context == CATCHPARM)
11415 if (ctype || in_namespace)
11416 error ("cannot use `::' in parameter declaration");
11418 /* A parameter declared as an array of T is really a pointer to T.
11419 One declared as a function is really a pointer to a function.
11420 One declared as a member is really a pointer to member. */
11422 if (TREE_CODE (type) == ARRAY_TYPE)
11424 /* Transfer const-ness of array into that of type pointed to. */
11425 type = build_pointer_type (TREE_TYPE (type));
11426 type_quals = TYPE_UNQUALIFIED;
11428 else if (TREE_CODE (type) == FUNCTION_TYPE)
11429 type = build_pointer_type (type);
11430 else if (TREE_CODE (type) == OFFSET_TYPE)
11431 type = build_pointer_type (type);
11435 register tree decl;
11437 if (decl_context == PARM)
11439 decl = cp_build_parm_decl (declarator, type);
11441 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11442 inlinep, friendp, raises != NULL_TREE);
11444 else if (decl_context == FIELD)
11446 if (type == error_mark_node)
11448 /* Happens when declaring arrays of sizes which
11449 are error_mark_node, for example. */
11452 else if (in_namespace && !friendp)
11454 /* Something like struct S { int N::j; }; */
11455 error ("invalid use of `::'");
11458 else if (TREE_CODE (type) == FUNCTION_TYPE)
11461 tree function_context;
11463 /* We catch the others as conflicts with the builtin
11465 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11467 error ("function `%D' cannot be declared friend",
11474 if (ctype == NULL_TREE)
11475 ctype = current_class_type;
11477 if (ctype == NULL_TREE)
11479 error ("can't make `%D' into a method -- not in a class",
11481 return void_type_node;
11484 /* ``A union may [ ... ] not [ have ] virtual functions.''
11486 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11488 error ("function `%D' declared virtual inside a union",
11490 return void_type_node;
11493 if (declarator == ansi_opname (NEW_EXPR)
11494 || declarator == ansi_opname (VEC_NEW_EXPR)
11495 || declarator == ansi_opname (DELETE_EXPR)
11496 || declarator == ansi_opname (VEC_DELETE_EXPR))
11500 error ("`%D' cannot be declared virtual, since it is always static",
11505 else if (staticp < 2)
11506 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11507 TYPE_ARG_TYPES (type));
11510 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11511 function_context = (ctype != NULL_TREE) ?
11512 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11513 publicp = (! friendp || ! staticp)
11514 && function_context == NULL_TREE;
11515 decl = grokfndecl (ctype, type,
11516 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11517 ? declarator : dname,
11519 virtualp, flags, quals, raises,
11520 friendp ? -1 : 0, friendp, publicp, inlinep,
11521 funcdef_flag, template_count, in_namespace);
11522 if (decl == NULL_TREE)
11525 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11526 /* The decl and setting of decl_attr is also turned off. */
11527 decl = build_decl_attribute_variant (decl, decl_attr);
11530 /* [class.conv.ctor]
11532 A constructor declared without the function-specifier
11533 explicit that can be called with a single parameter
11534 specifies a conversion from the type of its first
11535 parameter to the type of its class. Such a constructor
11536 is called a converting constructor. */
11537 if (explicitp == 2)
11538 DECL_NONCONVERTING_P (decl) = 1;
11539 else if (DECL_CONSTRUCTOR_P (decl))
11541 /* The constructor can be called with exactly one
11542 parameter if there is at least one parameter, and
11543 any subsequent parameters have default arguments.
11544 Ignore any compiler-added parms. */
11545 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11547 if (arg_types == void_list_node
11549 && TREE_CHAIN (arg_types)
11550 && TREE_CHAIN (arg_types) != void_list_node
11551 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11552 DECL_NONCONVERTING_P (decl) = 1;
11555 else if (TREE_CODE (type) == METHOD_TYPE)
11557 /* We only get here for friend declarations of
11558 members of other classes. */
11559 /* All method decls are public, so tell grokfndecl to set
11560 TREE_PUBLIC, also. */
11561 decl = grokfndecl (ctype, type, declarator, declarator,
11562 virtualp, flags, quals, raises,
11563 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11564 template_count, in_namespace);
11565 if (decl == NULL_TREE)
11568 else if (!staticp && ! processing_template_decl
11569 && !COMPLETE_TYPE_P (complete_type (type))
11570 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11573 error ("field `%D' has incomplete type", declarator);
11575 error ("name `%T' has incomplete type", type);
11577 /* If we're instantiating a template, tell them which
11578 instantiation made the field's type be incomplete. */
11579 if (current_class_type
11580 && TYPE_NAME (current_class_type)
11581 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11582 && declspecs && TREE_VALUE (declspecs)
11583 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11584 error (" in instantiation of template `%T'",
11585 current_class_type);
11587 type = error_mark_node;
11594 error ("`%s' is neither function nor member function; cannot be declared friend",
11595 IDENTIFIER_POINTER (declarator));
11603 /* Friends are treated specially. */
11604 if (ctype == current_class_type)
11605 warning ("member functions are implicitly friends of their class");
11608 tree t = NULL_TREE;
11609 if (decl && DECL_NAME (decl))
11611 if (template_class_depth (current_class_type) == 0)
11614 = check_explicit_specialization
11616 template_count, 2 * (funcdef_flag != 0) + 4);
11617 if (decl == error_mark_node)
11618 return error_mark_node;
11621 t = do_friend (ctype, declarator, decl,
11622 last_function_parms, *attrlist,
11623 flags, quals, funcdef_flag);
11625 if (t && funcdef_flag)
11628 return void_type_node;
11632 /* Structure field. It may not be a function, except for C++ */
11634 if (decl == NULL_TREE)
11640 /* An attempt is being made to initialize a non-static
11641 member. But, from [class.mem]:
11643 4 A member-declarator can contain a
11644 constant-initializer only if it declares a static
11645 member (_class.static_) of integral or enumeration
11646 type, see _class.static.data_.
11648 This used to be relatively common practice, but
11649 the rest of the compiler does not correctly
11650 handle the initialization unless the member is
11651 static so we make it static below. */
11652 pedwarn ("ISO C++ forbids initialization of member `%D'",
11654 pedwarn ("making `%D' static", declarator);
11658 if (uses_template_parms (type))
11659 /* We'll check at instantiation time. */
11661 else if (check_static_variable_definition (declarator,
11663 /* If we just return the declaration, crashes
11664 will sometimes occur. We therefore return
11665 void_type_node, as if this was a friend
11666 declaration, to cause callers to completely
11667 ignore this declaration. */
11668 return void_type_node;
11671 /* 9.2p13 [class.mem] */
11672 if (constructor_name_p (declarator, current_class_type)
11673 /* The standard does not allow non-static data members
11674 here either, but we agreed at the 10/99 meeting
11675 to change that in TC 1 so that they are allowed in
11676 classes with no user-defined constructors. */
11678 pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11683 /* C++ allows static class members. All other work
11684 for this is done by grokfield. */
11685 decl = build_lang_decl (VAR_DECL, declarator, type);
11686 TREE_STATIC (decl) = 1;
11687 /* In class context, 'static' means public access. */
11688 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11692 decl = build_decl (FIELD_DECL, declarator, type);
11693 DECL_NONADDRESSABLE_P (decl) = bitfield;
11694 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11696 DECL_MUTABLE_P (decl) = 1;
11697 RIDBIT_RESET (RID_MUTABLE, specbits);
11701 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11702 inlinep, friendp, raises != NULL_TREE);
11705 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11707 tree original_name;
11713 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11714 original_name = dname;
11716 original_name = declarator;
11718 if (RIDBIT_SETP (RID_AUTO, specbits))
11719 error ("storage class `auto' invalid for function `%s'", name);
11720 else if (RIDBIT_SETP (RID_REGISTER, specbits))
11721 error ("storage class `register' invalid for function `%s'", name);
11722 else if (RIDBIT_SETP (RID_THREAD, specbits))
11723 error ("storage class `__thread' invalid for function `%s'", name);
11725 /* Function declaration not at top level.
11726 Storage classes other than `extern' are not allowed
11727 and `extern' makes no difference. */
11728 if (! toplevel_bindings_p ()
11729 && (RIDBIT_SETP (RID_STATIC, specbits)
11730 || RIDBIT_SETP (RID_INLINE, specbits))
11733 if (RIDBIT_SETP (RID_STATIC, specbits))
11734 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11736 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11739 if (ctype == NULL_TREE)
11743 error ("virtual non-class function `%s'", name);
11747 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11748 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11749 TYPE_ARG_TYPES (type));
11751 /* Record presence of `static'. */
11752 publicp = (ctype != NULL_TREE
11753 || RIDBIT_SETP (RID_EXTERN, specbits)
11754 || !RIDBIT_SETP (RID_STATIC, specbits));
11756 decl = grokfndecl (ctype, type, original_name, declarator,
11757 virtualp, flags, quals, raises,
11759 publicp, inlinep, funcdef_flag,
11760 template_count, in_namespace);
11761 if (decl == NULL_TREE)
11766 int invalid_static = 0;
11768 /* Don't allow a static member function in a class, and forbid
11769 declaring main to be static. */
11770 if (TREE_CODE (type) == METHOD_TYPE)
11772 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11773 invalid_static = 1;
11775 else if (current_function_decl)
11777 /* FIXME need arm citation */
11778 error ("cannot declare static function inside another function");
11779 invalid_static = 1;
11782 if (invalid_static)
11785 RIDBIT_RESET (RID_STATIC, specbits);
11791 /* It's a variable. */
11793 /* An uninitialized decl with `extern' is a reference. */
11794 decl = grokvardecl (type, declarator, &specbits,
11796 (type_quals & TYPE_QUAL_CONST) != 0,
11797 ctype ? ctype : in_namespace);
11798 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11799 inlinep, friendp, raises != NULL_TREE);
11803 DECL_CONTEXT (decl) = ctype;
11806 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11808 RIDBIT_RESET (RID_STATIC, specbits);
11810 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11812 error ("static member `%D' declared `register'", decl);
11813 RIDBIT_RESET (RID_REGISTER, specbits);
11815 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11817 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11819 RIDBIT_RESET (RID_EXTERN, specbits);
11824 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11826 /* Record `register' declaration for warnings on &
11827 and in case doing stupid register allocation. */
11829 if (RIDBIT_SETP (RID_REGISTER, specbits))
11830 DECL_REGISTER (decl) = 1;
11832 if (RIDBIT_SETP (RID_EXTERN, specbits))
11833 DECL_THIS_EXTERN (decl) = 1;
11835 if (RIDBIT_SETP (RID_STATIC, specbits))
11836 DECL_THIS_STATIC (decl) = 1;
11838 /* Record constancy and volatility. There's no need to do this
11839 when processing a template; we'll do this for the instantiated
11840 declaration based on the type of DECL. */
11841 if (!processing_template_decl)
11842 c_apply_type_quals_to_decl (type_quals, decl);
11848 /* Subroutine of start_function. Ensure that each of the parameter
11849 types (as listed in PARMS) is complete, as is required for a
11850 function definition. */
11853 require_complete_types_for_parms (tree parms)
11855 for (; parms; parms = TREE_CHAIN (parms))
11857 if (VOID_TYPE_P (TREE_TYPE (parms)))
11858 /* grokparms will have already issued an error */
11859 TREE_TYPE (parms) = error_mark_node;
11860 else if (complete_type_or_else (TREE_TYPE (parms), parms))
11862 layout_decl (parms, 0);
11863 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
11866 TREE_TYPE (parms) = error_mark_node;
11870 /* Returns nonzero if T is a local variable. */
11873 local_variable_p (tree t)
11875 if ((TREE_CODE (t) == VAR_DECL
11876 /* A VAR_DECL with a context that is a _TYPE is a static data
11878 && !TYPE_P (CP_DECL_CONTEXT (t))
11879 /* Any other non-local variable must be at namespace scope. */
11880 && !DECL_NAMESPACE_SCOPE_P (t))
11881 || (TREE_CODE (t) == PARM_DECL))
11887 /* Returns nonzero if T is an automatic local variable or a label.
11888 (These are the declarations that need to be remapped when the code
11889 containing them is duplicated.) */
11892 nonstatic_local_decl_p (tree t)
11894 return ((local_variable_p (t) && !TREE_STATIC (t))
11895 || TREE_CODE (t) == LABEL_DECL
11896 || TREE_CODE (t) == RESULT_DECL);
11899 /* Like local_variable_p, but suitable for use as a tree-walking
11903 local_variable_p_walkfn (tree* tp,
11904 int* walk_subtrees ATTRIBUTE_UNUSED ,
11905 void* data ATTRIBUTE_UNUSED )
11907 return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11908 ? *tp : NULL_TREE);
11911 /* Check that ARG, which is a default-argument expression for a
11912 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11913 something goes wrong. DECL may also be a _TYPE node, rather than a
11914 DECL, if there is no DECL available. */
11917 check_default_argument (tree decl, tree arg)
11922 if (TREE_CODE (arg) == DEFAULT_ARG)
11923 /* We get a DEFAULT_ARG when looking at an in-class declaration
11924 with a default argument. Ignore the argument for now; we'll
11925 deal with it after the class is complete. */
11928 if (processing_template_decl || uses_template_parms (arg))
11929 /* We don't do anything checking until instantiation-time. Note
11930 that there may be uninstantiated arguments even for an
11931 instantiated function, since default arguments are not
11932 instantiated until they are needed. */
11941 decl_type = TREE_TYPE (decl);
11943 if (arg == error_mark_node
11944 || decl == error_mark_node
11945 || TREE_TYPE (arg) == error_mark_node
11946 || decl_type == error_mark_node)
11947 /* Something already went wrong. There's no need to check
11949 return error_mark_node;
11951 /* [dcl.fct.default]
11953 A default argument expression is implicitly converted to the
11955 if (!TREE_TYPE (arg)
11956 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11959 error ("default argument for `%#D' has type `%T'",
11960 decl, TREE_TYPE (arg));
11962 error ("default argument for parameter of type `%T' has type `%T'",
11963 decl_type, TREE_TYPE (arg));
11965 return error_mark_node;
11968 /* [dcl.fct.default]
11970 Local variables shall not be used in default argument
11973 The keyword `this' shall not be used in a default argument of a
11974 member function. */
11975 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11979 error ("default argument `%E' uses local variable `%D'",
11981 return error_mark_node;
11988 /* Decode the list of parameter types for a function type.
11989 Given the list of things declared inside the parens,
11990 return a list of types.
11992 We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11993 flag. If unset, we append void_list_node. A parmlist declared
11994 as `(void)' is accepted as the empty parmlist.
11996 Also set last_function_parms to the chain of PARM_DECLs. */
11999 grokparms (tree first_parm)
12001 tree result = NULL_TREE;
12002 tree decls = NULL_TREE;
12003 int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
12007 my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
12009 for (parm = first_parm; parm != NULL_TREE; parm = chain)
12011 tree type = NULL_TREE;
12012 tree decl = TREE_VALUE (parm);
12013 tree init = TREE_PURPOSE (parm);
12016 chain = TREE_CHAIN (parm);
12017 /* @@ weak defense against parse errors. */
12018 if (TREE_CODE (decl) != VOID_TYPE
12019 && TREE_CODE (decl) != TREE_LIST)
12021 /* Give various messages as the need arises. */
12022 if (TREE_CODE (decl) == STRING_CST)
12023 error ("invalid string constant `%E'", decl);
12024 else if (TREE_CODE (decl) == INTEGER_CST)
12025 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
12029 if (parm == void_list_node)
12032 split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12033 decl = grokdeclarator (TREE_VALUE (decl), specs,
12034 PARM, init != NULL_TREE, &attrs);
12035 if (! decl || TREE_TYPE (decl) == error_mark_node)
12039 cplus_decl_attributes (&decl, attrs, 0);
12041 type = TREE_TYPE (decl);
12042 if (VOID_TYPE_P (type))
12044 if (same_type_p (type, void_type_node)
12045 && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12046 /* this is a parmlist of `(void)', which is ok. */
12048 cxx_incomplete_type_error (decl, type);
12049 /* It's not a good idea to actually create parameters of
12050 type `void'; other parts of the compiler assume that a
12051 void type terminates the parameter list. */
12052 type = error_mark_node;
12053 TREE_TYPE (decl) = error_mark_node;
12056 if (type != error_mark_node)
12058 /* Top-level qualifiers on the parameters are
12059 ignored for function types. */
12060 type = TYPE_MAIN_VARIANT (type);
12061 if (TREE_CODE (type) == METHOD_TYPE)
12063 error ("parameter `%D' invalidly declared method type", decl);
12064 type = build_pointer_type (type);
12065 TREE_TYPE (decl) = type;
12067 else if (TREE_CODE (type) == OFFSET_TYPE)
12069 error ("parameter `%D' invalidly declared offset type", decl);
12070 type = build_pointer_type (type);
12071 TREE_TYPE (decl) = type;
12073 else if (abstract_virtuals_error (decl, type))
12074 any_error = 1; /* Seems like a good idea. */
12075 else if (POINTER_TYPE_P (type))
12077 /* [dcl.fct]/6, parameter types cannot contain pointers
12078 (references) to arrays of unknown bound. */
12079 tree t = TREE_TYPE (type);
12080 int ptr = TYPE_PTR_P (type);
12084 if (TYPE_PTR_P (t))
12086 else if (TREE_CODE (t) != ARRAY_TYPE)
12088 else if (!TYPE_DOMAIN (t))
12092 if (TREE_CODE (t) == ARRAY_TYPE)
12093 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12094 decl, ptr ? "pointer" : "reference", t);
12097 if (!any_error && init)
12098 init = check_default_argument (decl, init);
12103 TREE_CHAIN (decl) = decls;
12105 result = tree_cons (init, type, result);
12107 decls = nreverse (decls);
12108 result = nreverse (result);
12110 result = chainon (result, void_list_node);
12111 last_function_parms = decls;
12117 /* D is a constructor or overloaded `operator='.
12119 Let T be the class in which D is declared. Then, this function
12122 -1 if D's is an ill-formed constructor or copy assignment operator
12123 whose first parameter is of type `T'.
12124 0 if D is not a copy constructor or copy assignment
12126 1 if D is a copy constructor or copy assignment operator whose
12127 first parameter is a reference to const qualified T.
12128 2 if D is a copy constructor or copy assignment operator whose
12129 first parameter is a reference to non-const qualified T.
12131 This function can be used as a predicate. Positive values indicate
12132 a copy constructor and nonzero values indicate a copy assignment
12142 my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12144 if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12145 /* Instantiations of template member functions are never copy
12146 functions. Note that member functions of templated classes are
12147 represented as template functions internally, and we must
12148 accept those as copy functions. */
12151 args = FUNCTION_FIRST_USER_PARMTYPE (d);
12155 arg_type = TREE_VALUE (args);
12157 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12159 /* Pass by value copy assignment operator. */
12162 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12163 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12165 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12171 args = TREE_CHAIN (args);
12173 if (args && args != void_list_node && !TREE_PURPOSE (args))
12174 /* There are more non-optional args. */
12180 /* Remember any special properties of member function DECL. */
12182 void grok_special_member_properties (tree decl)
12184 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12185 ; /* Not special. */
12186 else if (DECL_CONSTRUCTOR_P (decl))
12188 int ctor = copy_fn_p (decl);
12194 A non-template constructor for class X is a copy
12195 constructor if its first parameter is of type X&, const
12196 X&, volatile X& or const volatile X&, and either there
12197 are no other parameters or else all other parameters have
12198 default arguments. */
12199 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12201 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12203 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12204 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12206 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12210 A non-template assignment operator for class X is a copy
12211 assignment operator if its parameter is of type X, X&, const
12212 X&, volatile X& or const volatile X&. */
12214 int assop = copy_fn_p (decl);
12218 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12220 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12221 if (DECL_PURE_VIRTUAL_P (decl))
12222 TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12227 /* Check a constructor DECL has the correct form. Complains
12228 if the class has a constructor of the form X(X). */
12231 grok_ctor_properties (tree ctype, tree decl)
12233 int ctor_parm = copy_fn_p (decl);
12239 A declaration of a constructor for a class X is ill-formed if
12240 its first parameter is of type (optionally cv-qualified) X
12241 and either there are no other parameters or else all other
12242 parameters have default arguments.
12244 We *don't* complain about member template instantiations that
12245 have this form, though; they can occur as we try to decide
12246 what constructor to use during overload resolution. Since
12247 overload resolution will never prefer such a constructor to
12248 the non-template copy constructor (which is either explicitly
12249 or implicitly defined), there's no need to worry about their
12250 existence. Theoretically, they should never even be
12251 instantiated, but that's hard to forestall. */
12252 error ("invalid constructor; you probably meant `%T (const %T&)'",
12254 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12261 /* An operator with this code is unary, but can also be binary. */
12264 ambi_op_p (enum tree_code code)
12266 return (code == INDIRECT_REF
12267 || code == ADDR_EXPR
12268 || code == CONVERT_EXPR
12269 || code == NEGATE_EXPR
12270 || code == PREINCREMENT_EXPR
12271 || code == PREDECREMENT_EXPR);
12274 /* An operator with this name can only be unary. */
12277 unary_op_p (enum tree_code code)
12279 return (code == TRUTH_NOT_EXPR
12280 || code == BIT_NOT_EXPR
12281 || code == COMPONENT_REF
12282 || code == TYPE_EXPR);
12285 /* Do a little sanity-checking on how they declared their operator. */
12288 grok_op_properties (tree decl, int friendp)
12290 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12292 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12293 tree name = DECL_NAME (decl);
12294 enum tree_code operator_code;
12297 /* Count the number of arguments. */
12298 for (argtype = argtypes, arity = 0;
12299 argtype && argtype != void_list_node;
12300 argtype = TREE_CHAIN (argtype))
12303 if (current_class_type == NULL_TREE)
12306 if (DECL_CONV_FN_P (decl))
12307 operator_code = TYPE_EXPR;
12311 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12312 if (ansi_opname (CODE) == name) \
12314 operator_code = (CODE); \
12317 else if (ansi_assopname (CODE) == name) \
12319 operator_code = (CODE); \
12320 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12324 #include "operators.def"
12325 #undef DEF_OPERATOR
12330 my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12331 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12335 switch (operator_code)
12338 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12342 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12345 case COMPONENT_REF:
12347 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12351 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12355 TYPE_GETS_DELETE (current_class_type) |= 1;
12359 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12362 case VEC_DELETE_EXPR:
12363 TYPE_GETS_DELETE (current_class_type) |= 2;
12371 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12373 /* When the compiler encounters the definition of A::operator new, it
12374 doesn't look at the class declaration to find out if it's static. */
12376 revert_static_member_fn (decl);
12378 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12380 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12383 revert_static_member_fn (decl);
12385 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12389 /* An operator function must either be a non-static member function
12390 or have at least one parameter of a class, a reference to a class,
12391 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12392 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12394 if (operator_code == TYPE_EXPR
12395 || operator_code == CALL_EXPR
12396 || operator_code == COMPONENT_REF
12397 || operator_code == ARRAY_REF
12398 || operator_code == NOP_EXPR)
12399 error ("`%D' must be a nonstatic member function", decl);
12404 if (DECL_STATIC_FUNCTION_P (decl))
12405 error ("`%D' must be either a non-static member function or a non-member function", decl);
12408 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12410 tree arg = TREE_VALUE (p);
12411 if (TREE_CODE (arg) == REFERENCE_TYPE)
12412 arg = TREE_TYPE (arg);
12414 /* This lets bad template code slip through. */
12415 if (IS_AGGR_TYPE (arg)
12416 || TREE_CODE (arg) == ENUMERAL_TYPE
12417 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12418 || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12422 ("`%D' must have an argument of class or enumerated type",
12429 if (operator_code == CALL_EXPR)
12430 return; /* No restrictions on args. */
12432 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12434 tree t = TREE_TYPE (name);
12437 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12438 const char *what = 0;
12441 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12443 if (TREE_CODE (t) == VOID_TYPE)
12445 else if (t == current_class_type)
12446 what = "the same type";
12447 /* Don't force t to be complete here. */
12448 else if (IS_AGGR_TYPE (t)
12449 && COMPLETE_TYPE_P (t)
12450 && DERIVED_FROM_P (t, current_class_type))
12451 what = "a base class";
12454 warning ("conversion to %s%s will never use a type conversion operator",
12455 ref ? "a reference to " : "", what);
12458 if (operator_code == COND_EXPR)
12461 error ("ISO C++ prohibits overloading operator ?:");
12463 else if (ambi_op_p (operator_code))
12466 /* We pick the one-argument operator codes by default, so
12467 we don't have to change anything. */
12469 else if (arity == 2)
12471 /* If we thought this was a unary operator, we now know
12472 it to be a binary operator. */
12473 switch (operator_code)
12476 operator_code = MULT_EXPR;
12480 operator_code = BIT_AND_EXPR;
12484 operator_code = PLUS_EXPR;
12488 operator_code = MINUS_EXPR;
12491 case PREINCREMENT_EXPR:
12492 operator_code = POSTINCREMENT_EXPR;
12495 case PREDECREMENT_EXPR:
12496 operator_code = POSTDECREMENT_EXPR;
12503 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12505 if ((operator_code == POSTINCREMENT_EXPR
12506 || operator_code == POSTDECREMENT_EXPR)
12507 && ! processing_template_decl
12508 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12511 error ("postfix `%D' must take `int' as its argument",
12515 ("postfix `%D' must take `int' as its second argument",
12522 error ("`%D' must take either zero or one argument", decl);
12524 error ("`%D' must take either one or two arguments", decl);
12527 /* More Effective C++ rule 6. */
12529 && (operator_code == POSTINCREMENT_EXPR
12530 || operator_code == POSTDECREMENT_EXPR
12531 || operator_code == PREINCREMENT_EXPR
12532 || operator_code == PREDECREMENT_EXPR))
12534 tree arg = TREE_VALUE (argtypes);
12535 tree ret = TREE_TYPE (TREE_TYPE (decl));
12536 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12537 arg = TREE_TYPE (arg);
12538 arg = TYPE_MAIN_VARIANT (arg);
12539 if (operator_code == PREINCREMENT_EXPR
12540 || operator_code == PREDECREMENT_EXPR)
12542 if (TREE_CODE (ret) != REFERENCE_TYPE
12543 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12545 warning ("prefix `%D' should return `%T'", decl,
12546 build_reference_type (arg));
12550 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12551 warning ("postfix `%D' should return `%T'", decl, arg);
12555 else if (unary_op_p (operator_code))
12560 error ("`%D' must take `void'", decl);
12562 error ("`%D' must take exactly one argument", decl);
12565 else /* if (binary_op_p (operator_code)) */
12570 error ("`%D' must take exactly one argument", decl);
12572 error ("`%D' must take exactly two arguments", decl);
12575 /* More Effective C++ rule 7. */
12577 && (operator_code == TRUTH_ANDIF_EXPR
12578 || operator_code == TRUTH_ORIF_EXPR
12579 || operator_code == COMPOUND_EXPR))
12580 warning ("user-defined `%D' always evaluates both arguments",
12584 /* Effective C++ rule 23. */
12587 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12588 && (operator_code == PLUS_EXPR
12589 || operator_code == MINUS_EXPR
12590 || operator_code == TRUNC_DIV_EXPR
12591 || operator_code == MULT_EXPR
12592 || operator_code == TRUNC_MOD_EXPR)
12593 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12594 warning ("`%D' should return by value", decl);
12596 /* [over.oper]/8 */
12597 for (; argtypes && argtypes != void_list_node;
12598 argtypes = TREE_CHAIN (argtypes))
12599 if (TREE_PURPOSE (argtypes))
12601 TREE_PURPOSE (argtypes) = NULL_TREE;
12602 if (operator_code == POSTINCREMENT_EXPR
12603 || operator_code == POSTDECREMENT_EXPR)
12606 pedwarn ("`%D' cannot have default arguments", decl);
12609 error ("`%D' cannot have default arguments", decl);
12615 static const char *
12616 tag_name (enum tag_types code)
12633 /* Get the struct, enum or union (CODE says which) with tag NAME.
12634 Define the tag as a forward-reference if it is not defined.
12636 C++: If a class derivation is given, process it here, and report
12637 an error if multiple derivation declarations are not identical.
12639 If this is a definition, come in through xref_tag and only look in
12640 the current frame for the name (since C++ allows new names in any
12644 xref_tag (enum tag_types tag_code, tree name, tree attributes,
12647 enum tree_code code;
12648 register tree ref, t;
12649 struct cp_binding_level *b = current_binding_level;
12650 tree context = NULL_TREE;
12652 timevar_push (TV_NAME_LOOKUP);
12657 code = RECORD_TYPE;
12663 code = ENUMERAL_TYPE;
12669 /* If a cross reference is requested, look up the type
12670 already defined for this tag and return it. */
12674 name = TYPE_IDENTIFIER (t);
12677 t = IDENTIFIER_TYPE_VALUE (name);
12679 /* Warn about 'friend struct Inherited;' doing the wrong thing. */
12680 if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12682 static int explained;
12685 warning ("`%s %T' declares a new type at namespace scope",
12686 tag_name (tag_code), name);
12688 warning (" names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12689 tag_name (tag_code),
12690 constructor_name (current_class_type),
12691 TYPE_IDENTIFIER (t));
12693 /* We need to remove the class scope binding for the
12694 TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12695 for (shadowed = b->class_shadowed;
12697 shadowed = TREE_CHAIN (shadowed))
12698 if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12700 TREE_PURPOSE (shadowed) = NULL_TREE;
12705 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12706 && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12711 /* If we know we are defining this tag, only look it up in
12712 this scope and don't try to find it as a type. */
12713 ref = lookup_tag (code, name, b, 1);
12719 ref = follow_tag_typedef (t);
12721 /* [dcl.type.elab] If the identifier resolves to a
12722 typedef-name or a template type-parameter, the
12723 elaborated-type-specifier is ill-formed. */
12726 pedwarn ("using typedef-name `%D' after `%s'",
12727 TYPE_NAME (t), tag_name (tag_code));
12730 else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12731 error ("using template type parameter `%T' after `%s'",
12732 t, tag_name (tag_code));
12735 ref = lookup_tag (code, name, b, 0);
12739 /* Try finding it as a type declaration. If that wins,
12741 ref = lookup_name (name, 1);
12743 if (ref != NULL_TREE
12744 && processing_template_decl
12745 && DECL_CLASS_TEMPLATE_P (ref)
12746 && template_class_depth (current_class_type) == 0)
12747 /* Since GLOBALIZE is true, we're declaring a global
12748 template, so we want this type. */
12749 ref = DECL_TEMPLATE_RESULT (ref);
12751 if (ref && TREE_CODE (ref) == TYPE_DECL
12752 && TREE_CODE (TREE_TYPE (ref)) == code)
12753 ref = TREE_TYPE (ref);
12758 if (ref && current_class_type
12759 && template_class_depth (current_class_type)
12760 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12762 /* Since GLOBALIZE is nonzero, we are not looking at a
12763 definition of this tag. Since, in addition, we are currently
12764 processing a (member) template declaration of a template
12765 class, we must be very careful; consider:
12772 { template <class V>
12773 friend struct S1; };
12775 Here, the S2::S1 declaration should not be confused with the
12776 outer declaration. In particular, the inner version should
12777 have a template parameter of level 2, not level 1. This
12778 would be particularly important if the member declaration
12781 template <class V = U> friend struct S1;
12783 say, when we should tsubst into `U' when instantiating
12784 S2. On the other hand, when presented with:
12794 we must find the inner binding eventually. We
12795 accomplish this by making sure that the new type we
12796 create to represent this declaration has the right
12798 context = TYPE_CONTEXT (ref);
12805 /* If no such tag is yet defined, create a forward-reference node
12806 and record it as the "definition".
12807 When a real declaration of this type is found,
12808 the forward-reference will be altered into a real type. */
12809 if (code == ENUMERAL_TYPE)
12811 error ("use of enum `%#D' without previous declaration", name);
12813 ref = make_node (ENUMERAL_TYPE);
12815 /* Give the type a default layout like unsigned int
12816 to avoid crashing if it does not get defined. */
12817 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12818 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12819 TYPE_USER_ALIGN (ref) = 0;
12820 TREE_UNSIGNED (ref) = 1;
12821 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12822 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12823 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12825 /* Enable us to recognize when a type is created in class context.
12826 To do nested classes correctly, this should probably be cleared
12827 out when we leave this classes scope. Currently this in only
12828 done in `start_enum'. */
12830 pushtag (name, ref, globalize);
12834 struct cp_binding_level *old_b = class_binding_level;
12836 ref = make_aggr_type (code);
12837 TYPE_CONTEXT (ref) = context;
12839 #ifdef NONNESTED_CLASSES
12840 /* Class types don't nest the way enums do. */
12841 class_binding_level = (struct cp_binding_level *)0;
12843 pushtag (name, ref, globalize);
12844 class_binding_level = old_b;
12849 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12850 redeclare_class_template (ref, current_template_parms);
12853 TYPE_ATTRIBUTES (ref) = attributes;
12855 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ref);
12859 xref_tag_from_type (tree old, tree id, int globalize)
12861 enum tag_types tag_kind;
12863 if (TREE_CODE (old) == RECORD_TYPE)
12864 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12866 tag_kind = union_type;
12868 if (id == NULL_TREE)
12869 id = TYPE_IDENTIFIER (old);
12871 return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
12874 /* REF is a type (named NAME), for which we have just seen some
12875 baseclasses. BASE_LIST is a list of those baseclasses; the
12876 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12877 the base-class. TREE_VIA_VIRTUAL indicates virtual
12878 inheritance. CODE_TYPE_NODE indicates whether REF is a class,
12879 struct, or union. */
12882 xref_basetypes (tree ref, tree base_list)
12884 /* In the declaration `A : X, Y, ... Z' we mark all the types
12885 (A, X, Y, ..., Z) so we can check for duplicates. */
12889 enum tag_types tag_code;
12891 if (TREE_CODE (ref) == UNION_TYPE)
12893 error ("derived union `%T' invalid", ref);
12897 tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
12899 /* First, make sure that any templates in base-classes are
12900 instantiated. This ensures that if we call ourselves recursively
12901 we do not get confused about which classes are marked and which
12903 basep = &base_list;
12906 tree basetype = TREE_VALUE (*basep);
12907 if (!(processing_template_decl && uses_template_parms (basetype))
12908 && !complete_type_or_else (basetype, NULL))
12909 /* An incomplete type. Remove it from the list. */
12910 *basep = TREE_CHAIN (*basep);
12912 basep = &TREE_CHAIN (*basep);
12915 SET_CLASSTYPE_MARKED (ref);
12916 i = list_length (base_list);
12919 tree binfo = TYPE_BINFO (ref);
12920 tree binfos = make_tree_vec (i);
12921 tree accesses = make_tree_vec (i);
12923 BINFO_BASETYPES (binfo) = binfos;
12924 BINFO_BASEACCESSES (binfo) = accesses;
12926 for (i = 0; base_list; base_list = TREE_CHAIN (base_list))
12928 tree access = TREE_PURPOSE (base_list);
12929 int via_virtual = TREE_VIA_VIRTUAL (base_list);
12930 tree basetype = TREE_VALUE (base_list);
12933 if (access == access_default_node)
12934 /* The base of a derived struct is public by default. */
12935 access = (tag_code == class_type
12936 ? access_private_node : access_public_node);
12938 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12939 basetype = TREE_TYPE (basetype);
12941 || (TREE_CODE (basetype) != RECORD_TYPE
12942 && TREE_CODE (basetype) != TYPENAME_TYPE
12943 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12944 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12946 error ("base type `%T' fails to be a struct or class type",
12951 if (CLASSTYPE_MARKED (basetype))
12953 if (basetype == ref)
12954 error ("recursive type `%T' undefined", basetype);
12956 error ("duplicate base type `%T' invalid", basetype);
12960 if (TYPE_FOR_JAVA (basetype)
12961 && (current_lang_depth () == 0))
12962 TYPE_FOR_JAVA (ref) = 1;
12964 if (CLASS_TYPE_P (basetype))
12966 base_binfo = TYPE_BINFO (basetype);
12967 /* This flag will be in the binfo of the base type, we must
12968 clear it after copying the base binfos. */
12969 BINFO_DEPENDENT_BASE_P (base_binfo)
12970 = dependent_type_p (basetype);
12973 base_binfo = make_binfo (size_zero_node, basetype,
12974 NULL_TREE, NULL_TREE);
12976 TREE_VEC_ELT (binfos, i) = base_binfo;
12977 TREE_VEC_ELT (accesses, i) = access;
12978 /* This flag will be in the binfo of the base type, we must
12979 clear it after copying the base binfos. */
12980 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12982 SET_CLASSTYPE_MARKED (basetype);
12984 /* We are free to modify these bits because they are meaningless
12985 at top level, and BASETYPE is a top-level type. */
12986 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12988 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12989 /* Converting to a virtual base class requires looking
12990 up the offset of the virtual base. */
12991 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12994 if (CLASS_TYPE_P (basetype))
12996 TYPE_HAS_NEW_OPERATOR (ref)
12997 |= TYPE_HAS_NEW_OPERATOR (basetype);
12998 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12999 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
13000 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
13001 /* If the base-class uses multiple inheritance, so do we. */
13002 TYPE_USES_MULTIPLE_INHERITANCE (ref)
13003 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
13004 /* Likewise, if converting to a base of the base may require
13005 code, then we may need to generate code to convert to a
13007 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
13008 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
13013 TREE_VEC_LENGTH (accesses) = TREE_VEC_LENGTH (binfos) = i;
13015 BINFO_BASEACCESSES (binfo) = BINFO_BASETYPES (binfo) = NULL_TREE;
13019 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
13020 /* If there is more than one non-empty they cannot be at the same
13022 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13026 /* Copy the base binfos, collect the virtual bases and set the
13027 inheritance order chain. */
13028 copy_base_binfos (TYPE_BINFO (ref), ref, NULL_TREE);
13029 CLASSTYPE_VBASECLASSES (ref) = nreverse (CLASSTYPE_VBASECLASSES (ref));
13031 /* Unmark all the types. */
13034 tree basetype = BINFO_TYPE (BINFO_BASETYPE (TYPE_BINFO (ref), i));
13036 CLEAR_CLASSTYPE_MARKED (basetype);
13037 if (CLASS_TYPE_P (basetype))
13039 TREE_VIA_VIRTUAL (TYPE_BINFO (basetype)) = 0;
13040 BINFO_DEPENDENT_BASE_P (TYPE_BINFO (basetype)) = 0;
13043 CLEAR_CLASSTYPE_MARKED (ref);
13047 /* Begin compiling the definition of an enumeration type.
13048 NAME is its name (or null if anonymous).
13049 Returns the type object, as yet incomplete.
13050 Also records info about it so that build_enumerator
13051 may be used to declare the individual values as they are read. */
13054 start_enum (tree name)
13056 register tree enumtype = NULL_TREE;
13057 struct cp_binding_level *b = current_binding_level;
13059 /* If this is the real definition for a previous forward reference,
13060 fill in the contents in the same object that used to be the
13061 forward reference. */
13063 if (name != NULL_TREE)
13064 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13066 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13068 error ("multiple definition of `%#T'", enumtype);
13069 cp_error_at ("previous definition here", enumtype);
13070 /* Clear out TYPE_VALUES, and start again. */
13071 TYPE_VALUES (enumtype) = NULL_TREE;
13075 enumtype = make_node (ENUMERAL_TYPE);
13076 pushtag (name, enumtype, 0);
13082 /* After processing and defining all the values of an enumeration type,
13083 install their decls in the enumeration type and finish it off.
13084 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
13087 finish_enum (tree enumtype)
13098 /* We built up the VALUES in reverse order. */
13099 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13101 /* For an enum defined in a template, just set the type of the values;
13102 all further processing is postponed until the template is
13103 instantiated. We need to set the type so that tsubst of a CONST_DECL
13105 if (processing_template_decl)
13107 for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13108 TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13109 if (at_function_scope_p ())
13110 add_stmt (build_min (TAG_DEFN, enumtype));
13114 if (TYPE_VALUES (enumtype))
13116 minnode = maxnode = NULL_TREE;
13118 for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13120 tree decl = TREE_VALUE (pair);
13121 tree value = DECL_INITIAL (decl);
13123 /* [dcl.enum]: Following the closing brace of an enum-specifier,
13124 each enumerator has the type of its enumeration. Prior to the
13125 closing brace, the type of each enumerator is the type of its
13126 initializing value. */
13127 TREE_TYPE (decl) = enumtype;
13129 /* Figure out what the minimum and maximum values of the
13130 enumerators are. */
13132 minnode = maxnode = value;
13133 else if (tree_int_cst_lt (maxnode, value))
13135 else if (tree_int_cst_lt (value, minnode))
13138 /* Set the TREE_TYPE for the values as well. That's so that when
13139 we call decl_constant_value we get an entity of the right type
13140 (but with the constant value). But first make a copy so we
13141 don't clobber shared INTEGER_CSTs. */
13142 if (TREE_TYPE (value) != enumtype)
13144 value = DECL_INITIAL (decl) = copy_node (value);
13145 TREE_TYPE (value) = enumtype;
13148 /* In addition, transform the TYPE_VALUES list to contain the
13149 values, rather than the CONST_DECLs for them. */
13150 TREE_VALUE (pair) = value;
13154 minnode = maxnode = integer_zero_node;
13156 /* Compute the number of bits require to represent all values of the
13157 enumeration. We must do this before the type of MINNODE and
13158 MAXNODE are transformed, since min_precision relies on the
13159 TREE_TYPE of the value it is passed. */
13160 unsignedp = tree_int_cst_sgn (minnode) >= 0;
13161 lowprec = min_precision (minnode, unsignedp);
13162 highprec = min_precision (maxnode, unsignedp);
13163 precision = MAX (lowprec, highprec);
13165 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
13166 TYPE_SIZE (enumtype) = NULL_TREE;
13167 TYPE_PRECISION (enumtype) = precision;
13169 fixup_unsigned_type (enumtype);
13171 fixup_signed_type (enumtype);
13173 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13174 /* Use the width of the narrowest normal C type which is wide
13176 TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13179 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13181 TYPE_SIZE (enumtype) = NULL_TREE;
13182 layout_type (enumtype);
13184 /* Fix up all variant types of this enum type. */
13185 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13187 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13188 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13189 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13190 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13191 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13192 TYPE_MODE (t) = TYPE_MODE (enumtype);
13193 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13194 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13195 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13196 TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13199 /* Finish debugging output for this type. */
13200 rest_of_type_compilation (enumtype, namespace_bindings_p ());
13203 /* Build and install a CONST_DECL for an enumeration constant of the
13204 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13205 Assignment of sequential values by default is handled here. */
13208 build_enumerator (tree name, tree value, tree enumtype)
13214 /* Remove no-op casts from the value. */
13216 STRIP_TYPE_NOPS (value);
13218 if (! processing_template_decl)
13220 /* Validate and default VALUE. */
13221 if (value != NULL_TREE)
13223 value = decl_constant_value (value);
13225 if (TREE_CODE (value) == INTEGER_CST)
13227 value = default_conversion (value);
13228 constant_expression_warning (value);
13232 error ("enumerator value for `%D' not integer constant", name);
13237 /* Default based on previous value. */
13238 if (value == NULL_TREE)
13242 if (TYPE_VALUES (enumtype))
13244 /* The next value is the previous value ... */
13245 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13246 /* ... plus one. */
13247 value = cp_build_binary_op (PLUS_EXPR,
13251 if (tree_int_cst_lt (value, prev_value))
13252 error ("overflow in enumeration values at `%D'", name);
13255 value = integer_zero_node;
13258 /* Remove no-op casts from the value. */
13259 STRIP_TYPE_NOPS (value);
13262 /* C++ associates enums with global, function, or class declarations. */
13263 context = current_scope ();
13265 /* Build the actual enumeration constant. Note that the enumeration
13266 constants have the type of their initializers until the
13267 enumeration is complete:
13271 Following the closing brace of an enum-specifier, each enumer-
13272 ator has the type of its enumeration. Prior to the closing
13273 brace, the type of each enumerator is the type of its
13274 initializing value.
13276 In finish_enum we will reset the type. Of course, if we're
13277 processing a template, there may be no value. */
13278 type = value ? TREE_TYPE (value) : NULL_TREE;
13280 if (context && context == current_class_type)
13281 /* This enum declaration is local to the class. We need the full
13282 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13283 decl = build_lang_decl (CONST_DECL, name, type);
13285 /* It's a global enum, or it's local to a function. (Note local to
13286 a function could mean local to a class method. */
13287 decl = build_decl (CONST_DECL, name, type);
13289 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13290 DECL_INITIAL (decl) = value;
13291 TREE_READONLY (decl) = 1;
13293 if (context && context == current_class_type)
13294 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13295 on the TYPE_FIELDS list for `S'. (That's so that you can say
13296 things like `S::i' later.) */
13297 finish_member_declaration (decl);
13301 /* Add this enumeration constant to the list for this type. */
13302 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13306 /* We're defining DECL. Make sure that it's type is OK. */
13309 check_function_type (tree decl, tree current_function_parms)
13311 tree fntype = TREE_TYPE (decl);
13312 tree return_type = complete_type (TREE_TYPE (fntype));
13314 /* In a function definition, arg types must be complete. */
13315 require_complete_types_for_parms (current_function_parms);
13317 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13319 error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13321 /* Make it return void instead, but don't change the
13322 type of the DECL_RESULT, in case we have a named return value. */
13323 if (TREE_CODE (fntype) == METHOD_TYPE)
13325 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13327 = build_cplus_method_type (ctype,
13329 FUNCTION_ARG_CHAIN (decl));
13333 = build_function_type (void_type_node,
13334 TYPE_ARG_TYPES (TREE_TYPE (decl)));
13336 = build_exception_variant (fntype,
13337 TYPE_RAISES_EXCEPTIONS (fntype));
13340 abstract_virtuals_error (decl, TREE_TYPE (fntype));
13343 /* Create the FUNCTION_DECL for a function definition.
13344 DECLSPECS and DECLARATOR are the parts of the declaration;
13345 they describe the function's name and the type it returns,
13346 but twisted together in a fashion that parallels the syntax of C.
13348 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13349 DECLARATOR is really the DECL for the function we are about to
13350 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13351 indicating that the function is an inline defined in-class.
13353 This function creates a binding context for the function body
13354 as well as setting up the FUNCTION_DECL in current_function_decl.
13356 Returns 1 on success. If the DECLARATOR is not suitable for a function
13357 (it defines a datum instead), we return 0, which tells
13358 yyparse to report a parse error.
13360 For C++, we must first check whether that datum makes any sense.
13361 For example, "class A local_a(1,2);" means that variable local_a
13362 is an aggregate of type A, which should have a constructor
13363 applied to it with the argument list [1, 2]. */
13366 start_function (tree declspecs, tree declarator, tree attrs, int flags)
13369 tree ctype = NULL_TREE;
13372 int doing_friend = 0;
13373 struct cp_binding_level *bl;
13374 tree current_function_parms;
13376 /* Sanity check. */
13377 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13378 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13380 /* This should only be done once on the top most decl. */
13381 if (have_extern_spec)
13383 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13384 have_extern_spec = false;
13387 if (flags & SF_PRE_PARSED)
13389 decl1 = declarator;
13391 fntype = TREE_TYPE (decl1);
13392 if (TREE_CODE (fntype) == METHOD_TYPE)
13393 ctype = TYPE_METHOD_BASETYPE (fntype);
13395 /* ISO C++ 11.4/5. A friend function defined in a class is in
13396 the (lexical) scope of the class in which it is defined. */
13397 if (!ctype && DECL_FRIEND_P (decl1))
13399 ctype = DECL_FRIEND_CONTEXT (decl1);
13401 /* CTYPE could be null here if we're dealing with a template;
13402 for example, `inline friend float foo()' inside a template
13403 will have no CTYPE set. */
13404 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13410 last_function_parms = DECL_ARGUMENTS (decl1);
13414 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13415 /* If the declarator is not suitable for a function definition,
13416 cause a syntax error. */
13417 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13420 cplus_decl_attributes (&decl1, attrs, 0);
13422 /* If #pragma weak was used, mark the decl weak now. */
13423 if (current_binding_level == global_binding_level)
13424 maybe_apply_pragma_weak (decl1);
13426 fntype = TREE_TYPE (decl1);
13428 restype = TREE_TYPE (fntype);
13429 if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13431 error ("semicolon missing after declaration of `%#T'", restype);
13432 shadow_tag (build_tree_list (NULL_TREE, restype));
13433 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13434 if (TREE_CODE (fntype) == FUNCTION_TYPE)
13435 fntype = build_function_type (integer_type_node,
13436 TYPE_ARG_TYPES (fntype));
13438 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13440 TYPE_ARG_TYPES (fntype));
13441 TREE_TYPE (decl1) = fntype;
13444 if (TREE_CODE (fntype) == METHOD_TYPE)
13445 ctype = TYPE_METHOD_BASETYPE (fntype);
13446 else if (DECL_MAIN_P (decl1))
13448 /* If this doesn't return integer_type, complain. */
13449 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13451 if (pedantic || warn_return_type)
13452 pedwarn ("return type for `main' changed to `int'");
13453 TREE_TYPE (decl1) = fntype = default_function_type;
13458 if (DECL_DECLARED_INLINE_P (decl1)
13459 && lookup_attribute ("noinline", attrs))
13460 warning ("%Hinline function '%D' given attribute noinline",
13461 &DECL_SOURCE_LOCATION (decl1), decl1);
13463 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13464 /* This is a constructor, we must ensure that any default args
13465 introduced by this definition are propagated to the clones
13466 now. The clones are used directly in overload resolution. */
13467 adjust_clone_args (decl1);
13469 /* Sometimes we don't notice that a function is a static member, and
13470 build a METHOD_TYPE for it. Fix that up now. */
13471 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13472 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13474 revert_static_member_fn (decl1);
13475 last_function_parms = TREE_CHAIN (last_function_parms);
13479 /* Warn if function was previously implicitly declared
13480 (but not if we warned then). */
13481 if (! warn_implicit
13482 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13483 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13485 /* Set up current_class_type, and enter the scope of the class, if
13488 push_nested_class (ctype);
13489 else if (DECL_STATIC_FUNCTION_P (decl1))
13490 push_nested_class (DECL_CONTEXT (decl1));
13492 /* Now that we have entered the scope of the class, we must restore
13493 the bindings for any template parameters surrounding DECL1, if it
13494 is an inline member template. (Order is important; consider the
13495 case where a template parameter has the same name as a field of
13496 the class.) It is not until after this point that
13497 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13498 if (flags & SF_INCLASS_INLINE)
13499 maybe_begin_member_template_processing (decl1);
13501 /* Effective C++ rule 15. */
13503 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13504 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13505 warning ("`operator=' should return a reference to `*this'");
13507 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13508 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13509 if (!DECL_INITIAL (decl1))
13510 DECL_INITIAL (decl1) = error_mark_node;
13512 /* This function exists in static storage.
13513 (This does not mean `static' in the C sense!) */
13514 TREE_STATIC (decl1) = 1;
13516 /* We must call push_template_decl after current_class_type is set
13517 up. (If we are processing inline definitions after exiting a
13518 class scope, current_class_type will be NULL_TREE until set above
13519 by push_nested_class.) */
13520 if (processing_template_decl)
13521 decl1 = push_template_decl (decl1);
13523 /* We are now in the scope of the function being defined. */
13524 current_function_decl = decl1;
13526 /* Save the parm names or decls from this function's declarator
13527 where store_parm_decls will find them. */
13528 current_function_parms = last_function_parms;
13530 /* Make sure the parameter and return types are reasonable. When
13531 you declare a function, these types can be incomplete, but they
13532 must be complete when you define the function. */
13533 if (! processing_template_decl)
13534 check_function_type (decl1, current_function_parms);
13536 /* Build the return declaration for the function. */
13537 restype = TREE_TYPE (fntype);
13538 /* Promote the value to int before returning it. */
13539 if (c_promoting_integer_type_p (restype))
13540 restype = type_promotes_to (restype);
13541 if (DECL_RESULT (decl1) == NULL_TREE)
13543 DECL_RESULT (decl1)
13544 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13545 c_apply_type_quals_to_decl (cp_type_quals (restype),
13546 DECL_RESULT (decl1));
13549 /* Initialize RTL machinery. We cannot do this until
13550 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13551 even when processing a template; this is how we get
13552 CFUN set up, and our per-function variables initialized.
13553 FIXME factor out the non-RTL stuff. */
13554 bl = current_binding_level;
13555 init_function_start (decl1, input_filename, lineno);
13556 current_binding_level = bl;
13558 /* Even though we're inside a function body, we still don't want to
13559 call expand_expr to calculate the size of a variable-sized array.
13560 We haven't necessarily assigned RTL to all variables yet, so it's
13561 not safe to try to expand expressions involving them. */
13562 immediate_size_expand = 0;
13563 cfun->x_dont_save_pending_sizes_p = 1;
13565 /* Start the statement-tree, start the tree now. */
13566 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13568 /* Don't double-count statements in templates. */
13569 DECL_NUM_STMTS (decl1) = 0;
13571 /* Let the user know we're compiling this function. */
13572 announce_function (decl1);
13574 /* Record the decl so that the function name is defined.
13575 If we already have a decl for this name, and it is a FUNCTION_DECL,
13576 use the old decl. */
13577 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13579 /* A specialization is not used to guide overload resolution. */
13580 if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13581 && ! DECL_FUNCTION_MEMBER_P (decl1))
13582 decl1 = pushdecl (decl1);
13585 /* We need to set the DECL_CONTEXT. */
13586 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13587 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13588 /* And make sure we have enough default args. */
13589 check_default_args (decl1);
13591 fntype = TREE_TYPE (decl1);
13594 /* Reset these in case the call to pushdecl changed them. */
13595 current_function_decl = decl1;
13596 cfun->decl = decl1;
13598 /* If we are (erroneously) defining a function that we have already
13599 defined before, wipe out what we knew before. */
13600 if (!DECL_PENDING_INLINE_P (decl1))
13601 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13603 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13605 /* We know that this was set up by `grokclassfn'. We do not
13606 wait until `store_parm_decls', since evil parse errors may
13607 never get us to that point. Here we keep the consistency
13608 between `current_class_type' and `current_class_ptr'. */
13609 tree t = DECL_ARGUMENTS (decl1);
13611 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13613 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13616 cp_function_chain->x_current_class_ref
13617 = build_indirect_ref (t, NULL);
13618 cp_function_chain->x_current_class_ptr = t;
13620 /* Constructors and destructors need to know whether they're "in
13621 charge" of initializing virtual base classes. */
13622 t = TREE_CHAIN (t);
13623 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13625 current_in_charge_parm = t;
13626 t = TREE_CHAIN (t);
13628 if (DECL_HAS_VTT_PARM_P (decl1))
13630 if (DECL_NAME (t) != vtt_parm_identifier)
13632 current_vtt_parm = t;
13636 if (DECL_INTERFACE_KNOWN (decl1))
13638 tree ctx = decl_function_context (decl1);
13640 if (DECL_NOT_REALLY_EXTERN (decl1))
13641 DECL_EXTERNAL (decl1) = 0;
13643 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13644 && TREE_PUBLIC (ctx))
13645 /* This is a function in a local class in an extern inline
13647 comdat_linkage (decl1);
13649 /* If this function belongs to an interface, it is public.
13650 If it belongs to someone else's interface, it is also external.
13651 This only affects inlines and template instantiations. */
13652 else if (interface_unknown == 0
13653 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13654 || flag_alt_external_templates))
13656 if (DECL_DECLARED_INLINE_P (decl1)
13657 || DECL_TEMPLATE_INSTANTIATION (decl1)
13658 || processing_template_decl)
13660 DECL_EXTERNAL (decl1)
13662 || (DECL_DECLARED_INLINE_P (decl1)
13663 && ! flag_implement_inlines
13664 && !DECL_VINDEX (decl1)));
13666 /* For WIN32 we also want to put these in linkonce sections. */
13667 maybe_make_one_only (decl1);
13670 DECL_EXTERNAL (decl1) = 0;
13671 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13672 DECL_INTERFACE_KNOWN (decl1) = 1;
13674 else if (interface_unknown && interface_only
13675 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13676 || flag_alt_external_templates))
13678 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13679 interface, we will have interface_only set but not
13680 interface_known. In that case, we don't want to use the normal
13681 heuristics because someone will supply a #pragma implementation
13682 elsewhere, and deducing it here would produce a conflict. */
13683 comdat_linkage (decl1);
13684 DECL_EXTERNAL (decl1) = 0;
13685 DECL_INTERFACE_KNOWN (decl1) = 1;
13686 DECL_DEFER_OUTPUT (decl1) = 1;
13690 /* This is a definition, not a reference.
13691 So clear DECL_EXTERNAL. */
13692 DECL_EXTERNAL (decl1) = 0;
13694 if ((DECL_DECLARED_INLINE_P (decl1)
13695 || DECL_TEMPLATE_INSTANTIATION (decl1))
13696 && ! DECL_INTERFACE_KNOWN (decl1)
13697 /* Don't try to defer nested functions for now. */
13698 && ! decl_function_context (decl1))
13699 DECL_DEFER_OUTPUT (decl1) = 1;
13701 DECL_INTERFACE_KNOWN (decl1) = 1;
13705 current_binding_level->parm_flag = 1;
13709 if (DECL_DESTRUCTOR_P (decl1))
13711 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13712 DECL_CONTEXT (dtor_label) = current_function_decl;
13715 start_fname_decls ();
13717 store_parm_decls (current_function_parms);
13722 /* Store the parameter declarations into the current function declaration.
13723 This is called after parsing the parameter declarations, before
13724 digesting the body of the function.
13726 Also install to binding contour return value identifier, if any. */
13729 store_parm_decls (tree current_function_parms)
13731 register tree fndecl = current_function_decl;
13732 register tree parm;
13734 /* This is a chain of any other decls that came in among the parm
13735 declarations. If a parm is declared with enum {foo, bar} x;
13736 then CONST_DECLs for foo and bar are put here. */
13737 tree nonparms = NULL_TREE;
13739 if (current_function_parms)
13741 /* This case is when the function was defined with an ANSI prototype.
13742 The parms already have decls, so we need not do anything here
13743 except record them as in effect
13744 and complain if any redundant old-style parm decls were written. */
13746 tree specparms = current_function_parms;
13749 /* Must clear this because it might contain TYPE_DECLs declared
13751 storedecls (NULL_TREE);
13753 /* If we're doing semantic analysis, then we'll call pushdecl
13754 for each of these. We must do them in reverse order so that
13755 they end in the correct forward order. */
13756 specparms = nreverse (specparms);
13758 for (parm = specparms; parm; parm = next)
13760 next = TREE_CHAIN (parm);
13761 if (TREE_CODE (parm) == PARM_DECL)
13763 if (DECL_NAME (parm) == NULL_TREE
13764 || TREE_CODE (parm) != VOID_TYPE)
13767 error ("parameter `%D' declared void", parm);
13771 /* If we find an enum constant or a type tag,
13772 put it aside for the moment. */
13773 TREE_CHAIN (parm) = NULL_TREE;
13774 nonparms = chainon (nonparms, parm);
13778 /* Get the decls in their original chain order and record in the
13779 function. This is all and only the PARM_DECLs that were
13780 pushed into scope by the loop above. */
13781 DECL_ARGUMENTS (fndecl) = getdecls ();
13782 storetags (gettags ());
13785 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13787 /* Now store the final chain of decls for the arguments
13788 as the decl-chain of the current lexical scope.
13789 Put the enumerators in as well, at the front so that
13790 DECL_ARGUMENTS is not modified. */
13791 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13793 /* Do the starting of the exception specifications, if we have any. */
13794 if (flag_exceptions && !processing_template_decl
13795 && flag_enforce_eh_specs
13796 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13797 current_eh_spec_block = begin_eh_spec_block ();
13801 /* We have finished doing semantic analysis on DECL, but have not yet
13802 generated RTL for its body. Save away our current state, so that
13803 when we want to generate RTL later we know what to do. */
13806 save_function_data (tree decl)
13808 struct language_function *f;
13810 /* Save the language-specific per-function data so that we can
13811 get it back when we really expand this function. */
13812 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13816 f = ((struct language_function *)
13817 ggc_alloc (sizeof (struct language_function)));
13818 memcpy (f, cp_function_chain, sizeof (struct language_function));
13819 DECL_SAVED_FUNCTION_DATA (decl) = f;
13821 /* Clear out the bits we don't need. */
13822 f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13823 f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13824 f->x_named_label_uses = NULL;
13825 f->bindings = NULL;
13826 f->x_local_names = NULL;
13828 /* When we get back here again, we will be expanding. */
13829 f->x_expanding_p = 1;
13831 /* If we've already decided that we cannot inline this function, we
13832 must remember that fact when we actually go to expand the
13834 if (current_function_cannot_inline)
13836 f->cannot_inline = current_function_cannot_inline;
13837 DECL_INLINE (decl) = 0;
13841 /* Add a note to mark the beginning of the main body of the constructor.
13842 This is used to set up the data structures for the cleanup regions for
13843 fully-constructed bases and members. */
13846 begin_constructor_body (void)
13850 /* Add a note to mark the end of the main body of the constructor. This is
13851 used to end the cleanup regions for fully-constructed bases and
13855 finish_constructor_body (void)
13859 /* Do all the processing for the beginning of a destructor; set up the
13860 vtable pointers and cleanups for bases and members. */
13863 begin_destructor_body (void)
13866 tree compound_stmt;
13868 /* If the dtor is empty, and we know there is not any possible
13869 way we could use any vtable entries, before they are possibly
13870 set by a base class dtor, we don't have to setup the vtables,
13871 as we know that any base class dtor will set up any vtables
13872 it needs. We avoid MI, because one base class dtor can do a
13873 virtual dispatch to an overridden function that would need to
13874 have a non-related vtable set up, we cannot avoid setting up
13875 vtables in that case. We could change this to see if there
13876 is just one vtable.
13878 ??? In the destructor for a class, the vtables are set
13879 appropriately for that class. There will be no non-related
13880 vtables. jason 2001-12-11. */
13881 if_stmt = begin_if_stmt ();
13883 /* If it is not safe to avoid setting up the vtables, then
13884 someone will change the condition to be boolean_true_node.
13885 (Actually, for now, we do not have code to set the condition
13886 appropriately, so we just assume that we always need to
13887 initialize the vtables.) */
13888 finish_if_stmt_cond (boolean_true_node, if_stmt);
13890 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13892 /* Make all virtual function table pointers in non-virtual base
13893 classes point to CURRENT_CLASS_TYPE's virtual function
13895 initialize_vtbl_ptrs (current_class_ptr);
13897 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13898 finish_then_clause (if_stmt);
13901 /* And insert cleanups for our bases and members so that they
13902 will be properly destroyed if we throw. */
13903 push_base_cleanups ();
13906 /* At the end of every destructor we generate code to delete the object if
13907 necessary. Do that now. */
13910 finish_destructor_body (void)
13914 /* Any return from a destructor will end up here; that way all base
13915 and member cleanups will be run when the function returns. */
13916 add_stmt (build_stmt (LABEL_STMT, dtor_label));
13918 /* In a virtual destructor, we must call delete. */
13919 if (DECL_VIRTUAL_P (current_function_decl))
13922 tree virtual_size = cxx_sizeof (current_class_type);
13926 At the point of definition of a virtual destructor (including
13927 an implicit definition), non-placement operator delete shall
13928 be looked up in the scope of the destructor's class and if
13929 found shall be accessible and unambiguous. */
13930 exprstmt = build_op_delete_call
13931 (DELETE_EXPR, current_class_ptr, virtual_size,
13932 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13934 if_stmt = begin_if_stmt ();
13935 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13936 current_in_charge_parm,
13939 finish_expr_stmt (exprstmt);
13940 finish_then_clause (if_stmt);
13945 /* Do the necessary processing for the beginning of a function body, which
13946 in this case includes member-initializers, but not the catch clauses of
13947 a function-try-block. Currently, this means opening a binding level
13948 for the member-initializers (in a ctor) and member cleanups (in a dtor).
13949 In other functions, this isn't necessary, but it doesn't hurt. */
13952 begin_function_body (void)
13956 if (processing_template_decl)
13957 /* Do nothing now. */;
13959 /* Always keep the BLOCK node associated with the outermost pair of
13960 curly braces of a function. These are needed for correct
13961 operation of dwarfout.c. */
13962 keep_next_level (1);
13964 stmt = begin_compound_stmt (0);
13965 COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
13967 if (processing_template_decl)
13968 /* Do nothing now. */;
13969 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13970 begin_constructor_body ();
13971 else if (DECL_DESTRUCTOR_P (current_function_decl))
13972 begin_destructor_body ();
13977 /* Do the processing for the end of a function body. Currently, this means
13978 closing out the cleanups for fully-constructed bases and members, and in
13979 the case of the destructor, deleting the object if desired. Again, this
13980 is only meaningful for [cd]tors, since they are the only functions where
13981 there is a significant distinction between the main body and any
13982 function catch clauses. Handling, say, main() return semantics here
13983 would be wrong, as flowing off the end of a function catch clause for
13984 main() would also need to return 0. */
13987 finish_function_body (tree compstmt)
13989 /* Close the block. */
13990 finish_compound_stmt (0, compstmt);
13992 if (processing_template_decl)
13993 /* Do nothing now. */;
13994 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13995 finish_constructor_body ();
13996 else if (DECL_DESTRUCTOR_P (current_function_decl))
13997 finish_destructor_body ();
14000 /* Finish up a function declaration and compile that function
14001 all the way to assembler language output. The free the storage
14002 for the function definition.
14004 FLAGS is a bitwise or of the following values:
14006 We just finished processing the body of an in-class inline
14007 function definition. (This processing will have taken place
14008 after the class definition is complete.) */
14011 finish_function (int flags)
14013 register tree fndecl = current_function_decl;
14014 tree fntype, ctype = NULL_TREE;
14015 int inclass_inline = (flags & 2) != 0;
14018 /* When we get some parse errors, we can end up without a
14019 current_function_decl, so cope. */
14020 if (fndecl == NULL_TREE)
14021 return error_mark_node;
14023 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
14024 && DECL_VIRTUAL_P (fndecl)
14025 && !processing_template_decl)
14027 tree fnclass = DECL_CONTEXT (fndecl);
14028 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
14029 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
14032 nested = function_depth > 1;
14033 fntype = TREE_TYPE (fndecl);
14035 /* TREE_READONLY (fndecl) = 1;
14036 This caused &foo to be of type ptr-to-const-function
14037 which then got a warning when stored in a ptr-to-function variable. */
14039 my_friendly_assert (building_stmt_tree (), 20000911);
14041 finish_fname_decls ();
14043 /* For a cloned function, we've already got all the code we need;
14044 there's no need to add any extra bits. */
14045 if (!DECL_CLONED_FUNCTION_P (fndecl))
14047 if (DECL_MAIN_P (current_function_decl))
14049 /* Make it so that `main' always returns 0 by default. */
14051 finish_return_stmt (integer_one_node);
14053 finish_return_stmt (integer_zero_node);
14057 /* Finish dealing with exception specifiers. */
14058 if (flag_exceptions && !processing_template_decl
14059 && flag_enforce_eh_specs
14060 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14061 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14062 (TREE_TYPE (current_function_decl)),
14063 current_eh_spec_block);
14066 /* If we're saving up tree structure, tie off the function now. */
14067 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14069 /* This must come after expand_function_end because cleanups might
14070 have declarations (from inline functions) that need to go into
14071 this function's blocks. */
14073 /* If the current binding level isn't the outermost binding level
14074 for this function, either there is a bug, or we have experienced
14075 syntax errors and the statement tree is malformed. */
14076 if (current_binding_level->parm_flag != 1)
14078 /* Make sure we have already experienced errors. */
14079 if (errorcount == 0)
14082 /* Throw away the broken statement tree and extra binding
14084 DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14086 while (current_binding_level->parm_flag != 1)
14088 if (current_binding_level->parm_flag == 2)
14089 pop_nested_class ();
14091 poplevel (0, 0, 0);
14094 poplevel (1, 0, 1);
14096 /* Set up the named return value optimization, if we can. Here, we
14097 eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14098 for the nrv. genrtl_start_function and declare_return_variable
14099 handle making the nrv and RESULT_DECL share space. */
14100 if (current_function_return_value)
14102 tree r = current_function_return_value;
14103 /* This is only worth doing for fns that return in memory--and
14104 simpler, since we don't have to worry about promoted modes. */
14105 if (r != error_mark_node
14106 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14108 DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14109 walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14110 nullify_returns_r, r);
14113 /* Clear it so genrtl_start_function and declare_return_variable
14114 know we're not optimizing. */
14115 current_function_return_value = NULL_TREE;
14118 /* Remember that we were in class scope. */
14119 if (current_class_name)
14120 ctype = current_class_type;
14122 /* Must mark the RESULT_DECL as being in this function. */
14123 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14125 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14126 to the FUNCTION_DECL node itself. */
14127 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14129 /* Save away current state, if appropriate. */
14130 if (!processing_template_decl)
14131 save_function_data (fndecl);
14133 /* If this function calls `setjmp' it cannot be inlined. When
14134 `longjmp' is called it is not guaranteed to restore the value of
14135 local variables that have been modified since the call to
14136 `setjmp'. So, if were to inline this function into some caller
14137 `c', then when we `longjmp', we might not restore all variables
14138 in `c'. (It might seem, at first blush, that there's no way for
14139 this function to modify local variables in `c', but their
14140 addresses may have been stored somewhere accessible to this
14142 if (!processing_template_decl && calls_setjmp_p (fndecl))
14143 DECL_UNINLINABLE (fndecl) = 1;
14145 /* Complain if there's just no return statement. */
14146 if (warn_return_type
14147 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14148 && !current_function_returns_value && !current_function_returns_null
14149 /* Don't complain if we abort or throw. */
14150 && !current_function_returns_abnormally
14151 && !DECL_NAME (DECL_RESULT (fndecl))
14152 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
14153 inline function, as we might never be compiled separately. */
14154 && (DECL_INLINE (fndecl) || processing_template_decl))
14155 warning ("no return statement in function returning non-void");
14157 /* Clear out memory we no longer need. */
14158 free_after_parsing (cfun);
14159 /* Since we never call rest_of_compilation, we never clear
14160 CFUN. Do so explicitly. */
14161 free_after_compilation (cfun);
14164 /* If this is an in-class inline definition, we may have to pop the
14165 bindings for the template parameters that we added in
14166 maybe_begin_member_template_processing when start_function was
14168 if (inclass_inline)
14169 maybe_end_member_template_processing ();
14171 /* Leave the scope of the class. */
14173 pop_nested_class ();
14179 /* Let the error reporting routines know that we're outside a
14180 function. For a nested function, this value is used in
14181 cxx_pop_function_context and then reset via pop_function_context. */
14182 current_function_decl = NULL_TREE;
14187 /* Create the FUNCTION_DECL for a function definition.
14188 DECLSPECS and DECLARATOR are the parts of the declaration;
14189 they describe the return type and the name of the function,
14190 but twisted together in a fashion that parallels the syntax of C.
14192 This function creates a binding context for the function body
14193 as well as setting up the FUNCTION_DECL in current_function_decl.
14195 Returns a FUNCTION_DECL on success.
14197 If the DECLARATOR is not suitable for a function (it defines a datum
14198 instead), we return 0, which tells yyparse to report a parse error.
14200 May return void_type_node indicating that this method is actually
14201 a friend. See grokfield for more details.
14203 Came here with a `.pushlevel' .
14205 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14206 CHANGES TO CODE IN `grokfield'. */
14209 start_method (tree declspecs, tree declarator, tree attrlist)
14211 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14214 if (fndecl == error_mark_node)
14215 return error_mark_node;
14217 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14219 error ("invalid member function declaration");
14220 return error_mark_node;
14224 cplus_decl_attributes (&fndecl, attrlist, 0);
14226 /* Pass friends other than inline friend functions back. */
14227 if (fndecl == void_type_node)
14230 if (DECL_IN_AGGR_P (fndecl))
14232 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14234 if (DECL_CONTEXT (fndecl)
14235 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14236 error ("`%D' is already defined in class `%T'", fndecl,
14237 DECL_CONTEXT (fndecl));
14239 return void_type_node;
14242 check_template_shadow (fndecl);
14244 DECL_DECLARED_INLINE_P (fndecl) = 1;
14246 DID_INLINE_FUNC (fndecl) = 0;
14247 if (flag_default_inline)
14248 DECL_INLINE (fndecl) = 1;
14250 /* We process method specializations in finish_struct_1. */
14251 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14252 fndecl = push_template_decl (fndecl);
14254 if (! DECL_FRIEND_P (fndecl))
14256 if (TREE_CHAIN (fndecl))
14258 fndecl = copy_node (fndecl);
14259 TREE_CHAIN (fndecl) = NULL_TREE;
14261 grok_special_member_properties (fndecl);
14264 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14266 /* Make a place for the parms */
14268 current_binding_level->parm_flag = 1;
14270 DECL_IN_AGGR_P (fndecl) = 1;
14274 /* Go through the motions of finishing a function definition.
14275 We don't compile this method until after the whole class has
14278 FINISH_METHOD must return something that looks as though it
14279 came from GROKFIELD (since we are defining a method, after all).
14281 This is called after parsing the body of the function definition.
14282 STMTS is the chain of statements that makes up the function body.
14284 DECL is the ..._DECL that `start_method' provided. */
14287 finish_method (tree decl)
14289 register tree fndecl = decl;
14292 register tree link;
14294 if (decl == void_type_node)
14297 old_initial = DECL_INITIAL (fndecl);
14299 /* Undo the level for the parms (from start_method).
14300 This is like poplevel, but it causes nothing to be
14301 saved. Saving information here confuses symbol-table
14302 output routines. Besides, this information will
14303 be correctly output when this method is actually
14306 /* Clear out the meanings of the local variables of this level;
14307 also record in each decl which block it belongs to. */
14309 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14311 if (DECL_NAME (link) != NULL_TREE)
14312 pop_binding (DECL_NAME (link), link);
14313 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14314 DECL_CONTEXT (link) = NULL_TREE;
14317 poplevel (0, 0, 0);
14319 DECL_INITIAL (fndecl) = old_initial;
14321 /* We used to check if the context of FNDECL was different from
14322 current_class_type as another way to get inside here. This didn't work
14323 for String.cc in libg++. */
14324 if (DECL_FRIEND_P (fndecl))
14326 CLASSTYPE_INLINE_FRIENDS (current_class_type)
14327 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14328 decl = void_type_node;
14335 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14336 we can lay it out later, when and if its type becomes complete. */
14339 maybe_register_incomplete_var (tree var)
14341 my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14343 /* Keep track of variables with incomplete types. */
14344 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14345 && DECL_EXTERNAL (var))
14347 tree inner_type = TREE_TYPE (var);
14349 while (TREE_CODE (inner_type) == ARRAY_TYPE)
14350 inner_type = TREE_TYPE (inner_type);
14351 inner_type = TYPE_MAIN_VARIANT (inner_type);
14353 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14354 /* RTTI TD entries are created while defining the type_info. */
14355 || (TYPE_LANG_SPECIFIC (inner_type)
14356 && TYPE_BEING_DEFINED (inner_type)))
14357 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14361 /* Called when a class type (given by TYPE) is defined. If there are
14362 any existing VAR_DECLs whose type hsa been completed by this
14363 declaration, update them now. */
14366 complete_vars (tree type)
14368 tree *list = &incomplete_vars;
14370 my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14373 if (same_type_p (type, TREE_PURPOSE (*list)))
14375 tree var = TREE_VALUE (*list);
14376 /* Complete the type of the variable. The VAR_DECL itself
14377 will be laid out in expand_expr. */
14378 complete_type (TREE_TYPE (var));
14379 /* Remove this entry from the list. */
14380 *list = TREE_CHAIN (*list);
14383 list = &TREE_CHAIN (*list);
14387 /* If DECL is of a type which needs a cleanup, build that cleanup
14391 cxx_maybe_build_cleanup (tree decl)
14393 tree type = TREE_TYPE (decl);
14395 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14397 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14400 if (TREE_CODE (type) == ARRAY_TYPE)
14404 cxx_mark_addressable (decl);
14405 rval = build_unary_op (ADDR_EXPR, decl, 0);
14408 /* Optimize for space over speed here. */
14409 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14410 || flag_expensive_optimizations)
14411 flags |= LOOKUP_NONVIRTUAL;
14413 rval = build_delete (TREE_TYPE (rval), rval,
14414 sfk_complete_destructor, flags, 0);
14416 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14417 && ! TYPE_HAS_DESTRUCTOR (type))
14418 rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14419 build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14426 /* When a stmt has been parsed, this function is called. */
14431 /* Always assume this statement was not an expression statement. If
14432 it actually was an expression statement, its our callers
14433 responsibility to fix this up. */
14434 last_expr_type = NULL_TREE;
14437 /* DECL was originally constructed as a non-static member function,
14438 but turned out to be static. Update it accordingly. */
14441 revert_static_member_fn (tree decl)
14444 tree function = TREE_TYPE (decl);
14445 tree args = TYPE_ARG_TYPES (function);
14447 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14448 != TYPE_UNQUALIFIED)
14449 error ("static member function `%#D' declared with type qualifiers",
14452 args = TREE_CHAIN (args);
14453 tmp = build_function_type (TREE_TYPE (function), args);
14454 tmp = build_qualified_type (tmp, cp_type_quals (function));
14455 tmp = build_exception_variant (tmp,
14456 TYPE_RAISES_EXCEPTIONS (function));
14457 TREE_TYPE (decl) = tmp;
14458 if (DECL_ARGUMENTS (decl))
14459 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14460 DECL_STATIC_FUNCTION_P (decl) = 1;
14463 /* Initialize the variables used during compilation of a C++
14467 cxx_push_function_context (struct function * f)
14469 struct language_function *p
14470 = ((struct language_function *)
14471 ggc_alloc_cleared (sizeof (struct language_function)));
14474 /* It takes an explicit call to expand_body to generate RTL for a
14478 /* Whenever we start a new function, we destroy temporaries in the
14480 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14483 /* Free the language-specific parts of F, now that we've finished
14484 compiling the function. */
14487 cxx_pop_function_context (struct function * f)
14492 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14493 one of the language-independent trees. */
14495 enum cp_tree_node_structure_enum
14496 cp_tree_node_structure (union lang_tree_node * t)
14498 switch (TREE_CODE (&t->generic))
14500 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
14501 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
14502 case CPLUS_BINDING: return TS_CP_BINDING;
14503 case OVERLOAD: return TS_CP_OVERLOAD;
14504 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
14505 case PTRMEM_CST: return TS_CP_PTRMEM;
14506 case BASELINK: return TS_CP_BASELINK;
14507 case WRAPPER: return TS_CP_WRAPPER;
14508 case SRCLOC: return TS_CP_SRCLOC;
14509 default: return TS_CP_GENERIC;
14513 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14514 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
14517 identifier_global_value (tree t)
14519 return IDENTIFIER_GLOBAL_VALUE (t);
14522 /* Build the void_list_node (void_type_node having been created). */
14524 build_void_list_node (void)
14526 tree t = build_tree_list (NULL_TREE, void_type_node);
14527 TREE_PARMLIST (t) = 1;
14532 cp_missing_noreturn_ok_p (tree decl)
14534 /* A missing noreturn is ok for the `main' function. */
14535 return DECL_MAIN_P (decl);
14538 #include "gt-cp-decl.h"
14539 #include "gtype-cp.h"