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"
54 static tree grokparms (tree);
55 static const char *redeclaration_error_message (tree, tree);
57 static void push_binding_level (struct cp_binding_level *, int,
59 static void pop_binding_level (void);
60 static void suspend_binding_level (void);
61 static void resume_binding_level (struct cp_binding_level *);
62 static struct cp_binding_level *make_binding_level (void);
63 static void declare_namespace_level (void);
64 static int decl_jump_unsafe (tree);
65 static void storedecls (tree);
66 static void require_complete_types_for_parms (tree);
67 static int ambi_op_p (enum tree_code);
68 static int unary_op_p (enum tree_code);
69 static tree store_bindings (tree, tree);
70 static tree lookup_tag_reverse (tree, tree);
71 static void push_local_name (tree);
72 static void warn_extern_redeclared_static (tree, tree);
73 static tree grok_reference_init (tree, tree, tree);
74 static tree grokfndecl (tree, tree, tree, tree, int,
75 enum overload_flags, tree,
76 tree, int, int, int, int, int, int, tree);
77 static tree grokvardecl (tree, tree, RID_BIT_TYPE *, int, int, tree);
78 static tree follow_tag_typedef (tree);
79 static tree lookup_tag (enum tree_code, tree,
80 struct cp_binding_level *, int);
81 static void set_identifier_type_value_with_scope
82 (tree, tree, struct cp_binding_level *);
83 static void record_unknown_type (tree, const char *);
84 static tree builtin_function_1 (const char *, tree, tree, int,
85 enum built_in_class, const char *,
87 static tree build_library_fn_1 (tree, enum tree_code, tree);
88 static int member_function_or_else (tree, tree, enum overload_flags);
89 static void bad_specifiers (tree, const char *, int, int, int, int,
91 static tree maybe_process_template_type_declaration
92 (tree, int, struct cp_binding_level*);
93 static void check_for_uninitialized_const_var (tree);
94 static hashval_t typename_hash (const void *);
95 static int typename_compare (const void *, const void *);
96 static void push_binding (tree, tree, struct cp_binding_level*);
97 static int add_binding (tree, tree);
98 static void pop_binding (tree, tree);
99 static tree local_variable_p_walkfn (tree *, int *, void *);
100 static tree find_binding (tree, tree);
101 static tree select_decl (tree, int);
102 static int lookup_flags (int, int);
103 static tree qualify_lookup (tree, int);
104 static tree record_builtin_java_type (const char *, int);
105 static const char *tag_name (enum tag_types code);
106 static void find_class_binding_level (void);
107 static struct cp_binding_level *innermost_nonclass_level (void);
108 static void warn_about_implicit_typename_lookup (tree, tree);
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 /* A chain of VTABLE_DECL nodes. */
333 /* A list of structure, union and enum definitions, for looking up
335 It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
336 or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
337 or ENUMERAL_TYPE node.
339 C++: the TREE_VALUE nodes can be simple types for
340 component_bindings. */
343 /* A list of USING_DECL nodes. */
346 /* A list of used namespaces. PURPOSE is the namespace,
347 VALUE the common ancestor with this binding_level's namespace. */
348 tree using_directives;
350 /* If this binding level is the binding level for a class, then
351 class_shadowed is a TREE_LIST. The TREE_PURPOSE of each node
352 is the name of an entity bound in the class. The TREE_TYPE is
353 the DECL bound by this name in the class. */
356 /* Similar to class_shadowed, but for IDENTIFIER_TYPE_VALUE, and
357 is used for all binding levels. In addition the TREE_VALUE is the
358 IDENTIFIER_TYPE_VALUE before we entered the class. */
361 /* A TREE_LIST. Each TREE_VALUE is the LABEL_DECL for a local
362 label in this scope. The TREE_PURPOSE is the previous value of
363 the IDENTIFIER_LABEL VALUE. */
364 tree shadowed_labels;
366 /* For each level (except not the global one),
367 a chain of BLOCK nodes for all the levels
368 that were entered and exited one level down. */
371 /* The _TYPE node for this level, if parm_flag == 2. */
374 /* The binding level which this one is contained in (inherits from). */
375 struct cp_binding_level *level_chain;
377 /* List of VAR_DECLS saved from a previous for statement.
378 These would be dead in ISO-conforming code, but might
379 be referenced in ARM-era code. These are stored in a
380 TREE_LIST; the TREE_VALUE is the actual declaration. */
381 tree dead_vars_from_for;
383 /* 1 for the level that holds the parameters of a function.
384 2 for the level that holds a class declaration. */
385 unsigned parm_flag : 2;
387 /* 1 means make a BLOCK for this level regardless of all else.
388 2 for temporary binding contours created by the compiler. */
391 /* Nonzero if this level "doesn't exist" for tags. */
392 unsigned tag_transparent : 1;
394 /* Nonzero if this level can safely have additional
395 cleanup-needing variables added to it. */
396 unsigned more_cleanups_ok : 1;
397 unsigned have_cleanups : 1;
399 /* Nonzero if this scope is for storing the decls for template
400 parameters and generic decls; these decls will be discarded and
401 replaced with a TEMPLATE_DECL. */
402 unsigned template_parms_p : 1;
404 /* Nonzero if this scope corresponds to the `<>' in a
405 `template <>' clause. Whenever this flag is set,
406 TEMPLATE_PARMS_P will be set as well. */
407 unsigned template_spec_p : 1;
409 /* This is set for a namespace binding level. */
410 unsigned namespace_p : 1;
412 /* True if this level is that of a for-statement where we need to
413 worry about ambiguous (ARM or ISO) scope rules. */
414 unsigned is_for_scope : 1;
416 /* True if this level corresponds to a TRY block. Currently this
417 information is only available while building the tree structure. */
418 unsigned is_try_scope : 1;
420 /* True if this level corresponds to a CATCH block. Currently this
421 information is only available while building the tree structure. */
422 unsigned is_catch_scope : 1;
424 /* Three bits left for this word. */
426 /* Binding depth at which this level began. */
427 unsigned binding_depth;
430 #define NULL_BINDING_LEVEL ((struct cp_binding_level *) NULL)
432 /* The binding level currently in effect. */
434 #define current_binding_level \
435 (cfun && cp_function_chain->bindings \
436 ? cp_function_chain->bindings \
437 : scope_chain->bindings)
439 /* The binding level of the current class, if any. */
441 #define class_binding_level scope_chain->class_bindings
443 /* A chain of binding_level structures awaiting reuse. */
445 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
447 /* The outermost binding level, for names of file scope.
448 This is created when the compiler is started and exists
449 through the entire run. */
451 static GTY(()) struct cp_binding_level *global_binding_level;
453 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
455 static int keep_next_level_flag;
457 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
458 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
459 time the VAR_DECL was declared, the type was incomplete. */
461 static GTY(()) tree incomplete_vars;
463 #if defined(DEBUG_BINDING_LEVELS)
464 static int binding_depth = 0;
465 static int is_class_level = 0;
472 for (i = 0; i < binding_depth*2; i++)
475 #endif /* defined(DEBUG_BINDING_LEVELS) */
477 static tree pushdecl_with_scope (tree, struct cp_binding_level *);
480 push_binding_level (struct cp_binding_level *newlevel,
484 /* Add this level to the front of the chain (stack) of levels that
486 memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
487 newlevel->level_chain = current_binding_level;
488 current_binding_level = newlevel;
489 newlevel->tag_transparent = tag_transparent;
490 newlevel->more_cleanups_ok = 1;
492 newlevel->keep = keep;
493 #if defined(DEBUG_BINDING_LEVELS)
494 newlevel->binding_depth = binding_depth;
496 fprintf (stderr, "push %s level 0x%08x line %d\n",
497 (is_class_level) ? "class" : "block", newlevel, lineno);
500 #endif /* defined(DEBUG_BINDING_LEVELS) */
503 /* Find the innermost enclosing class scope, and reset
504 CLASS_BINDING_LEVEL appropriately. */
507 find_class_binding_level (void)
509 struct cp_binding_level *level = current_binding_level;
511 while (level && level->parm_flag != 2)
512 level = level->level_chain;
513 if (level && level->parm_flag == 2)
514 class_binding_level = level;
516 class_binding_level = 0;
520 pop_binding_level (void)
522 if (global_binding_level)
524 /* Cannot pop a level, if there are none left to pop. */
525 if (current_binding_level == global_binding_level)
528 /* Pop the current level, and free the structure for reuse. */
529 #if defined(DEBUG_BINDING_LEVELS)
532 fprintf (stderr, "pop %s level 0x%08x line %d\n",
533 (is_class_level) ? "class" : "block",
534 current_binding_level, lineno);
535 if (is_class_level != (current_binding_level == class_binding_level))
538 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
541 #endif /* defined(DEBUG_BINDING_LEVELS) */
543 register struct cp_binding_level *level = current_binding_level;
544 current_binding_level = current_binding_level->level_chain;
545 level->level_chain = free_binding_level;
546 #if 0 /* defined(DEBUG_BINDING_LEVELS) */
547 if (level->binding_depth != binding_depth)
549 #endif /* defined(DEBUG_BINDING_LEVELS) */
550 free_binding_level = level;
551 find_class_binding_level ();
556 suspend_binding_level (void)
558 if (class_binding_level)
559 current_binding_level = class_binding_level;
561 if (global_binding_level)
563 /* Cannot suspend a level, if there are none left to suspend. */
564 if (current_binding_level == global_binding_level)
567 /* Suspend the current level. */
568 #if defined(DEBUG_BINDING_LEVELS)
571 fprintf (stderr, "suspend %s level 0x%08x line %d\n",
572 (is_class_level) ? "class" : "block",
573 current_binding_level, lineno);
574 if (is_class_level != (current_binding_level == class_binding_level))
577 fprintf (stderr, "XXX is_class_level != (current_binding_level == class_binding_level)\n");
580 #endif /* defined(DEBUG_BINDING_LEVELS) */
581 current_binding_level = current_binding_level->level_chain;
582 find_class_binding_level ();
586 resume_binding_level (struct cp_binding_level* b)
588 /* Resuming binding levels is meant only for namespaces,
589 and those cannot nest into classes. */
590 my_friendly_assert(!class_binding_level, 386);
591 /* Also, resuming a non-directly nested namespace is a no-no. */
592 my_friendly_assert(b->level_chain == current_binding_level, 386);
593 current_binding_level = b;
594 #if defined(DEBUG_BINDING_LEVELS)
595 b->binding_depth = binding_depth;
597 fprintf (stderr, "resume %s level 0x%08x line %d\n",
598 (is_class_level) ? "class" : "block", b, lineno);
601 #endif /* defined(DEBUG_BINDING_LEVELS) */
604 /* Create a new `struct cp_binding_level'. */
607 struct cp_binding_level *
608 make_binding_level (void)
611 return (struct cp_binding_level *) ggc_alloc (sizeof (struct cp_binding_level));
614 /* Nonzero if we are currently in the global binding level. */
617 global_bindings_p (void)
619 return current_binding_level == global_binding_level;
622 /* Return the innermost binding level that is not for a class scope. */
624 static struct cp_binding_level *
625 innermost_nonclass_level (void)
627 struct cp_binding_level *b;
629 b = current_binding_level;
630 while (b->parm_flag == 2)
636 /* Nonzero if we are currently in a toplevel binding level. This
637 means either the global binding level or a namespace in a toplevel
638 binding level. Since there are no non-toplevel namespace levels,
639 this really means any namespace or template parameter level. We
640 also include a class whose context is toplevel. */
643 toplevel_bindings_p (void)
645 struct cp_binding_level *b = innermost_nonclass_level ();
647 return b->namespace_p || b->template_parms_p;
650 /* Nonzero if this is a namespace scope, or if we are defining a class
651 which is itself at namespace scope, or whose enclosing class is
652 such a class, etc. */
655 namespace_bindings_p (void)
657 struct cp_binding_level *b = innermost_nonclass_level ();
659 return b->namespace_p;
662 /* If KEEP is nonzero, make a BLOCK node for the next binding level,
663 unconditionally. Otherwise, use the normal logic to decide whether
664 or not to create a BLOCK. */
667 keep_next_level (int keep)
669 keep_next_level_flag = keep;
672 /* Nonzero if the current level needs to have a BLOCK made. */
677 return (current_binding_level->blocks != NULL_TREE
678 || current_binding_level->keep
679 || current_binding_level->names != NULL_TREE
680 || (current_binding_level->tags != NULL_TREE
681 && !current_binding_level->tag_transparent));
685 declare_namespace_level (void)
687 current_binding_level->namespace_p = 1;
690 /* Returns nonzero if this scope was created to store template
694 template_parm_scope_p (void)
696 return current_binding_level->template_parms_p;
699 /* Returns the kind of template specialization we are currently
700 processing, given that it's declaration contained N_CLASS_SCOPES
701 explicit scope qualifications. */
704 current_tmpl_spec_kind (int n_class_scopes)
706 int n_template_parm_scopes = 0;
707 int seen_specialization_p = 0;
708 int innermost_specialization_p = 0;
709 struct cp_binding_level *b;
711 /* Scan through the template parameter scopes. */
712 for (b = current_binding_level; b->template_parms_p; b = b->level_chain)
714 /* If we see a specialization scope inside a parameter scope,
715 then something is wrong. That corresponds to a declaration
718 template <class T> template <> ...
720 which is always invalid since [temp.expl.spec] forbids the
721 specialization of a class member template if the enclosing
722 class templates are not explicitly specialized as well. */
723 if (b->template_spec_p)
725 if (n_template_parm_scopes == 0)
726 innermost_specialization_p = 1;
728 seen_specialization_p = 1;
730 else if (seen_specialization_p == 1)
731 return tsk_invalid_member_spec;
733 ++n_template_parm_scopes;
736 /* Handle explicit instantiations. */
737 if (processing_explicit_instantiation)
739 if (n_template_parm_scopes != 0)
740 /* We've seen a template parameter list during an explicit
741 instantiation. For example:
743 template <class T> template void f(int);
745 This is erroneous. */
746 return tsk_invalid_expl_inst;
748 return tsk_expl_inst;
751 if (n_template_parm_scopes < n_class_scopes)
752 /* We've not seen enough template headers to match all the
753 specialized classes present. For example:
755 template <class T> void R<T>::S<T>::f(int);
757 This is invalid; there needs to be one set of template
758 parameters for each class. */
759 return tsk_insufficient_parms;
760 else if (n_template_parm_scopes == n_class_scopes)
761 /* We're processing a non-template declaration (even though it may
762 be a member of a template class.) For example:
764 template <class T> void S<T>::f(int);
766 The `class T' maches the `S<T>', leaving no template headers
767 corresponding to the `f'. */
769 else if (n_template_parm_scopes > n_class_scopes + 1)
770 /* We've got too many template headers. For example:
772 template <> template <class T> void f (T);
774 There need to be more enclosing classes. */
775 return tsk_excessive_parms;
777 /* This must be a template. It's of the form:
779 template <class T> template <class U> void S<T>::f(U);
781 This is a specialization if the innermost level was a
782 specialization; otherwise it's just a definition of the
784 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
788 set_class_shadows (tree shadows)
790 class_binding_level->class_shadowed = shadows;
793 /* Enter a new binding level.
794 If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
795 not for that of tags. */
798 pushlevel (int tag_transparent)
800 struct cp_binding_level *newlevel;
802 if (cfun && !doing_semantic_analysis_p ())
805 /* Reuse or create a struct for this binding level. */
806 #if defined(DEBUG_BINDING_LEVELS)
808 #else /* !defined(DEBUG_BINDING_LEVELS) */
809 if (free_binding_level)
810 #endif /* !defined(DEBUG_BINDING_LEVELS) */
812 newlevel = free_binding_level;
813 free_binding_level = free_binding_level->level_chain;
816 newlevel = make_binding_level ();
818 push_binding_level (newlevel, tag_transparent, keep_next_level_flag);
819 keep_next_level_flag = 0;
822 /* We're defining an object of type TYPE. If it needs a cleanup, but
823 we're not allowed to add any more objects with cleanups to the current
824 scope, create a new binding level. */
827 maybe_push_cleanup_level (tree type)
829 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
830 && current_binding_level->more_cleanups_ok == 0)
835 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
839 /* Enter a new scope. The KIND indicates what kind of scope is being
843 begin_scope (scope_kind sk)
853 current_binding_level->is_try_scope = 1;
857 current_binding_level->is_catch_scope = 1;
861 current_binding_level->is_for_scope = 1;
864 case sk_template_spec:
865 current_binding_level->template_spec_p = 1;
868 case sk_template_parms:
869 current_binding_level->template_parms_p = 1;
877 /* Exit the current scope. */
885 /* For a binding between a name and an entity at a block scope,
886 this is the `struct cp_binding_level' for the block. */
887 #define BINDING_LEVEL(NODE) \
888 (((struct tree_binding*)(NODE))->scope.level)
890 /* A free list of CPLUS_BINDING nodes, connected by their
893 static GTY((deletable (""))) tree free_bindings;
895 /* Make DECL the innermost binding for ID. The LEVEL is the binding
896 level at which this declaration is being bound. */
899 push_binding (tree id,
901 struct cp_binding_level* level)
907 binding = free_bindings;
908 free_bindings = TREE_CHAIN (binding);
911 binding = make_node (CPLUS_BINDING);
913 /* Now, fill in the binding information. */
914 BINDING_VALUE (binding) = decl;
915 BINDING_TYPE (binding) = NULL_TREE;
916 BINDING_LEVEL (binding) = level;
917 INHERITED_VALUE_BINDING_P (binding) = 0;
918 LOCAL_BINDING_P (binding) = (level != class_binding_level);
919 BINDING_HAS_LEVEL_P (binding) = 1;
921 /* And put it on the front of the list of bindings for ID. */
922 TREE_CHAIN (binding) = IDENTIFIER_BINDING (id);
923 IDENTIFIER_BINDING (id) = binding;
926 /* ID is already bound in the current scope. But, DECL is an
927 additional binding for ID in the same scope. This is the `struct
928 stat' hack whereby a non-typedef class-name or enum-name can be
929 bound at the same level as some other kind of entity. It's the
930 responsibility of the caller to check that inserting this name is
931 valid here. Returns nonzero if the new binding was successful. */
933 add_binding (tree id, tree decl)
935 tree binding = IDENTIFIER_BINDING (id);
938 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
939 /* The new name is the type name. */
940 BINDING_TYPE (binding) = decl;
941 else if (!BINDING_VALUE (binding))
942 /* This situation arises when push_class_level_binding moves an
943 inherited type-binding out of the way to make room for a new
945 BINDING_VALUE (binding) = decl;
946 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
947 && DECL_ARTIFICIAL (BINDING_VALUE (binding)))
949 /* The old binding was a type name. It was placed in
950 BINDING_VALUE because it was thought, at the point it was
951 declared, to be the only entity with such a name. Move the
952 type name into the type slot; it is now hidden by the new
954 BINDING_TYPE (binding) = BINDING_VALUE (binding);
955 BINDING_VALUE (binding) = decl;
956 INHERITED_VALUE_BINDING_P (binding) = 0;
958 else if (TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
959 && TREE_CODE (decl) == TYPE_DECL
960 && DECL_NAME (decl) == DECL_NAME (BINDING_VALUE (binding))
961 && (same_type_p (TREE_TYPE (decl),
962 TREE_TYPE (BINDING_VALUE (binding)))
963 /* If either type involves template parameters, we must
964 wait until instantiation. */
965 || uses_template_parms (TREE_TYPE (decl))
966 || uses_template_parms (TREE_TYPE (BINDING_VALUE (binding)))))
967 /* We have two typedef-names, both naming the same type to have
968 the same name. This is OK because of:
972 In a given scope, a typedef specifier can be used to redefine
973 the name of any type declared in that scope to refer to the
974 type to which it already refers. */
976 /* There can be two block-scope declarations of the same variable,
977 so long as they are `extern' declarations. */
978 else if (TREE_CODE (decl) == VAR_DECL
979 && TREE_CODE (BINDING_VALUE (binding)) == VAR_DECL
980 && DECL_EXTERNAL (decl)
981 && DECL_EXTERNAL (BINDING_VALUE (binding)))
983 duplicate_decls (decl, BINDING_VALUE (binding));
988 error ("declaration of `%#D'", decl);
989 cp_error_at ("conflicts with previous declaration `%#D'",
990 BINDING_VALUE (binding));
997 /* Add DECL to the list of things declared in B. */
1000 add_decl_to_level (tree decl,
1001 struct cp_binding_level* b)
1003 if (TREE_CODE (decl) == NAMESPACE_DECL
1004 && !DECL_NAMESPACE_ALIAS (decl))
1006 TREE_CHAIN (decl) = b->namespaces;
1007 b->namespaces = decl;
1009 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
1011 TREE_CHAIN (decl) = b->vtables;
1016 /* We build up the list in reverse order, and reverse it later if
1018 TREE_CHAIN (decl) = b->names;
1024 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1025 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1026 doesn't really belong to this binding level, that it got here
1027 through a using-declaration. */
1030 push_local_binding (tree id, tree decl, int flags)
1032 struct cp_binding_level *b;
1034 /* Skip over any local classes. This makes sense if we call
1035 push_local_binding with a friend decl of a local class. */
1036 b = current_binding_level;
1037 while (b->parm_flag == 2)
1040 if (lookup_name_current_level (id))
1042 /* Supplement the existing binding. */
1043 if (!add_binding (id, decl))
1044 /* It didn't work. Something else must be bound at this
1045 level. Do not add DECL to the list of things to pop
1050 /* Create a new binding. */
1051 push_binding (id, decl, b);
1053 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1054 /* We must put the OVERLOAD into a TREE_LIST since the
1055 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1056 decls that got here through a using-declaration. */
1057 decl = build_tree_list (NULL_TREE, decl);
1059 /* And put DECL on the list of things declared by the current
1061 add_decl_to_level (decl, b);
1064 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
1065 binding was successful. */
1068 push_class_binding (tree id, tree decl)
1071 tree binding = IDENTIFIER_BINDING (id);
1074 /* Note that we declared this value so that we can issue an error if
1075 this is an invalid redeclaration of a name already used for some
1077 note_name_declared_in_class (id, decl);
1079 if (binding && BINDING_LEVEL (binding) == class_binding_level)
1080 /* Supplement the existing binding. */
1081 result = add_binding (id, decl);
1083 /* Create a new binding. */
1084 push_binding (id, decl, class_binding_level);
1086 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
1087 class-level declaration. Note that we do not use DECL here
1088 because of the possibility of the `struct stat' hack; if DECL is
1089 a class-name or enum-name we might prefer a field-name, or some
1091 IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
1093 /* If this is a binding from a base class, mark it as such. */
1094 binding = IDENTIFIER_BINDING (id);
1095 if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
1097 if (TREE_CODE (decl) == OVERLOAD)
1098 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
1101 my_friendly_assert (DECL_P (decl), 0);
1102 context = context_for_name_lookup (decl);
1105 if (is_properly_derived_from (current_class_type, context))
1106 INHERITED_VALUE_BINDING_P (binding) = 1;
1108 INHERITED_VALUE_BINDING_P (binding) = 0;
1110 else if (BINDING_VALUE (binding) == decl)
1111 /* We only encounter a TREE_LIST when push_class_decls detects an
1112 ambiguity. Such an ambiguity can be overridden by a definition
1114 INHERITED_VALUE_BINDING_P (binding) = 1;
1119 /* Remove the binding for DECL which should be the innermost binding
1123 pop_binding (tree id, tree decl)
1127 if (id == NULL_TREE)
1128 /* It's easiest to write the loops that call this function without
1129 checking whether or not the entities involved have names. We
1130 get here for such an entity. */
1133 /* Get the innermost binding for ID. */
1134 binding = IDENTIFIER_BINDING (id);
1136 /* The name should be bound. */
1137 my_friendly_assert (binding != NULL_TREE, 0);
1139 /* The DECL will be either the ordinary binding or the type
1140 binding for this identifier. Remove that binding. */
1141 if (BINDING_VALUE (binding) == decl)
1142 BINDING_VALUE (binding) = NULL_TREE;
1143 else if (BINDING_TYPE (binding) == decl)
1144 BINDING_TYPE (binding) = NULL_TREE;
1148 if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
1150 /* We're completely done with the innermost binding for this
1151 identifier. Unhook it from the list of bindings. */
1152 IDENTIFIER_BINDING (id) = TREE_CHAIN (binding);
1154 /* Add it to the free list. */
1155 TREE_CHAIN (binding) = free_bindings;
1156 free_bindings = binding;
1158 /* Clear the BINDING_LEVEL so the garbage collector doesn't walk
1160 BINDING_LEVEL (binding) = NULL;
1164 /* When a label goes out of scope, check to see if that label was used
1165 in a valid manner, and issue any appropriate warnings or errors. */
1168 pop_label (tree label, tree old_value)
1170 if (!processing_template_decl && doing_semantic_analysis_p ())
1172 if (DECL_INITIAL (label) == NULL_TREE)
1174 cp_error_at ("label `%D' used but not defined", label);
1175 /* Avoid crashing later. */
1176 define_label (input_filename, 1, DECL_NAME (label));
1178 else if (warn_unused_label && !TREE_USED (label))
1179 cp_warning_at ("label `%D' defined but not used", label);
1182 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
1185 /* At the end of a function, all labels declared within the function
1186 go out of scope. BLOCK is the top-level block for the
1190 pop_labels (tree block)
1192 struct named_label_list *link;
1194 /* Clear out the definitions of all label names, since their scopes
1196 for (link = named_labels; link; link = link->next)
1198 pop_label (link->label_decl, link->old_value);
1199 /* Put the labels into the "variables" of the top-level block,
1200 so debugger can see them. */
1201 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
1202 BLOCK_VARS (block) = link->label_decl;
1205 named_labels = NULL;
1208 /* Exit a binding level.
1209 Pop the level off, and restore the state of the identifier-decl mappings
1210 that were in effect when this level was entered.
1212 If KEEP == 1, this level had explicit declarations, so
1213 and create a "block" (a BLOCK node) for the level
1214 to record its declarations and subblocks for symbol table output.
1216 If FUNCTIONBODY is nonzero, this level is the body of a function,
1217 so create a block as if KEEP were set and also clear out all
1220 If REVERSE is nonzero, reverse the order of decls before putting
1221 them into the BLOCK. */
1224 poplevel (int keep, int reverse, int functionbody)
1227 /* The chain of decls was accumulated in reverse order.
1228 Put it into forward order, just for cleanliness. */
1230 int tmp = functionbody;
1231 int real_functionbody;
1234 tree block = NULL_TREE;
1236 int leaving_for_scope;
1238 if (cfun && !doing_semantic_analysis_p ())
1241 my_friendly_assert (current_binding_level->parm_flag != 2,
1244 real_functionbody = (current_binding_level->keep == 2
1245 ? ((functionbody = 0), tmp) : functionbody);
1246 tags = functionbody >= 0 ? current_binding_level->tags : 0;
1247 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
1249 my_friendly_assert (!current_binding_level->class_shadowed,
1252 /* We used to use KEEP == 2 to indicate that the new block should go
1253 at the beginning of the list of blocks at this binding level,
1254 rather than the end. This hack is no longer used. */
1255 my_friendly_assert (keep == 0 || keep == 1, 0);
1257 if (current_binding_level->keep == 1)
1260 /* Any uses of undefined labels, and any defined labels, now operate
1261 under constraints of next binding contour. */
1262 if (cfun && !functionbody)
1264 struct cp_binding_level *level_chain;
1265 level_chain = current_binding_level->level_chain;
1268 struct named_label_use_list *uses;
1269 struct named_label_list *labels;
1270 for (labels = named_labels; labels; labels = labels->next)
1271 if (labels->binding_level == current_binding_level)
1274 if (current_binding_level->is_try_scope)
1275 labels->in_try_scope = 1;
1276 if (current_binding_level->is_catch_scope)
1277 labels->in_catch_scope = 1;
1278 for (decl = labels->names_in_scope; decl;
1279 decl = TREE_CHAIN (decl))
1280 if (decl_jump_unsafe (decl))
1281 labels->bad_decls = tree_cons (NULL_TREE, decl,
1283 labels->binding_level = level_chain;
1284 labels->names_in_scope = level_chain->names;
1287 for (uses = named_label_uses; uses; uses = uses->next)
1288 if (uses->binding_level == current_binding_level)
1290 uses->binding_level = level_chain;
1291 uses->names_in_scope = level_chain->names;
1296 /* Get the decls in the order they were written.
1297 Usually current_binding_level->names is in reverse order.
1298 But parameter decls were previously put in forward order. */
1301 current_binding_level->names
1302 = decls = nreverse (current_binding_level->names);
1304 decls = current_binding_level->names;
1306 /* Output any nested inline functions within this block
1307 if they weren't already output. */
1308 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1309 if (TREE_CODE (decl) == FUNCTION_DECL
1310 && ! TREE_ASM_WRITTEN (decl)
1311 && DECL_INITIAL (decl) != NULL_TREE
1312 && TREE_ADDRESSABLE (decl)
1313 && decl_function_context (decl) == current_function_decl)
1315 /* If this decl was copied from a file-scope decl
1316 on account of a block-scope extern decl,
1317 propagate TREE_ADDRESSABLE to the file-scope decl. */
1318 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
1319 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1322 push_function_context ();
1323 output_inline_function (decl);
1324 pop_function_context ();
1328 /* When not in function-at-a-time mode, expand_end_bindings will
1329 warn about unused variables. But, in function-at-a-time mode
1330 expand_end_bindings is not passed the list of variables in the
1331 current scope, and therefore no warning is emitted. So, we
1332 explicitly warn here. */
1333 if (!processing_template_decl)
1334 warn_about_unused_variables (getdecls ());
1336 /* If there were any declarations or structure tags in that level,
1337 or if this level is a function body,
1338 create a BLOCK to record them for the life of this function. */
1340 if (keep == 1 || functionbody)
1341 block = make_node (BLOCK);
1342 if (block != NULL_TREE)
1344 BLOCK_VARS (block) = decls;
1345 BLOCK_SUBBLOCKS (block) = subblocks;
1348 /* In each subblock, record that this is its superior. */
1350 for (link = subblocks; link; link = TREE_CHAIN (link))
1351 BLOCK_SUPERCONTEXT (link) = block;
1353 /* We still support the old for-scope rules, whereby the variables
1354 in a for-init statement were in scope after the for-statement
1355 ended. We only use the new rules if flag_new_for_scope is
1358 = current_binding_level->is_for_scope && flag_new_for_scope == 1;
1360 /* Remove declarations for all the DECLs in this level. */
1361 for (link = decls; link; link = TREE_CHAIN (link))
1363 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
1364 && DECL_NAME (link))
1367 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (link)));
1371 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
1373 ns_binding = NULL_TREE;
1376 && (BINDING_LEVEL (outer_binding)
1377 == current_binding_level->level_chain))
1378 /* We have something like:
1383 and we are leaving the `for' scope. There's no reason to
1384 keep the binding of the inner `i' in this case. */
1385 pop_binding (DECL_NAME (link), link);
1386 else if ((outer_binding
1387 && (TREE_CODE (BINDING_VALUE (outer_binding))
1390 && TREE_CODE (ns_binding) == TYPE_DECL))
1391 /* Here, we have something like:
1399 We must pop the for-scope binding so we know what's a
1400 type and what isn't. */
1401 pop_binding (DECL_NAME (link), link);
1404 /* Mark this VAR_DECL as dead so that we can tell we left it
1405 there only for backward compatibility. */
1406 DECL_DEAD_FOR_LOCAL (link) = 1;
1408 /* Keep track of what should of have happenned when we
1409 popped the binding. */
1410 if (outer_binding && BINDING_VALUE (outer_binding))
1411 DECL_SHADOWED_FOR_VAR (link)
1412 = BINDING_VALUE (outer_binding);
1414 /* Add it to the list of dead variables in the next
1415 outermost binding to that we can remove these when we
1416 leave that binding. */
1417 current_binding_level->level_chain->dead_vars_from_for
1418 = tree_cons (NULL_TREE, link,
1419 current_binding_level->level_chain->
1420 dead_vars_from_for);
1422 /* Although we don't pop the CPLUS_BINDING, we do clear
1423 its BINDING_LEVEL since the level is going away now. */
1424 BINDING_LEVEL (IDENTIFIER_BINDING (DECL_NAME (link)))
1430 /* Remove the binding. */
1432 if (TREE_CODE (decl) == TREE_LIST)
1433 decl = TREE_VALUE (decl);
1435 pop_binding (DECL_NAME (decl), decl);
1436 else if (TREE_CODE (decl) == OVERLOAD)
1437 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
1443 /* Remove declarations for any `for' variables from inner scopes
1444 that we kept around. */
1445 for (link = current_binding_level->dead_vars_from_for;
1446 link; link = TREE_CHAIN (link))
1447 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
1449 /* Restore the IDENTIFIER_TYPE_VALUEs. */
1450 for (link = current_binding_level->type_shadowed;
1451 link; link = TREE_CHAIN (link))
1452 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
1454 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
1455 for (link = current_binding_level->shadowed_labels;
1457 link = TREE_CHAIN (link))
1458 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
1460 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
1461 list if a `using' declaration put them there. The debugging
1462 back-ends won't understand OVERLOAD, so we remove them here.
1463 Because the BLOCK_VARS are (temporarily) shared with
1464 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
1465 popped all the bindings. */
1470 for (d = &BLOCK_VARS (block); *d; )
1472 if (TREE_CODE (*d) == TREE_LIST)
1473 *d = TREE_CHAIN (*d);
1475 d = &TREE_CHAIN (*d);
1479 /* If the level being exited is the top level of a function,
1480 check over all the labels. */
1483 /* Since this is the top level block of a function, the vars are
1484 the function's parameters. Don't leave them in the BLOCK
1485 because they are found in the FUNCTION_DECL instead. */
1486 BLOCK_VARS (block) = 0;
1490 tmp = current_binding_level->keep;
1492 pop_binding_level ();
1494 DECL_INITIAL (current_function_decl) = block;
1496 current_binding_level->blocks
1497 = chainon (current_binding_level->blocks, block);
1499 /* If we did not make a block for the level just exited,
1500 any blocks made for inner levels
1501 (since they cannot be recorded as subblocks in that level)
1502 must be carried forward so they will later become subblocks
1503 of something else. */
1505 current_binding_level->blocks
1506 = chainon (current_binding_level->blocks, subblocks);
1508 /* Each and every BLOCK node created here in `poplevel' is important
1509 (e.g. for proper debugging information) so if we created one
1510 earlier, mark it as "used". */
1512 TREE_USED (block) = 1;
1514 /* Take care of compiler's internal binding structures. */
1520 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
1523 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
1524 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
1527 block = poplevel (keep, reverse, functionbody);
1533 /* Delete the node BLOCK from the current binding level.
1534 This is used for the block inside a stmt expr ({...})
1535 so that the block can be reinserted where appropriate. */
1538 delete_block (tree block)
1541 if (current_binding_level->blocks == block)
1542 current_binding_level->blocks = TREE_CHAIN (block);
1543 for (t = current_binding_level->blocks; t;)
1545 if (TREE_CHAIN (t) == block)
1546 TREE_CHAIN (t) = TREE_CHAIN (block);
1550 TREE_CHAIN (block) = NULL_TREE;
1551 /* Clear TREE_USED which is always set by poplevel.
1552 The flag is set again if insert_block is called. */
1553 TREE_USED (block) = 0;
1556 /* Insert BLOCK at the end of the list of subblocks of the
1557 current binding level. This is used when a BIND_EXPR is expanded,
1558 to handle the BLOCK node inside the BIND_EXPR. */
1561 insert_block (tree block)
1563 TREE_USED (block) = 1;
1564 current_binding_level->blocks
1565 = chainon (current_binding_level->blocks, block);
1568 /* Set the BLOCK node for the innermost scope
1569 (the one we are currently in). */
1572 set_block (tree block ATTRIBUTE_UNUSED )
1574 /* The RTL expansion machinery requires us to provide this callback,
1575 but it is not applicable in function-at-a-time mode. */
1576 my_friendly_assert (cfun && !doing_semantic_analysis_p (), 20000911);
1579 /* Do a pushlevel for class declarations. */
1582 pushlevel_class (void)
1584 register struct cp_binding_level *newlevel;
1586 /* Reuse or create a struct for this binding level. */
1587 #if defined(DEBUG_BINDING_LEVELS)
1589 #else /* !defined(DEBUG_BINDING_LEVELS) */
1590 if (free_binding_level)
1591 #endif /* !defined(DEBUG_BINDING_LEVELS) */
1593 newlevel = free_binding_level;
1594 free_binding_level = free_binding_level->level_chain;
1597 newlevel = make_binding_level ();
1599 #if defined(DEBUG_BINDING_LEVELS)
1601 #endif /* defined(DEBUG_BINDING_LEVELS) */
1603 push_binding_level (newlevel, 0, 0);
1605 class_binding_level = current_binding_level;
1606 class_binding_level->parm_flag = 2;
1607 class_binding_level->this_class = current_class_type;
1610 /* ...and a poplevel for class declarations. */
1613 poplevel_class (void)
1615 register struct cp_binding_level *level = class_binding_level;
1618 my_friendly_assert (level != 0, 354);
1620 /* If we're leaving a toplevel class, don't bother to do the setting
1621 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
1622 shouldn't even be used when current_class_type isn't set, and second,
1623 if we don't touch it here, we're able to use the cache effect if the
1624 next time we're entering a class scope, it is the same class. */
1625 if (current_class_depth != 1)
1627 struct cp_binding_level* b;
1629 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
1630 for (shadowed = level->class_shadowed;
1632 shadowed = TREE_CHAIN (shadowed))
1633 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
1635 /* Find the next enclosing class, and recreate
1636 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
1637 b = level->level_chain;
1638 while (b && b->parm_flag != 2)
1642 for (shadowed = b->class_shadowed;
1644 shadowed = TREE_CHAIN (shadowed))
1648 t = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
1649 while (t && BINDING_LEVEL (t) != b)
1653 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
1654 = BINDING_VALUE (t);
1658 /* Remember to save what IDENTIFIER's were bound in this scope so we
1659 can recover from cache misses. */
1661 previous_class_type = current_class_type;
1662 previous_class_values = class_binding_level->class_shadowed;
1664 for (shadowed = level->type_shadowed;
1666 shadowed = TREE_CHAIN (shadowed))
1667 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
1669 /* Remove the bindings for all of the class-level declarations. */
1670 for (shadowed = level->class_shadowed;
1672 shadowed = TREE_CHAIN (shadowed))
1673 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
1675 /* Now, pop out of the binding level which we created up in the
1676 `pushlevel_class' routine. */
1677 #if defined(DEBUG_BINDING_LEVELS)
1679 #endif /* defined(DEBUG_BINDING_LEVELS) */
1681 pop_binding_level ();
1684 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
1685 for any names in enclosing classes. */
1688 clear_identifier_class_values (void)
1692 if (!class_binding_level)
1695 for (t = class_binding_level->class_shadowed;
1698 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
1701 /* Returns nonzero if T is a virtual function table. */
1704 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
1706 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
1709 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
1713 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
1715 return (TREE_CODE (t) == TYPE_DECL
1716 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1717 && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
1720 /* Return the declarations that are members of the namespace NS. */
1723 cp_namespace_decls (tree ns)
1725 return NAMESPACE_LEVEL (ns)->names;
1728 struct walk_globals_data {
1729 walk_globals_pred p;
1734 /* Walk the vtable declarations in NAMESPACE. Whenever one is found
1735 for which P returns nonzero, call F with its address. If any call
1736 to F returns a nonzero value, return a nonzero value. */
1739 walk_vtables_r (tree namespace, void* data)
1741 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1742 walk_globals_fn f = wgd->f;
1743 void *d = wgd->data;
1744 tree decl = NAMESPACE_LEVEL (namespace)->vtables;
1747 for (; decl ; decl = TREE_CHAIN (decl))
1748 result |= (*f) (&decl, d);
1753 /* Walk the vtable declarations. Whenever one is found for which P
1754 returns nonzero, call F with its address. If any call to F
1755 returns a nonzero value, return a nonzero value. */
1757 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
1759 struct walk_globals_data wgd;
1764 return walk_namespaces (walk_vtables_r, &wgd);
1767 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
1768 itself, calling F for each. The DATA is passed to F as well. */
1771 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
1774 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
1776 result |= (*f) (namespace, data);
1778 for (; current; current = TREE_CHAIN (current))
1779 result |= walk_namespaces_r (current, f, data);
1784 /* Walk all the namespaces, calling F for each. The DATA is passed to
1788 walk_namespaces (walk_namespaces_fn f, void* data)
1790 return walk_namespaces_r (global_namespace, f, data);
1793 /* Walk the global declarations in NAMESPACE. Whenever one is found
1794 for which P returns nonzero, call F with its address. If any call
1795 to F returns a nonzero value, return a nonzero value. */
1798 walk_globals_r (tree namespace, void* data)
1800 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
1801 walk_globals_pred p = wgd->p;
1802 walk_globals_fn f = wgd->f;
1803 void *d = wgd->data;
1807 t = &NAMESPACE_LEVEL (namespace)->names;
1814 result |= (*f) (t, d);
1816 /* If F changed *T, then *T still points at the next item to
1819 t = &TREE_CHAIN (*t);
1825 /* Walk the global declarations. Whenever one is found for which P
1826 returns true, call F with its address. If any call to F
1827 returns true, return true. */
1830 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
1832 struct walk_globals_data wgd;
1837 return walk_namespaces (walk_globals_r, &wgd);
1840 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
1841 DATA is non-NULL, this is the last time we will call
1842 wrapup_global_declarations for this NAMESPACE. */
1845 wrapup_globals_for_namespace (tree namespace, void* data)
1847 tree globals = cp_namespace_decls (namespace);
1848 int len = NAMESPACE_LEVEL (namespace)->names_size;
1849 tree *vec = (tree *) alloca (sizeof (tree) * len);
1853 int last_time = (data != 0);
1855 if (last_time && namespace == global_namespace)
1856 /* Let compile_file handle the global namespace. */
1859 /* Process the decls in reverse order--earliest first.
1860 Put them into VEC from back to front, then take out from front. */
1861 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
1862 vec[len - i - 1] = decl;
1866 check_global_declarations (vec, len);
1870 /* Write out any globals that need to be output. */
1871 result = wrapup_global_declarations (vec, len);
1877 /* For debugging. */
1878 static int no_print_functions = 0;
1879 static int no_print_builtins = 0;
1882 print_binding_level (struct cp_binding_level* lvl)
1886 fprintf (stderr, " blocks=");
1887 fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
1888 if (lvl->tag_transparent)
1889 fprintf (stderr, " tag-transparent");
1890 if (lvl->more_cleanups_ok)
1891 fprintf (stderr, " more-cleanups-ok");
1892 if (lvl->have_cleanups)
1893 fprintf (stderr, " have-cleanups");
1894 fprintf (stderr, "\n");
1897 fprintf (stderr, " names:\t");
1898 /* We can probably fit 3 names to a line? */
1899 for (t = lvl->names; t; t = TREE_CHAIN (t))
1901 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1903 if (no_print_builtins
1904 && (TREE_CODE (t) == TYPE_DECL)
1905 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1908 /* Function decls tend to have longer names. */
1909 if (TREE_CODE (t) == FUNCTION_DECL)
1916 fprintf (stderr, "\n\t");
1919 print_node_brief (stderr, "", t, 0);
1920 if (t == error_mark_node)
1924 fprintf (stderr, "\n");
1928 fprintf (stderr, " tags:\t");
1930 for (t = lvl->tags; t; t = TREE_CHAIN (t))
1932 if (TREE_PURPOSE (t) == NULL_TREE)
1934 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1941 fprintf (stderr, "\n\t");
1944 if (TREE_PURPOSE (t) == NULL_TREE)
1946 print_node_brief (stderr, "<unnamed-typedef", TREE_VALUE (t), 0);
1947 fprintf (stderr, ">");
1949 else if (TREE_PURPOSE (t) == TYPE_IDENTIFIER (TREE_VALUE (t)))
1950 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1953 print_node_brief (stderr, "<typedef", TREE_PURPOSE (t), 0);
1954 print_node_brief (stderr, "", TREE_VALUE (t), 0);
1955 fprintf (stderr, ">");
1959 fprintf (stderr, "\n");
1961 if (lvl->class_shadowed)
1963 fprintf (stderr, " class-shadowed:");
1964 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1966 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1968 fprintf (stderr, "\n");
1970 if (lvl->type_shadowed)
1972 fprintf (stderr, " type-shadowed:");
1973 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1975 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1977 fprintf (stderr, "\n");
1982 print_other_binding_stack (struct cp_binding_level *stack)
1984 struct cp_binding_level *level;
1985 for (level = stack; level != global_binding_level; level = level->level_chain)
1987 fprintf (stderr, "binding level ");
1988 fprintf (stderr, HOST_PTR_PRINTF, level);
1989 fprintf (stderr, "\n");
1990 print_binding_level (level);
1995 print_binding_stack (void)
1997 struct cp_binding_level *b;
1998 fprintf (stderr, "current_binding_level=");
1999 fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
2000 fprintf (stderr, "\nclass_binding_level=");
2001 fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
2002 fprintf (stderr, "\nglobal_binding_level=");
2003 fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
2004 fprintf (stderr, "\n");
2005 if (class_binding_level)
2007 for (b = class_binding_level; b; b = b->level_chain)
2008 if (b == current_binding_level)
2011 b = class_binding_level;
2013 b = current_binding_level;
2016 b = current_binding_level;
2017 print_other_binding_stack (b);
2018 fprintf (stderr, "global:\n");
2019 print_binding_level (global_binding_level);
2022 /* Namespace binding access routines: The namespace_bindings field of
2023 the identifier is polymorphic, with three possible values:
2024 NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
2025 indicating the BINDING_VALUE of global_namespace. */
2027 /* Check whether the a binding for the name to scope is known.
2028 Assumes that the bindings of the name are already a list
2029 of bindings. Returns the binding found, or NULL_TREE. */
2032 find_binding (tree name, tree scope)
2034 tree iter, prev = NULL_TREE;
2036 scope = ORIGINAL_NAMESPACE (scope);
2038 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name); iter;
2039 iter = TREE_CHAIN (iter))
2041 my_friendly_assert (TREE_CODE (iter) == CPLUS_BINDING, 374);
2042 if (BINDING_SCOPE (iter) == scope)
2044 /* Move binding found to the front of the list, so
2045 subsequent lookups will find it faster. */
2048 TREE_CHAIN (prev) = TREE_CHAIN (iter);
2049 TREE_CHAIN (iter) = IDENTIFIER_NAMESPACE_BINDINGS (name);
2050 IDENTIFIER_NAMESPACE_BINDINGS (name) = iter;
2059 /* Always returns a binding for name in scope. If the
2060 namespace_bindings is not a list, convert it to one first.
2061 If no binding is found, make a new one. */
2064 binding_for_name (tree name, tree scope)
2066 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2069 scope = ORIGINAL_NAMESPACE (scope);
2071 if (b && TREE_CODE (b) != CPLUS_BINDING)
2073 /* Get rid of optimization for global scope. */
2074 IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
2075 BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
2076 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2078 if (b && (result = find_binding (name, scope)))
2080 /* Not found, make a new one. */
2081 result = make_node (CPLUS_BINDING);
2082 TREE_CHAIN (result) = b;
2083 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2084 BINDING_SCOPE (result) = scope;
2085 BINDING_TYPE (result) = NULL_TREE;
2086 BINDING_VALUE (result) = NULL_TREE;
2090 /* Return the binding value for name in scope, considering that
2091 namespace_binding may or may not be a list of CPLUS_BINDINGS. */
2094 namespace_binding (tree name, tree scope)
2096 tree b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2099 if (scope == NULL_TREE)
2100 scope = global_namespace;
2101 if (TREE_CODE (b) != CPLUS_BINDING)
2102 return (scope == global_namespace) ? b : NULL_TREE;
2103 name = find_binding (name,scope);
2104 if (name == NULL_TREE)
2106 return BINDING_VALUE (name);
2109 /* Set the binding value for name in scope. If modifying the binding
2110 of global_namespace is attempted, try to optimize it. */
2113 set_namespace_binding (tree name, tree scope, tree val)
2117 if (scope == NULL_TREE)
2118 scope = global_namespace;
2120 if (scope == global_namespace)
2122 b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2123 if (b == NULL_TREE || TREE_CODE (b) != CPLUS_BINDING)
2125 IDENTIFIER_NAMESPACE_BINDINGS (name) = val;
2129 b = binding_for_name (name, scope);
2130 BINDING_VALUE (b) = val;
2133 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2134 select a name that is unique to this compilation unit. */
2137 push_namespace (tree name)
2141 int implicit_use = 0;
2143 if (!global_namespace)
2145 /* This must be ::. */
2146 my_friendly_assert (name == get_identifier ("::"), 377);
2151 /* The name of anonymous namespace is unique for the translation
2153 if (!anonymous_namespace_name)
2154 anonymous_namespace_name = get_file_function_name ('N');
2155 name = anonymous_namespace_name;
2156 d = IDENTIFIER_NAMESPACE_VALUE (name);
2158 /* Reopening anonymous namespace. */
2164 /* Check whether this is an extended namespace definition. */
2165 d = IDENTIFIER_NAMESPACE_VALUE (name);
2166 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2169 if (DECL_NAMESPACE_ALIAS (d))
2171 error ("namespace alias `%D' not allowed here, assuming `%D'",
2172 d, DECL_NAMESPACE_ALIAS (d));
2173 d = DECL_NAMESPACE_ALIAS (d);
2180 /* Make a new namespace, binding the name to it. */
2181 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2182 /* The global namespace is not pushed, and the global binding
2183 level is set elsewhere. */
2186 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2189 declare_namespace_level ();
2190 NAMESPACE_LEVEL (d) = current_binding_level;
2194 resume_binding_level (NAMESPACE_LEVEL (d));
2197 do_using_directive (d);
2198 /* Enter the name space. */
2199 current_namespace = d;
2202 /* Pop from the scope of the current namespace. */
2205 pop_namespace (void)
2207 my_friendly_assert (current_namespace != global_namespace, 20010801);
2208 current_namespace = CP_DECL_CONTEXT (current_namespace);
2209 /* The binding level is not popped, as it might be re-opened later. */
2210 suspend_binding_level ();
2213 /* Push into the scope of the namespace NS, even if it is deeply
2214 nested within another namespace. */
2217 push_nested_namespace (tree ns)
2219 if (ns == global_namespace)
2220 push_to_top_level ();
2223 push_nested_namespace (CP_DECL_CONTEXT (ns));
2224 push_namespace (DECL_NAME (ns));
2228 /* Pop back from the scope of the namespace NS, which was previously
2229 entered with push_nested_namespace. */
2232 pop_nested_namespace (tree ns)
2234 while (ns != global_namespace)
2237 ns = CP_DECL_CONTEXT (ns);
2240 pop_from_top_level ();
2244 /* Subroutines for reverting temporarily to top-level for instantiation
2245 of templates and such. We actually need to clear out the class- and
2246 local-value slots of all identifiers, so that only the global values
2247 are at all visible. Simply setting current_binding_level to the global
2248 scope isn't enough, because more binding levels may be pushed. */
2249 struct saved_scope *scope_chain;
2252 store_bindings (tree names, tree old_bindings)
2255 tree search_bindings = old_bindings;
2257 for (t = names; t; t = TREE_CHAIN (t))
2259 tree binding, t1, id;
2261 if (TREE_CODE (t) == TREE_LIST)
2262 id = TREE_PURPOSE (t);
2267 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
2268 we have no IDENTIFIER_BINDING if we have left the class
2269 scope, but cached the class-level declarations. */
2270 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
2273 for (t1 = search_bindings; t1; t1 = TREE_CHAIN (t1))
2274 if (TREE_VEC_ELT (t1, 0) == id)
2277 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
2278 binding = make_tree_vec (4);
2279 TREE_VEC_ELT (binding, 0) = id;
2280 TREE_VEC_ELT (binding, 1) = REAL_IDENTIFIER_TYPE_VALUE (id);
2281 TREE_VEC_ELT (binding, 2) = IDENTIFIER_BINDING (id);
2282 TREE_VEC_ELT (binding, 3) = IDENTIFIER_CLASS_VALUE (id);
2283 IDENTIFIER_BINDING (id) = NULL_TREE;
2284 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
2285 TREE_CHAIN (binding) = old_bindings;
2286 old_bindings = binding;
2290 return old_bindings;
2294 maybe_push_to_top_level (int pseudo)
2296 struct saved_scope *s;
2297 struct cp_binding_level *b;
2301 s = (struct saved_scope *) ggc_alloc_cleared (sizeof (struct saved_scope));
2303 b = scope_chain ? current_binding_level : 0;
2305 /* If we're in the middle of some function, save our state. */
2309 push_function_context_to (NULL_TREE);
2314 old_bindings = NULL_TREE;
2315 if (scope_chain && previous_class_type)
2316 old_bindings = store_bindings (previous_class_values, old_bindings);
2318 /* Have to include global_binding_level, because class-level decls
2319 aren't listed anywhere useful. */
2320 for (; b; b = b->level_chain)
2324 /* Template IDs are inserted into the global level. If they were
2325 inserted into namespace level, finish_file wouldn't find them
2326 when doing pending instantiations. Therefore, don't stop at
2327 namespace level, but continue until :: . */
2328 if (b == global_binding_level || (pseudo && b->template_parms_p))
2331 old_bindings = store_bindings (b->names, old_bindings);
2332 /* We also need to check class_shadowed to save class-level type
2333 bindings, since pushclass doesn't fill in b->names. */
2334 if (b->parm_flag == 2)
2335 old_bindings = store_bindings (b->class_shadowed, old_bindings);
2337 /* Unwind type-value slots back to top level. */
2338 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
2339 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
2341 s->prev = scope_chain;
2342 s->old_bindings = old_bindings;
2344 s->need_pop_function_context = need_pop;
2345 s->function_decl = current_function_decl;
2346 s->last_parms = last_function_parms;
2347 s->check_access = flag_access_control;
2350 current_function_decl = NULL_TREE;
2351 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
2352 current_lang_name = lang_name_cplusplus;
2353 current_namespace = global_namespace;
2357 push_to_top_level (void)
2359 maybe_push_to_top_level (0);
2363 pop_from_top_level (void)
2365 struct saved_scope *s = scope_chain;
2368 /* Clear out class-level bindings cache. */
2369 if (previous_class_type)
2370 invalidate_class_lookup_cache ();
2372 current_lang_base = 0;
2374 scope_chain = s->prev;
2375 for (t = s->old_bindings; t; t = TREE_CHAIN (t))
2377 tree id = TREE_VEC_ELT (t, 0);
2379 SET_IDENTIFIER_TYPE_VALUE (id, TREE_VEC_ELT (t, 1));
2380 IDENTIFIER_BINDING (id) = TREE_VEC_ELT (t, 2);
2381 IDENTIFIER_CLASS_VALUE (id) = TREE_VEC_ELT (t, 3);
2384 /* If we were in the middle of compiling a function, restore our
2386 if (s->need_pop_function_context)
2387 pop_function_context_from (NULL_TREE);
2388 current_function_decl = s->function_decl;
2389 last_function_parms = s->last_parms;
2392 /* Push a definition of struct, union or enum tag "name".
2393 into binding_level "b". "type" should be the type node,
2394 We assume that the tag "name" is not already defined.
2396 Note that the definition may really be just a forward reference.
2397 In that case, the TYPE_SIZE will be a NULL_TREE.
2399 C++ gratuitously puts all these tags in the name space. */
2401 /* When setting the IDENTIFIER_TYPE_VALUE field of an identifier ID,
2402 record the shadowed value for this binding contour. TYPE is
2403 the type that ID maps to. */
2406 set_identifier_type_value_with_scope (tree id,
2408 struct cp_binding_level* b)
2410 if (!b->namespace_p)
2412 /* Shadow the marker, not the real thing, so that the marker
2413 gets restored later. */
2414 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
2416 = tree_cons (id, old_type_value, b->type_shadowed);
2420 tree binding = binding_for_name (id, current_namespace);
2421 BINDING_TYPE (binding) = type;
2422 /* Store marker instead of real type. */
2423 type = global_type_node;
2425 SET_IDENTIFIER_TYPE_VALUE (id, type);
2428 /* As set_identifier_type_value_with_scope, but using current_binding_level. */
2431 set_identifier_type_value (tree id, tree type)
2433 set_identifier_type_value_with_scope (id, type, current_binding_level);
2436 /* Return the type associated with id. */
2439 identifier_type_value (tree id)
2441 /* There is no type with that name, anywhere. */
2442 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
2444 /* This is not the type marker, but the real thing. */
2445 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
2446 return REAL_IDENTIFIER_TYPE_VALUE (id);
2447 /* Have to search for it. It must be on the global level, now.
2448 Ask lookup_name not to return non-types. */
2449 id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
2451 return TREE_TYPE (id);
2455 /* Pop off extraneous binding levels left over due to syntax errors.
2457 We don't pop past namespaces, as they might be valid. */
2460 pop_everything (void)
2462 #ifdef DEBUG_BINDING_LEVELS
2463 fprintf (stderr, "XXX entering pop_everything ()\n");
2465 while (!toplevel_bindings_p ())
2467 if (current_binding_level->parm_flag == 2)
2468 pop_nested_class ();
2472 #ifdef DEBUG_BINDING_LEVELS
2473 fprintf (stderr, "XXX leaving pop_everything ()\n");
2477 /* The type TYPE is being declared. If it is a class template, or a
2478 specialization of a class template, do any processing required and
2479 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
2480 being declared a friend. B is the binding level at which this TYPE
2483 Returns the TYPE_DECL for TYPE, which may have been altered by this
2487 maybe_process_template_type_declaration (tree type,
2489 struct cp_binding_level* b)
2491 tree decl = TYPE_NAME (type);
2493 if (processing_template_parmlist)
2494 /* You can't declare a new template type in a template parameter
2495 list. But, you can declare a non-template type:
2497 template <class A*> struct S;
2499 is a forward-declaration of `A'. */
2503 maybe_check_template_type (type);
2505 my_friendly_assert (IS_AGGR_TYPE (type)
2506 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
2509 if (processing_template_decl)
2511 /* This may change after the call to
2512 push_template_decl_real, but we want the original value. */
2513 tree name = DECL_NAME (decl);
2515 decl = push_template_decl_real (decl, globalize);
2516 /* If the current binding level is the binding level for the
2517 template parameters (see the comment in
2518 begin_template_parm_list) and the enclosing level is a class
2519 scope, and we're not looking at a friend, push the
2520 declaration of the member class into the class scope. In the
2521 friend case, push_template_decl will already have put the
2522 friend into global scope, if appropriate. */
2523 if (TREE_CODE (type) != ENUMERAL_TYPE
2524 && !globalize && b->template_parms_p
2525 && b->level_chain->parm_flag == 2)
2527 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
2528 /* Put this tag on the list of tags for the class, since
2529 that won't happen below because B is not the class
2530 binding level, but is instead the pseudo-global level. */
2531 b->level_chain->tags =
2532 tree_cons (name, type, b->level_chain->tags);
2533 if (!COMPLETE_TYPE_P (current_class_type))
2535 maybe_add_class_template_decl_list (current_class_type,
2536 type, /*friend_p=*/0);
2537 CLASSTYPE_TAGS (current_class_type) = b->level_chain->tags;
2546 /* In C++, you don't have to write `struct S' to refer to `S'; you
2547 can just use `S'. We accomplish this by creating a TYPE_DECL as
2548 if the user had written `typedef struct S S'. Create and return
2549 the TYPE_DECL for TYPE. */
2552 create_implicit_typedef (tree name, tree type)
2556 decl = build_decl (TYPE_DECL, name, type);
2557 DECL_ARTIFICIAL (decl) = 1;
2558 /* There are other implicit type declarations, like the one *within*
2559 a class that allows you to write `S::S'. We must distinguish
2561 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
2562 TYPE_NAME (type) = decl;
2567 /* Remember a local name for name-mangling purposes. */
2570 push_local_name (tree decl)
2576 VARRAY_TREE_INIT (local_names, 8, "local_names");
2578 name = DECL_NAME (decl);
2580 nelts = VARRAY_ACTIVE_SIZE (local_names);
2581 for (i = 0; i < nelts; i++)
2583 t = VARRAY_TREE (local_names, i);
2584 if (DECL_NAME (t) == name)
2586 if (!DECL_LANG_SPECIFIC (decl))
2587 retrofit_lang_decl (decl);
2588 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
2589 if (DECL_LANG_SPECIFIC (t))
2590 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
2592 DECL_DISCRIMINATOR (decl) = 1;
2594 VARRAY_TREE (local_names, i) = decl;
2599 VARRAY_PUSH_TREE (local_names, decl);
2602 /* Push a tag name NAME for struct/class/union/enum type TYPE.
2603 Normally put it into the inner-most non-tag-transparent scope,
2604 but if GLOBALIZE is true, put it in the inner-most non-class scope.
2605 The latter is needed for implicit declarations. */
2608 pushtag (tree name, tree type, int globalize)
2610 register struct cp_binding_level *b;
2612 b = current_binding_level;
2613 while (b->tag_transparent
2614 || (b->parm_flag == 2
2616 /* We may be defining a new type in the initializer
2617 of a static member variable. We allow this when
2618 not pedantic, and it is particularly useful for
2619 type punning via an anonymous union. */
2620 || COMPLETE_TYPE_P (b->this_class))))
2623 b->tags = tree_cons (name, type, b->tags);
2627 /* Do C++ gratuitous typedefing. */
2628 if (IDENTIFIER_TYPE_VALUE (name) != type)
2630 register tree d = NULL_TREE;
2632 tree context = TYPE_CONTEXT (type);
2636 tree cs = current_scope ();
2640 else if (cs != NULL_TREE && TYPE_P (cs))
2641 /* When declaring a friend class of a local class, we want
2642 to inject the newly named class into the scope
2643 containing the local class, not the namespace scope. */
2644 context = decl_function_context (get_type_decl (cs));
2647 context = current_namespace;
2649 if ((b->template_parms_p && b->level_chain->parm_flag == 2)
2650 || b->parm_flag == 2)
2653 if (current_lang_name == lang_name_java)
2654 TYPE_FOR_JAVA (type) = 1;
2656 d = create_implicit_typedef (name, type);
2657 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2659 set_identifier_type_value_with_scope (name, type, b);
2661 d = maybe_process_template_type_declaration (type,
2664 if (b->parm_flag == 2)
2666 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
2667 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
2668 class. But if it's a member template class, we
2669 want the TEMPLATE_DECL, not the TYPE_DECL, so this
2671 finish_member_declaration (d);
2673 pushdecl_class_level (d);
2676 d = pushdecl_with_scope (d, b);
2678 /* FIXME what if it gets a name from typedef? */
2679 if (ANON_AGGRNAME_P (name))
2680 DECL_IGNORED_P (d) = 1;
2682 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
2684 /* If this is a local class, keep track of it. We need this
2685 information for name-mangling, and so that it is possible to find
2686 all function definitions in a translation unit in a convenient
2687 way. (It's otherwise tricky to find a member function definition
2688 it's only pointed to from within a local class.) */
2689 if (TYPE_CONTEXT (type)
2690 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
2691 && !processing_template_decl)
2692 VARRAY_PUSH_TREE (local_classes, type);
2694 if (b->parm_flag == 2)
2696 if (!COMPLETE_TYPE_P (current_class_type))
2698 maybe_add_class_template_decl_list (current_class_type,
2699 type, /*friend_p=*/0);
2700 CLASSTYPE_TAGS (current_class_type) = b->tags;
2705 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2706 /* Use the canonical TYPE_DECL for this node. */
2707 TYPE_STUB_DECL (type) = TYPE_NAME (type);
2710 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
2711 will be the tagged type we just added to the current
2712 binding level. This fake NULL-named TYPE_DECL node helps
2713 dwarfout.c to know when it needs to output a
2714 representation of a tagged type, and it also gives us a
2715 convenient place to record the "scope start" address for
2718 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
2719 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
2723 /* Counter used to create anonymous type names. */
2725 static GTY(()) int anon_cnt;
2727 /* Return an IDENTIFIER which can be used as a name for
2728 anonymous structs and unions. */
2731 make_anon_name (void)
2735 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
2736 return get_identifier (buf);
2739 /* Clear the TREE_PURPOSE slot of tags which have anonymous typenames.
2740 This keeps dbxout from getting confused. */
2743 clear_anon_tags (void)
2745 register struct cp_binding_level *b;
2747 static int last_cnt = 0;
2749 /* Fast out if no new anon names were declared. */
2750 if (last_cnt == anon_cnt)
2753 b = current_binding_level;
2754 while (b->tag_transparent)
2759 /* A NULL purpose means we have already processed all tags
2760 from here to the end of the list. */
2761 if (TREE_PURPOSE (tags) == NULL_TREE)
2763 if (ANON_AGGRNAME_P (TREE_PURPOSE (tags)))
2764 TREE_PURPOSE (tags) = NULL_TREE;
2765 tags = TREE_CHAIN (tags);
2767 last_cnt = anon_cnt;
2770 /* Subroutine of duplicate_decls: return truthvalue of whether
2771 or not types of these decls match.
2773 For C++, we must compare the parameter list so that `int' can match
2774 `int&' in a parameter position, but `int&' is not confused with
2778 decls_match (tree newdecl, tree olddecl)
2782 if (newdecl == olddecl)
2785 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
2786 /* If the two DECLs are not even the same kind of thing, we're not
2787 interested in their types. */
2790 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2792 tree f1 = TREE_TYPE (newdecl);
2793 tree f2 = TREE_TYPE (olddecl);
2794 tree p1 = TYPE_ARG_TYPES (f1);
2795 tree p2 = TYPE_ARG_TYPES (f2);
2797 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
2798 && ! (DECL_EXTERN_C_P (newdecl)
2799 && DECL_EXTERN_C_P (olddecl)))
2802 if (TREE_CODE (f1) != TREE_CODE (f2))
2805 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
2807 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
2808 && (DECL_BUILT_IN (olddecl)
2809 #ifndef NO_IMPLICIT_EXTERN_C
2810 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
2811 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
2815 types_match = self_promoting_args_p (p1);
2816 if (p1 == void_list_node)
2817 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2819 #ifndef NO_IMPLICIT_EXTERN_C
2820 else if (p1 == NULL_TREE
2821 && (DECL_EXTERN_C_P (olddecl)
2822 && DECL_IN_SYSTEM_HEADER (olddecl)
2823 && !DECL_CLASS_SCOPE_P (olddecl))
2824 && (DECL_EXTERN_C_P (newdecl)
2825 && DECL_IN_SYSTEM_HEADER (newdecl)
2826 && !DECL_CLASS_SCOPE_P (newdecl)))
2828 types_match = self_promoting_args_p (p2);
2829 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
2833 types_match = compparms (p1, p2);
2838 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2840 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
2841 DECL_TEMPLATE_PARMS (olddecl)))
2844 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
2845 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
2848 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2851 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
2852 DECL_TEMPLATE_RESULT (newdecl));
2856 if (TREE_TYPE (newdecl) == error_mark_node)
2857 types_match = TREE_TYPE (olddecl) == error_mark_node;
2858 else if (TREE_TYPE (olddecl) == NULL_TREE)
2859 types_match = TREE_TYPE (newdecl) == NULL_TREE;
2860 else if (TREE_TYPE (newdecl) == NULL_TREE)
2863 types_match = comptypes (TREE_TYPE (newdecl),
2864 TREE_TYPE (olddecl),
2865 COMPARE_REDECLARATION);
2871 /* If NEWDECL is `static' and an `extern' was seen previously,
2872 warn about it. OLDDECL is the previous declaration.
2874 Note that this does not apply to the C++ case of declaring
2875 a variable `extern const' and then later `const'.
2877 Don't complain about built-in functions, since they are beyond
2878 the user's control. */
2881 warn_extern_redeclared_static (tree newdecl, tree olddecl)
2883 static const char *const explicit_extern_static_warning
2884 = "`%D' was declared `extern' and later `static'";
2885 static const char *const implicit_extern_static_warning
2886 = "`%D' was declared implicitly `extern' and later `static'";
2890 if (TREE_CODE (newdecl) == TYPE_DECL
2891 || TREE_CODE (newdecl) == TEMPLATE_DECL
2892 || TREE_CODE (newdecl) == CONST_DECL)
2895 /* Don't get confused by static member functions; that's a different
2897 if (TREE_CODE (newdecl) == FUNCTION_DECL
2898 && DECL_STATIC_FUNCTION_P (newdecl))
2901 /* If the old declaration was `static', or the new one isn't, then
2902 then everything is OK. */
2903 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
2906 /* It's OK to declare a builtin function as `static'. */
2907 if (TREE_CODE (olddecl) == FUNCTION_DECL
2908 && DECL_ARTIFICIAL (olddecl))
2911 name = DECL_ASSEMBLER_NAME (newdecl);
2912 pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
2913 ? implicit_extern_static_warning
2914 : explicit_extern_static_warning, newdecl);
2915 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
2918 /* Handle when a new declaration NEWDECL has the same name as an old
2919 one OLDDECL in the same binding contour. Prints an error message
2922 If safely possible, alter OLDDECL to look like NEWDECL, and return 1.
2923 Otherwise, return 0. */
2926 duplicate_decls (tree newdecl, tree olddecl)
2928 unsigned olddecl_uid = DECL_UID (olddecl);
2929 int olddecl_friend = 0, types_match = 0;
2930 int new_defines_function = 0;
2932 if (newdecl == olddecl)
2935 types_match = decls_match (newdecl, olddecl);
2937 /* If either the type of the new decl or the type of the old decl is an
2938 error_mark_node, then that implies that we have already issued an
2939 error (earlier) for some bogus type specification, and in that case,
2940 it is rather pointless to harass the user with yet more error message
2941 about the same declaration, so just pretend the types match here. */
2942 if (TREE_TYPE (newdecl) == error_mark_node
2943 || TREE_TYPE (olddecl) == error_mark_node)
2946 if (DECL_P (olddecl)
2947 && TREE_CODE (newdecl) == FUNCTION_DECL
2948 && TREE_CODE (olddecl) == FUNCTION_DECL
2949 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
2951 if (DECL_DECLARED_INLINE_P (newdecl)
2952 && DECL_UNINLINABLE (newdecl)
2953 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2954 /* Already warned elsewhere. */;
2955 else if (DECL_DECLARED_INLINE_P (olddecl)
2956 && DECL_UNINLINABLE (olddecl)
2957 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2958 /* Already warned. */;
2959 else if (DECL_DECLARED_INLINE_P (newdecl)
2960 && DECL_UNINLINABLE (olddecl)
2961 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
2963 warning_with_decl (newdecl,
2964 "function `%s' redeclared as inline");
2965 warning_with_decl (olddecl,
2966 "previous declaration of function `%s' with attribute noinline");
2968 else if (DECL_DECLARED_INLINE_P (olddecl)
2969 && DECL_UNINLINABLE (newdecl)
2970 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
2972 warning_with_decl (newdecl,
2973 "function `%s' redeclared with attribute noinline");
2974 warning_with_decl (olddecl,
2975 "previous declaration of function `%s' was inline");
2979 /* Check for redeclaration and other discrepancies. */
2980 if (TREE_CODE (olddecl) == FUNCTION_DECL
2981 && DECL_ARTIFICIAL (olddecl))
2983 if (TREE_CODE (newdecl) != FUNCTION_DECL)
2985 /* Avoid warnings redeclaring anticipated built-ins. */
2986 if (DECL_ANTICIPATED (olddecl))
2989 /* If you declare a built-in or predefined function name as static,
2990 the old definition is overridden, but optionally warn this was a
2991 bad choice of name. */
2992 if (! TREE_PUBLIC (newdecl))
2995 warning ("shadowing %s function `%#D'",
2996 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
2998 /* Discard the old built-in function. */
3001 /* If the built-in is not ansi, then programs can override
3002 it even globally without an error. */
3003 else if (! DECL_BUILT_IN (olddecl))
3004 warning ("library function `%#D' redeclared as non-function `%#D'",
3008 error ("declaration of `%#D'", newdecl);
3009 error ("conflicts with built-in declaration `%#D'",
3014 else if (!types_match)
3016 /* Avoid warnings redeclaring anticipated built-ins. */
3017 if (DECL_ANTICIPATED (olddecl))
3018 ; /* Do nothing yet. */
3019 else if ((DECL_EXTERN_C_P (newdecl)
3020 && DECL_EXTERN_C_P (olddecl))
3021 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3022 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3024 /* A near match; override the builtin. */
3026 if (TREE_PUBLIC (newdecl))
3028 warning ("new declaration `%#D'", newdecl);
3029 warning ("ambiguates built-in declaration `%#D'",
3032 else if (warn_shadow)
3033 warning ("shadowing %s function `%#D'",
3034 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
3038 /* Discard the old built-in function. */
3041 /* Replace the old RTL to avoid problems with inlining. */
3042 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3045 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
3047 /* If a builtin function is redeclared as `static', merge
3048 the declarations, but make the original one static. */
3049 DECL_THIS_STATIC (olddecl) = 1;
3050 TREE_PUBLIC (olddecl) = 0;
3052 /* Make the old declaration consistent with the new one so
3053 that all remnants of the builtin-ness of this function
3054 will be banished. */
3055 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3056 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3059 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
3061 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
3062 && TREE_CODE (newdecl) != TYPE_DECL
3063 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
3064 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
3065 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
3066 && TREE_CODE (olddecl) != TYPE_DECL
3067 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
3068 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
3071 /* We do nothing special here, because C++ does such nasty
3072 things with TYPE_DECLs. Instead, just let the TYPE_DECL
3073 get shadowed, and know that if we need to find a TYPE_DECL
3074 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
3075 slot of the identifier. */
3079 if ((TREE_CODE (newdecl) == FUNCTION_DECL
3080 && DECL_FUNCTION_TEMPLATE_P (olddecl))
3081 || (TREE_CODE (olddecl) == FUNCTION_DECL
3082 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
3085 error ("`%#D' redeclared as different kind of symbol", newdecl);
3086 if (TREE_CODE (olddecl) == TREE_LIST)
3087 olddecl = TREE_VALUE (olddecl);
3088 cp_error_at ("previous declaration of `%#D'", olddecl);
3090 /* New decl is completely inconsistent with the old one =>
3091 tell caller to replace the old one. */
3095 else if (!types_match)
3097 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
3098 /* These are certainly not duplicate declarations; they're
3099 from different scopes. */
3102 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3104 /* The name of a class template may not be declared to refer to
3105 any other template, class, function, object, namespace, value,
3106 or type in the same scope. */
3107 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
3108 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
3110 error ("declaration of template `%#D'", newdecl);
3111 cp_error_at ("conflicts with previous declaration `%#D'",
3114 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
3115 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
3116 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
3117 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
3118 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
3119 DECL_TEMPLATE_PARMS (olddecl))
3120 /* Template functions can be disambiguated by
3122 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
3123 TREE_TYPE (TREE_TYPE (olddecl))))
3125 error ("new declaration `%#D'", newdecl);
3126 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3130 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3132 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
3134 error ("declaration of C function `%#D' conflicts with",
3136 cp_error_at ("previous declaration `%#D' here", olddecl);
3138 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
3139 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
3141 error ("new declaration `%#D'", newdecl);
3142 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
3148 /* Already complained about this, so don't do so again. */
3149 else if (current_class_type == NULL_TREE
3150 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
3152 error ("conflicting types for `%#D'", newdecl);
3153 cp_error_at ("previous declaration as `%#D'", olddecl);
3156 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3157 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
3158 && (!DECL_TEMPLATE_INFO (newdecl)
3159 || (DECL_TI_TEMPLATE (newdecl)
3160 != DECL_TI_TEMPLATE (olddecl))))
3161 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
3162 && (!DECL_TEMPLATE_INFO (olddecl)
3163 || (DECL_TI_TEMPLATE (olddecl)
3164 != DECL_TI_TEMPLATE (newdecl))))))
3165 /* It's OK to have a template specialization and a non-template
3166 with the same type, or to have specializations of two
3167 different templates with the same type. Note that if one is a
3168 specialization, and the other is an instantiation of the same
3169 template, that we do not exit at this point. That situation
3170 can occur if we instantiate a template class, and then
3171 specialize one of its methods. This situation is valid, but
3172 the declarations must be merged in the usual way. */
3174 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3175 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
3176 && !DECL_USE_TEMPLATE (newdecl))
3177 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
3178 && !DECL_USE_TEMPLATE (olddecl))))
3179 /* One of the declarations is a template instantiation, and the
3180 other is not a template at all. That's OK. */
3182 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
3183 && DECL_NAMESPACE_ALIAS (newdecl)
3184 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
3185 /* Redeclaration of namespace alias, ignore it. */
3189 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
3192 error (errmsg, newdecl);
3193 if (DECL_NAME (olddecl) != NULL_TREE)
3194 cp_error_at ((DECL_INITIAL (olddecl)
3195 && namespace_bindings_p ())
3196 ? "`%#D' previously defined here"
3197 : "`%#D' previously declared here", olddecl);
3200 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3201 && DECL_INITIAL (olddecl) != NULL_TREE
3202 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
3203 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
3205 /* Prototype decl follows defn w/o prototype. */
3206 cp_warning_at ("prototype for `%#D'", newdecl);
3207 cp_warning_at ("follows non-prototype definition here", olddecl);
3209 else if (TREE_CODE (olddecl) == FUNCTION_DECL
3210 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
3212 /* extern "C" int foo ();
3213 int foo () { bar (); }
3215 if (current_lang_depth () == 0)
3216 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3219 cp_error_at ("previous declaration of `%#D' with %L linkage",
3220 olddecl, DECL_LANGUAGE (olddecl));
3221 error ("conflicts with new declaration with %L linkage",
3222 DECL_LANGUAGE (newdecl));
3226 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
3228 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
3230 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
3231 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
3234 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
3235 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
3237 for (; t1 && t1 != void_list_node;
3238 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
3239 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
3241 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
3244 pedwarn ("default argument given for parameter %d of `%#D'",
3246 cp_pedwarn_at ("after previous specification in `%#D'",
3251 error ("default argument given for parameter %d of `%#D'",
3253 cp_error_at ("after previous specification in `%#D'",
3258 if (DECL_DECLARED_INLINE_P (newdecl)
3259 && ! DECL_DECLARED_INLINE_P (olddecl)
3260 && TREE_ADDRESSABLE (olddecl) && warn_inline)
3262 warning ("`%#D' was used before it was declared inline",
3264 cp_warning_at ("previous non-inline declaration here",
3270 /* Do not merge an implicit typedef with an explicit one. In:
3274 typedef class A A __attribute__ ((foo));
3276 the attribute should apply only to the typedef. */
3277 if (TREE_CODE (olddecl) == TYPE_DECL
3278 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
3279 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
3282 /* If new decl is `static' and an `extern' was seen previously,
3284 warn_extern_redeclared_static (newdecl, olddecl);
3286 /* We have committed to returning 1 at this point. */
3287 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3289 /* Now that functions must hold information normally held
3290 by field decls, there is extra work to do so that
3291 declaration information does not get destroyed during
3293 if (DECL_VINDEX (olddecl))
3294 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
3295 if (DECL_CONTEXT (olddecl))
3296 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
3297 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
3298 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
3299 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
3300 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
3301 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
3302 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
3303 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
3304 SET_OVERLOADED_OPERATOR_CODE
3305 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
3306 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
3308 /* Optionally warn about more than one declaration for the same
3309 name, but don't warn about a function declaration followed by a
3311 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
3312 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
3313 /* Don't warn about extern decl followed by definition. */
3314 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
3315 /* Don't warn about friends, let add_friend take care of it. */
3316 && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
3318 warning ("redundant redeclaration of `%D' in same scope", newdecl);
3319 cp_warning_at ("previous declaration of `%D'", olddecl);
3323 /* Deal with C++: must preserve virtual function table size. */
3324 if (TREE_CODE (olddecl) == TYPE_DECL)
3326 register tree newtype = TREE_TYPE (newdecl);
3327 register tree oldtype = TREE_TYPE (olddecl);
3329 if (newtype != error_mark_node && oldtype != error_mark_node
3330 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
3331 CLASSTYPE_FRIEND_CLASSES (newtype)
3332 = CLASSTYPE_FRIEND_CLASSES (oldtype);
3334 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
3337 /* Copy all the DECL_... slots specified in the new decl
3338 except for any that we copy here from the old type. */
3339 DECL_ATTRIBUTES (newdecl)
3340 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
3342 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
3344 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
3345 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
3346 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
3347 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
3349 /* If the new declaration is a definition, update the file and
3350 line information on the declaration. */
3351 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
3352 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
3354 DECL_SOURCE_LOCATION (olddecl)
3355 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
3356 = DECL_SOURCE_LOCATION (newdecl);
3364 /* Automatically handles default parameters. */
3365 tree oldtype = TREE_TYPE (olddecl);
3368 /* Merge the data types specified in the two decls. */
3369 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
3371 /* If merge_types produces a non-typedef type, just use the old type. */
3372 if (TREE_CODE (newdecl) == TYPE_DECL
3373 && newtype == DECL_ORIGINAL_TYPE (newdecl))
3376 if (TREE_CODE (newdecl) == VAR_DECL)
3378 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
3379 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3382 /* Do this after calling `merge_types' so that default
3383 parameters don't confuse us. */
3384 else if (TREE_CODE (newdecl) == FUNCTION_DECL
3385 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
3386 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
3388 TREE_TYPE (newdecl) = build_exception_variant (newtype,
3389 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
3390 TREE_TYPE (olddecl) = build_exception_variant (newtype,
3391 TYPE_RAISES_EXCEPTIONS (oldtype));
3393 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
3394 && DECL_SOURCE_LINE (olddecl) != 0
3396 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
3397 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
3399 error ("declaration of `%F' throws different exceptions",
3401 cp_error_at ("than previous declaration `%F'", olddecl);
3404 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
3406 /* Lay the type out, unless already done. */
3407 if (! same_type_p (newtype, oldtype)
3408 && TREE_TYPE (newdecl) != error_mark_node
3409 && !(processing_template_decl && uses_template_parms (newdecl)))
3410 layout_type (TREE_TYPE (newdecl));
3412 if ((TREE_CODE (newdecl) == VAR_DECL
3413 || TREE_CODE (newdecl) == PARM_DECL
3414 || TREE_CODE (newdecl) == RESULT_DECL
3415 || TREE_CODE (newdecl) == FIELD_DECL
3416 || TREE_CODE (newdecl) == TYPE_DECL)
3417 && !(processing_template_decl && uses_template_parms (newdecl)))
3418 layout_decl (newdecl, 0);
3420 /* Merge the type qualifiers. */
3421 if (TREE_READONLY (newdecl))
3422 TREE_READONLY (olddecl) = 1;
3423 if (TREE_THIS_VOLATILE (newdecl))
3424 TREE_THIS_VOLATILE (olddecl) = 1;
3426 /* Merge the initialization information. */
3427 if (DECL_INITIAL (newdecl) == NULL_TREE
3428 && DECL_INITIAL (olddecl) != NULL_TREE)
3430 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
3431 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
3432 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
3433 && DECL_LANG_SPECIFIC (newdecl)
3434 && DECL_LANG_SPECIFIC (olddecl))
3435 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
3438 /* Merge the section attribute.
3439 We want to issue an error if the sections conflict but that must be
3440 done later in decl_attributes since we are called before attributes
3442 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
3443 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
3445 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3447 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
3448 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
3449 DECL_NO_LIMIT_STACK (newdecl)
3450 |= DECL_NO_LIMIT_STACK (olddecl);
3451 /* Keep the old RTL. */
3452 COPY_DECL_RTL (olddecl, newdecl);
3454 else if (TREE_CODE (newdecl) == VAR_DECL
3455 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
3457 /* Keep the old RTL. We cannot keep the old RTL if the old
3458 declaration was for an incomplete object and the new
3459 declaration is not since many attributes of the RTL will
3461 COPY_DECL_RTL (olddecl, newdecl);
3464 /* If cannot merge, then use the new type and qualifiers,
3465 and don't preserve the old rtl. */
3468 /* Clean out any memory we had of the old declaration. */
3469 tree oldstatic = value_member (olddecl, static_aggregates);
3471 TREE_VALUE (oldstatic) = error_mark_node;
3473 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
3474 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
3475 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
3476 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
3479 /* Merge the storage class information. */
3480 merge_weak (newdecl, olddecl);
3482 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
3483 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
3484 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
3485 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
3486 if (! DECL_EXTERNAL (olddecl))
3487 DECL_EXTERNAL (newdecl) = 0;
3489 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
3491 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
3492 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
3493 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
3494 DECL_TEMPLATE_INSTANTIATED (newdecl)
3495 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
3496 /* Don't really know how much of the language-specific
3497 values we should copy from old to new. */
3498 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
3499 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
3500 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
3501 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
3502 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3503 DECL_INITIALIZED_IN_CLASS_P (newdecl)
3504 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
3505 olddecl_friend = DECL_FRIEND_P (olddecl);
3507 /* Only functions have DECL_BEFRIENDING_CLASSES. */
3508 if (TREE_CODE (newdecl) == FUNCTION_DECL
3509 || DECL_FUNCTION_TEMPLATE_P (newdecl))
3511 DECL_BEFRIENDING_CLASSES (newdecl)
3512 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
3513 DECL_BEFRIENDING_CLASSES (olddecl));
3514 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
3518 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3520 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
3521 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
3523 /* If newdecl is not a specialization, then it is not a
3524 template-related function at all. And that means that we
3525 shoud have exited above, returning 0. */
3526 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
3529 if (TREE_USED (olddecl))
3530 /* From [temp.expl.spec]:
3532 If a template, a member template or the member of a class
3533 template is explicitly specialized then that
3534 specialization shall be declared before the first use of
3535 that specialization that would cause an implicit
3536 instantiation to take place, in every translation unit in
3537 which such a use occurs. */
3538 error ("explicit specialization of %D after first use",
3541 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
3543 /* [temp.expl.spec/14] We don't inline explicit specialization
3544 just because the primary template says so. */
3548 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
3549 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
3551 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
3553 /* If either decl says `inline', this fn is inline, unless
3554 its definition was passed already. */
3555 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
3556 DECL_INLINE (olddecl) = 1;
3557 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
3559 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
3560 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
3563 /* Preserve abstractness on cloned [cd]tors. */
3564 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
3568 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
3569 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
3570 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
3572 if (! types_match || new_defines_function)
3574 /* These need to be copied so that the names are available.
3575 Note that if the types do match, we'll preserve inline
3576 info and other bits, but if not, we won't. */
3577 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
3578 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
3580 if (new_defines_function)
3581 /* If defining a function declared with other language
3582 linkage, use the previously declared language linkage. */
3583 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
3584 else if (types_match)
3586 /* If redeclaring a builtin function, and not a definition,
3587 it stays built in. */
3588 if (DECL_BUILT_IN (olddecl))
3590 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
3591 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
3592 /* If we're keeping the built-in definition, keep the rtl,
3593 regardless of declaration matches. */
3594 SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
3597 DECL_NUM_STMTS (newdecl) = DECL_NUM_STMTS (olddecl);
3599 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
3600 /* Don't clear out the arguments if we're redefining a function. */
3601 if (DECL_ARGUMENTS (olddecl))
3602 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
3605 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
3606 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
3608 /* Now preserve various other info from the definition. */
3609 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
3610 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
3611 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
3612 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
3614 if (TREE_CODE (newdecl) == FUNCTION_DECL)
3618 function_size = sizeof (struct tree_decl);
3620 memcpy ((char *) olddecl + sizeof (struct tree_common),
3621 (char *) newdecl + sizeof (struct tree_common),
3622 function_size - sizeof (struct tree_common));
3624 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
3626 /* If newdecl is a template instantiation, it is possible that
3627 the following sequence of events has occurred:
3629 o A friend function was declared in a class template. The
3630 class template was instantiated.
3632 o The instantiation of the friend declaration was
3633 recorded on the instantiation list, and is newdecl.
3635 o Later, however, instantiate_class_template called pushdecl
3636 on the newdecl to perform name injection. But, pushdecl in
3637 turn called duplicate_decls when it discovered that another
3638 declaration of a global function with the same name already
3641 o Here, in duplicate_decls, we decided to clobber newdecl.
3643 If we're going to do that, we'd better make sure that
3644 olddecl, and not newdecl, is on the list of
3645 instantiations so that if we try to do the instantiation
3646 again we won't get the clobbered declaration. */
3648 tree tmpl = DECL_TI_TEMPLATE (newdecl);
3649 tree decls = DECL_TEMPLATE_SPECIALIZATIONS (tmpl);
3651 for (; decls; decls = TREE_CHAIN (decls))
3652 if (TREE_VALUE (decls) == newdecl)
3653 TREE_VALUE (decls) = olddecl;
3658 memcpy ((char *) olddecl + sizeof (struct tree_common),
3659 (char *) newdecl + sizeof (struct tree_common),
3660 sizeof (struct tree_decl) - sizeof (struct tree_common)
3661 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
3664 DECL_UID (olddecl) = olddecl_uid;
3666 DECL_FRIEND_P (olddecl) = 1;
3668 /* NEWDECL contains the merged attribute lists.
3669 Update OLDDECL to be the same. */
3670 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
3675 /* Record a decl-node X as belonging to the current lexical scope.
3676 Check for errors (such as an incompatible declaration for the same
3677 name already seen in the same scope).
3679 Returns either X or an old decl for the same name.
3680 If an old decl is returned, it may have been smashed
3681 to agree with what X says. */
3688 int need_new_binding;
3690 /* We shouldn't be calling pushdecl when we're generating RTL for a
3691 function that we already did semantic analysis on previously. */
3692 my_friendly_assert (!cfun || doing_semantic_analysis_p (),
3695 need_new_binding = 1;
3697 if (DECL_TEMPLATE_PARM_P (x))
3698 /* Template parameters have no context; they are not X::T even
3699 when declared within a class or namespace. */
3703 if (current_function_decl && x != current_function_decl
3704 /* A local declaration for a function doesn't constitute
3706 && !(TREE_CODE (x) == FUNCTION_DECL && !DECL_INITIAL (x))
3707 /* A local declaration for an `extern' variable is in the
3708 scope of the current namespace, not the current
3710 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
3711 && !DECL_CONTEXT (x))
3712 DECL_CONTEXT (x) = current_function_decl;
3714 /* If this is the declaration for a namespace-scope function,
3715 but the declaration itself is in a local scope, mark the
3717 if (TREE_CODE (x) == FUNCTION_DECL
3718 && DECL_NAMESPACE_SCOPE_P (x)
3719 && current_function_decl
3720 && x != current_function_decl)
3721 DECL_LOCAL_FUNCTION_P (x) = 1;
3724 name = DECL_NAME (x);
3727 int different_binding_level = 0;
3729 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3730 name = TREE_OPERAND (name, 0);
3732 /* In case this decl was explicitly namespace-qualified, look it
3733 up in its namespace context. */
3734 if (TREE_CODE (x) == VAR_DECL && DECL_NAMESPACE_SCOPE_P (x)
3735 && namespace_bindings_p ())
3736 t = namespace_binding (name, DECL_CONTEXT (x));
3738 t = lookup_name_current_level (name);
3740 /* [basic.link] If there is a visible declaration of an entity
3741 with linkage having the same name and type, ignoring entities
3742 declared outside the innermost enclosing namespace scope, the
3743 block scope declaration declares that same entity and
3744 receives the linkage of the previous declaration. */
3745 if (! t && current_function_decl && x != current_function_decl
3746 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
3747 && DECL_EXTERNAL (x))
3749 /* Look in block scope. */
3750 t = IDENTIFIER_VALUE (name);
3751 /* Or in the innermost namespace. */
3753 t = namespace_binding (name, DECL_CONTEXT (x));
3754 /* Does it have linkage? Note that if this isn't a DECL, it's an
3755 OVERLOAD, which is OK. */
3756 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
3759 different_binding_level = 1;
3762 /* If we are declaring a function, and the result of name-lookup
3763 was an OVERLOAD, look for an overloaded instance that is
3764 actually the same as the function we are declaring. (If
3765 there is one, we have to merge our declaration with the
3766 previous declaration.) */
3767 if (t && TREE_CODE (t) == OVERLOAD)
3771 if (TREE_CODE (x) == FUNCTION_DECL)
3772 for (match = t; match; match = OVL_NEXT (match))
3774 if (decls_match (OVL_CURRENT (match), x))
3778 /* Just choose one. */
3782 t = OVL_CURRENT (match);
3787 if (t == error_mark_node)
3789 /* error_mark_node is 0 for a while during initialization! */
3791 cp_error_at ("`%#D' used prior to declaration", x);
3793 else if (t != NULL_TREE)
3795 if (different_binding_level)
3797 if (decls_match (x, t))
3798 /* The standard only says that the local extern
3799 inherits linkage from the previous decl; in
3800 particular, default args are not shared. It would
3801 be nice to propagate inlining info, though. FIXME. */
3802 TREE_PUBLIC (x) = TREE_PUBLIC (t);
3804 else if (TREE_CODE (t) == PARM_DECL)
3806 if (DECL_CONTEXT (t) == NULL_TREE)
3807 /* This is probaby caused by too many errors, but calling
3808 abort will say that if errors have occurred. */
3811 /* Check for duplicate params. */
3812 if (duplicate_decls (x, t))
3815 else if ((DECL_EXTERN_C_FUNCTION_P (x)
3816 || DECL_FUNCTION_TEMPLATE_P (x))
3817 && is_overloaded_fn (t))
3818 /* Don't do anything just yet. */;
3819 else if (t == wchar_decl_node)
3821 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
3822 pedwarn ("redeclaration of `wchar_t' as `%T'",
3825 /* Throw away the redeclaration. */
3828 else if (TREE_CODE (t) != TREE_CODE (x))
3830 if (duplicate_decls (x, t))
3833 else if (duplicate_decls (x, t))
3835 if (TREE_CODE (t) == TYPE_DECL)
3836 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
3837 else if (TREE_CODE (t) == FUNCTION_DECL)
3838 check_default_args (t);
3842 else if (DECL_MAIN_P (x))
3844 /* A redeclaration of main, but not a duplicate of the
3849 This function shall not be overloaded. */
3850 cp_error_at ("invalid redeclaration of `%D'", t);
3851 error ("as `%D'", x);
3852 /* We don't try to push this declaration since that
3858 check_template_shadow (x);
3860 /* If this is a function conjured up by the backend, massage it
3861 so it looks friendly. */
3862 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
3864 retrofit_lang_decl (x);
3865 SET_DECL_LANGUAGE (x, lang_c);
3868 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
3870 t = push_overloaded_decl (x, PUSH_LOCAL);
3873 if (!namespace_bindings_p ())
3874 /* We do not need to create a binding for this name;
3875 push_overloaded_decl will have already done so if
3877 need_new_binding = 0;
3879 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
3881 t = push_overloaded_decl (x, PUSH_GLOBAL);
3883 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
3887 /* If declaring a type as a typedef, copy the type (unless we're
3888 at line 0), and install this TYPE_DECL as the new type's typedef
3889 name. See the extensive comment in ../c-decl.c (pushdecl). */
3890 if (TREE_CODE (x) == TYPE_DECL)
3892 tree type = TREE_TYPE (x);
3893 if (DECL_SOURCE_LINE (x) == 0)
3895 if (TYPE_NAME (type) == 0)
3896 TYPE_NAME (type) = x;
3898 else if (type != error_mark_node && TYPE_NAME (type) != x
3899 /* We don't want to copy the type when all we're
3900 doing is making a TYPE_DECL for the purposes of
3902 && (!TYPE_NAME (type)
3903 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
3905 DECL_ORIGINAL_TYPE (x) = type;
3906 type = build_type_copy (type);
3907 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
3908 TYPE_NAME (type) = x;
3909 TREE_TYPE (x) = type;
3912 if (type != error_mark_node
3914 && TYPE_IDENTIFIER (type))
3915 set_identifier_type_value_with_scope (DECL_NAME (x), type,
3916 current_binding_level);
3920 /* Multiple external decls of the same identifier ought to match.
3922 We get warnings about inline functions where they are defined.
3923 We get warnings about other functions from push_overloaded_decl.
3925 Avoid duplicate warnings where they are used. */
3926 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
3930 decl = IDENTIFIER_NAMESPACE_VALUE (name);
3931 if (decl && TREE_CODE (decl) == OVERLOAD)
3932 decl = OVL_FUNCTION (decl);
3934 if (decl && decl != error_mark_node
3935 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
3936 /* If different sort of thing, we already gave an error. */
3937 && TREE_CODE (decl) == TREE_CODE (x)
3938 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
3940 pedwarn ("type mismatch with previous external decl", x);
3941 cp_pedwarn_at ("previous external decl of `%#D'", decl);
3945 /* This name is new in its binding level.
3946 Install the new declaration and return it. */
3947 if (namespace_bindings_p ())
3949 /* Install a global value. */
3951 /* If the first global decl has external linkage,
3952 warn if we later see static one. */
3953 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
3954 TREE_PUBLIC (name) = 1;
3956 /* Bind the name for the entity. */
3957 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
3959 && (TREE_CODE (x) == TYPE_DECL
3960 || TREE_CODE (x) == VAR_DECL
3961 || TREE_CODE (x) == ALIAS_DECL
3962 || TREE_CODE (x) == NAMESPACE_DECL
3963 || TREE_CODE (x) == CONST_DECL
3964 || TREE_CODE (x) == TEMPLATE_DECL))
3965 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
3967 /* Don't forget if the function was used via an implicit decl. */
3968 if (IDENTIFIER_IMPLICIT_DECL (name)
3969 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
3972 /* Don't forget if its address was taken in that way. */
3973 if (IDENTIFIER_IMPLICIT_DECL (name)
3974 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
3975 TREE_ADDRESSABLE (x) = 1;
3977 /* Warn about mismatches against previous implicit decl. */
3978 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
3979 /* If this real decl matches the implicit, don't complain. */
3980 && ! (TREE_CODE (x) == FUNCTION_DECL
3981 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
3983 ("`%D' was previously implicitly declared to return `int'", x);
3985 /* If new decl is `static' and an `extern' was seen previously,
3987 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
3988 warn_extern_redeclared_static (x, t);
3992 /* Here to install a non-global value. */
3993 tree oldlocal = IDENTIFIER_VALUE (name);
3994 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
3996 if (need_new_binding)
3998 push_local_binding (name, x, 0);
3999 /* Because push_local_binding will hook X on to the
4000 current_binding_level's name list, we don't want to
4001 do that again below. */
4002 need_new_binding = 0;
4005 /* If this is a TYPE_DECL, push it into the type value slot. */
4006 if (TREE_CODE (x) == TYPE_DECL)
4007 set_identifier_type_value_with_scope (name, TREE_TYPE (x),
4008 current_binding_level);
4010 /* Clear out any TYPE_DECL shadowed by a namespace so that
4011 we won't think this is a type. The C struct hack doesn't
4012 go through namespaces. */
4013 if (TREE_CODE (x) == NAMESPACE_DECL)
4014 set_identifier_type_value_with_scope (name, NULL_TREE,
4015 current_binding_level);
4022 && TREE_CODE (oldlocal) == VAR_DECL
4023 && DECL_DEAD_FOR_LOCAL (oldlocal))
4024 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
4026 if (oldlocal == NULL_TREE)
4027 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
4030 /* If this is an extern function declaration, see if we
4031 have a global definition or declaration for the function. */
4032 if (oldlocal == NULL_TREE
4033 && DECL_EXTERNAL (x)
4034 && oldglobal != NULL_TREE
4035 && TREE_CODE (x) == FUNCTION_DECL
4036 && TREE_CODE (oldglobal) == FUNCTION_DECL)
4038 /* We have one. Their types must agree. */
4039 if (decls_match (x, oldglobal))
4043 warning ("extern declaration of `%#D' doesn't match", x);
4044 cp_warning_at ("global declaration `%#D'", oldglobal);
4047 /* If we have a local external declaration,
4048 and no file-scope declaration has yet been seen,
4049 then if we later have a file-scope decl it must not be static. */
4050 if (oldlocal == NULL_TREE
4051 && oldglobal == NULL_TREE
4052 && DECL_EXTERNAL (x)
4054 TREE_PUBLIC (name) = 1;
4056 /* Warn if shadowing an argument at the top level of the body. */
4057 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
4058 /* Inline decls shadow nothing. */
4059 && !DECL_FROM_INLINE (x)
4060 && TREE_CODE (oldlocal) == PARM_DECL)
4064 /* Don't complain if it's from an enclosing function. */
4065 if (DECL_CONTEXT (oldlocal) == current_function_decl
4066 && TREE_CODE (x) != PARM_DECL)
4068 /* Go to where the parms should be and see if we find
4070 struct cp_binding_level *b = current_binding_level->level_chain;
4072 /* Skip the ctor/dtor cleanup level. */
4076 if (b->parm_flag == 1)
4078 error ("declaration of `%#D' shadows a parameter",
4084 if (warn_shadow && !err)
4085 shadow_warning ("a parameter", name, oldlocal);
4088 /* Maybe warn if shadowing something else. */
4089 else if (warn_shadow && !DECL_EXTERNAL (x)
4090 /* No shadow warnings for internally generated vars. */
4091 && ! DECL_ARTIFICIAL (x)
4092 /* No shadow warnings for vars made for inlining. */
4093 && ! DECL_FROM_INLINE (x))
4095 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
4096 && current_class_ptr
4097 && !TREE_STATIC (name))
4098 warning ("declaration of `%s' shadows a member of `this'",
4099 IDENTIFIER_POINTER (name));
4100 else if (oldlocal != NULL_TREE
4101 && TREE_CODE (oldlocal) == VAR_DECL)
4102 shadow_warning ("a previous local", name, oldlocal);
4103 else if (oldglobal != NULL_TREE
4104 && TREE_CODE (oldglobal) == VAR_DECL)
4105 /* XXX shadow warnings in outer-more namespaces */
4106 shadow_warning ("a global declaration", name, oldglobal);
4110 if (TREE_CODE (x) == FUNCTION_DECL)
4111 check_default_args (x);
4113 if (TREE_CODE (x) == VAR_DECL)
4114 maybe_register_incomplete_var (x);
4117 if (need_new_binding)
4118 add_decl_to_level (x,
4119 DECL_NAMESPACE_SCOPE_P (x)
4120 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
4121 : current_binding_level);
4126 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
4127 caller to set DECL_CONTEXT properly. */
4130 pushdecl_with_scope (tree x, struct cp_binding_level* level)
4132 register struct cp_binding_level *b;
4133 tree function_decl = current_function_decl;
4135 current_function_decl = NULL_TREE;
4136 if (level->parm_flag == 2)
4138 b = class_binding_level;
4139 class_binding_level = level;
4140 pushdecl_class_level (x);
4141 class_binding_level = b;
4145 b = current_binding_level;
4146 current_binding_level = level;
4148 current_binding_level = b;
4150 current_function_decl = function_decl;
4154 /* Like pushdecl, only it places X in the current namespace,
4158 pushdecl_namespace_level (tree x)
4160 register struct cp_binding_level *b = current_binding_level;
4163 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
4165 /* Now, the type_shadowed stack may screw us. Munge it so it does
4167 if (TREE_CODE (x) == TYPE_DECL)
4169 tree name = DECL_NAME (x);
4171 tree *ptr = (tree *)0;
4172 for (; b != global_binding_level; b = b->level_chain)
4174 tree shadowed = b->type_shadowed;
4175 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
4176 if (TREE_PURPOSE (shadowed) == name)
4178 ptr = &TREE_VALUE (shadowed);
4179 /* Can't break out of the loop here because sometimes
4180 a binding level will have duplicate bindings for
4181 PT names. It's gross, but I haven't time to fix it. */
4184 newval = TREE_TYPE (x);
4185 if (ptr == (tree *)0)
4187 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
4188 up here if this is changed to an assertion. --KR */
4189 SET_IDENTIFIER_TYPE_VALUE (name, newval);
4199 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL,
4203 pushdecl_top_level (tree x)
4205 push_to_top_level ();
4206 x = pushdecl_namespace_level (x);
4207 pop_from_top_level ();
4211 /* Make the declaration of X appear in CLASS scope. */
4214 pushdecl_class_level (tree x)
4218 /* Get the name of X. */
4219 if (TREE_CODE (x) == OVERLOAD)
4220 name = DECL_NAME (get_first_fn (x));
4222 name = DECL_NAME (x);
4226 push_class_level_binding (name, x);
4227 if (TREE_CODE (x) == TYPE_DECL)
4228 set_identifier_type_value (name, TREE_TYPE (x));
4230 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
4232 /* If X is an anonymous aggregate, all of its members are
4233 treated as if they were members of the class containing the
4234 aggregate, for naming purposes. */
4237 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
4238 pushdecl_class_level (f);
4242 /* Enter DECL into the symbol table, if that's appropriate. Returns
4243 DECL, or a modified version thereof. */
4246 maybe_push_decl (tree decl)
4248 tree type = TREE_TYPE (decl);
4250 /* Add this decl to the current binding level, but not if it comes
4251 from another scope, e.g. a static member variable. TEM may equal
4252 DECL or it may be a previous decl of the same name. */
4253 if (decl == error_mark_node
4254 || (TREE_CODE (decl) != PARM_DECL
4255 && DECL_CONTEXT (decl) != NULL_TREE
4256 /* Definitions of namespace members outside their namespace are
4258 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
4259 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
4260 || TREE_CODE (type) == UNKNOWN_TYPE
4261 /* The declaration of a template specialization does not affect
4262 the functions available for overload resolution, so we do not
4264 || (TREE_CODE (decl) == FUNCTION_DECL
4265 && DECL_TEMPLATE_SPECIALIZATION (decl)))
4268 return pushdecl (decl);
4271 /* Make the declaration(s) of X appear in CLASS scope
4272 under the name NAME. */
4275 push_class_level_binding (tree name, tree x)
4278 /* The class_binding_level will be NULL if x is a template
4279 parameter name in a member template. */
4280 if (!class_binding_level)
4283 /* Make sure that this new member does not have the same name
4284 as a template parameter. */
4285 if (TYPE_BEING_DEFINED (current_class_type))
4286 check_template_shadow (x);
4288 /* If this declaration shadows a declaration from an enclosing
4289 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
4290 we leave this class. Record the shadowed declaration here. */
4291 binding = IDENTIFIER_BINDING (name);
4293 && ((TREE_CODE (x) == OVERLOAD
4294 && BINDING_VALUE (binding)
4295 && is_overloaded_fn (BINDING_VALUE (binding)))
4296 || INHERITED_VALUE_BINDING_P (binding)))
4301 /* If the old binding was from a base class, and was for a tag
4302 name, slide it over to make room for the new binding. The
4303 old binding is still visible if explicitly qualified with a
4305 if (INHERITED_VALUE_BINDING_P (binding)
4306 && BINDING_VALUE (binding)
4307 && TREE_CODE (BINDING_VALUE (binding)) == TYPE_DECL
4308 && DECL_ARTIFICIAL (BINDING_VALUE (binding))
4309 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
4311 old_decl = BINDING_TYPE (binding);
4312 BINDING_TYPE (binding) = BINDING_VALUE (binding);
4313 BINDING_VALUE (binding) = NULL_TREE;
4314 INHERITED_VALUE_BINDING_P (binding) = 0;
4317 old_decl = BINDING_VALUE (binding);
4319 /* Find the previous binding of name on the class-shadowed
4320 list, and update it. */
4321 for (shadow = class_binding_level->class_shadowed;
4323 shadow = TREE_CHAIN (shadow))
4324 if (TREE_PURPOSE (shadow) == name
4325 && TREE_TYPE (shadow) == old_decl)
4327 BINDING_VALUE (binding) = x;
4328 INHERITED_VALUE_BINDING_P (binding) = 0;
4329 TREE_TYPE (shadow) = x;
4330 IDENTIFIER_CLASS_VALUE (name) = x;
4335 /* If we didn't replace an existing binding, put the binding on the
4336 stack of bindings for the identifier, and update the shadowed list. */
4337 if (push_class_binding (name, x))
4339 class_binding_level->class_shadowed
4340 = tree_cons (name, NULL,
4341 class_binding_level->class_shadowed);
4342 /* Record the value we are binding NAME to so that we can know
4343 what to pop later. */
4344 TREE_TYPE (class_binding_level->class_shadowed) = x;
4348 /* Insert another USING_DECL into the current binding level, returning
4349 this declaration. If this is a redeclaration, do nothing, and
4350 return NULL_TREE if this not in namespace scope (in namespace
4351 scope, a using decl might extend any previous bindings). */
4354 push_using_decl (tree scope, tree name)
4358 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
4359 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
4360 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
4361 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
4364 return namespace_bindings_p () ? decl : NULL_TREE;
4365 decl = build_lang_decl (USING_DECL, name, void_type_node);
4366 DECL_INITIAL (decl) = scope;
4367 TREE_CHAIN (decl) = current_binding_level->usings;
4368 current_binding_level->usings = decl;
4372 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4373 changed (i.e. there was already a directive), or the fresh
4374 TREE_LIST otherwise. */
4377 push_using_directive (tree used)
4379 tree ud = current_binding_level->using_directives;
4380 tree iter, ancestor;
4382 /* Check if we already have this. */
4383 if (purpose_member (used, ud) != NULL_TREE)
4386 /* Recursively add all namespaces used. */
4387 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4388 push_using_directive (TREE_PURPOSE (iter));
4390 ancestor = namespace_ancestor (current_decl_namespace (), used);
4391 ud = current_binding_level->using_directives;
4392 ud = tree_cons (used, ancestor, ud);
4393 current_binding_level->using_directives = ud;
4397 /* DECL is a FUNCTION_DECL for a non-member function, which may have
4398 other definitions already in place. We get around this by making
4399 the value of the identifier point to a list of all the things that
4400 want to be referenced by that name. It is then up to the users of
4401 that name to decide what to do with that list.
4403 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
4404 DECL_TEMPLATE_RESULT. It is dealt with the same way.
4406 FLAGS is a bitwise-or of the following values:
4407 PUSH_LOCAL: Bind DECL in the current scope, rather than at
4409 PUSH_USING: DECL is being pushed as the result of a using
4412 The value returned may be a previous declaration if we guessed wrong
4413 about what language DECL should belong to (C or C++). Otherwise,
4414 it's always DECL (and never something that's not a _DECL). */
4417 push_overloaded_decl (tree decl, int flags)
4419 tree name = DECL_NAME (decl);
4422 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
4425 old = namespace_binding (name, DECL_CONTEXT (decl));
4427 old = lookup_name_current_level (name);
4431 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
4433 tree t = TREE_TYPE (old);
4434 if (IS_AGGR_TYPE (t) && warn_shadow
4435 && (! DECL_IN_SYSTEM_HEADER (decl)
4436 || ! DECL_IN_SYSTEM_HEADER (old)))
4437 warning ("`%#D' hides constructor for `%#T'", decl, t);
4440 else if (is_overloaded_fn (old))
4444 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
4446 tree fn = OVL_CURRENT (tmp);
4448 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
4449 && !(flags & PUSH_USING)
4450 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
4451 TYPE_ARG_TYPES (TREE_TYPE (decl))))
4452 error ("`%#D' conflicts with previous using declaration `%#D'",
4455 if (duplicate_decls (decl, fn))
4459 else if (old == error_mark_node)
4460 /* Ignore the undefined symbol marker. */
4464 cp_error_at ("previous non-function declaration `%#D'", old);
4465 error ("conflicts with function declaration `%#D'", decl);
4470 if (old || TREE_CODE (decl) == TEMPLATE_DECL)
4472 if (old && TREE_CODE (old) != OVERLOAD)
4473 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
4475 new_binding = ovl_cons (decl, old);
4476 if (flags & PUSH_USING)
4477 OVL_USED (new_binding) = 1;
4480 /* NAME is not ambiguous. */
4484 set_namespace_binding (name, current_namespace, new_binding);
4487 /* We only create an OVERLOAD if there was a previous binding at
4488 this level, or if decl is a template. In the former case, we
4489 need to remove the old binding and replace it with the new
4490 binding. We must also run through the NAMES on the binding
4491 level where the name was bound to update the chain. */
4493 if (TREE_CODE (new_binding) == OVERLOAD && old)
4497 for (d = &BINDING_LEVEL (IDENTIFIER_BINDING (name))->names;
4499 d = &TREE_CHAIN (*d))
4501 || (TREE_CODE (*d) == TREE_LIST
4502 && TREE_VALUE (*d) == old))
4504 if (TREE_CODE (*d) == TREE_LIST)
4505 /* Just replace the old binding with the new. */
4506 TREE_VALUE (*d) = new_binding;
4508 /* Build a TREE_LIST to wrap the OVERLOAD. */
4509 *d = tree_cons (NULL_TREE, new_binding,
4512 /* And update the CPLUS_BINDING node. */
4513 BINDING_VALUE (IDENTIFIER_BINDING (name))
4518 /* We should always find a previous binding in this case. */
4522 /* Install the new binding. */
4523 push_local_binding (name, new_binding, flags);
4529 /* Generate an implicit declaration for identifier FUNCTIONID
4530 as a function of type int (). Print a warning if appropriate. */
4533 implicitly_declare (tree functionid)
4537 /* We used to reuse an old implicit decl here,
4538 but this loses with inline functions because it can clobber
4539 the saved decl chains. */
4540 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
4542 DECL_EXTERNAL (decl) = 1;
4543 TREE_PUBLIC (decl) = 1;
4545 /* ISO standard says implicit declarations are in the innermost block.
4546 So we record the decl in the standard fashion. */
4548 rest_of_decl_compilation (decl, NULL, 0, 0);
4551 /* Only one warning per identifier. */
4552 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
4554 pedwarn ("implicit declaration of function `%#D'", decl);
4557 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
4562 /* Return zero if the declaration NEWDECL is valid
4563 when the declaration OLDDECL (assumed to be for the same name)
4564 has already been seen.
4565 Otherwise return an error message format string with a %s
4566 where the identifier should go. */
4569 redeclaration_error_message (tree newdecl, tree olddecl)
4571 if (TREE_CODE (newdecl) == TYPE_DECL)
4573 /* Because C++ can put things into name space for free,
4574 constructs like "typedef struct foo { ... } foo"
4575 would look like an erroneous redeclaration. */
4576 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
4579 return "redefinition of `%#D'";
4581 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
4583 /* If this is a pure function, its olddecl will actually be
4584 the original initialization to `0' (which we force to call
4585 abort()). Don't complain about redefinition in this case. */
4586 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
4589 /* If both functions come from different namespaces, this is not
4590 a redeclaration - this is a conflict with a used function. */
4591 if (DECL_NAMESPACE_SCOPE_P (olddecl)
4592 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
4593 return "`%D' conflicts with used function";
4595 /* We'll complain about linkage mismatches in
4596 warn_extern_redeclared_static. */
4598 /* Defining the same name twice is no good. */
4599 if (DECL_INITIAL (olddecl) != NULL_TREE
4600 && DECL_INITIAL (newdecl) != NULL_TREE)
4602 if (DECL_NAME (olddecl) == NULL_TREE)
4603 return "`%#D' not declared in class";
4605 return "redefinition of `%#D'";
4609 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
4611 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
4612 && (DECL_TEMPLATE_RESULT (newdecl)
4613 != DECL_TEMPLATE_RESULT (olddecl))
4614 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
4615 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
4616 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
4617 && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
4618 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
4619 return "redefinition of `%#D'";
4622 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
4624 /* Objects declared at top level: */
4625 /* If at least one is a reference, it's ok. */
4626 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
4628 /* Reject two definitions. */
4629 return "redefinition of `%#D'";
4633 /* Objects declared with block scope: */
4634 /* Reject two definitions, and reject a definition
4635 together with an external reference. */
4636 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
4637 return "redeclaration of `%#D'";
4642 /* Create a new label, named ID. */
4645 make_label_decl (tree id, int local_p)
4649 decl = build_decl (LABEL_DECL, id, void_type_node);
4651 /* Make sure every label has an rtx. */
4654 DECL_CONTEXT (decl) = current_function_decl;
4655 DECL_MODE (decl) = VOIDmode;
4656 C_DECLARED_LABEL_FLAG (decl) = local_p;
4658 /* Say where one reference is to the label, for the sake of the
4659 error if it is not defined. */
4660 DECL_SOURCE_LINE (decl) = lineno;
4661 DECL_SOURCE_FILE (decl) = input_filename;
4663 /* Record the fact that this identifier is bound to this label. */
4664 SET_IDENTIFIER_LABEL_VALUE (id, decl);
4669 /* Record this label on the list of used labels so that we can check
4670 at the end of the function to see whether or not the label was
4671 actually defined, and so we can check when the label is defined whether
4672 this use is valid. */
4675 use_label (tree decl)
4677 if (named_label_uses == NULL
4678 || named_label_uses->names_in_scope != current_binding_level->names
4679 || named_label_uses->label_decl != decl)
4681 struct named_label_use_list *new_ent;
4682 new_ent = ((struct named_label_use_list *)
4683 ggc_alloc (sizeof (struct named_label_use_list)));
4684 new_ent->label_decl = decl;
4685 new_ent->names_in_scope = current_binding_level->names;
4686 new_ent->binding_level = current_binding_level;
4687 new_ent->lineno_o_goto = lineno;
4688 new_ent->filename_o_goto = input_filename;
4689 new_ent->next = named_label_uses;
4690 named_label_uses = new_ent;
4694 /* Look for a label named ID in the current function. If one cannot
4695 be found, create one. (We keep track of used, but undefined,
4696 labels, and complain about them at the end of a function.) */
4699 lookup_label (tree id)
4702 struct named_label_list *ent;
4704 /* You can't use labels at global scope. */
4705 if (current_function_decl == NULL_TREE)
4707 error ("label `%s' referenced outside of any function",
4708 IDENTIFIER_POINTER (id));
4712 /* See if we've already got this label. */
4713 decl = IDENTIFIER_LABEL_VALUE (id);
4714 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
4717 /* Record this label on the list of labels used in this function.
4718 We do this before calling make_label_decl so that we get the
4719 IDENTIFIER_LABEL_VALUE before the new label is declared. */
4720 ent = ((struct named_label_list *)
4721 ggc_alloc_cleared (sizeof (struct named_label_list)));
4722 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
4723 ent->next = named_labels;
4726 /* We need a new label. */
4727 decl = make_label_decl (id, /*local_p=*/0);
4729 /* Now fill in the information we didn't have before. */
4730 ent->label_decl = decl;
4735 /* Declare a local label named ID. */
4738 declare_local_label (tree id)
4742 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
4743 this scope we can restore the old value of
4744 IDENTIFIER_TYPE_VALUE. */
4745 current_binding_level->shadowed_labels
4746 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
4747 current_binding_level->shadowed_labels);
4748 /* Look for the label. */
4749 decl = make_label_decl (id, /*local_p=*/1);
4750 /* Now fill in the information we didn't have before. */
4751 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
4756 /* Returns nonzero if it is ill-formed to jump past the declaration of
4757 DECL. Returns 2 if it's also a real problem. */
4760 decl_jump_unsafe (tree decl)
4762 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
4765 if (DECL_INITIAL (decl) == NULL_TREE
4766 && pod_type_p (TREE_TYPE (decl)))
4769 /* This is really only important if we're crossing an initialization.
4770 The POD stuff is just pedantry; why should it matter if the class
4771 contains a field of pointer to member type? */
4772 if (DECL_INITIAL (decl)
4773 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
4778 /* Check that a single previously seen jump to a newly defined label
4779 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
4780 the jump context; NAMES are the names in scope in LEVEL at the jump
4781 context; FILE and LINE are the source position of the jump or 0. */
4784 check_previous_goto_1 (tree decl,
4785 struct cp_binding_level* level,
4792 struct cp_binding_level *b = current_binding_level;
4793 for (; b; b = b->level_chain)
4795 tree new_decls = b->names;
4796 tree old_decls = (b == level ? names : NULL_TREE);
4797 for (; new_decls != old_decls;
4798 new_decls = TREE_CHAIN (new_decls))
4800 int problem = decl_jump_unsafe (new_decls);
4807 pedwarn ("jump to label `%D'", decl);
4809 pedwarn ("jump to case label");
4812 pedwarn_with_file_and_line (file, line, " from here");
4817 cp_error_at (" crosses initialization of `%#D'",
4820 cp_pedwarn_at (" enters scope of non-POD `%#D'",
4826 if ((b->is_try_scope || b->is_catch_scope) && ! saw_eh)
4831 pedwarn ("jump to label `%D'", decl);
4833 pedwarn ("jump to case label");
4836 pedwarn_with_file_and_line (file, line, " from here");
4839 if (b->is_try_scope)
4840 error (" enters try block");
4842 error (" enters catch block");
4849 check_previous_goto (struct named_label_use_list* use)
4851 check_previous_goto_1 (use->label_decl, use->binding_level,
4852 use->names_in_scope, use->filename_o_goto,
4853 use->lineno_o_goto);
4857 check_switch_goto (struct cp_binding_level* level)
4859 check_previous_goto_1 (NULL_TREE, level, level->names, NULL, 0);
4862 /* Check that any previously seen jumps to a newly defined label DECL
4863 are OK. Called by define_label. */
4866 check_previous_gotos (tree decl)
4868 struct named_label_use_list **usep;
4870 if (! TREE_USED (decl))
4873 for (usep = &named_label_uses; *usep; )
4875 struct named_label_use_list *use = *usep;
4876 if (use->label_decl == decl)
4878 check_previous_goto (use);
4882 usep = &(use->next);
4886 /* Check that a new jump to a label DECL is OK. Called by
4887 finish_goto_stmt. */
4890 check_goto (tree decl)
4894 struct named_label_list *lab;
4896 /* We can't know where a computed goto is jumping. So we assume
4898 if (! DECL_P (decl))
4901 /* If the label hasn't been defined yet, defer checking. */
4902 if (! DECL_INITIAL (decl))
4908 for (lab = named_labels; lab; lab = lab->next)
4909 if (decl == lab->label_decl)
4912 /* If the label is not on named_labels it's a gcc local label, so
4913 it must be in an outer scope, so jumping to it is always OK. */
4917 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
4920 cp_pedwarn_at ("jump to label `%D'", decl);
4921 pedwarn (" from here");
4925 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
4927 tree b = TREE_VALUE (bad);
4928 int u = decl_jump_unsafe (b);
4930 if (u > 1 && DECL_ARTIFICIAL (b))
4931 /* Can't skip init of __exception_info. */
4932 cp_error_at (" enters catch block", b);
4934 cp_error_at (" skips initialization of `%#D'", b);
4936 cp_pedwarn_at (" enters scope of non-POD `%#D'", b);
4939 if (lab->in_try_scope)
4940 error (" enters try block");
4941 else if (lab->in_catch_scope)
4942 error (" enters catch block");
4945 /* Define a label, specifying the location in the source file.
4946 Return the LABEL_DECL node for the label, if the definition is valid.
4947 Otherwise return 0. */
4950 define_label (const char* filename, int line, tree name)
4952 tree decl = lookup_label (name);
4953 struct named_label_list *ent;
4954 register struct cp_binding_level *p;
4956 for (ent = named_labels; ent; ent = ent->next)
4957 if (ent->label_decl == decl)
4960 /* After labels, make any new cleanups in the function go into their
4961 own new (temporary) binding contour. */
4962 for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
4963 p->more_cleanups_ok = 0;
4965 if (name == get_identifier ("wchar_t"))
4966 pedwarn ("label named wchar_t");
4968 if (DECL_INITIAL (decl) != NULL_TREE)
4970 error ("duplicate label `%D'", decl);
4975 /* Mark label as having been defined. */
4976 DECL_INITIAL (decl) = error_mark_node;
4977 /* Say where in the source. */
4978 DECL_SOURCE_FILE (decl) = filename;
4979 DECL_SOURCE_LINE (decl) = line;
4982 ent->names_in_scope = current_binding_level->names;
4983 ent->binding_level = current_binding_level;
4985 check_previous_gotos (decl);
4992 struct cp_binding_level *level;
4993 struct cp_switch *next;
4994 /* The SWITCH_STMT being built. */
4996 /* A splay-tree mapping the low element of a case range to the high
4997 element, or NULL_TREE if there is no high element. Used to
4998 determine whether or not a new case label duplicates an old case
4999 label. We need a tree, rather than simply a hash table, because
5000 of the GNU case range extension. */
5004 /* A stack of the currently active switch statements. The innermost
5005 switch statement is on the top of the stack. There is no need to
5006 mark the stack for garbage collection because it is only active
5007 during the processing of the body of a function, and we never
5008 collect at that point. */
5010 static struct cp_switch *switch_stack;
5012 /* Called right after a switch-statement condition is parsed.
5013 SWITCH_STMT is the switch statement being parsed. */
5016 push_switch (tree switch_stmt)
5019 = (struct cp_switch *) xmalloc (sizeof (struct cp_switch));
5020 p->level = current_binding_level;
5021 p->next = switch_stack;
5022 p->switch_stmt = switch_stmt;
5023 p->cases = splay_tree_new (case_compare, NULL, NULL);
5030 struct cp_switch *cs;
5033 splay_tree_delete (cs->cases);
5034 switch_stack = switch_stack->next;
5038 /* Note that we've seen a definition of a case label, and complain if this
5039 is a bad place for one. */
5042 finish_case_label (tree low_value, tree high_value)
5045 register struct cp_binding_level *p;
5050 error ("case label not within a switch statement");
5052 error ("case label `%E' not within a switch statement",
5055 error ("`default' label not within a switch statement");
5059 if (processing_template_decl)
5063 /* For templates, just add the case label; we'll do semantic
5064 analysis at instantiation-time. */
5065 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5066 return add_stmt (build_case_label (low_value, high_value, label));
5069 /* Find the condition on which this switch statement depends. */
5070 cond = SWITCH_COND (switch_stack->switch_stmt);
5071 if (cond && TREE_CODE (cond) == TREE_LIST)
5072 cond = TREE_VALUE (cond);
5074 r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
5075 if (r == error_mark_node)
5078 check_switch_goto (switch_stack->level);
5080 /* After labels, make any new cleanups in the function go into their
5081 own new (temporary) binding contour. */
5082 for (p = current_binding_level; !(p->parm_flag); p = p->level_chain)
5083 p->more_cleanups_ok = 0;
5088 /* Return the list of declarations of the current level.
5089 Note that this list is in reverse order unless/until
5090 you nreverse it; and when you do nreverse it, you must
5091 store the result back using `storedecls' or you will lose. */
5096 return current_binding_level->names;
5099 /* Return the list of type-tags (for structs, etc) of the current level. */
5104 return current_binding_level->tags;
5107 /* Store the list of declarations of the current level.
5108 This is done for the parameter declarations of a function being defined,
5109 after they are modified in the light of any missing parameters. */
5112 storedecls (tree decls)
5114 current_binding_level->names = decls;
5117 /* Similarly, store the list of tags of the current level. */
5120 storetags (tree tags)
5122 current_binding_level->tags = tags;
5125 /* Return the type that should be used when TYPE's name is preceded
5126 by a tag such as 'struct' or 'union', or null if the name cannot
5127 be used in this way.
5129 For example, when processing the third line of:
5135 lookup of A will find the typedef. Given A's typedef, this function
5136 will return the type associated with "struct A". For the tag to be
5137 anything other than TYPE, TYPE must be a typedef whose original type
5138 has the same name and context as TYPE itself.
5140 It is not valid for a typedef of an anonymous type to be used with
5143 typedef struct { ... } B;
5146 Return null for this case. */
5149 follow_tag_typedef (tree type)
5153 original = original_type (type);
5154 if (! TYPE_NAME (original))
5156 if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
5157 && (CP_DECL_CONTEXT (TYPE_NAME (original))
5158 == CP_DECL_CONTEXT (TYPE_NAME (type)))
5159 && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
5165 /* Given NAME, an IDENTIFIER_NODE,
5166 return the structure (or union or enum) definition for that name.
5167 Searches binding levels from BINDING_LEVEL up to the global level.
5168 If THISLEVEL_ONLY is nonzero, searches only the specified context
5169 (but skips any tag-transparent contexts to find one that is
5170 meaningful for tags).
5171 FORM says which kind of type the caller wants;
5172 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
5173 If the wrong kind of type is found, and it's not a template, an error is
5177 lookup_tag (enum tree_code form,
5179 struct cp_binding_level* binding_level,
5182 register struct cp_binding_level *level;
5183 /* Nonzero if, we should look past a template parameter level, even
5184 if THISLEVEL_ONLY. */
5185 int allow_template_parms_p = 1;
5187 for (level = binding_level; level; level = level->level_chain)
5190 if (ANON_AGGRNAME_P (name))
5191 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5193 /* There's no need for error checking here, because
5194 anon names are unique throughout the compilation. */
5195 if (TYPE_IDENTIFIER (TREE_VALUE (tail)) == name)
5196 return TREE_VALUE (tail);
5198 else if (level->namespace_p)
5199 /* Do namespace lookup. */
5200 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
5202 tree old = binding_for_name (name, tail);
5204 /* If we just skipped past a template parameter level,
5205 even though THISLEVEL_ONLY, and we find a template
5206 class declaration, then we use the _TYPE node for the
5207 template. See the example below. */
5208 if (thislevel_only && !allow_template_parms_p
5209 && old && BINDING_VALUE (old)
5210 && DECL_CLASS_TEMPLATE_P (BINDING_VALUE (old)))
5211 old = TREE_TYPE (BINDING_VALUE (old));
5213 old = BINDING_TYPE (old);
5217 /* We've found something at this binding level. If it is
5218 a typedef, extract the tag it refers to. Lookup fails
5219 if the typedef doesn't refer to a taggable type. */
5220 old = follow_tag_typedef (old);
5223 if (TREE_CODE (old) != form
5224 && (form == ENUMERAL_TYPE
5225 || TREE_CODE (old) == ENUMERAL_TYPE))
5227 error ("`%#D' redeclared as %C", old, form);
5232 if (thislevel_only || tail == global_namespace)
5236 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5238 if (TREE_PURPOSE (tail) == name)
5240 enum tree_code code = TREE_CODE (TREE_VALUE (tail));
5243 && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
5245 /* Definition isn't the kind we were looking for. */
5246 error ("`%#D' redeclared as %C", TREE_VALUE (tail), form);
5249 return TREE_VALUE (tail);
5252 if (thislevel_only && ! level->tag_transparent)
5254 if (level->template_parms_p && allow_template_parms_p)
5256 /* We must deal with cases like this:
5258 template <class T> struct S;
5259 template <class T> struct S {};
5261 When looking up `S', for the second declaration, we
5262 would like to find the first declaration. But, we
5263 are in the pseudo-global level created for the
5264 template parameters, rather than the (surrounding)
5265 namespace level. Thus, we keep going one more level,
5266 even though THISLEVEL_ONLY is nonzero. */
5267 allow_template_parms_p = 0;
5277 /* Given a type, find the tag that was defined for it and return the tag name.
5278 Otherwise return 0. However, the value can never be 0
5279 in the cases in which this is used.
5281 C++: If NAME is nonzero, this is the new name to install. This is
5282 done when replacing anonymous tags with real tag names. */
5285 lookup_tag_reverse (tree type, tree name)
5287 register struct cp_binding_level *level;
5289 for (level = current_binding_level; level; level = level->level_chain)
5292 for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
5294 if (TREE_VALUE (tail) == type)
5297 TREE_PURPOSE (tail) = name;
5298 return TREE_PURPOSE (tail);
5305 /* Look up NAME in the NAMESPACE. */
5308 lookup_namespace_name (tree namespace, tree name)
5311 tree template_id = NULL_TREE;
5313 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
5315 if (TREE_CODE (name) == NAMESPACE_DECL)
5316 /* This happens for A::B<int> when B is a namespace. */
5318 else if (TREE_CODE (name) == TEMPLATE_DECL)
5320 /* This happens for A::B where B is a template, and there are no
5321 template arguments. */
5322 error ("invalid use of `%D'", name);
5323 return error_mark_node;
5326 namespace = ORIGINAL_NAMESPACE (namespace);
5328 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5331 name = TREE_OPERAND (name, 0);
5332 if (TREE_CODE (name) == OVERLOAD)
5333 name = DECL_NAME (OVL_CURRENT (name));
5334 else if (DECL_P (name))
5335 name = DECL_NAME (name);
5338 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
5340 val = make_node (CPLUS_BINDING);
5341 if (!qualified_lookup_using_namespace (name, namespace, val, 0))
5342 return error_mark_node;
5344 if (BINDING_VALUE (val))
5346 val = BINDING_VALUE (val);
5350 if (DECL_CLASS_TEMPLATE_P (val))
5351 val = lookup_template_class (val,
5352 TREE_OPERAND (template_id, 1),
5353 /*in_decl=*/NULL_TREE,
5354 /*context=*/NULL_TREE,
5355 /*entering_scope=*/0,
5356 tf_error | tf_warning);
5357 else if (DECL_FUNCTION_TEMPLATE_P (val)
5358 || TREE_CODE (val) == OVERLOAD)
5359 val = lookup_template_function (val,
5360 TREE_OPERAND (template_id, 1));
5363 error ("`%D::%D' is not a template",
5365 return error_mark_node;
5369 /* If we have a single function from a using decl, pull it out. */
5370 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5371 val = OVL_FUNCTION (val);
5373 /* Ignore built-in functions that haven't been prototyped yet. */
5374 if (!val || !DECL_P(val)
5375 || !DECL_LANG_SPECIFIC(val)
5376 || !DECL_ANTICIPATED (val))
5380 error ("`%D' undeclared in namespace `%D'", name, namespace);
5381 return error_mark_node;
5384 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
5387 typename_hash (const void* k)
5392 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
5393 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
5398 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
5401 typename_compare (const void * k1, const void * k2)
5410 d1 = TYPE_NAME (t1);
5411 d2 = TYPE_NAME (t2);
5413 return (DECL_NAME (d1) == DECL_NAME (d2)
5414 && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
5415 && ((TREE_TYPE (t1) != NULL_TREE)
5416 == (TREE_TYPE (t2) != NULL_TREE))
5417 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
5418 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
5421 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
5422 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
5423 is non-NULL, this type is being created by the implicit typename
5424 extension, and BASE_TYPE is a type named `t' in some base class of
5425 `T' which depends on template parameters.
5427 Returns the new TYPENAME_TYPE. */
5429 static GTY ((param_is (union tree_node))) htab_t typename_htab;
5432 build_typename_type (tree context, tree name, tree fullname)
5438 if (typename_htab == NULL)
5440 typename_htab = htab_create_ggc (61, &typename_hash,
5441 &typename_compare, NULL);
5444 /* Build the TYPENAME_TYPE. */
5445 t = make_aggr_type (TYPENAME_TYPE);
5446 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5447 TYPENAME_TYPE_FULLNAME (t) = fullname;
5449 /* Build the corresponding TYPE_DECL. */
5450 d = build_decl (TYPE_DECL, name, t);
5451 TYPE_NAME (TREE_TYPE (d)) = d;
5452 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5453 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5454 DECL_ARTIFICIAL (d) = 1;
5456 /* See if we already have this type. */
5457 e = htab_find_slot (typename_htab, t, INSERT);
5466 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
5467 unless an error occurs, in which case error_mark_node is returned.
5468 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
5469 set, we return that, rather than the _TYPE it corresponds to, in
5470 other cases we look through the type decl. If TF_ERROR is set,
5471 complain about errors, otherwise be quiet. */
5474 make_typename_type (tree context, tree name, tsubst_flags_t complain)
5480 if (!(TYPE_LANG_SPECIFIC (name)
5481 && (CLASSTYPE_IS_TEMPLATE (name)
5482 || CLASSTYPE_USE_TEMPLATE (name))))
5483 name = TYPE_IDENTIFIER (name);
5485 /* Create a TEMPLATE_ID_EXPR for the type. */
5486 name = build_nt (TEMPLATE_ID_EXPR,
5487 CLASSTYPE_TI_TEMPLATE (name),
5488 CLASSTYPE_TI_ARGS (name));
5490 else if (TREE_CODE (name) == TYPE_DECL)
5491 name = DECL_NAME (name);
5495 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
5497 name = TREE_OPERAND (name, 0);
5498 if (TREE_CODE (name) == TEMPLATE_DECL)
5499 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
5501 if (TREE_CODE (name) == TEMPLATE_DECL)
5503 error ("`%D' used without template parameters", name);
5504 return error_mark_node;
5506 if (TREE_CODE (name) != IDENTIFIER_NODE)
5509 if (TREE_CODE (context) == NAMESPACE_DECL)
5511 /* We can get here from typename_sub0 in the explicit_template_type
5512 expansion. Just fail. */
5513 if (complain & tf_error)
5514 error ("no class template named `%#T' in `%#T'",
5516 return error_mark_node;
5519 if (! uses_template_parms (context)
5520 || currently_open_class (context))
5522 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
5524 tree tmpl = NULL_TREE;
5525 if (IS_AGGR_TYPE (context))
5526 tmpl = lookup_field (context, name, 0, 0);
5527 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5529 if (complain & tf_error)
5530 error ("no class template named `%#T' in `%#T'",
5532 return error_mark_node;
5535 if (complain & tf_error)
5537 if (complain & tf_parsing)
5538 perform_or_defer_access_check (context, tmpl);
5540 enforce_access (context, tmpl);
5543 return lookup_template_class (tmpl,
5544 TREE_OPERAND (fullname, 1),
5546 /*entering_scope=*/0,
5547 tf_error | tf_warning);
5553 if (!IS_AGGR_TYPE (context))
5555 if (complain & tf_error)
5556 error ("no type named `%#T' in `%#T'", name, context);
5557 return error_mark_node;
5560 t = lookup_field (context, name, 0, 1);
5563 if (TREE_CODE (t) != TYPE_DECL)
5565 if (complain & tf_error)
5566 error ("no type named `%#T' in `%#T'", name, context);
5567 return error_mark_node;
5570 if (complain & tf_error)
5572 if (complain & tf_parsing)
5573 perform_or_defer_access_check (context, t);
5575 enforce_access (context, t);
5578 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
5586 /* If the CONTEXT is not a template type, then either the field is
5587 there now or its never going to be. */
5588 if (!uses_template_parms (context))
5590 if (complain & tf_error)
5591 error ("no type named `%#T' in `%#T'", name, context);
5592 return error_mark_node;
5595 return build_typename_type (context, name, fullname);
5598 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
5599 unless an error occurs, in which case error_mark_node is returned.
5600 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
5601 corresponds to. If COMPLAIN zero, don't complain about any errors
5605 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
5611 name = TYPE_IDENTIFIER (name);
5612 else if (DECL_P (name))
5613 name = DECL_NAME (name);
5614 if (TREE_CODE (name) != IDENTIFIER_NODE)
5617 if (!uses_template_parms (context)
5618 || currently_open_class (context))
5620 tree tmpl = NULL_TREE;
5622 if (IS_AGGR_TYPE (context))
5623 tmpl = lookup_field (context, name, 0, 0);
5625 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
5627 if (complain & tf_error)
5628 error ("no class template named `%#T' in `%#T'", name, context);
5629 return error_mark_node;
5632 if (complain & tf_error)
5634 if (complain & tf_parsing)
5635 perform_or_defer_access_check (context, tmpl);
5637 enforce_access (context, tmpl);
5643 /* Build the UNBOUND_CLASS_TEMPLATE. */
5644 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
5645 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
5646 TREE_TYPE (t) = NULL_TREE;
5648 /* Build the corresponding TEMPLATE_DECL. */
5649 d = build_decl (TEMPLATE_DECL, name, t);
5650 TYPE_NAME (TREE_TYPE (d)) = d;
5651 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
5652 DECL_CONTEXT (d) = FROB_CONTEXT (context);
5653 DECL_ARTIFICIAL (d) = 1;
5658 /* Select the right _DECL from multiple choices. */
5661 select_decl (tree binding, int flags)
5664 val = BINDING_VALUE (binding);
5666 if (LOOKUP_NAMESPACES_ONLY (flags))
5668 /* We are not interested in types. */
5669 if (val && TREE_CODE (val) == NAMESPACE_DECL)
5674 /* If we could have a type and
5675 we have nothing or we need a type and have none. */
5676 if (BINDING_TYPE (binding)
5677 && (!val || ((flags & LOOKUP_PREFER_TYPES)
5678 && TREE_CODE (val) != TYPE_DECL)))
5679 val = TYPE_STUB_DECL (BINDING_TYPE (binding));
5680 /* Don't return non-types if we really prefer types. */
5681 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
5682 && (TREE_CODE (val) != TEMPLATE_DECL
5683 || !DECL_CLASS_TEMPLATE_P (val)))
5689 /* Unscoped lookup of a global: iterate over current namespaces,
5690 considering using-directives. If SPACESP is non-NULL, store a list
5691 of the namespaces we've considered in it. */
5694 unqualified_namespace_lookup (tree name, int flags, tree* spacesp)
5696 tree b = make_node (CPLUS_BINDING);
5697 tree initial = current_decl_namespace ();
5698 tree scope = initial;
5700 struct cp_binding_level *level;
5701 tree val = NULL_TREE;
5704 *spacesp = NULL_TREE;
5706 for (; !val; scope = CP_DECL_CONTEXT (scope))
5709 *spacesp = tree_cons (scope, NULL_TREE, *spacesp);
5710 val = binding_for_name (name, scope);
5712 /* Ignore anticipated built-in functions. */
5713 if (val && BINDING_VALUE (val)
5714 && DECL_P (BINDING_VALUE (val))
5715 && DECL_LANG_SPECIFIC (BINDING_VALUE (val))
5716 && DECL_ANTICIPATED (BINDING_VALUE (val)))
5718 BINDING_VALUE (b) = NULL_TREE;
5719 BINDING_TYPE (b) = NULL_TREE;
5723 /* Initialize binding for this context. */
5724 BINDING_VALUE (b) = BINDING_VALUE (val);
5725 BINDING_TYPE (b) = BINDING_TYPE (val);
5728 /* Add all _DECLs seen through local using-directives. */
5729 for (level = current_binding_level;
5730 !level->namespace_p;
5731 level = level->level_chain)
5732 if (!lookup_using_namespace (name, b, level->using_directives,
5733 scope, flags, spacesp))
5734 /* Give up because of error. */
5735 return error_mark_node;
5737 /* Add all _DECLs seen through global using-directives. */
5738 /* XXX local and global using lists should work equally. */
5742 if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
5743 scope, flags, spacesp))
5744 /* Give up because of error. */
5745 return error_mark_node;
5746 if (siter == scope) break;
5747 siter = CP_DECL_CONTEXT (siter);
5750 val = select_decl (b, flags);
5751 if (scope == global_namespace)
5757 /* Combine prefer_type and namespaces_only into flags. */
5760 lookup_flags (int prefer_type, int namespaces_only)
5762 if (namespaces_only)
5763 return LOOKUP_PREFER_NAMESPACES;
5764 if (prefer_type > 1)
5765 return LOOKUP_PREFER_TYPES;
5766 if (prefer_type > 0)
5767 return LOOKUP_PREFER_BOTH;
5771 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
5772 ignore it or not. Subroutine of lookup_name_real. */
5775 qualify_lookup (tree val, int flags)
5777 if (val == NULL_TREE)
5779 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
5781 if ((flags & LOOKUP_PREFER_TYPES) && TREE_CODE (val) == TYPE_DECL)
5783 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
5788 /* Any other BINDING overrides an implicit TYPENAME. Warn about
5792 warn_about_implicit_typename_lookup (tree typename, tree binding)
5794 tree subtype = TREE_TYPE (TREE_TYPE (typename));
5795 tree name = DECL_NAME (typename);
5797 if (! (TREE_CODE (binding) == TEMPLATE_DECL
5798 && CLASSTYPE_TEMPLATE_INFO (subtype)
5799 && CLASSTYPE_TI_TEMPLATE (subtype) == binding)
5800 && ! (TREE_CODE (binding) == TYPE_DECL
5801 && same_type_p (TREE_TYPE (binding), subtype)))
5803 warning ("lookup of `%D' finds `%#D'",
5805 warning (" instead of `%D' from dependent base class",
5807 warning (" (use `typename %T::%D' if that's what you meant)",
5808 constructor_name (current_class_type), name);
5812 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
5813 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
5816 Returns a DECL (or OVERLOAD, or BASELINK) representing the
5817 declaration found. */
5820 lookup_qualified_name (tree scope, tree name, bool is_type_p, int flags)
5822 if (TREE_CODE (scope) == NAMESPACE_DECL)
5826 val = make_node (CPLUS_BINDING);
5827 flags |= LOOKUP_COMPLAIN;
5829 flags |= LOOKUP_PREFER_TYPES;
5830 if (!qualified_lookup_using_namespace (name, scope, val, flags))
5832 return select_decl (val, flags);
5835 return lookup_member (scope, name, 0, is_type_p);
5838 /* Check to see whether or not DECL is a variable that would have been
5839 in scope under the ARM, but is not in scope under the ANSI/ISO
5840 standard. If so, issue an error message. If name lookup would
5841 work in both cases, but return a different result, this function
5842 returns the result of ANSI/ISO lookup. Otherwise, it returns
5846 check_for_out_of_scope_variable (tree decl)
5850 /* We only care about out of scope variables. */
5851 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
5854 shadowed = DECL_SHADOWED_FOR_VAR (decl);
5855 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
5856 && DECL_DEAD_FOR_LOCAL (shadowed))
5857 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
5859 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
5862 if (!DECL_ERROR_REPORTED (decl))
5864 warning ("name lookup of `%D' changed",
5866 cp_warning_at (" matches this `%D' under ISO standard rules",
5868 cp_warning_at (" matches this `%D' under old rules", decl);
5869 DECL_ERROR_REPORTED (decl) = 1;
5874 /* If we have already complained about this declaration, there's no
5875 need to do it again. */
5876 if (DECL_ERROR_REPORTED (decl))
5879 DECL_ERROR_REPORTED (decl) = 1;
5880 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5882 error ("name lookup of `%D' changed for new ISO `for' scoping",
5884 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl);
5885 return error_mark_node;
5889 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
5891 cp_pedwarn_at (" using obsolete binding at `%D'", decl);
5897 /* Look up NAME in the current binding level and its superiors in the
5898 namespace of variables, functions and typedefs. Return a ..._DECL
5899 node of some kind representing its definition if there is only one
5900 such declaration, or return a TREE_LIST with all the overloaded
5901 definitions if there are many, or return 0 if it is undefined.
5903 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
5904 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
5905 Otherwise we prefer non-TYPE_DECLs.
5907 If NONCLASS is nonzero, we don't look for the NAME in class scope,
5908 using IDENTIFIER_CLASS_VALUE. */
5911 lookup_name_real (tree name,
5914 int namespaces_only,
5918 tree val = NULL_TREE;
5920 /* Conversion operators are handled specially because ordinary
5921 unqualified name lookup will not find template conversion
5923 if (IDENTIFIER_TYPENAME_P (name))
5925 struct cp_binding_level *level;
5927 for (level = current_binding_level;
5928 level && !level->namespace_p;
5929 level = level->level_chain)
5934 /* A conversion operator can only be declared in a class
5936 if (level->parm_flag != 2)
5939 /* Lookup the conversion operator in the class. */
5940 class_type = level->this_class;
5941 operators = lookup_fnfields (class_type, name, /*protect=*/0);
5949 flags |= lookup_flags (prefer_type, namespaces_only);
5951 /* First, look in non-namespace scopes. */
5953 if (current_class_type == NULL_TREE)
5956 for (t = IDENTIFIER_BINDING (name); t; t = TREE_CHAIN (t))
5960 if (!LOCAL_BINDING_P (t) && nonclass)
5961 /* We're not looking for class-scoped bindings, so keep going. */
5964 /* If this is the kind of thing we're looking for, we're done. */
5965 if (qualify_lookup (BINDING_VALUE (t), flags))
5966 binding = BINDING_VALUE (t);
5967 else if ((flags & LOOKUP_PREFER_TYPES)
5968 && qualify_lookup (BINDING_TYPE (t), flags))
5969 binding = BINDING_TYPE (t);
5971 binding = NULL_TREE;
5980 /* Now lookup in namespace scopes. */
5983 t = unqualified_namespace_lookup (name, flags, 0);
5990 /* If we have a single function from a using decl, pull it out. */
5991 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
5992 val = OVL_FUNCTION (val);
5999 lookup_name_nonclass (tree name)
6001 return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
6005 lookup_function_nonclass (tree name, tree args)
6007 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
6011 lookup_name (tree name, int prefer_type)
6013 return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
6016 /* Similar to `lookup_name' but look only in the innermost non-class
6020 lookup_name_current_level (tree name)
6022 struct cp_binding_level *b;
6025 b = current_binding_level;
6026 while (b->parm_flag == 2)
6031 t = IDENTIFIER_NAMESPACE_VALUE (name);
6033 /* extern "C" function() */
6034 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
6037 else if (IDENTIFIER_BINDING (name)
6038 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
6042 if (BINDING_LEVEL (IDENTIFIER_BINDING (name)) == b)
6043 return IDENTIFIER_VALUE (name);
6055 /* Like lookup_name_current_level, but for types. */
6058 lookup_type_current_level (tree name)
6060 register tree t = NULL_TREE;
6062 my_friendly_assert (! current_binding_level->namespace_p, 980716);
6064 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
6065 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
6067 struct cp_binding_level *b = current_binding_level;
6070 if (purpose_member (name, b->type_shadowed))
6071 return REAL_IDENTIFIER_TYPE_VALUE (name);
6083 /* Push the declarations of builtin types into the namespace.
6084 RID_INDEX is the index of the builtin type
6085 in the array RID_POINTERS. NAME is the name used when looking
6086 up the builtin type. TYPE is the _TYPE node for the builtin type. */
6089 record_builtin_type (enum rid rid_index,
6093 tree rname = NULL_TREE, tname = NULL_TREE;
6094 tree tdecl = NULL_TREE;
6096 if ((int) rid_index < (int) RID_MAX)
6097 rname = ridpointers[(int) rid_index];
6099 tname = get_identifier (name);
6101 TYPE_BUILT_IN (type) = 1;
6105 tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
6106 set_identifier_type_value (tname, NULL_TREE);
6107 if ((int) rid_index < (int) RID_MAX)
6108 /* Built-in types live in the global namespace. */
6109 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
6111 if (rname != NULL_TREE)
6113 if (tname != NULL_TREE)
6115 set_identifier_type_value (rname, NULL_TREE);
6116 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
6120 tdecl = pushdecl (build_decl (TYPE_DECL, rname, type));
6121 set_identifier_type_value (rname, NULL_TREE);
6126 /* Record one of the standard Java types.
6127 * Declare it as having the given NAME.
6128 * If SIZE > 0, it is the size of one of the integral types;
6129 * otherwise it is the negative of the size of one of the other types. */
6132 record_builtin_java_type (const char* name, int size)
6136 type = make_signed_type (size);
6137 else if (size > -32)
6138 { /* "__java_char" or ""__java_boolean". */
6139 type = make_unsigned_type (-size);
6140 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
6143 { /* "__java_float" or ""__java_double". */
6144 type = make_node (REAL_TYPE);
6145 TYPE_PRECISION (type) = - size;
6148 record_builtin_type (RID_MAX, name, type);
6149 decl = TYPE_NAME (type);
6151 /* Suppress generate debug symbol entries for these types,
6152 since for normal C++ they are just clutter.
6153 However, push_lang_context undoes this if extern "Java" is seen. */
6154 DECL_IGNORED_P (decl) = 1;
6156 TYPE_FOR_JAVA (type) = 1;
6160 /* Push a type into the namespace so that the back-ends ignore it. */
6163 record_unknown_type (tree type, const char* name)
6165 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
6166 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
6167 DECL_IGNORED_P (decl) = 1;
6168 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6169 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
6170 TYPE_ALIGN (type) = 1;
6171 TYPE_USER_ALIGN (type) = 0;
6172 TYPE_MODE (type) = TYPE_MODE (void_type_node);
6175 /* An string for which we should create an IDENTIFIER_NODE at
6178 typedef struct predefined_identifier
6180 /* The name of the identifier. */
6181 const char *const name;
6182 /* The place where the IDENTIFIER_NODE should be stored. */
6184 /* Nonzero if this is the name of a constructor or destructor. */
6185 const int ctor_or_dtor_p;
6186 } predefined_identifier;
6188 /* Create all the predefined identifiers. */
6191 initialize_predefined_identifiers (void)
6193 const predefined_identifier *pid;
6195 /* A table of identifiers to create at startup. */
6196 static const predefined_identifier predefined_identifiers[] = {
6197 { "C++", &lang_name_cplusplus, 0 },
6198 { "C", &lang_name_c, 0 },
6199 { "Java", &lang_name_java, 0 },
6200 { CTOR_NAME, &ctor_identifier, 1 },
6201 { "__base_ctor", &base_ctor_identifier, 1 },
6202 { "__comp_ctor", &complete_ctor_identifier, 1 },
6203 { DTOR_NAME, &dtor_identifier, 1 },
6204 { "__comp_dtor", &complete_dtor_identifier, 1 },
6205 { "__base_dtor", &base_dtor_identifier, 1 },
6206 { "__deleting_dtor", &deleting_dtor_identifier, 1 },
6207 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
6208 { "nelts", &nelts_identifier, 0 },
6209 { THIS_NAME, &this_identifier, 0 },
6210 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
6211 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
6212 { "_vptr", &vptr_identifier, 0 },
6213 { "__vtt_parm", &vtt_parm_identifier, 0 },
6214 { "std", &std_identifier, 0 },
6218 for (pid = predefined_identifiers; pid->name; ++pid)
6220 *pid->node = get_identifier (pid->name);
6221 if (pid->ctor_or_dtor_p)
6222 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
6226 /* Create the predefined scalar types of C,
6227 and some nodes representing standard constants (0, 1, (void *)0).
6228 Initialize the global binding level.
6229 Make definitions for built-in primitive functions. */
6232 cxx_init_decl_processing (void)
6235 tree void_ftype_ptr;
6237 /* Create all the identifiers we need. */
6238 initialize_predefined_identifiers ();
6240 /* Fill in back-end hooks. */
6241 lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
6243 /* Create the global variables. */
6244 push_to_top_level ();
6246 /* Enter the global namespace. */
6247 my_friendly_assert (global_namespace == NULL_TREE, 375);
6248 push_namespace (get_identifier ("::"));
6249 global_namespace = current_namespace;
6250 current_lang_name = NULL_TREE;
6252 /* Adjust various flags based on command-line settings. */
6253 if (! flag_permissive && ! pedantic)
6254 flag_pedantic_errors = 1;
6255 if (!flag_no_inline)
6257 flag_inline_trees = 1;
6260 if (flag_inline_functions)
6262 flag_inline_trees = 2;
6263 flag_inline_functions = 0;
6266 /* Force minimum function alignment if using the least significant
6267 bit of function pointers to store the virtual bit. */
6268 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6269 && force_align_functions_log < 1)
6270 force_align_functions_log = 1;
6273 current_lang_name = lang_name_c;
6275 current_function_decl = NULL_TREE;
6276 current_binding_level = NULL_BINDING_LEVEL;
6277 free_binding_level = NULL_BINDING_LEVEL;
6279 build_common_tree_nodes (flag_signed_char);
6281 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
6282 TREE_TYPE (error_mark_list) = error_mark_node;
6284 /* Make the binding_level structure for global names. */
6286 global_binding_level = current_binding_level;
6287 /* The global level is the namespace level of ::. */
6288 NAMESPACE_LEVEL (global_namespace) = global_binding_level;
6289 declare_namespace_level ();
6291 /* Create the `std' namespace. */
6292 push_namespace (std_identifier);
6293 std_node = current_namespace;
6296 c_common_nodes_and_builtins ();
6298 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
6299 java_short_type_node = record_builtin_java_type ("__java_short", 16);
6300 java_int_type_node = record_builtin_java_type ("__java_int", 32);
6301 java_long_type_node = record_builtin_java_type ("__java_long", 64);
6302 java_float_type_node = record_builtin_java_type ("__java_float", -32);
6303 java_double_type_node = record_builtin_java_type ("__java_double", -64);
6304 java_char_type_node = record_builtin_java_type ("__java_char", -16);
6305 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
6307 integer_two_node = build_int_2 (2, 0);
6308 TREE_TYPE (integer_two_node) = integer_type_node;
6309 integer_three_node = build_int_2 (3, 0);
6310 TREE_TYPE (integer_three_node) = integer_type_node;
6312 boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
6313 TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
6314 TYPE_MAX_VALUE (boolean_type_node) = build_int_2 (1, 0);
6315 TREE_TYPE (TYPE_MAX_VALUE (boolean_type_node)) = boolean_type_node;
6316 TYPE_PRECISION (boolean_type_node) = 1;
6317 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
6318 boolean_false_node = build_int_2 (0, 0);
6319 TREE_TYPE (boolean_false_node) = boolean_type_node;
6320 boolean_true_node = build_int_2 (1, 0);
6321 TREE_TYPE (boolean_true_node) = boolean_type_node;
6323 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
6326 record_builtin_type (RID_MAX, NULL, string_type_node);
6329 delta_type_node = ptrdiff_type_node;
6330 vtable_index_type = ptrdiff_type_node;
6332 vtt_parm_type = build_pointer_type (const_ptr_type_node);
6333 void_ftype = build_function_type (void_type_node, void_list_node);
6334 void_ftype_ptr = build_function_type (void_type_node,
6335 tree_cons (NULL_TREE,
6339 = build_exception_variant (void_ftype_ptr, empty_except_spec);
6341 /* C++ extensions */
6343 unknown_type_node = make_node (UNKNOWN_TYPE);
6344 record_unknown_type (unknown_type_node, "unknown type");
6346 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
6347 TREE_TYPE (unknown_type_node) = unknown_type_node;
6349 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
6351 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
6352 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
6355 /* Make sure we get a unique function type, so we can give
6356 its pointer type a name. (This wins for gdb.) */
6357 tree vfunc_type = make_node (FUNCTION_TYPE);
6358 TREE_TYPE (vfunc_type) = integer_type_node;
6359 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
6360 layout_type (vfunc_type);
6362 vtable_entry_type = build_pointer_type (vfunc_type);
6364 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
6367 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
6368 layout_type (vtbl_type_node);
6369 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
6370 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
6371 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
6372 layout_type (vtbl_ptr_type_node);
6373 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
6375 push_namespace (get_identifier ("__cxxabiv1"));
6376 abi_node = current_namespace;
6379 global_type_node = make_node (LANG_TYPE);
6380 record_unknown_type (global_type_node, "global type");
6383 current_lang_name = lang_name_cplusplus;
6386 tree bad_alloc_type_node, newtype, deltype;
6387 tree ptr_ftype_sizetype;
6389 push_namespace (std_identifier);
6391 = xref_tag (class_type, get_identifier ("bad_alloc"),
6392 /*attributes=*/NULL_TREE, 1);
6395 = build_function_type (ptr_type_node,
6396 tree_cons (NULL_TREE,
6399 newtype = build_exception_variant
6400 (ptr_ftype_sizetype, add_exception_specifier
6401 (NULL_TREE, bad_alloc_type_node, -1));
6402 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
6403 push_cp_library_fn (NEW_EXPR, newtype);
6404 push_cp_library_fn (VEC_NEW_EXPR, newtype);
6405 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
6406 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
6410 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
6412 /* Perform other language dependent initializations. */
6413 init_class_processing ();
6414 init_search_processing ();
6415 init_rtti_processing ();
6417 if (flag_exceptions)
6418 init_exception_processing ();
6420 if (! supports_one_only ())
6423 make_fname_decl = cp_make_fname_decl;
6424 start_fname_decls ();
6426 /* Show we use EH for cleanups. */
6427 using_eh_for_cleanups ();
6429 /* Maintain consistency. Perhaps we should just complain if they
6430 say -fwritable-strings? */
6431 if (flag_writable_strings)
6432 flag_const_strings = 0;
6435 /* Generate an initializer for a function naming variable from
6436 NAME. NAME may be NULL, in which case we generate a special
6437 ERROR_MARK node which should be replaced later. */
6440 cp_fname_init (const char* name)
6442 tree domain = NULL_TREE;
6444 tree init = NULL_TREE;
6449 length = strlen (name);
6450 domain = build_index_type (size_int (length));
6451 init = build_string (length + 1, name);
6454 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
6455 type = build_cplus_array_type (type, domain);
6458 TREE_TYPE (init) = type;
6460 /* We don't know the value until instantiation time. Make
6461 something which will be digested now, but replaced later. */
6462 init = build (ERROR_MARK, type);
6467 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
6468 decl, NAME is the initialization string and TYPE_DEP indicates whether
6469 NAME depended on the type of the function. We make use of that to detect
6470 __PRETTY_FUNCTION__ inside a template fn. This is being done
6471 lazily at the point of first use, so we musn't push the decl now. */
6474 cp_make_fname_decl (tree id, int type_dep)
6476 const char *const name = (type_dep && processing_template_decl
6477 ? NULL : fname_as_string (type_dep));
6478 tree init = cp_fname_init (name);
6479 tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
6481 /* As we're using pushdecl_with_scope, we must set the context. */
6482 DECL_CONTEXT (decl) = current_function_decl;
6483 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
6485 TREE_STATIC (decl) = 1;
6486 TREE_READONLY (decl) = 1;
6487 DECL_ARTIFICIAL (decl) = 1;
6488 DECL_INITIAL (decl) = init;
6490 TREE_USED (decl) = 1;
6492 if (current_function_decl)
6494 struct cp_binding_level *b = current_binding_level;
6495 while (b->level_chain->parm_flag == 0)
6497 pushdecl_with_scope (decl, b);
6500 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
6505 /* Make a definition for a builtin function named NAME in the current
6506 namespace, whose data type is TYPE and whose context is CONTEXT.
6507 TYPE should be a function type with argument types.
6509 CLASS and CODE tell later passes how to compile calls to this function.
6510 See tree.h for possible values.
6512 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6513 the name to be called if we can't opencode the function.
6514 If ATTRS is nonzero, use that for the function's attribute
6518 builtin_function_1 (const char* name,
6522 enum built_in_class class,
6523 const char* libname,
6526 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
6527 DECL_BUILT_IN_CLASS (decl) = class;
6528 DECL_FUNCTION_CODE (decl) = code;
6529 DECL_CONTEXT (decl) = context;
6533 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
6534 we cannot change DECL_ASSEMBLER_NAME until we have installed this
6535 function in the namespace. */
6537 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
6538 make_decl_rtl (decl, NULL);
6540 /* Warn if a function in the namespace for users
6541 is used without an occasion to consider it declared. */
6542 if (name[0] != '_' || name[1] != '_')
6543 DECL_ANTICIPATED (decl) = 1;
6545 /* Possibly apply some default attributes to this built-in function. */
6547 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
6549 decl_attributes (&decl, NULL_TREE, 0);
6554 /* Entry point for the benefit of c_common_nodes_and_builtins.
6556 Make a defintion for a builtin function named NAME and whose data type
6557 is TYPE. TYPE should be a function type with argument types. This
6558 function places the anticipated declaration in the global namespace
6559 and additionally in the std namespace if appropriate.
6561 CLASS and CODE tell later passes how to compile calls to this function.
6562 See tree.h for possible values.
6564 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
6565 the name to be called if we can't opencode the function.
6567 If ATTRS is nonzero, use that for the function's attribute
6571 builtin_function (const char* name,
6574 enum built_in_class class,
6575 const char* libname,
6578 /* All builtins that don't begin with an '_' should additionally
6579 go in the 'std' namespace. */
6582 push_namespace (std_identifier);
6583 builtin_function_1 (name, type, std_node, code, class, libname, attrs);
6587 return builtin_function_1 (name, type, NULL_TREE, code,
6588 class, libname, attrs);
6591 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
6592 function. Not called directly. */
6595 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
6597 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
6598 DECL_EXTERNAL (fn) = 1;
6599 TREE_PUBLIC (fn) = 1;
6600 DECL_ARTIFICIAL (fn) = 1;
6601 TREE_NOTHROW (fn) = 1;
6602 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
6603 SET_DECL_LANGUAGE (fn, lang_c);
6607 /* Returns the _DECL for a library function with C linkage.
6608 We assume that such functions never throw; if this is incorrect,
6609 callers should unset TREE_NOTHROW. */
6612 build_library_fn (tree name, tree type)
6614 return build_library_fn_1 (name, ERROR_MARK, type);
6617 /* Returns the _DECL for a library function with C++ linkage. */
6620 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
6622 tree fn = build_library_fn_1 (name, operator_code, type);
6623 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6624 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
6625 SET_DECL_LANGUAGE (fn, lang_cplusplus);
6626 set_mangled_name_for_decl (fn);
6630 /* Like build_library_fn, but takes a C string instead of an
6634 build_library_fn_ptr (const char* name, tree type)
6636 return build_library_fn (get_identifier (name), type);
6639 /* Like build_cp_library_fn, but takes a C string instead of an
6643 build_cp_library_fn_ptr (const char* name, tree type)
6645 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
6648 /* Like build_library_fn, but also pushes the function so that we will
6649 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
6652 push_library_fn (tree name, tree type)
6654 tree fn = build_library_fn (name, type);
6655 pushdecl_top_level (fn);
6659 /* Like build_cp_library_fn, but also pushes the function so that it
6660 will be found by normal lookup. */
6663 push_cp_library_fn (enum tree_code operator_code, tree type)
6665 tree fn = build_cp_library_fn (ansi_opname (operator_code),
6672 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
6676 push_void_library_fn (tree name, tree parmtypes)
6678 tree type = build_function_type (void_type_node, parmtypes);
6679 return push_library_fn (name, type);
6682 /* Like push_library_fn, but also note that this function throws
6683 and does not return. Used for __throw_foo and the like. */
6686 push_throw_library_fn (tree name, tree type)
6688 tree fn = push_library_fn (name, type);
6689 TREE_THIS_VOLATILE (fn) = 1;
6690 TREE_NOTHROW (fn) = 0;
6694 /* Apply default attributes to a function, if a system function with default
6698 cxx_insert_default_attributes (tree decl)
6700 if (!DECL_EXTERN_C_FUNCTION_P (decl))
6702 if (!TREE_PUBLIC (decl))
6704 c_common_insert_default_attributes (decl);
6707 /* When we call finish_struct for an anonymous union, we create
6708 default copy constructors and such. But, an anonymous union
6709 shouldn't have such things; this function undoes the damage to the
6710 anonymous union type T.
6712 (The reason that we create the synthesized methods is that we don't
6713 distinguish `union { int i; }' from `typedef union { int i; } U'.
6714 The first is an anonymous union; the second is just an ordinary
6718 fixup_anonymous_aggr (tree t)
6722 /* Wipe out memory of synthesized methods */
6723 TYPE_HAS_CONSTRUCTOR (t) = 0;
6724 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
6725 TYPE_HAS_INIT_REF (t) = 0;
6726 TYPE_HAS_CONST_INIT_REF (t) = 0;
6727 TYPE_HAS_ASSIGN_REF (t) = 0;
6728 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
6730 /* Splice the implicitly generated functions out of the TYPE_METHODS
6732 q = &TYPE_METHODS (t);
6735 if (DECL_ARTIFICIAL (*q))
6736 *q = TREE_CHAIN (*q);
6738 q = &TREE_CHAIN (*q);
6741 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
6742 if (TYPE_METHODS (t))
6743 cp_error_at ("an anonymous union cannot have function members", t);
6745 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
6746 assignment operators (because they cannot have these methods themselves).
6747 For anonymous unions this is already checked because they are not allowed
6748 in any union, otherwise we have to check it. */
6749 if (TREE_CODE (t) != UNION_TYPE)
6753 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
6754 if (TREE_CODE (field) == FIELD_DECL)
6756 type = TREE_TYPE (field);
6757 if (CLASS_TYPE_P (type))
6759 if (TYPE_NEEDS_CONSTRUCTING (type))
6760 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
6762 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6763 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
6765 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
6766 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
6773 /* Make sure that a declaration with no declarator is well-formed, i.e.
6774 just declares a tagged type or anonymous union.
6776 Returns the type declared; or NULL_TREE if none. */
6779 check_tag_decl (tree declspecs)
6783 int saw_typedef = 0;
6784 tree ob_modifier = NULL_TREE;
6786 /* If a class, struct, or enum type is declared by the DECLSPECS
6787 (i.e, if a class-specifier, enum-specifier, or non-typename
6788 elaborated-type-specifier appears in the DECLSPECS),
6789 DECLARED_TYPE is set to the corresponding type. */
6790 tree declared_type = NULL_TREE;
6791 bool error_p = false;
6793 for (link = declspecs; link; link = TREE_CHAIN (link))
6795 tree value = TREE_VALUE (link);
6798 || TREE_CODE (value) == TYPE_DECL
6799 || (TREE_CODE (value) == IDENTIFIER_NODE
6800 && IDENTIFIER_GLOBAL_VALUE (value)
6801 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (value)) == TYPE_DECL))
6805 if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
6807 if (! in_system_header)
6808 pedwarn ("redeclaration of C++ built-in type `%T'", value);
6813 && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
6814 || TREE_CODE (value) == ENUMERAL_TYPE))
6816 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
6817 declared_type = value;
6820 else if (value == ridpointers[(int) RID_TYPEDEF])
6822 else if (value == ridpointers[(int) RID_FRIEND])
6824 if (current_class_type == NULL_TREE
6825 || current_scope () != current_class_type)
6826 ob_modifier = value;
6830 else if (value == ridpointers[(int) RID_STATIC]
6831 || value == ridpointers[(int) RID_EXTERN]
6832 || value == ridpointers[(int) RID_AUTO]
6833 || value == ridpointers[(int) RID_REGISTER]
6834 || value == ridpointers[(int) RID_INLINE]
6835 || value == ridpointers[(int) RID_VIRTUAL]
6836 || value == ridpointers[(int) RID_CONST]
6837 || value == ridpointers[(int) RID_VOLATILE]
6838 || value == ridpointers[(int) RID_EXPLICIT]
6839 || value == ridpointers[(int) RID_THREAD])
6840 ob_modifier = value;
6841 else if (value == error_mark_node)
6846 error ("multiple types in one declaration");
6848 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
6849 pedwarn ("declaration does not declare anything");
6850 /* Check for an anonymous union. */
6851 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
6852 && TYPE_ANONYMOUS_P (declared_type))
6854 /* 7/3 In a simple-declaration, the optional init-declarator-list
6855 can be omitted only when declaring a class (clause 9) or
6856 enumeration (7.2), that is, when the decl-specifier-seq contains
6857 either a class-specifier, an elaborated-type-specifier with
6858 a class-key (9.1), or an enum-specifier. In these cases and
6859 whenever a class-specifier or enum-specifier is present in the
6860 decl-specifier-seq, the identifiers in these specifiers are among
6861 the names being declared by the declaration (as class-name,
6862 enum-names, or enumerators, depending on the syntax). In such
6863 cases, and except for the declaration of an unnamed bit-field (9.6),
6864 the decl-specifier-seq shall introduce one or more names into the
6865 program, or shall redeclare a name introduced by a previous
6866 declaration. [Example:
6867 enum { }; // ill-formed
6868 typedef class { }; // ill-formed
6872 error ("missing type-name in typedef-declaration");
6875 /* Anonymous unions are objects, so they can have specifiers. */;
6876 SET_ANON_AGGR_TYPE_P (declared_type);
6878 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
6879 && !in_system_header)
6880 pedwarn ("ISO C++ prohibits anonymous structs");
6883 else if (ob_modifier)
6885 if (ob_modifier == ridpointers[(int) RID_INLINE]
6886 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
6887 error ("`%D' can only be specified for functions", ob_modifier);
6888 else if (ob_modifier == ridpointers[(int) RID_FRIEND])
6889 error ("`%D' can only be specified inside a class", ob_modifier);
6890 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
6891 error ("`%D' can only be specified for constructors",
6894 error ("`%D' can only be specified for objects and functions",
6898 return declared_type;
6901 /* Called when a declaration is seen that contains no names to declare.
6902 If its type is a reference to a structure, union or enum inherited
6903 from a containing scope, shadow that tag name for the current scope
6904 with a forward reference.
6905 If its type defines a new named structure or union
6906 or defines an enum, it is valid but we need not do anything here.
6907 Otherwise, it is an error.
6909 C++: may have to grok the declspecs to learn about static,
6910 complain for anonymous unions.
6912 Returns the TYPE declared -- or NULL_TREE if none. */
6915 shadow_tag (tree declspecs)
6917 tree t = check_tag_decl (declspecs);
6922 maybe_process_partial_specialization (t);
6924 /* This is where the variables in an anonymous union are
6925 declared. An anonymous union declaration looks like:
6927 because there is no declarator after the union, the parser
6928 sends that declaration here. */
6929 if (ANON_AGGR_TYPE_P (t))
6931 fixup_anonymous_aggr (t);
6933 if (TYPE_FIELDS (t))
6935 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
6937 finish_anon_union (decl);
6944 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
6947 groktypename (tree typename)
6951 if (TREE_CODE (typename) != TREE_LIST)
6953 split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
6954 type = grokdeclarator (TREE_VALUE (typename), specs,
6955 TYPENAME, 0, &attrs);
6957 cplus_decl_attributes (&type, attrs, 0);
6961 /* Decode a declarator in an ordinary declaration or data definition.
6962 This is called as soon as the type information and variable name
6963 have been parsed, before parsing the initializer if any.
6964 Here we create the ..._DECL node, fill in its type,
6965 and put it on the list of decls for the current context.
6966 The ..._DECL node is returned as the value.
6968 Exception: for arrays where the length is not specified,
6969 the type is left null, to be filled in by `cp_finish_decl'.
6971 Function definitions do not come here; they go to start_function
6972 instead. However, external and forward declarations of functions
6973 do go through here. Structure field declarations are done by
6974 grokfield and not through here. */
6977 start_decl (tree declarator,
6981 tree prefix_attributes)
6984 register tree type, tem;
6987 /* This should only be done once on the top most decl. */
6988 if (have_extern_spec)
6990 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
6992 have_extern_spec = false;
6995 /* An object declared as __attribute__((deprecated)) suppresses
6996 warnings of uses of other deprecated items. */
6997 if (lookup_attribute ("deprecated", attributes))
6998 deprecated_state = DEPRECATED_SUPPRESS;
7000 attributes = chainon (attributes, prefix_attributes);
7002 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
7005 deprecated_state = DEPRECATED_NORMAL;
7007 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
7010 type = TREE_TYPE (decl);
7012 if (type == error_mark_node)
7015 context = DECL_CONTEXT (decl);
7017 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
7018 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
7020 /* When parsing the initializer, lookup should use the object's
7022 push_decl_namespace (context);
7025 /* We are only interested in class contexts, later. */
7026 if (context && TREE_CODE (context) == NAMESPACE_DECL)
7027 context = NULL_TREE;
7030 /* Is it valid for this decl to have an initializer at all?
7031 If not, set INITIALIZED to zero, which will indirectly
7032 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7033 switch (TREE_CODE (decl))
7036 error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
7041 error ("function `%#D' is initialized like a variable", decl);
7051 if (! toplevel_bindings_p ()
7052 && DECL_EXTERNAL (decl))
7053 warning ("declaration of `%#D' has `extern' and is initialized",
7055 DECL_EXTERNAL (decl) = 0;
7056 if (toplevel_bindings_p ())
7057 TREE_STATIC (decl) = 1;
7059 /* Tell `pushdecl' this is an initialized decl
7060 even though we don't yet have the initializer expression.
7061 Also tell `cp_finish_decl' it may store the real initializer. */
7062 DECL_INITIAL (decl) = error_mark_node;
7065 /* Set attributes here so if duplicate decl, will have proper attributes. */
7066 cplus_decl_attributes (&decl, attributes, 0);
7068 /* If #pragma weak was used, mark the decl weak now. */
7069 if (current_binding_level == global_binding_level)
7070 maybe_apply_pragma_weak (decl);
7072 if (TREE_CODE (decl) == FUNCTION_DECL
7073 && DECL_DECLARED_INLINE_P (decl)
7074 && DECL_UNINLINABLE (decl)
7075 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
7076 warning_with_decl (decl,
7077 "inline function `%s' given attribute noinline");
7079 if (context && COMPLETE_TYPE_P (complete_type (context)))
7081 push_nested_class (context, 2);
7083 if (TREE_CODE (decl) == VAR_DECL)
7085 tree field = lookup_field (context, DECL_NAME (decl), 0, 0);
7086 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
7087 error ("`%#D' is not a static member of `%#T'", decl, context);
7090 if (DECL_CONTEXT (field) != context)
7092 if (!same_type_p (DECL_CONTEXT (field), context))
7093 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
7094 DECL_CONTEXT (field), DECL_NAME (decl),
7095 context, DECL_NAME (decl));
7096 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
7098 /* Static data member are tricky; an in-class initialization
7099 still doesn't provide a definition, so the in-class
7100 declaration will have DECL_EXTERNAL set, but will have an
7101 initialization. Thus, duplicate_decls won't warn
7102 about this situation, and so we check here. */
7103 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
7104 error ("duplicate initialization of %D", decl);
7105 if (duplicate_decls (decl, field))
7111 tree field = check_classfn (context, decl);
7112 if (field && duplicate_decls (decl, field))
7116 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
7117 DECL_IN_AGGR_P (decl) = 0;
7118 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
7119 || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
7121 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
7122 /* [temp.expl.spec] An explicit specialization of a static data
7123 member of a template is a definition if the declaration
7124 includes an initializer; otherwise, it is a declaration.
7126 We check for processing_specialization so this only applies
7127 to the new specialization syntax. */
7128 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
7129 DECL_EXTERNAL (decl) = 1;
7132 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
7133 pedwarn ("declaration of `%#D' outside of class is not definition",
7137 /* Enter this declaration into the symbol table. */
7138 tem = maybe_push_decl (decl);
7140 if (processing_template_decl)
7141 tem = push_template_decl (tem);
7143 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
7144 /* Tell the back-end to use or not use .common as appropriate. If we say
7145 -fconserve-space, we want this to save .data space, at the expense of
7146 wrong semantics. If we say -fno-conserve-space, we want this to
7147 produce errors about redefs; to do this we force variables into the
7149 DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
7150 || !DECL_THREAD_LOCAL (tem))
7151 && (flag_conserve_space || ! TREE_PUBLIC (tem)));
7154 if (! processing_template_decl)
7161 start_decl_1 (tree decl)
7163 tree type = TREE_TYPE (decl);
7164 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
7166 if (type == error_mark_node)
7169 maybe_push_cleanup_level (type);
7172 /* Is it valid for this decl to have an initializer at all?
7173 If not, set INITIALIZED to zero, which will indirectly
7174 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
7176 /* Don't allow initializations for incomplete types except for
7177 arrays which might be completed by the initialization. */
7178 if (COMPLETE_TYPE_P (complete_type (type)))
7179 ; /* A complete type is ok. */
7180 else if (TREE_CODE (type) != ARRAY_TYPE)
7182 error ("variable `%#D' has initializer but incomplete type",
7185 type = TREE_TYPE (decl) = error_mark_node;
7187 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7189 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
7190 error ("elements of array `%#D' have incomplete type", decl);
7191 /* else we already gave an error in start_decl. */
7197 && TREE_CODE (decl) != TYPE_DECL
7198 && TREE_CODE (decl) != TEMPLATE_DECL
7199 && type != error_mark_node
7200 && IS_AGGR_TYPE (type)
7201 && ! DECL_EXTERNAL (decl))
7203 if ((! processing_template_decl || ! uses_template_parms (type))
7204 && !COMPLETE_TYPE_P (complete_type (type)))
7206 error ("aggregate `%#D' has incomplete type and cannot be defined",
7208 /* Change the type so that assemble_variable will give
7209 DECL an rtl we can live with: (mem (const_int 0)). */
7210 type = TREE_TYPE (decl) = error_mark_node;
7214 /* If any base type in the hierarchy of TYPE needs a constructor,
7215 then we set initialized to 1. This way any nodes which are
7216 created for the purposes of initializing this aggregate
7217 will live as long as it does. This is necessary for global
7218 aggregates which do not have their initializers processed until
7219 the end of the file. */
7220 initialized = TYPE_NEEDS_CONSTRUCTING (type);
7225 DECL_INITIAL (decl) = NULL_TREE;
7228 /* Handle initialization of references.
7229 These three arguments are from `cp_finish_decl', and have the
7230 same meaning here that they do there.
7232 Quotes on semantics can be found in ARM 8.4.3. */
7235 grok_reference_init (tree decl, tree type, tree init)
7239 if (init == NULL_TREE)
7241 if ((DECL_LANG_SPECIFIC (decl) == 0
7242 || DECL_IN_AGGR_P (decl) == 0)
7243 && ! DECL_THIS_EXTERN (decl))
7244 error ("`%D' declared as reference but not initialized", decl);
7248 if (TREE_CODE (init) == CONSTRUCTOR)
7250 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
7254 if (TREE_CODE (init) == TREE_LIST)
7255 init = build_compound_expr (init);
7257 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
7258 init = convert_from_reference (init);
7260 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
7261 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
7263 /* Note: default conversion is only called in very special cases. */
7264 init = default_conversion (init);
7267 /* Convert INIT to the reference type TYPE. This may involve the
7268 creation of a temporary, whose lifetime must be the same as that
7269 of the reference. If so, a DECL_STMT for the temporary will be
7270 added just after the DECL_STMT for DECL. That's why we don't set
7271 DECL_INITIAL for local references (instead assigning to them
7272 explicitly); we need to allow the temporary to be initialized
7274 tmp = convert_to_reference
7275 (type, init, CONV_IMPLICIT,
7276 LOOKUP_ONLYCONVERTING|LOOKUP_SPECULATIVELY|LOOKUP_NORMAL|DIRECT_BIND,
7279 if (tmp == error_mark_node)
7281 else if (tmp == NULL_TREE)
7283 error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
7287 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
7290 DECL_INITIAL (decl) = tmp;
7295 /* When parsing `int a[] = {1, 2};' we don't know the size of the
7296 array until we finish parsing the initializer. If that's the
7297 situation we're in, update DECL accordingly. */
7300 maybe_deduce_size_from_array_init (tree decl, tree init)
7302 tree type = TREE_TYPE (decl);
7304 if (TREE_CODE (type) == ARRAY_TYPE
7305 && TYPE_DOMAIN (type) == NULL_TREE
7306 && TREE_CODE (decl) != TYPE_DECL)
7308 /* do_default is really a C-ism to deal with tentative definitions.
7309 But let's leave it here to ease the eventual merge. */
7310 int do_default = !DECL_EXTERNAL (decl);
7311 tree initializer = init ? init : DECL_INITIAL (decl);
7312 int failure = complete_array_type (type, initializer, do_default);
7315 error ("initializer fails to determine size of `%D'", decl);
7320 error ("array size missing in `%D'", decl);
7321 /* If a `static' var's size isn't known, make it extern as
7322 well as static, so it does not get allocated. If it's not
7323 `static', then don't mark it extern; finish_incomplete_decl
7324 will give it a default size and it will get allocated. */
7325 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
7326 DECL_EXTERNAL (decl) = 1;
7329 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
7330 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
7332 error ("zero-size array `%D'", decl);
7334 layout_decl (decl, 0);
7338 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
7339 any appropriate error messages regarding the layout. */
7342 layout_var_decl (tree decl)
7344 tree type = TREE_TYPE (decl);
7346 tree ttype = target_type (type);
7349 /* If we haven't already layed out this declaration, do so now.
7350 Note that we must not call complete type for an external object
7351 because it's type might involve templates that we are not
7352 supposed to isntantiate yet. (And it's perfectly valid to say
7353 `extern X x' for some incomplete type `X'.) */
7354 if (!DECL_EXTERNAL (decl))
7355 complete_type (type);
7356 if (!DECL_SIZE (decl)
7357 && TREE_TYPE (decl) != error_mark_node
7358 && (COMPLETE_TYPE_P (type)
7359 || (TREE_CODE (type) == ARRAY_TYPE
7360 && !TYPE_DOMAIN (type)
7361 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
7362 layout_decl (decl, 0);
7364 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
7366 /* An automatic variable with an incomplete type: that is an error.
7367 Don't talk about array types here, since we took care of that
7368 message in grokdeclarator. */
7369 error ("storage size of `%D' isn't known", decl);
7370 TREE_TYPE (decl) = error_mark_node;
7373 /* Keep this code around in case we later want to control debug info
7374 based on whether a type is "used". (jason 1999-11-11) */
7376 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
7377 /* Let debugger know it should output info for this type. */
7378 note_debug_info_needed (ttype);
7380 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
7381 note_debug_info_needed (DECL_CONTEXT (decl));
7384 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
7385 && DECL_SIZE (decl) != NULL_TREE
7386 && ! TREE_CONSTANT (DECL_SIZE (decl)))
7388 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
7389 constant_expression_warning (DECL_SIZE (decl));
7391 error ("storage size of `%D' isn't constant", decl);
7394 if (TREE_STATIC (decl)
7395 && !DECL_ARTIFICIAL (decl)
7396 && current_function_decl
7397 && DECL_CONTEXT (decl) == current_function_decl)
7398 push_local_name (decl);
7401 /* If a local static variable is declared in an inline function, or if
7402 we have a weak definition, we must endeavor to create only one
7403 instance of the variable at link-time. */
7406 maybe_commonize_var (tree decl)
7408 /* Static data in a function with comdat linkage also has comdat
7410 if (TREE_STATIC (decl)
7411 /* Don't mess with __FUNCTION__. */
7412 && ! DECL_ARTIFICIAL (decl)
7413 && current_function_decl
7414 && DECL_CONTEXT (decl) == current_function_decl
7415 && (DECL_DECLARED_INLINE_P (current_function_decl)
7416 || DECL_TEMPLATE_INSTANTIATION (current_function_decl))
7417 && TREE_PUBLIC (current_function_decl))
7419 /* If flag_weak, we don't need to mess with this, as we can just
7420 make the function weak, and let it refer to its unique local
7421 copy. This works because we don't allow the function to be
7425 if (DECL_INTERFACE_KNOWN (current_function_decl))
7427 TREE_PUBLIC (decl) = 1;
7428 DECL_EXTERNAL (decl) = DECL_EXTERNAL (current_function_decl);
7430 else if (DECL_INITIAL (decl) == NULL_TREE
7431 || DECL_INITIAL (decl) == error_mark_node)
7433 TREE_PUBLIC (decl) = 1;
7434 DECL_COMMON (decl) = 1;
7436 /* else we lose. We can only do this if we can use common,
7437 which we can't if it has been initialized. */
7439 if (!TREE_PUBLIC (decl))
7441 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
7442 cp_warning_at (" you can work around this by removing the initializer", decl);
7446 comdat_linkage (decl);
7448 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
7449 /* Set it up again; we might have set DECL_INITIAL since the last
7451 comdat_linkage (decl);
7454 /* Issue an error message if DECL is an uninitialized const variable. */
7457 check_for_uninitialized_const_var (tree decl)
7459 tree type = TREE_TYPE (decl);
7461 /* ``Unless explicitly declared extern, a const object does not have
7462 external linkage and must be initialized. ($8.4; $12.1)'' ARM
7464 if (TREE_CODE (decl) == VAR_DECL
7465 && TREE_CODE (type) != REFERENCE_TYPE
7466 && CP_TYPE_CONST_P (type)
7467 && !TYPE_NEEDS_CONSTRUCTING (type)
7468 && !DECL_INITIAL (decl))
7469 error ("uninitialized const `%D'", decl);
7472 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
7473 returned is the next FIELD_DECL (possibly FIELD itself) that can be
7474 initialized. If there are no more such fields, the return value
7478 next_initializable_field (tree field)
7481 && (TREE_CODE (field) != FIELD_DECL
7482 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
7483 || DECL_ARTIFICIAL (field)))
7484 field = TREE_CHAIN (field);
7489 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7490 brace-enclosed aggregate initializer.
7492 *INITP is one of a list of initializers describing a brace-enclosed
7493 initializer for an entity of the indicated aggregate TYPE. It may
7494 not presently match the shape of the TYPE; for example:
7496 struct S { int a; int b; };
7497 struct S a[] = { 1, 2, 3, 4 };
7499 Here *INITP will point to TREE_LIST of four elements, rather than a
7500 list of two elements, each itself a list of two elements. This
7501 routine transforms INIT from the former form into the latter. The
7502 revised initializer is returned. */
7505 reshape_init (tree type, tree *initp)
7509 tree old_init_value;
7511 bool brace_enclosed_p;
7514 old_init_value = (TREE_CODE (*initp) == TREE_LIST
7515 ? TREE_VALUE (*initp) : old_init);
7517 /* For some parse errors, OLD_INIT_VALUE may be NULL. */
7518 if (!old_init_value)
7520 my_friendly_assert (TREE_CODE (old_init) == TREE_LIST, 20021202);
7521 TREE_VALUE (old_init) = error_mark_node;
7525 /* If the initializer is brace-enclosed, pull initializers from the
7526 enclosed elements. Advance past the brace-enclosed initializer
7528 if (TREE_CODE (old_init_value) == CONSTRUCTOR
7529 && TREE_HAS_CONSTRUCTOR (old_init_value))
7531 *initp = TREE_CHAIN (old_init);
7532 TREE_CHAIN (old_init) = NULL_TREE;
7533 inits = CONSTRUCTOR_ELTS (old_init_value);
7535 brace_enclosed_p = true;
7540 brace_enclosed_p = false;
7543 /* A non-aggregate type is always initialized with a single
7545 if (!CP_AGGREGATE_TYPE_P (type))
7547 *initp = TREE_CHAIN (old_init);
7548 TREE_CHAIN (old_init) = NULL_TREE;
7549 /* It is invalid to initialize a non-aggregate type with a
7550 brace-enclosed initializer. */
7551 if (brace_enclosed_p)
7553 error ("brace-enclosed initializer used to initialize `%T'",
7555 if (TREE_CODE (old_init) == TREE_LIST)
7556 TREE_VALUE (old_init) = error_mark_node;
7558 old_init = error_mark_node;
7566 All implicit type conversions (clause _conv_) are considered when
7567 initializing the aggregate member with an initializer from an
7568 initializer-list. If the initializer can initialize a member,
7569 the member is initialized. Otherwise, if the member is itself a
7570 non-empty subaggregate, brace elision is assumed and the
7571 initializer is considered for the initialization of the first
7572 member of the subaggregate. */
7573 if (CLASS_TYPE_P (type)
7574 && !brace_enclosed_p
7575 && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
7577 *initp = TREE_CHAIN (old_init);
7578 TREE_CHAIN (old_init) = NULL_TREE;
7582 if (TREE_CODE (old_init_value) == STRING_CST
7583 && TREE_CODE (type) == ARRAY_TYPE
7584 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
7586 /* [dcl.init.string]
7588 A char array (whether plain char, signed char, or unsigned char)
7589 can be initialized by a string-literal (optionally enclosed in
7590 braces); a wchar_t array can be initialized by a wide
7591 string-literal (optionally enclosed in braces). */
7592 new_init = old_init;
7593 /* Move past the initializer. */
7594 *initp = TREE_CHAIN (old_init);
7595 TREE_CHAIN (old_init) = NULL_TREE;
7599 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
7600 new_init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
7601 TREE_HAS_CONSTRUCTOR (new_init) = 1;
7603 if (CLASS_TYPE_P (type))
7607 field = next_initializable_field (TYPE_FIELDS (type));
7613 An initializer for an aggregate member that is an
7614 empty class shall have the form of an empty
7615 initializer-list {}. */
7616 if (!brace_enclosed_p)
7617 error ("initializer for `%T' must be brace-enclosed",
7622 /* Loop through the initializable fields, gathering
7624 while (*initp && field)
7628 field_init = reshape_init (TREE_TYPE (field), initp);
7629 TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
7630 CONSTRUCTOR_ELTS (new_init) = field_init;
7633 When a union is initialized with a brace-enclosed
7634 initializer, the braces shall only contain an
7635 initializer for the first member of the union. */
7636 if (TREE_CODE (type) == UNION_TYPE)
7638 if (TREE_PURPOSE (field_init))
7639 field = TREE_PURPOSE (field_init);
7640 field = next_initializable_field (TREE_CHAIN (field));
7644 else if (TREE_CODE (type) == ARRAY_TYPE)
7649 /* If the bound of the array is known, take no more initializers
7650 than are allowed. */
7651 max_index = (TYPE_DOMAIN (type)
7652 ? array_type_nelts (type) : NULL_TREE);
7653 /* Loop through the array elements, gathering initializers. */
7654 for (index = size_zero_node;
7655 *initp && (!max_index || !tree_int_cst_lt (max_index, index));
7656 index = size_binop (PLUS_EXPR, index, size_one_node))
7660 element_init = reshape_init (TREE_TYPE (type), initp);
7661 TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
7662 CONSTRUCTOR_ELTS (new_init) = element_init;
7663 if (TREE_PURPOSE (element_init))
7664 index = TREE_PURPOSE (element_init);
7670 /* The initializers were placed in reverse order in the
7672 CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
7674 if (TREE_CODE (old_init) == TREE_LIST)
7675 new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
7678 /* If this was a brace-enclosed initializer and all of the
7679 initializers were not used up, there is a problem. */
7680 if (brace_enclosed_p && *initp)
7681 error ("too many initializers for `%T'", type);
7686 /* Verify INIT (the initializer for DECL), and record the
7687 initialization in DECL_INITIAL, if appropriate.
7689 If the return value is non-NULL, it is an expression that must be
7690 evaluated dynamically to initialize DECL. */
7693 check_initializer (tree decl, tree init, int flags)
7695 tree type = TREE_TYPE (decl);
7697 /* If `start_decl' didn't like having an initialization, ignore it now. */
7698 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
7701 /* If an initializer is present, DECL_INITIAL has been
7702 error_mark_node, to indicate that an as-of-yet unevaluated
7703 initialization will occur. From now on, DECL_INITIAL reflects
7704 the static initialization -- if any -- of DECL. */
7705 DECL_INITIAL (decl) = NULL_TREE;
7707 /* Things that are going to be initialized need to have complete
7709 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
7711 if (type == error_mark_node)
7712 /* We will have already complained. */
7714 else if (init && COMPLETE_TYPE_P (type)
7715 && !TREE_CONSTANT (TYPE_SIZE (type)))
7717 error ("variable-sized object `%D' may not be initialized", decl);
7720 else if (TREE_CODE (type) == ARRAY_TYPE
7721 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
7723 error ("elements of array `%#D' have incomplete type", decl);
7726 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
7728 error ("`%D' has incomplete type", decl);
7729 TREE_TYPE (decl) = error_mark_node;
7733 if (TREE_CODE (decl) == CONST_DECL)
7735 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
7737 DECL_INITIAL (decl) = init;
7739 my_friendly_assert (init != NULL_TREE, 149);
7742 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7743 init = grok_reference_init (decl, type, init);
7746 if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7748 /* [dcl.init] paragraph 13,
7749 If T is a scalar type, then a declaration of the form
7754 reshape_init will complain about the extra braces,
7755 and doesn't do anything useful in the case where TYPE is
7756 scalar, so just don't call it. */
7757 if (CP_AGGREGATE_TYPE_P (type))
7758 init = reshape_init (type, &init);
7761 /* If DECL has an array type without a specific bound, deduce the
7762 array size from the initializer. */
7763 maybe_deduce_size_from_array_init (decl, init);
7764 type = TREE_TYPE (decl);
7765 if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
7766 TREE_TYPE (init) = type;
7768 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
7770 if (TREE_CODE (type) == ARRAY_TYPE)
7771 goto initialize_aggr;
7772 else if (TREE_CODE (init) == CONSTRUCTOR
7773 && TREE_HAS_CONSTRUCTOR (init))
7775 if (TYPE_NON_AGGREGATE_CLASS (type))
7777 error ("`%D' must be initialized by constructor, not by `{...}'",
7779 init = error_mark_node;
7782 goto dont_use_constructor;
7786 int saved_stmts_are_full_exprs_p;
7789 saved_stmts_are_full_exprs_p = 0;
7790 if (building_stmt_tree ())
7792 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7793 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7795 init = build_aggr_init (decl, init, flags);
7796 if (building_stmt_tree ())
7797 current_stmt_tree ()->stmts_are_full_exprs_p =
7798 saved_stmts_are_full_exprs_p;
7804 dont_use_constructor:
7805 if (TREE_CODE (init) != TREE_VEC)
7806 init = store_init_value (decl, init);
7809 else if (DECL_EXTERNAL (decl))
7811 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
7812 goto initialize_aggr;
7813 else if (IS_AGGR_TYPE (type))
7815 tree core_type = strip_array_types (type);
7817 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
7818 error ("structure `%D' with uninitialized const members", decl);
7819 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
7820 error ("structure `%D' with uninitialized reference members",
7823 check_for_uninitialized_const_var (decl);
7826 check_for_uninitialized_const_var (decl);
7828 if (init && init != error_mark_node)
7829 init = build (INIT_EXPR, type, decl, init);
7834 /* If DECL is not a local variable, give it RTL. */
7837 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
7839 int toplev = toplevel_bindings_p ();
7842 /* Handle non-variables up front. */
7843 if (TREE_CODE (decl) != VAR_DECL)
7845 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7849 /* If we see a class member here, it should be a static data
7851 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
7853 my_friendly_assert (TREE_STATIC (decl), 19990828);
7854 /* An in-class declaration of a static data member should be
7855 external; it is only a declaration, and not a definition. */
7856 if (init == NULL_TREE)
7857 my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
7860 /* Set the DECL_ASSEMBLER_NAME for the variable. */
7863 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
7864 /* The `register' keyword, when used together with an
7865 asm-specification, indicates that the variable should be
7866 placed in a particular register. */
7867 if (DECL_REGISTER (decl))
7868 DECL_C_HARD_REGISTER (decl) = 1;
7871 /* We don't create any RTL for local variables. */
7872 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7875 /* We defer emission of local statics until the corresponding
7876 DECL_STMT is expanded. */
7877 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
7879 /* We try to defer namespace-scope static constants so that they are
7880 not emitted into the object file unnecessarily. */
7881 if (!DECL_VIRTUAL_P (decl)
7882 && TREE_READONLY (decl)
7883 && DECL_INITIAL (decl) != NULL_TREE
7884 && DECL_INITIAL (decl) != error_mark_node
7885 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
7887 && !TREE_PUBLIC (decl))
7889 /* Fool with the linkage of static consts according to #pragma
7891 if (!interface_unknown && !TREE_PUBLIC (decl))
7893 TREE_PUBLIC (decl) = 1;
7894 DECL_EXTERNAL (decl) = interface_only;
7899 /* Likewise for template instantiations. */
7900 else if (DECL_COMDAT (decl))
7903 /* If we're deferring the variable, we only need to make RTL if
7904 there's an ASMSPEC. Otherwise, we'll lazily create it later when
7905 we need it. (There's no way to lazily create RTL for things that
7906 have assembly specs because the information about the specifier
7907 isn't stored in the tree, yet) */
7908 if (defer_p && asmspec)
7909 make_decl_rtl (decl, asmspec);
7910 /* If we're not deferring, go ahead and assemble the variable. */
7912 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
7915 /* The old ARM scoping rules injected variables declared in the
7916 initialization statement of a for-statement into the surrounding
7917 scope. We support this usage, in order to be backward-compatible.
7918 DECL is a just-declared VAR_DECL; if necessary inject its
7919 declaration into the surrounding scope. */
7922 maybe_inject_for_scope_var (tree decl)
7924 if (!DECL_NAME (decl))
7927 /* Declarations of __FUNCTION__ and its ilk appear magically when
7928 the variable is first used. If that happens to be inside a
7929 for-loop, we don't want to do anything special. */
7930 if (DECL_PRETTY_FUNCTION_P (decl))
7933 if (current_binding_level->is_for_scope)
7935 struct cp_binding_level *outer
7936 = current_binding_level->level_chain;
7938 /* Check to see if the same name is already bound at the outer
7939 level, either because it was directly declared, or because a
7940 dead for-decl got preserved. In either case, the code would
7941 not have been valid under the ARM scope rules, so clear
7942 is_for_scope for the current_binding_level.
7944 Otherwise, we need to preserve the temp slot for decl to last
7945 into the outer binding level. */
7948 = TREE_CHAIN (IDENTIFIER_BINDING (DECL_NAME (decl)));
7950 if (outer_binding && BINDING_LEVEL (outer_binding) == outer
7951 && (TREE_CODE (BINDING_VALUE (outer_binding))
7953 && DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
7955 BINDING_VALUE (outer_binding)
7956 = DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
7957 current_binding_level->is_for_scope = 0;
7962 /* Generate code to initialize DECL (a local variable). */
7965 initialize_local_var (tree decl, tree init)
7967 tree type = TREE_TYPE (decl);
7969 my_friendly_assert (TREE_CODE (decl) == VAR_DECL
7970 || TREE_CODE (decl) == RESULT_DECL,
7972 my_friendly_assert (!TREE_STATIC (decl), 20021010);
7974 if (DECL_SIZE (decl) == NULL_TREE)
7976 /* If we used it already as memory, it must stay in memory. */
7977 DECL_INITIAL (decl) = NULL_TREE;
7978 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
7981 if (DECL_SIZE (decl) && type != error_mark_node)
7985 /* Compute and store the initial value. */
7986 already_used = TREE_USED (decl) || TREE_USED (type);
7988 /* Perform the initialization. */
7991 int saved_stmts_are_full_exprs_p;
7993 my_friendly_assert (building_stmt_tree (), 20000906);
7994 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
7995 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
7996 finish_expr_stmt (init);
7997 current_stmt_tree ()->stmts_are_full_exprs_p =
7998 saved_stmts_are_full_exprs_p;
8001 /* Set this to 0 so we can tell whether an aggregate which was
8002 initialized was ever used. Don't do this if it has a
8003 destructor, so we don't complain about the 'resource
8004 allocation is initialization' idiom. Now set
8005 attribute((unused)) on types so decls of that type will be
8006 marked used. (see TREE_USED, above.) */
8007 if (TYPE_NEEDS_CONSTRUCTING (type)
8009 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
8010 && DECL_NAME (decl))
8011 TREE_USED (decl) = 0;
8012 else if (already_used)
8013 TREE_USED (decl) = 1;
8016 /* Generate a cleanup, if necessary. */
8017 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8021 /* Compute the cleanup. */
8022 cleanup = cxx_maybe_build_cleanup (decl);
8024 /* Record the cleanup required for this declaration. */
8025 if (DECL_SIZE (decl) && cleanup)
8026 finish_decl_cleanup (decl, cleanup);
8030 /* Finish processing of a declaration;
8031 install its line number and initial value.
8032 If the length of an array type is not known before,
8033 it must be determined now, from the initial value, or it is an error.
8035 INIT holds the value of an initializer that should be allowed to escape
8038 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8039 if the (init) syntax was used. */
8042 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
8045 tree ttype = NULL_TREE;
8046 const char *asmspec = NULL;
8047 int was_readonly = 0;
8052 error ("assignment (not initialization) in declaration");
8056 /* If a name was specified, get the string. */
8057 if (current_binding_level == global_binding_level)
8058 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
8060 asmspec = TREE_STRING_POINTER (asmspec_tree);
8062 if (init && TREE_CODE (init) == NAMESPACE_DECL)
8064 error ("cannot initialize `%D' to namespace `%D'",
8069 if (current_class_type
8070 && CP_DECL_CONTEXT (decl) == current_class_type
8071 && TYPE_BEING_DEFINED (current_class_type)
8072 && (DECL_INITIAL (decl) || init))
8073 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
8075 if (TREE_CODE (decl) == VAR_DECL
8076 && DECL_CONTEXT (decl)
8077 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
8078 && DECL_CONTEXT (decl) != current_namespace
8081 /* Leave the namespace of the object. */
8082 pop_decl_namespace ();
8085 type = TREE_TYPE (decl);
8087 if (type == error_mark_node)
8090 if (TYPE_HAS_MUTABLE_P (type))
8091 TREE_READONLY (decl) = 0;
8093 if (processing_template_decl)
8095 /* Add this declaration to the statement-tree. */
8096 if (at_function_scope_p ()
8097 && TREE_CODE (decl) != RESULT_DECL)
8098 add_decl_stmt (decl);
8100 if (init && DECL_INITIAL (decl))
8101 DECL_INITIAL (decl) = init;
8105 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8106 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
8108 /* Take care of TYPE_DECLs up front. */
8109 if (TREE_CODE (decl) == TYPE_DECL)
8111 if (type != error_mark_node
8112 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
8114 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
8115 warning ("shadowing previous type declaration of `%#D'", decl);
8116 set_identifier_type_value (DECL_NAME (decl), type);
8117 CLASSTYPE_GOT_SEMICOLON (type) = 1;
8120 /* If we have installed this as the canonical typedef for this
8121 type, and that type has not been defined yet, delay emitting
8122 the debug information for it, as we will emit it later. */
8123 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
8124 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
8125 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
8127 rest_of_decl_compilation (decl, NULL,
8128 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
8132 if (TREE_CODE (decl) != FUNCTION_DECL)
8133 ttype = target_type (type);
8135 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
8136 && TYPE_NEEDS_CONSTRUCTING (type))
8138 /* Currently, GNU C++ puts constants in text space, making them
8139 impossible to initialize. In the future, one would hope for
8140 an operating system which understood the difference between
8141 initialization and the running of a program. */
8143 TREE_READONLY (decl) = 0;
8146 if (TREE_CODE (decl) == FIELD_DECL && asmspec)
8148 /* This must override the asm specifier which was placed by
8149 grokclassfn. Lay this out fresh. */
8150 SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
8151 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
8152 make_decl_rtl (decl, asmspec);
8154 else if (TREE_CODE (decl) == RESULT_DECL)
8155 init = check_initializer (decl, init, flags);
8156 else if (TREE_CODE (decl) == VAR_DECL)
8158 /* Only PODs can have thread-local storage. Other types may require
8159 various kinds of non-trivial initialization. */
8160 if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
8161 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
8162 decl, TREE_TYPE (decl));
8163 /* Convert the initializer to the type of DECL, if we have not
8164 already initialized DECL. */
8165 if (!DECL_INITIALIZED_P (decl)
8166 /* If !DECL_EXTERNAL then DECL is being defined. In the
8167 case of a static data member initialized inside the
8168 class-specifier, there can be an initializer even if DECL
8169 is *not* defined. */
8170 && (!DECL_EXTERNAL (decl) || init))
8172 init = check_initializer (decl, init, flags);
8173 /* Thread-local storage cannot be dynamically initialized. */
8174 if (DECL_THREAD_LOCAL (decl) && init)
8176 error ("`%D' is thread-local and so cannot be dynamically "
8177 "initialized", decl);
8184 The memory occupied by any object of static storage
8185 duration is zero-initialized at program startup before
8186 any other initialization takes place.
8188 We cannot create an appropriate initializer until after
8189 the type of DECL is finalized. If DECL_INITIAL is set,
8190 then the DECL is statically initialized, and any
8191 necessary zero-initialization has already been performed. */
8192 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
8193 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
8194 /*static_storage_p=*/true);
8195 /* Remember that the initialization for this variable has
8197 DECL_INITIALIZED_P (decl) = 1;
8199 /* If the variable has an array type, lay out the type, even if
8200 there is no initializer. It is valid to index through the
8201 array, and we must get TYPE_ALIGN set correctly on the array
8203 else if (TREE_CODE (type) == ARRAY_TYPE)
8207 /* Add this declaration to the statement-tree. This needs to happen
8208 after the call to check_initializer so that the DECL_STMT for a
8209 reference temp is added before the DECL_STMT for the reference itself. */
8210 if (building_stmt_tree ()
8211 && at_function_scope_p ()
8212 && TREE_CODE (decl) != RESULT_DECL)
8213 add_decl_stmt (decl);
8215 if (TREE_CODE (decl) == VAR_DECL)
8216 layout_var_decl (decl);
8218 /* Output the assembler code and/or RTL code for variables and functions,
8219 unless the type is an undefined structure or union.
8220 If not, it will get done when the type is completed. */
8221 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
8222 || TREE_CODE (decl) == RESULT_DECL)
8224 if (TREE_CODE (decl) == VAR_DECL)
8225 maybe_commonize_var (decl);
8227 make_rtl_for_nonlocal_decl (decl, init, asmspec);
8229 if (TREE_CODE (type) == FUNCTION_TYPE
8230 || TREE_CODE (type) == METHOD_TYPE)
8231 abstract_virtuals_error (decl,
8232 strip_array_types (TREE_TYPE (type)));
8234 abstract_virtuals_error (decl, strip_array_types (type));
8236 if (TREE_CODE (decl) == FUNCTION_DECL
8237 || TREE_TYPE (decl) == error_mark_node)
8238 /* No initialization required. */
8240 else if (DECL_EXTERNAL (decl)
8241 && ! (DECL_LANG_SPECIFIC (decl)
8242 && DECL_NOT_REALLY_EXTERN (decl)))
8245 DECL_INITIAL (decl) = init;
8249 /* A variable definition. */
8250 if (DECL_FUNCTION_SCOPE_P (decl))
8252 /* This is a local declaration. */
8253 if (doing_semantic_analysis_p ())
8254 maybe_inject_for_scope_var (decl);
8255 /* Initialize the local variable. */
8256 if (processing_template_decl)
8258 if (init || DECL_INITIAL (decl) == error_mark_node)
8259 DECL_INITIAL (decl) = init;
8261 else if (!TREE_STATIC (decl))
8262 initialize_local_var (decl, init);
8265 if (TREE_STATIC (decl))
8266 expand_static_init (decl, init);
8270 /* Undo call to `pushclass' that was done in `start_decl'
8271 due to initialization of qualified member variable.
8272 I.e., Foo::x = 10; */
8274 tree context = CP_DECL_CONTEXT (decl);
8277 && (TREE_CODE (decl) == VAR_DECL
8278 /* We also have a pushclass done that we need to undo here
8279 if we're at top level and declare a method. */
8280 || TREE_CODE (decl) == FUNCTION_DECL)
8281 /* If size hasn't been set, we're still defining it,
8282 and therefore inside the class body; don't pop
8283 the binding level.. */
8284 && COMPLETE_TYPE_P (context)
8285 && context == current_class_type)
8286 pop_nested_class ();
8293 TREE_READONLY (decl) = 1;
8296 /* This is here for a midend callback from c-common.c */
8299 finish_decl (tree decl, tree init, tree asmspec_tree)
8301 cp_finish_decl (decl, init, asmspec_tree, 0);
8304 /* Returns a declaration for a VAR_DECL as if:
8306 extern "C" TYPE NAME;
8308 had been seen. Used to create compiler-generated global
8312 declare_global_var (tree name, tree type)
8316 push_to_top_level ();
8317 decl = build_decl (VAR_DECL, name, type);
8318 TREE_PUBLIC (decl) = 1;
8319 DECL_EXTERNAL (decl) = 1;
8320 DECL_ARTIFICIAL (decl) = 1;
8322 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
8323 pop_from_top_level ();
8328 /* Returns a pointer to the `atexit' function. Note that if
8329 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8330 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8333 get_atexit_node (void)
8344 if (flag_use_cxa_atexit)
8346 /* The declaration for `__cxa_atexit' is:
8348 int __cxa_atexit (void (*)(void *), void *, void *)
8350 We build up the argument types and then then function type
8353 /* First, build the pointer-to-function type for the first
8355 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8356 fn_type = build_function_type (void_type_node, arg_types);
8357 fn_ptr_type = build_pointer_type (fn_type);
8358 /* Then, build the rest of the argument types. */
8359 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8360 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
8361 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
8362 /* And the final __cxa_atexit type. */
8363 fn_type = build_function_type (integer_type_node, arg_types);
8364 fn_ptr_type = build_pointer_type (fn_type);
8365 name = "__cxa_atexit";
8369 /* The declaration for `atexit' is:
8371 int atexit (void (*)());
8373 We build up the argument types and then then function type
8375 fn_type = build_function_type (void_type_node, void_list_node);
8376 fn_ptr_type = build_pointer_type (fn_type);
8377 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
8378 /* Build the final atexit type. */
8379 fn_type = build_function_type (integer_type_node, arg_types);
8383 /* Now, build the function declaration. */
8384 push_lang_context (lang_name_c);
8385 atexit_fndecl = build_library_fn_ptr (name, fn_type);
8386 mark_used (atexit_fndecl);
8387 pop_lang_context ();
8388 atexit_node = default_conversion (atexit_fndecl);
8393 /* Returns the __dso_handle VAR_DECL. */
8396 get_dso_handle_node (void)
8398 if (dso_handle_node)
8399 return dso_handle_node;
8401 /* Declare the variable. */
8402 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8405 return dso_handle_node;
8408 /* Begin a new function with internal linkage whose job will be simply
8409 to destroy some particular variable. */
8412 start_cleanup_fn (void)
8414 static int counter = 0;
8415 int old_interface_only = interface_only;
8416 int old_interface_unknown = interface_unknown;
8422 push_to_top_level ();
8424 /* No need to mangle this. */
8425 push_lang_context (lang_name_c);
8428 interface_unknown = 1;
8430 /* Build the parameter-types. */
8431 parmtypes = void_list_node;
8432 /* Functions passed to __cxa_atexit take an additional parameter.
8433 We'll just ignore it. After we implement the new calling
8434 convention for destructors, we can eliminate the use of
8435 additional cleanup functions entirely in the -fnew-abi case. */
8436 if (flag_use_cxa_atexit)
8437 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
8438 /* Build the function type itself. */
8439 fntype = build_function_type (void_type_node, parmtypes);
8440 /* Build the name of the function. */
8441 sprintf (name, "__tcf_%d", counter++);
8442 /* Build the function declaration. */
8443 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8444 /* It's a function with internal linkage, generated by the
8446 TREE_PUBLIC (fndecl) = 0;
8447 DECL_ARTIFICIAL (fndecl) = 1;
8448 /* Make the function `inline' so that it is only emitted if it is
8449 actually needed. It is unlikely that it will be inlined, since
8450 it is only called via a function pointer, but we avoid unnecessary
8451 emissions this way. */
8452 DECL_INLINE (fndecl) = 1;
8453 /* Build the parameter. */
8454 if (flag_use_cxa_atexit)
8458 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
8459 DECL_CONTEXT (parmdecl) = fndecl;
8460 TREE_USED (parmdecl) = 1;
8461 DECL_ARGUMENTS (fndecl) = parmdecl;
8465 start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
8467 interface_unknown = old_interface_unknown;
8468 interface_only = old_interface_only;
8470 pop_lang_context ();
8472 return current_function_decl;
8475 /* Finish the cleanup function begun by start_cleanup_fn. */
8478 end_cleanup_fn (void)
8480 expand_body (finish_function (0));
8482 pop_from_top_level ();
8485 /* Generate code to handle the destruction of DECL, an object with
8486 static storage duration. */
8489 register_dtor_fn (tree decl)
8495 int saved_flag_access_control;
8497 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8500 /* Call build_cleanup before we enter the anonymous function so that
8501 any access checks will be done relative to the current scope,
8502 rather than the scope of the anonymous function. */
8503 build_cleanup (decl);
8505 /* Now start the function. */
8506 cleanup = start_cleanup_fn ();
8508 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8509 to the original function, rather than the anonymous one. That
8510 will make the back-end think that nested functions are in use,
8511 which causes confusion. */
8512 saved_flag_access_control = flag_access_control;
8513 scope_chain->check_access = flag_access_control = 0;
8514 fcall = build_cleanup (decl);
8515 scope_chain->check_access = flag_access_control = saved_flag_access_control;
8517 /* Create the body of the anonymous function. */
8518 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
8519 finish_expr_stmt (fcall);
8520 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
8523 /* Call atexit with the cleanup function. */
8524 cxx_mark_addressable (cleanup);
8525 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
8526 if (flag_use_cxa_atexit)
8528 args = tree_cons (NULL_TREE,
8529 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
8531 args = tree_cons (NULL_TREE, null_pointer_node, args);
8532 args = tree_cons (NULL_TREE, cleanup, args);
8535 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
8536 finish_expr_stmt (build_function_call (get_atexit_node (), args));
8539 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
8540 is its initializer. Generate code to handle the construction
8541 and destruction of DECL. */
8544 expand_static_init (tree decl, tree init)
8548 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
8549 my_friendly_assert (TREE_STATIC (decl), 20021010);
8551 /* Some variables require no initialization. */
8553 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
8554 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8557 oldstatic = value_member (decl, static_aggregates);
8561 if (TREE_PURPOSE (oldstatic) && init != NULL_TREE)
8562 error ("multiple initializations given for `%D'", decl);
8564 else if (! toplevel_bindings_p ())
8566 /* Emit code to perform this initialization but once. */
8573 /* Emit code to perform this initialization but once. This code
8576 static int guard = 0;
8578 // Do initialization.
8580 // Register variable for destruction at end of program.
8583 Note that the `temp' variable is only set to 1 *after* the
8584 initialization is complete. This ensures that an exception,
8585 thrown during the construction, will cause the variable to
8586 reinitialized when we pass through this code again, as per:
8590 If the initialization exits by throwing an exception, the
8591 initialization is not complete, so it will be tried again
8592 the next time control enters the declaration.
8594 In theory, this process should be thread-safe, too; multiple
8595 threads should not be able to initialize the variable more
8596 than once. We don't yet attempt to ensure thread-safety. */
8598 /* Create the guard variable. */
8599 guard = get_guard (decl);
8601 /* Begin the conditional initialization. */
8602 if_stmt = begin_if_stmt ();
8603 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
8604 then_clause = begin_compound_stmt (/*has_no_scope=*/0);
8606 /* Do the initialization itself. */
8607 assignment = init ? init : NULL_TREE;
8609 /* Once the assignment is complete, set TEMP to 1. Since the
8610 construction of the static object is complete at this point,
8611 we want to make sure TEMP is set to 1 even if a temporary
8612 constructed during the initialization throws an exception
8613 when it is destroyed. So, we combine the initialization and
8614 the assignment to TEMP into a single expression, ensuring
8615 that when we call finish_expr_stmt the cleanups will not be
8616 run until after TEMP is set to 1. */
8617 guard_init = set_guard (guard);
8620 assignment = tree_cons (NULL_TREE, assignment,
8621 build_tree_list (NULL_TREE,
8623 assignment = build_compound_expr (assignment);
8626 assignment = guard_init;
8627 finish_expr_stmt (assignment);
8629 /* Use atexit to register a function for destroying this static
8631 register_dtor_fn (decl);
8633 finish_compound_stmt (/*has_no_scope=*/0, then_clause);
8634 finish_then_clause (if_stmt);
8638 static_aggregates = tree_cons (init, decl, static_aggregates);
8641 /* Finish the declaration of a catch-parameter. */
8644 start_handler_parms (tree declspecs, tree declarator)
8649 decl = grokdeclarator (declarator, declspecs, CATCHPARM,
8651 if (decl == NULL_TREE)
8652 error ("invalid catch parameter");
8661 /* Make TYPE a complete type based on INITIAL_VALUE.
8662 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8663 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
8666 complete_array_type (tree type, tree initial_value, int do_default)
8668 register tree maxindex = NULL_TREE;
8673 /* An array of character type can be initialized from a
8674 brace-enclosed string constant. */
8675 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
8676 && TREE_CODE (initial_value) == CONSTRUCTOR
8677 && CONSTRUCTOR_ELTS (initial_value)
8678 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
8680 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
8681 initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
8683 /* Note MAXINDEX is really the maximum index, one less than the
8685 if (TREE_CODE (initial_value) == STRING_CST)
8688 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8689 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
8692 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8694 tree elts = CONSTRUCTOR_ELTS (initial_value);
8696 maxindex = ssize_int (-1);
8697 for (; elts; elts = TREE_CHAIN (elts))
8699 if (TREE_PURPOSE (elts))
8700 maxindex = TREE_PURPOSE (elts);
8702 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
8704 maxindex = copy_node (maxindex);
8708 /* Make an error message unless that happened already. */
8709 if (initial_value != error_mark_node)
8712 initial_value = NULL_TREE;
8714 /* Prevent further error messages. */
8715 maxindex = build_int_2 (0, 0);
8722 maxindex = build_int_2 (0, 0);
8731 domain = build_index_type (maxindex);
8732 TYPE_DOMAIN (type) = domain;
8734 if (! TREE_TYPE (maxindex))
8735 TREE_TYPE (maxindex) = domain;
8737 itype = TREE_TYPE (initial_value);
8740 if (itype && !TYPE_DOMAIN (itype))
8741 TYPE_DOMAIN (itype) = domain;
8742 /* The type of the main variant should never be used for arrays
8743 of different sizes. It should only ever be completed with the
8744 size of the array. */
8745 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
8746 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
8749 /* Lay out the type now that we can get the real answer. */
8756 /* Return zero if something is declared to be a member of type
8757 CTYPE when in the context of CUR_TYPE. STRING is the error
8758 message to print in that case. Otherwise, quietly return 1. */
8761 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
8763 if (ctype && ctype != cur_type)
8765 if (flags == DTOR_FLAG)
8766 error ("destructor for alien class `%T' cannot be a member",
8769 error ("constructor for alien class `%T' cannot be a member",
8776 /* Subroutine of `grokdeclarator'. */
8778 /* Generate errors possibly applicable for a given set of specifiers.
8779 This is for ARM $7.1.2. */
8782 bad_specifiers (tree object,
8791 error ("`%D' declared as a `virtual' %s", object, type);
8793 error ("`%D' declared as an `inline' %s", object, type);
8795 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
8798 cp_error_at ("`%D' declared as a friend", object);
8800 && (TREE_CODE (object) == TYPE_DECL
8801 || (!TYPE_PTRFN_P (TREE_TYPE (object))
8802 && !TYPE_REFFN_P (TREE_TYPE (object))
8803 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8804 cp_error_at ("`%D' declared with an exception specification", object);
8807 /* CTYPE is class type, or null if non-class.
8808 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8810 DECLARATOR is the function's name.
8811 VIRTUALP is truthvalue of whether the function is virtual or not.
8812 FLAGS are to be passed through to `grokclassfn'.
8813 QUALS are qualifiers indicating whether the function is `const'
8815 RAISES is a list of exceptions that this function can raise.
8816 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8817 not look, and -1 if we should not call `grokclassfn' at all.
8819 Returns `NULL_TREE' if something goes wrong, after issuing
8820 applicable error messages. */
8823 grokfndecl (tree ctype,
8826 tree orig_declarator,
8828 enum overload_flags flags,
8840 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8841 int has_default_arg = 0;
8845 type = build_exception_variant (type, raises);
8847 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
8848 /* Propagate volatile out from type to decl. */
8849 if (TYPE_VOLATILE (type))
8850 TREE_THIS_VOLATILE (decl) = 1;
8852 /* If this decl has namespace scope, set that up. */
8854 set_decl_namespace (decl, in_namespace, friendp);
8856 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8858 /* `main' and builtins have implicit 'C' linkage. */
8859 if ((MAIN_NAME_P (declarator)
8860 || (IDENTIFIER_LENGTH (declarator) > 10
8861 && IDENTIFIER_POINTER (declarator)[0] == '_'
8862 && IDENTIFIER_POINTER (declarator)[1] == '_'
8863 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
8864 && current_lang_name == lang_name_cplusplus
8865 && ctype == NULL_TREE
8866 /* NULL_TREE means global namespace. */
8867 && DECL_CONTEXT (decl) == NULL_TREE)
8868 SET_DECL_LANGUAGE (decl, lang_c);
8870 /* Should probably propagate const out from type to decl I bet (mrs). */
8873 DECL_STATIC_FUNCTION_P (decl) = 1;
8874 DECL_CONTEXT (decl) = ctype;
8878 DECL_CONTEXT (decl) = ctype;
8880 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
8882 if (processing_template_decl)
8883 error ("cannot declare `::main' to be a template");
8885 error ("cannot declare `::main' to be inline");
8887 error ("cannot declare `::main' to be static");
8888 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
8890 error ("`main' must return `int'");
8895 /* Members of anonymous types and local classes have no linkage; make
8897 /* FIXME what if it gets a name from typedef? */
8898 if (ctype && (TYPE_ANONYMOUS_P (ctype)
8899 || decl_function_context (TYPE_MAIN_DECL (ctype))))
8904 /* [basic.link]: A name with no linkage (notably, the name of a class
8905 or enumeration declared in a local scope) shall not be used to
8906 declare an entity with linkage.
8908 Only check this for public decls for now. */
8909 t = no_linkage_check (TREE_TYPE (decl));
8912 if (TYPE_ANONYMOUS_P (t))
8914 if (DECL_EXTERN_C_P (decl))
8915 /* Allow this; it's pretty common in C. */;
8918 pedwarn ("non-local function `%#D' uses anonymous type",
8920 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
8922 `%#D' does not refer to the unqualified type, so it is not used for linkage",
8927 pedwarn ("non-local function `%#D' uses local type `%T'",
8932 TREE_PUBLIC (decl) = publicp;
8935 DECL_INTERFACE_KNOWN (decl) = 1;
8936 DECL_NOT_REALLY_EXTERN (decl) = 1;
8939 /* If the declaration was declared inline, mark it as such. */
8941 DECL_DECLARED_INLINE_P (decl) = 1;
8942 /* We inline functions that are explicitly declared inline, or, when
8943 the user explicitly asks us to, all functions. */
8944 if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
8945 DECL_INLINE (decl) = 1;
8947 DECL_EXTERNAL (decl) = 1;
8948 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
8950 error ("%smember function `%D' cannot have `%T' method qualifier",
8951 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
8955 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
8956 grok_op_properties (decl, friendp);
8958 if (ctype && decl_function_context (decl))
8959 DECL_NO_STATIC_CHAIN (decl) = 1;
8961 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8962 if (TREE_PURPOSE (t)
8963 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8965 has_default_arg = 1;
8970 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8974 ("defining explicit specialization `%D' in friend declaration",
8978 tree fns = TREE_OPERAND (orig_declarator, 0);
8979 tree args = TREE_OPERAND (orig_declarator, 1);
8981 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8983 /* Something like `template <class T> friend void f<T>()'. */
8984 error ("invalid use of template-id `%D' in declaration of primary template",
8990 /* A friend declaration of the form friend void f<>(). Record
8991 the information in the TEMPLATE_ID_EXPR. */
8992 SET_DECL_IMPLICIT_INSTANTIATION (decl);
8994 if (TREE_CODE (fns) == COMPONENT_REF)
8996 /* Due to bison parser ickiness, we will have already looked
8997 up an operator_name or PFUNCNAME within the current class
8998 (see template_id in parse.y). If the current class contains
8999 such a name, we'll get a COMPONENT_REF here. Undo that. */
9001 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
9002 == current_class_type, 20001120);
9003 fns = TREE_OPERAND (fns, 1);
9005 my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
9006 || TREE_CODE (fns) == LOOKUP_EXPR
9007 || TREE_CODE (fns) == OVERLOAD, 20001120);
9008 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
9010 if (has_default_arg)
9012 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
9019 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
9027 /* Make the init_value nonzero so pushdecl knows this is not
9028 tentative. error_mark_node is replaced later with the BLOCK. */
9029 DECL_INITIAL (decl) = error_mark_node;
9031 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9032 TREE_NOTHROW (decl) = 1;
9034 /* Caller will do the rest of this. */
9038 if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
9039 DECL_CONSTRUCTOR_P (decl) = 1;
9041 /* Function gets the ugly name, field gets the nice one. This call
9042 may change the type of the function (because of default
9044 if (ctype != NULL_TREE)
9045 grokclassfn (ctype, decl, flags, quals);
9047 decl = check_explicit_specialization (orig_declarator, decl,
9049 2 * (funcdef_flag != 0) +
9050 4 * (friendp != 0));
9051 if (decl == error_mark_node)
9054 if (ctype != NULL_TREE
9055 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
9060 old_decl = check_classfn (ctype, decl);
9062 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
9063 /* Because grokfndecl is always supposed to return a
9064 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9065 here. We depend on our callers to figure out that its
9066 really a template that's being returned. */
9067 old_decl = DECL_TEMPLATE_RESULT (old_decl);
9069 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
9070 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9072 /* Remove the `this' parm added by grokclassfn.
9073 XXX Isn't this done in start_function, too? */
9074 revert_static_member_fn (decl);
9075 last_function_parms = TREE_CHAIN (last_function_parms);
9077 if (old_decl && DECL_ARTIFICIAL (old_decl))
9078 error ("definition of implicitly-declared `%D'", old_decl);
9082 /* Since we've smashed OLD_DECL to its
9083 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9084 if (TREE_CODE (decl) == TEMPLATE_DECL)
9085 decl = DECL_TEMPLATE_RESULT (decl);
9087 /* Attempt to merge the declarations. This can fail, in
9088 the case of some invalid specialization declarations. */
9089 if (!duplicate_decls (decl, old_decl))
9090 error ("no `%#D' member function declared in class `%T'",
9096 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9099 if (ctype == NULL_TREE || check)
9103 DECL_VIRTUAL_P (decl) = 1;
9108 /* Create a VAR_DECL named NAME with the indicated TYPE.
9110 If SCOPE is non-NULL, it is the class type or namespace containing
9111 the variable. If SCOPE is NULL, the variable should is created in
9112 the innermost enclosings scope. */
9115 grokvardecl (tree type,
9117 RID_BIT_TYPE * specbits_in,
9123 RID_BIT_TYPE specbits;
9125 my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
9128 specbits = *specbits_in;
9130 /* Compute the scope in which to place the variable. */
9133 /* An explicit "extern" specifier indicates a namespace-scope
9135 if (RIDBIT_SETP (RID_EXTERN, specbits))
9136 scope = current_namespace;
9137 else if (!at_function_scope_p ())
9139 scope = current_scope ();
9141 scope = current_namespace;
9146 && (/* If the variable is a namespace-scope variable declared in a
9147 template, we need DECL_LANG_SPECIFIC. */
9148 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9149 /* Similarly for namespace-scope variables with language linkage
9151 || (TREE_CODE (scope) == NAMESPACE_DECL
9152 && current_lang_name != lang_name_cplusplus)
9153 /* Similarly for static data members. */
9155 decl = build_lang_decl (VAR_DECL, name, type);
9157 decl = build_decl (VAR_DECL, name, type);
9159 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9160 set_decl_namespace (decl, scope, 0);
9162 DECL_CONTEXT (decl) = scope;
9164 if (name && scope && current_lang_name != lang_name_c)
9165 /* We can't mangle lazily here because we don't have any
9166 way to recover whether or not a variable was `extern
9170 if (RIDBIT_SETP (RID_EXTERN, specbits))
9172 DECL_THIS_EXTERN (decl) = 1;
9173 DECL_EXTERNAL (decl) = !initialized;
9176 /* In class context, static means one per class,
9177 public access, and static storage. */
9178 if (DECL_CLASS_SCOPE_P (decl))
9180 TREE_PUBLIC (decl) = 1;
9181 TREE_STATIC (decl) = 1;
9182 DECL_EXTERNAL (decl) = 0;
9184 /* At top level, either `static' or no s.c. makes a definition
9185 (perhaps tentative), and absence of `static' makes it public. */
9186 else if (toplevel_bindings_p ())
9188 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
9189 && (DECL_THIS_EXTERN (decl) || ! constp));
9190 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9192 /* Not at top level, only `static' makes a static definition. */
9195 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
9196 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9199 if (RIDBIT_SETP (RID_THREAD, specbits))
9201 if (targetm.have_tls)
9202 DECL_THREAD_LOCAL (decl) = 1;
9204 /* A mere warning is sure to result in improper semantics
9205 at runtime. Don't bother to allow this to compile. */
9206 error ("thread-local storage not supported for this target");
9209 if (TREE_PUBLIC (decl))
9211 /* [basic.link]: A name with no linkage (notably, the name of a class
9212 or enumeration declared in a local scope) shall not be used to
9213 declare an entity with linkage.
9215 Only check this for public decls for now. */
9216 tree t = no_linkage_check (TREE_TYPE (decl));
9219 if (TYPE_ANONYMOUS_P (t))
9220 /* Ignore for now; `enum { foo } e' is pretty common. */;
9222 pedwarn ("non-local variable `%#D' uses local type `%T'",
9230 /* Create and return a canonical pointer to member function type, for
9231 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9234 build_ptrmemfunc_type (tree type)
9238 tree unqualified_variant = NULL_TREE;
9240 if (type == error_mark_node)
9243 /* If a canonical type already exists for this type, use it. We use
9244 this method instead of type_hash_canon, because it only does a
9245 simple equality check on the list of field members. */
9247 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
9250 /* Make sure that we always have the unqualified pointer-to-member
9252 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9254 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9256 t = make_aggr_type (RECORD_TYPE);
9257 /* Let the front-end know this is a pointer to member function... */
9258 TYPE_PTRMEMFUNC_FLAG (t) = 1;
9259 /* ... and not really an aggregate. */
9260 SET_IS_AGGR_TYPE (t, 0);
9262 field = build_decl (FIELD_DECL, pfn_identifier, type);
9265 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
9266 TREE_CHAIN (field) = fields;
9269 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9271 /* Zap out the name so that the back-end will give us the debugging
9272 information for this anonymous RECORD_TYPE. */
9273 TYPE_NAME (t) = NULL_TREE;
9275 /* If this is not the unqualified form of this pointer-to-member
9276 type, set the TYPE_MAIN_VARIANT for this type to be the
9277 unqualified type. Since they are actually RECORD_TYPEs that are
9278 not variants of each other, we must do this manually. */
9279 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
9281 t = build_qualified_type (t, cp_type_quals (type));
9282 TYPE_MAIN_VARIANT (t) = unqualified_variant;
9283 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
9284 TYPE_NEXT_VARIANT (unqualified_variant) = t;
9287 /* Cache this pointer-to-member type so that we can find it again
9289 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
9291 /* Seems to be wanted. */
9292 CLASSTYPE_GOT_SEMICOLON (t) = 1;
9297 /* Create and return a pointer to data member type. */
9300 build_ptrmem_type (tree class_type, tree member_type)
9302 return build_pointer_type (build_offset_type (class_type, member_type));
9305 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9306 Check to see that the definition is valid. Issue appropriate error
9307 messages. Return 1 if the definition is particularly bad, or 0
9311 check_static_variable_definition (tree decl, tree type)
9313 /* Motion 10 at San Diego: If a static const integral data member is
9314 initialized with an integral constant expression, the initializer
9315 may appear either in the declaration (within the class), or in
9316 the definition, but not both. If it appears in the class, the
9317 member is a member constant. The file-scope definition is always
9319 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9321 error ("invalid in-class initialization of static data member of non-integral type `%T'",
9323 /* If we just return the declaration, crashes will sometimes
9324 occur. We therefore return void_type_node, as if this was a
9325 friend declaration, to cause callers to completely ignore
9326 this declaration. */
9329 else if (!CP_TYPE_CONST_P (type))
9330 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
9332 else if (pedantic && !INTEGRAL_TYPE_P (type))
9333 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
9338 /* Given the SIZE (i.e., number of elements) in an array, compute an
9339 appropriate index type for the array. If non-NULL, NAME is the
9340 name of the thing being declared. */
9343 compute_array_index_type (tree name, tree size)
9347 /* If this involves a template parameter, it will be a constant at
9348 instantiation time, but we don't know what the value is yet.
9349 Even if no template parameters are involved, we may an expression
9350 that is not a constant; we don't even simplify `1 + 2' when
9351 processing a template. */
9352 if (processing_template_decl)
9354 /* Resolve a qualified reference to an enumerator or static
9355 const data member of ours. */
9356 if (TREE_CODE (size) == SCOPE_REF
9357 && TREE_OPERAND (size, 0) == current_class_type)
9359 tree t = lookup_field (current_class_type,
9360 TREE_OPERAND (size, 1), 0, 0);
9365 return build_index_type (build_min (MINUS_EXPR, sizetype,
9366 size, integer_one_node));
9369 /* The size might be the result of a cast. */
9370 STRIP_TYPE_NOPS (size);
9372 /* It might be a const variable or enumeration constant. */
9373 size = decl_constant_value (size);
9375 /* The array bound must be an integer type. */
9376 if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
9377 && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE
9378 && TREE_CODE (TREE_TYPE (size)) != BOOLEAN_TYPE)
9381 error ("size of array `%D' has non-integer type", name);
9383 error ("size of array has non-integer type");
9384 size = integer_one_node;
9387 /* Normally, the array-bound will be a constant. */
9388 if (TREE_CODE (size) == INTEGER_CST)
9390 /* Check to see if the array bound overflowed. Make that an
9391 error, no matter how generous we're being. */
9392 int old_flag_pedantic_errors = flag_pedantic_errors;
9393 int old_pedantic = pedantic;
9394 pedantic = flag_pedantic_errors = 1;
9395 constant_expression_warning (size);
9396 pedantic = old_pedantic;
9397 flag_pedantic_errors = old_flag_pedantic_errors;
9399 /* An array must have a positive number of elements. */
9400 if (INT_CST_LT (size, integer_zero_node))
9403 error ("size of array `%D' is negative", name);
9405 error ("size of array is negative");
9406 size = integer_one_node;
9408 /* Except that an extension we allow zero-sized arrays. We
9409 always allow them in system headers because glibc uses
9411 else if (integer_zerop (size) && pedantic && !in_system_header)
9414 pedwarn ("ISO C++ forbids zero-size array `%D'", name);
9416 pedwarn ("ISO C++ forbids zero-size array");
9419 else if (TREE_CONSTANT (size))
9421 /* `(int) &fn' is not a valid array bound. */
9423 error ("size of array `%D' is not an integral constant-expression",
9426 error ("size of array is not an integral constant-expression");
9429 /* Compute the index of the largest element in the array. It is
9430 one less than the number of elements in the array. */
9432 = fold (cp_build_binary_op (MINUS_EXPR,
9433 cp_convert (ssizetype, size),
9434 cp_convert (ssizetype,
9435 integer_one_node)));
9437 /* Check for variable-sized arrays. We allow such things as an
9438 extension, even though they are not allowed in ANSI/ISO C++. */
9439 if (!TREE_CONSTANT (itype))
9444 pedwarn ("ISO C++ forbids variable-size array `%D'",
9447 pedwarn ("ISO C++ forbids variable-size array");
9450 /* Create a variable-sized array index type. */
9451 itype = variable_size (itype);
9453 /* Make sure that there was no overflow when creating to a signed
9454 index type. (For example, on a 32-bit machine, an array with
9455 size 2^32 - 1 is too big.) */
9456 else if (TREE_OVERFLOW (itype))
9458 error ("overflow in array dimension");
9459 TREE_OVERFLOW (itype) = 0;
9462 /* Create and return the appropriate index type. */
9463 return build_index_type (itype);
9466 /* Returns the scope (if any) in which the entity declared by
9467 DECLARATOR will be located. If the entity was declared with an
9468 unqualified name, NULL_TREE is returned. */
9471 get_scope_of_declarator (tree declarator)
9476 switch (TREE_CODE (declarator))
9482 /* For any of these, the main declarator is the first operand. */
9483 return get_scope_of_declarator (TREE_OPERAND
9487 /* For a pointer-to-member, continue descending. */
9488 if (TREE_CODE (TREE_OPERAND (declarator, 1))
9490 return get_scope_of_declarator (TREE_OPERAND
9492 /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in
9493 which the declaration occurs is the first operand. */
9494 return TREE_OPERAND (declarator, 0);
9497 /* Attributes to be applied. The declarator is TREE_VALUE. */
9498 return get_scope_of_declarator (TREE_VALUE (declarator));
9501 /* Otherwise, we have a declarator-id which is not a qualified
9502 name; the entity will be declared in the current scope. */
9507 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9508 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9512 create_array_type_for_decl (tree name, tree type, tree size)
9514 tree itype = NULL_TREE;
9515 const char* error_msg;
9517 /* If things have already gone awry, bail now. */
9518 if (type == error_mark_node || size == error_mark_node)
9519 return error_mark_node;
9521 /* Assume that everything will go OK. */
9524 /* There are some types which cannot be array elements. */
9525 switch (TREE_CODE (type))
9528 error_msg = "array of void";
9532 error_msg = "array of functions";
9535 case REFERENCE_TYPE:
9536 error_msg = "array of references";
9540 error_msg = "array of data members";
9544 error_msg = "array of function members";
9551 /* If something went wrong, issue an error-message and return. */
9555 error ("declaration of `%D' as %s", name, error_msg);
9557 error ("creating %s", error_msg);
9559 return error_mark_node;
9564 The constant expressions that specify the bounds of the arrays
9565 can be omitted only for the first member of the sequence. */
9566 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
9569 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
9572 error ("multidimensional array must have bounds for all dimensions except the first");
9574 return error_mark_node;
9577 /* Figure out the index type for the array. */
9579 itype = compute_array_index_type (name, size);
9581 return build_cplus_array_type (type, itype);
9584 /* Check that it's OK to declare a function with the indicated TYPE.
9585 SFK indicates the kind of special function (if any) that this
9586 function is. OPTYPE is the type given in a conversion operator
9587 declaration. Returns the actual return type of the function; that
9588 may be different than TYPE if an error occurs, or for certain
9589 special functions. */
9592 check_special_function_return_type (special_function_kind sfk,
9598 case sfk_constructor:
9600 error ("return type specification for constructor invalid");
9602 type = void_type_node;
9605 case sfk_destructor:
9607 error ("return type specification for destructor invalid");
9608 type = void_type_node;
9611 case sfk_conversion:
9612 if (type && !same_type_p (type, optype))
9613 error ("operator `%T' declared to return `%T'", optype, type);
9615 pedwarn ("return type specified for `operator %T'", optype);
9627 /* Given declspecs and a declarator (abstract or otherwise), determine
9628 the name and type of the object declared and construct a DECL node
9631 DECLSPECS is a chain of tree_list nodes whose value fields
9632 are the storage classes and type specifiers.
9634 DECL_CONTEXT says which syntactic context this declaration is in:
9635 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9636 FUNCDEF for a function definition. Like NORMAL but a few different
9637 error messages in each case. Return value may be zero meaning
9638 this definition is too screwy to try to parse.
9639 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9640 handle member functions (which have FIELD context).
9641 Return value may be zero meaning this definition is too screwy to
9643 PARM for a parameter declaration (either within a function prototype
9644 or before a function body). Make a PARM_DECL, or return void_type_node.
9645 CATCHPARM for a parameter declaration before a catch clause.
9646 TYPENAME if for a typename (in a cast or sizeof).
9647 Don't make a DECL node; just return the ..._TYPE node.
9648 FIELD for a struct or union field; make a FIELD_DECL.
9649 BITFIELD for a field with specified width.
9650 INITIALIZED is 1 if the decl has an initializer.
9652 ATTRLIST is a pointer to the list of attributes, which may be NULL
9653 if there are none; *ATTRLIST may be modified if attributes from inside
9654 the declarator should be applied to the declaration.
9656 When this function is called, scoping variables (such as
9657 CURRENT_CLASS_TYPE) should reflect the scope in which the
9658 declaration occurs, not the scope in which the new declaration will
9659 be placed. For example, on:
9663 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9664 should not be `S'. */
9667 grokdeclarator (tree declarator,
9669 enum decl_context decl_context,
9673 RID_BIT_TYPE specbits;
9676 tree type = NULL_TREE;
9679 int virtualp, explicitp, friendp, inlinep, staticp;
9680 int explicit_int = 0;
9681 int explicit_char = 0;
9682 int defaulted_int = 0;
9683 int extern_langp = 0;
9684 tree dependant_name = NULL_TREE;
9686 tree typedef_decl = NULL_TREE;
9688 tree typedef_type = NULL_TREE;
9689 int funcdef_flag = 0;
9690 enum tree_code innermost_code = ERROR_MARK;
9693 /* See the code below that used this. */
9694 tree decl_attr = NULL_TREE;
9697 /* Keep track of what sort of function is being processed
9698 so that we can warn about default return values, or explicit
9699 return values which do not match prescribed defaults. */
9700 special_function_kind sfk = sfk_none;
9702 tree dname = NULL_TREE;
9703 tree ctype = current_class_type;
9704 tree ctor_return_type = NULL_TREE;
9705 enum overload_flags flags = NO_SPECIAL;
9706 tree quals = NULL_TREE;
9707 tree raises = NULL_TREE;
9708 int template_count = 0;
9709 tree in_namespace = NULL_TREE;
9710 tree returned_attrs = NULL_TREE;
9711 tree scope = NULL_TREE;
9713 RIDBIT_RESET_ALL (specbits);
9714 if (decl_context == FUNCDEF)
9715 funcdef_flag = 1, decl_context = NORMAL;
9716 else if (decl_context == MEMFUNCDEF)
9717 funcdef_flag = -1, decl_context = FIELD;
9718 else if (decl_context == BITFIELD)
9719 bitfield = 1, decl_context = FIELD;
9721 /* Look inside a declarator for the name being declared
9722 and get it as a string, for an error message. */
9724 tree *next = &declarator;
9728 while (next && *next)
9731 switch (TREE_CODE (decl))
9734 /* For attributes. */
9735 next = &TREE_VALUE (decl);
9740 next = &TREE_OPERAND (decl, 0);
9743 case BIT_NOT_EXPR: /* For C++ destructors! */
9745 tree name = TREE_OPERAND (decl, 0);
9746 tree rename = NULL_TREE;
9748 my_friendly_assert (flags == NO_SPECIAL, 152);
9750 sfk = sfk_destructor;
9752 TREE_OPERAND (decl, 0) = name = constructor_name (name);
9753 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
9754 if (ctype == NULL_TREE)
9756 if (current_class_type == NULL_TREE)
9758 error ("destructors must be member functions");
9763 tree t = constructor_name (current_class_type);
9770 tree t = constructor_name (ctype);
9777 error ("destructor `%T' must match class name `%T'",
9779 TREE_OPERAND (decl, 0) = rename;
9785 case ADDR_EXPR: /* C++ reference declaration */
9790 innermost_code = TREE_CODE (decl);
9791 next = &TREE_OPERAND (decl, 0);
9795 innermost_code = TREE_CODE (decl);
9796 if (decl_context == FIELD && ctype == NULL_TREE)
9797 ctype = current_class_type;
9799 && TREE_OPERAND (decl, 0)
9800 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
9801 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
9803 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9804 next = &TREE_OPERAND (decl, 0);
9806 if (ctype != NULL_TREE
9807 && decl != NULL_TREE && flags != DTOR_FLAG
9808 && constructor_name_p (decl, ctype))
9810 sfk = sfk_constructor;
9811 ctor_return_type = ctype;
9816 case TEMPLATE_ID_EXPR:
9818 tree fns = TREE_OPERAND (decl, 0);
9820 if (TREE_CODE (fns) == LOOKUP_EXPR)
9821 fns = TREE_OPERAND (fns, 0);
9824 if (TREE_CODE (dname) == COMPONENT_REF)
9825 dname = TREE_OPERAND (dname, 1);
9826 if (TREE_CODE (dname) != IDENTIFIER_NODE)
9828 my_friendly_assert (is_overloaded_fn (dname),
9830 dname = DECL_NAME (get_first_fn (dname));
9835 case IDENTIFIER_NODE:
9836 if (TREE_CODE (decl) == IDENTIFIER_NODE)
9841 if (C_IS_RESERVED_WORD (dname))
9843 error ("declarator-id missing; using reserved word `%D'",
9845 name = IDENTIFIER_POINTER (dname);
9847 else if (!IDENTIFIER_TYPENAME_P (dname))
9848 name = IDENTIFIER_POINTER (dname);
9851 my_friendly_assert (flags == NO_SPECIAL, 154);
9852 flags = TYPENAME_FLAG;
9853 ctor_return_type = TREE_TYPE (dname);
9854 sfk = sfk_conversion;
9855 if (IDENTIFIER_GLOBAL_VALUE (dname)
9856 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (dname))
9858 name = IDENTIFIER_POINTER (dname);
9860 name = "<invalid operator>";
9867 /* Perform error checking, and decide on a ctype. */
9868 tree cname = TREE_OPERAND (decl, 0);
9869 if (cname == NULL_TREE)
9871 else if (TREE_CODE (cname) == NAMESPACE_DECL)
9874 in_namespace = TREE_OPERAND (decl, 0);
9876 else if (! is_aggr_type (cname, 1))
9878 /* Must test TREE_OPERAND (decl, 1), in case user gives
9879 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
9880 else if (TREE_OPERAND (decl, 1)
9881 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
9883 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
9884 || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
9886 /* This might be declaring a member of a template
9887 parm to be a friend. */
9889 dependant_name = TREE_OPERAND (decl, 1);
9891 else if (ctype == NULL_TREE)
9893 else if (TREE_COMPLEXITY (decl) == current_class_depth)
9897 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
9899 error ("type `%T' is not derived from type `%T'",
9907 /* It is valid to write:
9909 class C { void f(); };
9913 The standard is not clear about whether `typedef const C D' is
9914 legal; as of 2002-09-15 the committee is considering
9915 that question. EDG 3.0 allows that syntax.
9916 Therefore, we do as well. */
9918 ctype = TYPE_MAIN_VARIANT (ctype);
9919 /* Update the declarator so that when we process it
9920 again the correct type is present. */
9921 TREE_OPERAND (decl, 0) = ctype;
9923 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
9924 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
9926 TREE_OPERAND (decl, 1) = constructor_name (ctype);
9927 next = &TREE_OPERAND (decl, 1);
9931 if (TREE_CODE (decl) == IDENTIFIER_NODE
9932 && constructor_name_p (decl, ctype))
9934 sfk = sfk_constructor;
9935 ctor_return_type = ctype;
9937 else if (TREE_CODE (decl) == BIT_NOT_EXPR
9938 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
9939 && constructor_name_p (TREE_OPERAND (decl, 0),
9942 sfk = sfk_destructor;
9943 ctor_return_type = ctype;
9945 TREE_OPERAND (decl, 0) = constructor_name (ctype);
9946 next = &TREE_OPERAND (decl, 0);
9957 /* Parse error puts this typespec where
9958 a declarator should go. */
9959 error ("`%T' specified as declarator-id", DECL_NAME (decl));
9960 if (TREE_TYPE (decl) == current_class_type)
9961 error (" perhaps you want `%T' for a constructor",
9962 current_class_name);
9963 dname = DECL_NAME (decl);
9964 name = IDENTIFIER_POINTER (dname);
9966 /* Avoid giving two errors for this. */
9967 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
9969 declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
9975 next = &BASELINK_FUNCTIONS (decl);
9979 /* Sometimes, we see a template-name used as part of a
9980 decl-specifier like in
9981 std::allocator alloc;
9982 Handle that gracefully. */
9983 error ("invalid use of template-name '%E' in a declarator", decl);
9984 return error_mark_node;
9988 my_friendly_assert (0, 20020917);
9993 /* A function definition's declarator must have the form of
9994 a function declarator. */
9996 if (funcdef_flag && innermost_code != CALL_EXPR)
9999 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
10000 && innermost_code != CALL_EXPR
10001 && ! (ctype && declspecs == NULL_TREE))
10003 error ("declaration of `%D' as non-function", dname);
10004 return void_type_node;
10007 /* Anything declared one level down from the top level
10008 must be one of the parameters of a function
10009 (because the body is at least two levels down). */
10011 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10012 by not allowing C++ class definitions to specify their parameters
10013 with xdecls (must be spec.d in the parmlist).
10015 Since we now wait to push a class scope until we are sure that
10016 we are in a legitimate method context, we must set oldcname
10017 explicitly (since current_class_name is not yet alive).
10019 We also want to avoid calling this a PARM if it is in a namespace. */
10021 if (decl_context == NORMAL && !toplevel_bindings_p ())
10023 struct cp_binding_level *b = current_binding_level;
10024 current_binding_level = b->level_chain;
10025 if (current_binding_level != 0 && toplevel_bindings_p ())
10026 decl_context = PARM;
10027 current_binding_level = b;
10031 name = decl_context == PARM ? "parameter" : "type name";
10033 /* Look through the decl specs and record which ones appear.
10034 Some typespecs are defined as built-in typenames.
10035 Others, the ones that are modifiers of other types,
10036 are represented by bits in SPECBITS: set the bits for
10037 the modifiers that appear. Storage class keywords are also in SPECBITS.
10039 If there is a typedef name or a type, store the type in TYPE.
10040 This includes builtin typedefs such as `int'.
10042 Set EXPLICIT_INT if the type is `int' or `char' and did not
10043 come from a user typedef.
10045 Set LONGLONG if `long' is mentioned twice.
10047 For C++, constructors and destructors have their own fast treatment. */
10049 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
10054 /* Certain parse errors slip through. For example,
10055 `int class;' is not caught by the parser. Try
10056 weakly to recover here. */
10057 if (TREE_CODE (spec) != TREE_LIST)
10060 id = TREE_VALUE (spec);
10062 /* If the entire declaration is itself tagged as deprecated then
10063 suppress reports of deprecated items. */
10064 if (!adding_implicit_members && id && TREE_DEPRECATED (id))
10066 if (deprecated_state != DEPRECATED_SUPPRESS)
10067 warn_deprecated_use (id);
10070 if (TREE_CODE (id) == IDENTIFIER_NODE)
10072 if (id == ridpointers[(int) RID_INT]
10073 || id == ridpointers[(int) RID_CHAR]
10074 || id == ridpointers[(int) RID_BOOL]
10075 || id == ridpointers[(int) RID_WCHAR])
10079 if (id == ridpointers[(int) RID_BOOL])
10080 error ("`bool' is now a keyword");
10082 error ("extraneous `%T' ignored", id);
10086 if (id == ridpointers[(int) RID_INT])
10088 else if (id == ridpointers[(int) RID_CHAR])
10090 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
10094 /* C++ aggregate types. */
10095 if (IDENTIFIER_HAS_TYPE_VALUE (id))
10098 error ("multiple declarations `%T' and `%T'", type, id);
10100 type = IDENTIFIER_TYPE_VALUE (id);
10104 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
10106 if (ridpointers[i] == id)
10108 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
10110 if (pedantic && ! in_system_header && warn_long_long)
10111 pedwarn ("ISO C++ does not support `long long'");
10113 error ("`long long long' is too long for GCC");
10117 else if (RIDBIT_SETP (i, specbits))
10118 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
10120 /* Diagnose "__thread extern" or "__thread static". */
10121 if (RIDBIT_SETP (RID_THREAD, specbits))
10123 if (i == (int)RID_EXTERN)
10124 error ("`__thread' before `extern'");
10125 else if (i == (int)RID_STATIC)
10126 error ("`__thread' before `static'");
10129 if (i == (int)RID_EXTERN
10130 && TREE_PURPOSE (spec) == error_mark_node)
10131 /* This extern was part of a language linkage. */
10134 RIDBIT_SET (i, specbits);
10139 else if (TREE_CODE (id) == TYPE_DECL)
10142 error ("multiple declarations `%T' and `%T'", type,
10146 type = TREE_TYPE (id);
10147 TREE_VALUE (spec) = type;
10153 error ("two or more data types in declaration of `%s'", name);
10154 else if (TREE_CODE (id) == IDENTIFIER_NODE)
10156 register tree t = lookup_name (id, 1);
10157 if (!t || TREE_CODE (t) != TYPE_DECL)
10158 error ("`%s' fails to be a typedef or built in type",
10159 IDENTIFIER_POINTER (id));
10162 type = TREE_TYPE (t);
10166 else if (id != error_mark_node)
10167 /* Can't change CLASS nodes into RECORD nodes here! */
10174 /* See the code below that used this. */
10176 decl_attr = DECL_ATTRIBUTES (typedef_decl);
10178 typedef_type = type;
10180 /* No type at all: default to `int', and set DEFAULTED_INT
10181 because it was not a user-defined typedef. */
10183 if (type == NULL_TREE
10184 && (RIDBIT_SETP (RID_SIGNED, specbits)
10185 || RIDBIT_SETP (RID_UNSIGNED, specbits)
10186 || RIDBIT_SETP (RID_LONG, specbits)
10187 || RIDBIT_SETP (RID_SHORT, specbits)))
10189 /* These imply 'int'. */
10190 type = integer_type_node;
10194 if (sfk != sfk_none)
10195 type = check_special_function_return_type (sfk, type,
10197 else if (type == NULL_TREE)
10203 /* We handle `main' specially here, because 'main () { }' is so
10204 common. With no options, it is allowed. With -Wreturn-type,
10205 it is a warning. It is only an error with -pedantic-errors. */
10206 is_main = (funcdef_flag
10207 && dname && MAIN_NAME_P (dname)
10208 && ctype == NULL_TREE
10209 && in_namespace == NULL_TREE
10210 && current_namespace == global_namespace);
10212 if (in_system_header || flag_ms_extensions)
10213 /* Allow it, sigh. */;
10214 else if (pedantic || ! is_main)
10215 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
10217 else if (warn_return_type)
10218 warning ("ISO C++ forbids declaration of `%s' with no type",
10221 type = integer_type_node;
10226 /* Now process the modifiers that were specified
10227 and check for invalid combinations. */
10229 /* Long double is a special combination. */
10231 if (RIDBIT_SETP (RID_LONG, specbits)
10232 && TYPE_MAIN_VARIANT (type) == double_type_node)
10234 RIDBIT_RESET (RID_LONG, specbits);
10235 type = build_qualified_type (long_double_type_node,
10236 cp_type_quals (type));
10239 /* Check all other uses of type modifiers. */
10241 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10242 || RIDBIT_SETP (RID_SIGNED, specbits)
10243 || RIDBIT_SETP (RID_LONG, specbits)
10244 || RIDBIT_SETP (RID_SHORT, specbits))
10248 if (TREE_CODE (type) == REAL_TYPE)
10249 error ("short, signed or unsigned invalid for `%s'", name);
10250 else if (TREE_CODE (type) != INTEGER_TYPE)
10251 error ("long, short, signed or unsigned invalid for `%s'", name);
10252 else if (RIDBIT_SETP (RID_LONG, specbits)
10253 && RIDBIT_SETP (RID_SHORT, specbits))
10254 error ("long and short specified together for `%s'", name);
10255 else if ((RIDBIT_SETP (RID_LONG, specbits)
10256 || RIDBIT_SETP (RID_SHORT, specbits))
10258 error ("long or short specified with char for `%s'", name);
10259 else if ((RIDBIT_SETP (RID_LONG, specbits)
10260 || RIDBIT_SETP (RID_SHORT, specbits))
10261 && TREE_CODE (type) == REAL_TYPE)
10262 error ("long or short specified with floating type for `%s'", name);
10263 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10264 && RIDBIT_SETP (RID_UNSIGNED, specbits))
10265 error ("signed and unsigned given together for `%s'", name);
10269 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
10271 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
10273 if (flag_pedantic_errors)
10278 /* Discard the type modifiers if they are invalid. */
10281 RIDBIT_RESET (RID_UNSIGNED, specbits);
10282 RIDBIT_RESET (RID_SIGNED, specbits);
10283 RIDBIT_RESET (RID_LONG, specbits);
10284 RIDBIT_RESET (RID_SHORT, specbits);
10289 if (RIDBIT_SETP (RID_COMPLEX, specbits)
10290 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10292 error ("complex invalid for `%s'", name);
10293 RIDBIT_RESET (RID_COMPLEX, specbits);
10296 /* Decide whether an integer type is signed or not.
10297 Optionally treat bitfields as signed by default. */
10298 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
10301 It is implementation-defined whether a plain (neither
10302 explicitly signed or unsigned) char, short, int, or long
10303 bit-field is signed or unsigned.
10305 Naturally, we extend this to long long as well. Note that
10306 this does not include wchar_t. */
10307 || (bitfield && !flag_signed_bitfields
10308 && RIDBIT_NOTSETP (RID_SIGNED, specbits)
10309 /* A typedef for plain `int' without `signed' can be
10310 controlled just like plain `int', but a typedef for
10311 `signed int' cannot be so controlled. */
10313 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10314 && (TREE_CODE (type) == INTEGER_TYPE
10315 || TREE_CODE (type) == CHAR_TYPE)
10316 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10319 type = long_long_unsigned_type_node;
10320 else if (RIDBIT_SETP (RID_LONG, specbits))
10321 type = long_unsigned_type_node;
10322 else if (RIDBIT_SETP (RID_SHORT, specbits))
10323 type = short_unsigned_type_node;
10324 else if (type == char_type_node)
10325 type = unsigned_char_type_node;
10326 else if (typedef_decl)
10327 type = c_common_unsigned_type (type);
10329 type = unsigned_type_node;
10331 else if (RIDBIT_SETP (RID_SIGNED, specbits)
10332 && type == char_type_node)
10333 type = signed_char_type_node;
10335 type = long_long_integer_type_node;
10336 else if (RIDBIT_SETP (RID_LONG, specbits))
10337 type = long_integer_type_node;
10338 else if (RIDBIT_SETP (RID_SHORT, specbits))
10339 type = short_integer_type_node;
10341 if (RIDBIT_SETP (RID_COMPLEX, specbits))
10343 /* If we just have "complex", it is equivalent to
10344 "complex double", but if any modifiers at all are specified it is
10345 the complex form of TYPE. E.g, "complex short" is
10346 "complex short int". */
10348 if (defaulted_int && ! longlong
10349 && ! (RIDBIT_SETP (RID_LONG, specbits)
10350 || RIDBIT_SETP (RID_SHORT, specbits)
10351 || RIDBIT_SETP (RID_SIGNED, specbits)
10352 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
10353 type = complex_double_type_node;
10354 else if (type == integer_type_node)
10355 type = complex_integer_type_node;
10356 else if (type == float_type_node)
10357 type = complex_float_type_node;
10358 else if (type == double_type_node)
10359 type = complex_double_type_node;
10360 else if (type == long_double_type_node)
10361 type = complex_long_double_type_node;
10363 type = build_complex_type (type);
10366 type_quals = TYPE_UNQUALIFIED;
10367 if (RIDBIT_SETP (RID_CONST, specbits))
10368 type_quals |= TYPE_QUAL_CONST;
10369 if (RIDBIT_SETP (RID_VOLATILE, specbits))
10370 type_quals |= TYPE_QUAL_VOLATILE;
10371 if (RIDBIT_SETP (RID_RESTRICT, specbits))
10372 type_quals |= TYPE_QUAL_RESTRICT;
10373 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
10374 error ("qualifiers are not allowed on declaration of `operator %T'",
10377 type_quals |= cp_type_quals (type);
10378 type = cp_build_qualified_type_real
10379 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
10380 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
10381 /* We might have ignored or rejected some of the qualifiers. */
10382 type_quals = cp_type_quals (type);
10385 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
10386 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
10387 RIDBIT_RESET (RID_VIRTUAL, specbits);
10388 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
10389 RIDBIT_RESET (RID_EXPLICIT, specbits);
10391 if (RIDBIT_SETP (RID_STATIC, specbits))
10392 staticp = 1 + (decl_context == FIELD);
10394 if (virtualp && staticp == 2)
10396 error ("member `%D' cannot be declared both virtual and static",
10400 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
10401 RIDBIT_RESET (RID_FRIEND, specbits);
10403 if (dependant_name && !friendp)
10405 error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
10406 return void_type_node;
10409 /* Warn if two storage classes are given. Default to `auto'. */
10411 if (RIDBIT_ANY_SET (specbits))
10413 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
10414 if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
10415 if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
10416 if (decl_context == PARM && nclasses > 0)
10417 error ("storage class specifiers invalid in parameter declarations");
10418 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10420 if (decl_context == PARM)
10421 error ("typedef declaration invalid in parameter declaration");
10424 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
10425 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
10426 if (!nclasses && !friendp && extern_langp)
10430 /* Give error if `virtual' is used outside of class declaration. */
10432 && (current_class_name == NULL_TREE || decl_context != FIELD))
10434 error ("virtual outside class declaration");
10438 /* Static anonymous unions are dealt with here. */
10439 if (staticp && decl_context == TYPENAME
10440 && TREE_CODE (declspecs) == TREE_LIST
10441 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
10442 decl_context = FIELD;
10444 /* Warn about storage classes that are invalid for certain
10445 kinds of declarations (parameters, typenames, etc.). */
10447 /* "static __thread" and "extern __thread" are allowed. */
10449 && RIDBIT_SETP (RID_THREAD, specbits)
10450 && (RIDBIT_SETP (RID_EXTERN, specbits)
10451 || RIDBIT_SETP (RID_STATIC, specbits)))
10455 error ("multiple storage classes in declaration of `%s'", name);
10456 else if (decl_context != NORMAL && nclasses > 0)
10458 if ((decl_context == PARM || decl_context == CATCHPARM)
10459 && (RIDBIT_SETP (RID_REGISTER, specbits)
10460 || RIDBIT_SETP (RID_AUTO, specbits)))
10462 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
10464 else if (decl_context == FIELD
10465 /* C++ allows static class elements */
10466 && RIDBIT_SETP (RID_STATIC, specbits))
10467 /* C++ also allows inlines and signed and unsigned elements,
10468 but in those cases we don't come in here. */
10472 if (decl_context == FIELD)
10474 tree tmp = NULL_TREE;
10475 register int op = 0;
10479 /* Avoid trying to get an operand off an identifier node. */
10480 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
10483 tmp = TREE_OPERAND (declarator, 0);
10484 op = IDENTIFIER_OPNAME_P (tmp);
10485 if (IDENTIFIER_TYPENAME_P (tmp))
10487 if (IDENTIFIER_GLOBAL_VALUE (tmp)
10488 && (TREE_CODE (IDENTIFIER_GLOBAL_VALUE (tmp))
10490 name = IDENTIFIER_POINTER (tmp);
10492 name = "<invalid operator>";
10495 error ("storage class specified for %s `%s'",
10496 op ? "member operator" : "field",
10501 if (decl_context == PARM || decl_context == CATCHPARM)
10502 error ("storage class specified for parameter `%s'", name);
10504 error ("storage class specified for typename");
10506 RIDBIT_RESET (RID_REGISTER, specbits);
10507 RIDBIT_RESET (RID_AUTO, specbits);
10508 RIDBIT_RESET (RID_EXTERN, specbits);
10509 RIDBIT_RESET (RID_THREAD, specbits);
10512 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
10514 if (toplevel_bindings_p ())
10516 /* It's common practice (and completely valid) to have a const
10517 be initialized and declared extern. */
10518 if (!(type_quals & TYPE_QUAL_CONST))
10519 warning ("`%s' initialized and declared `extern'", name);
10522 error ("`%s' has both `extern' and initializer", name);
10524 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
10525 && ! toplevel_bindings_p ())
10526 error ("nested function `%s' declared `extern'", name);
10527 else if (toplevel_bindings_p ())
10529 if (RIDBIT_SETP (RID_AUTO, specbits))
10530 error ("top-level declaration of `%s' specifies `auto'", name);
10532 else if (RIDBIT_SETP (RID_THREAD, specbits)
10533 && !RIDBIT_SETP (RID_EXTERN, specbits)
10534 && !RIDBIT_SETP (RID_STATIC, specbits))
10536 error ("function-scope `%s' implicitly auto and declared `__thread'",
10538 RIDBIT_RESET (RID_THREAD, specbits);
10541 if (nclasses > 0 && friendp)
10542 error ("storage class specifiers invalid in friend function declarations");
10544 scope = get_scope_of_declarator (declarator);
10546 /* Now figure out the structure of the declarator proper.
10547 Descend through it, creating more complex types, until we reach
10548 the declared identifier (or NULL_TREE, in an abstract declarator). */
10550 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
10551 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
10553 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
10554 an INDIRECT_REF (for *...),
10555 a CALL_EXPR (for ...(...)),
10556 an identifier (for the name being declared)
10557 or a null pointer (for the place in an absolute declarator
10558 where the name was omitted).
10559 For the last two cases, we have just exited the loop.
10561 For C++ it could also be
10562 a SCOPE_REF (for class :: ...). In this case, we have converted
10563 sensible names to types, and those are the values we use to
10564 qualify the member name.
10565 an ADDR_EXPR (for &...),
10566 a BIT_NOT_EXPR (for destructors)
10568 At this point, TYPE is the type of elements of an array,
10569 or for a function to return, or for a pointer to point to.
10570 After this sequence of ifs, TYPE is the type of the
10571 array or function or pointer, and DECLARATOR has had its
10572 outermost layer removed. */
10574 if (type == error_mark_node)
10576 if (TREE_CODE (declarator) == SCOPE_REF)
10577 declarator = TREE_OPERAND (declarator, 1);
10579 declarator = TREE_OPERAND (declarator, 0);
10582 if (quals != NULL_TREE
10583 && (declarator == NULL_TREE
10584 || TREE_CODE (declarator) != SCOPE_REF))
10586 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
10587 ctype = TYPE_METHOD_BASETYPE (type);
10588 if (ctype != NULL_TREE)
10590 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
10591 grok_method_quals (ctype, dummy, quals);
10592 type = TREE_TYPE (dummy);
10597 switch (TREE_CODE (declarator))
10601 /* We encode a declarator with embedded attributes using
10603 tree attrs = TREE_PURPOSE (declarator);
10607 declarator = TREE_VALUE (declarator);
10608 inner_decl = declarator;
10609 while (inner_decl != NULL_TREE
10610 && TREE_CODE (inner_decl) == TREE_LIST)
10611 inner_decl = TREE_VALUE (inner_decl);
10613 if (inner_decl == NULL_TREE
10614 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
10615 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
10616 if (TREE_CODE (inner_decl) == CALL_EXPR)
10617 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
10618 if (TREE_CODE (inner_decl) == ARRAY_REF)
10619 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
10620 returned_attrs = decl_attributes (&type,
10621 chainon (returned_attrs, attrs),
10628 register tree size;
10630 size = TREE_OPERAND (declarator, 1);
10632 /* VC++ spells a zero-sized array with []. */
10633 if (size == NULL_TREE && decl_context == FIELD && ! staticp
10634 && ! RIDBIT_SETP (RID_TYPEDEF, specbits))
10635 size = integer_zero_node;
10637 declarator = TREE_OPERAND (declarator, 0);
10639 type = create_array_type_for_decl (dname, type, size);
10649 tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
10650 tree inner_decl = TREE_OPERAND (declarator, 0);
10652 /* Declaring a function type.
10653 Make sure we have a valid type for the function to return. */
10655 /* We now know that the TYPE_QUALS don't apply to the
10656 decl, but to its return type. */
10657 type_quals = TYPE_UNQUALIFIED;
10659 /* Warn about some types functions can't return. */
10661 if (TREE_CODE (type) == FUNCTION_TYPE)
10663 error ("`%s' declared as function returning a function", name);
10664 type = integer_type_node;
10666 if (TREE_CODE (type) == ARRAY_TYPE)
10668 error ("`%s' declared as function returning an array", name);
10669 type = integer_type_node;
10672 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
10673 inner_decl = TREE_OPERAND (inner_decl, 1);
10675 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
10676 inner_decl = dname;
10678 /* Pick up type qualifiers which should be applied to `this'. */
10679 quals = CALL_DECLARATOR_QUALS (declarator);
10681 /* Pick up the exception specifications. */
10682 raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
10684 /* Say it's a definition only for the CALL_EXPR
10685 closest to the identifier. */
10688 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
10689 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
10690 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
10692 if (ctype == NULL_TREE
10693 && decl_context == FIELD
10695 && (friendp == 0 || dname == current_class_name))
10696 ctype = current_class_type;
10698 if (ctype && sfk == sfk_conversion)
10699 TYPE_HAS_CONVERSION (ctype) = 1;
10700 if (ctype && constructor_name_p (dname, ctype))
10702 /* We are within a class's scope. If our declarator name
10703 is the same as the class name, and we are defining
10704 a function, then it is a constructor/destructor, and
10705 therefore returns a void type. */
10707 if (flags == DTOR_FLAG)
10709 /* ISO C++ 12.4/2. A destructor may not be
10710 declared const or volatile. A destructor may
10713 error ("destructor cannot be static member function");
10716 error ("destructors may not be `%s'",
10717 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10720 if (decl_context == FIELD)
10722 if (! member_function_or_else (ctype,
10723 current_class_type,
10725 return void_type_node;
10728 else /* It's a constructor. */
10730 if (explicitp == 1)
10732 /* ISO C++ 12.1. A constructor may not be
10733 declared const or volatile. A constructor may
10734 not be virtual. A constructor may not be
10737 error ("constructor cannot be static member function");
10740 pedwarn ("constructors cannot be declared virtual");
10745 error ("constructors may not be `%s'",
10746 IDENTIFIER_POINTER (TREE_VALUE (quals)));
10750 RID_BIT_TYPE tmp_bits;
10751 memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
10752 RIDBIT_RESET (RID_INLINE, tmp_bits);
10753 RIDBIT_RESET (RID_STATIC, tmp_bits);
10754 if (RIDBIT_ANY_SET (tmp_bits))
10755 error ("return value type specifier for constructor ignored");
10757 if (decl_context == FIELD)
10759 if (! member_function_or_else (ctype,
10760 current_class_type,
10762 return void_type_node;
10763 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
10764 if (sfk != sfk_constructor)
10768 if (decl_context == FIELD)
10774 error ("can't initialize friend function `%s'", name);
10777 /* Cannot be both friend and virtual. */
10778 error ("virtual functions cannot be friends");
10779 RIDBIT_RESET (RID_FRIEND, specbits);
10782 if (decl_context == NORMAL)
10783 error ("friend declaration not in class definition");
10784 if (current_function_decl && funcdef_flag)
10785 error ("can't define friend function `%s' in a local class definition",
10789 /* Construct the function type and go to the next
10790 inner layer of declarator. */
10792 declarator = TREE_OPERAND (declarator, 0);
10794 /* FIXME: This is where default args should be fully
10797 arg_types = grokparms (inner_parms);
10799 if (declarator && flags == DTOR_FLAG)
10801 /* A destructor declared in the body of a class will
10802 be represented as a BIT_NOT_EXPR. But, we just
10803 want the underlying IDENTIFIER. */
10804 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
10805 declarator = TREE_OPERAND (declarator, 0);
10807 if (arg_types != void_list_node)
10809 error ("destructors may not have parameters");
10810 arg_types = void_list_node;
10811 last_function_parms = NULL_TREE;
10815 /* ANSI says that `const int foo ();'
10816 does not make the function foo const. */
10817 type = build_function_type (type, arg_types);
10823 /* Filter out pointers-to-references and references-to-references.
10824 We can get these if a TYPE_DECL is used. */
10826 if (TREE_CODE (type) == REFERENCE_TYPE)
10828 error (TREE_CODE (declarator) == ADDR_EXPR
10829 ? "cannot declare reference to `%#T'"
10830 : "cannot declare pointer to `%#T'", type);
10831 type = TREE_TYPE (type);
10833 else if (VOID_TYPE_P (type)
10834 && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
10835 error (ctype ? "cannot declare pointer to `%#T' member"
10836 : "cannot declare reference to `%#T'", type);
10838 /* Merge any constancy or volatility into the target type
10839 for the pointer. */
10841 /* We now know that the TYPE_QUALS don't apply to the decl,
10842 but to the target of the pointer. */
10843 type_quals = TYPE_UNQUALIFIED;
10845 if (TREE_CODE (declarator) == ADDR_EXPR)
10847 if (!VOID_TYPE_P (type))
10848 type = build_reference_type (type);
10850 else if (TREE_CODE (type) == METHOD_TYPE)
10851 type = build_ptrmemfunc_type (build_pointer_type (type));
10853 type = build_ptrmem_type (ctype, type);
10855 type = build_pointer_type (type);
10857 /* Process a list of type modifier keywords (such as
10858 const or volatile) that were given inside the `*' or `&'. */
10860 if (TREE_TYPE (declarator))
10862 register tree typemodlist;
10868 for (typemodlist = TREE_TYPE (declarator); typemodlist;
10869 typemodlist = TREE_CHAIN (typemodlist))
10871 tree qualifier = TREE_VALUE (typemodlist);
10873 if (qualifier == ridpointers[(int) RID_CONST])
10876 type_quals |= TYPE_QUAL_CONST;
10878 else if (qualifier == ridpointers[(int) RID_VOLATILE])
10881 type_quals |= TYPE_QUAL_VOLATILE;
10883 else if (qualifier == ridpointers[(int) RID_RESTRICT])
10886 type_quals |= TYPE_QUAL_RESTRICT;
10891 error ("invalid type modifier within pointer declarator");
10895 pedwarn ("duplicate `const'");
10897 pedwarn ("duplicate `volatile'");
10899 pedwarn ("duplicate `restrict'");
10900 type = cp_build_qualified_type (type, type_quals);
10901 type_quals = cp_type_quals (type);
10903 declarator = TREE_OPERAND (declarator, 0);
10909 /* We have converted type names to NULL_TREE if the
10910 name was bogus, or to a _TYPE node, if not.
10912 The variable CTYPE holds the type we will ultimately
10913 resolve to. The code here just needs to build
10914 up appropriate member types. */
10915 tree sname = TREE_OPERAND (declarator, 1);
10918 /* Destructors can have their visibilities changed as well. */
10919 if (TREE_CODE (sname) == BIT_NOT_EXPR)
10920 sname = TREE_OPERAND (sname, 0);
10922 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
10924 /* We had a reference to a global decl, or
10925 perhaps we were given a non-aggregate typedef,
10926 in which case we cleared this out, and should just
10927 keep going as though it wasn't there. */
10928 declarator = sname;
10931 ctype = TREE_OPERAND (declarator, 0);
10934 while (t != NULL_TREE && CLASS_TYPE_P (t))
10936 /* You're supposed to have one `template <...>'
10937 for every template class, but you don't need one
10938 for a full specialization. For example:
10940 template <class T> struct S{};
10941 template <> struct S<int> { void f(); };
10942 void S<int>::f () {}
10944 is correct; there shouldn't be a `template <>' for
10945 the definition of `S<int>::f'. */
10946 if (CLASSTYPE_TEMPLATE_INFO (t)
10947 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
10948 || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
10949 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
10950 template_count += 1;
10952 t = TYPE_MAIN_DECL (t);
10953 t = DECL_CONTEXT (t);
10956 if (sname == NULL_TREE)
10959 if (TREE_CODE (sname) == IDENTIFIER_NODE)
10961 /* This is the `standard' use of the scoping operator:
10962 basetype :: member . */
10964 if (ctype == current_class_type)
10970 Is this ill-formed? */
10973 pedwarn ("extra qualification `%T::' on member `%s' ignored",
10976 else if (TREE_CODE (type) == FUNCTION_TYPE)
10978 if (current_class_type == NULL_TREE || friendp)
10979 type = build_cplus_method_type (ctype, TREE_TYPE (type),
10980 TYPE_ARG_TYPES (type));
10983 error ("cannot declare member function `%T::%s' within `%T'",
10984 ctype, name, current_class_type);
10985 return error_mark_node;
10988 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
10989 || COMPLETE_TYPE_P (complete_type (ctype)))
10991 /* Have to move this code elsewhere in this function.
10992 this code is used for i.e., typedef int A::M; M *pm;
10994 It is? How? jason 10/2/94 */
10996 if (current_class_type)
10998 error ("cannot declare member `%T::%s' within `%T'",
10999 ctype, name, current_class_type);
11000 return void_type_node;
11005 cxx_incomplete_type_error (NULL_TREE, ctype);
11006 return error_mark_node;
11009 declarator = sname;
11011 else if (TREE_CODE (sname) == SCOPE_REF)
11016 declarator = TREE_OPERAND (declarator, 1);
11017 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
11018 /* In this case, we will deal with it later. */
11020 else if (TREE_CODE (type) == FUNCTION_TYPE)
11021 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11022 TYPE_ARG_TYPES (type));
11028 declarator = TREE_OPERAND (declarator, 0);
11032 declarator = BASELINK_FUNCTIONS (declarator);
11037 case ENUMERAL_TYPE:
11038 declarator = NULL_TREE;
11042 declarator = NULL_TREE;
11050 if (returned_attrs)
11053 *attrlist = chainon (returned_attrs, *attrlist);
11055 attrlist = &returned_attrs;
11058 /* Resolve any TYPENAME_TYPEs from the decl-specifier-seq that refer
11059 to ctype. They couldn't be resolved earlier because we hadn't
11060 pushed into the class yet.
11062 For example, consider:
11064 template <typename T>
11070 template <typename T>
11071 typename S<T>::X f() {}
11073 When parsing the decl-specifier-seq for the definition of `f',
11074 we construct a TYPENAME_TYPE for `S<T>::X'. By substituting
11075 here, we resolve it to the correct type. */
11076 if (scope && CLASS_TYPE_P (scope)
11077 && current_template_parms
11078 && uses_template_parms (scope))
11080 tree args = current_template_args ();
11081 push_scope (scope);
11082 type = tsubst (type, args, tf_error | tf_warning,
11087 /* Now TYPE has the actual type. */
11089 /* Did array size calculations overflow? */
11091 if (TREE_CODE (type) == ARRAY_TYPE
11092 && COMPLETE_TYPE_P (type)
11093 && TREE_OVERFLOW (TYPE_SIZE (type)))
11095 error ("size of array `%s' is too large", name);
11096 /* If we proceed with the array type as it is, we'll eventually
11097 crash in tree_low_cst(). */
11098 type = error_mark_node;
11101 if (decl_context == FIELD
11102 && !processing_template_decl
11103 && variably_modified_type_p (type))
11105 error ("data member may not have variably modified type `%T'", type);
11106 type = error_mark_node;
11109 if (explicitp == 1 || (explicitp && friendp))
11111 /* [dcl.fct.spec] The explicit specifier shall only be used in
11112 declarations of constructors within a class definition. */
11113 error ("only declarations of constructors can be `explicit'");
11117 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11119 if (current_class_name == NULL_TREE || decl_context == PARM || friendp)
11121 error ("non-member `%s' cannot be declared `mutable'", name);
11122 RIDBIT_RESET (RID_MUTABLE, specbits);
11124 else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
11126 error ("non-object member `%s' cannot be declared `mutable'", name);
11127 RIDBIT_RESET (RID_MUTABLE, specbits);
11129 else if (TREE_CODE (type) == FUNCTION_TYPE
11130 || TREE_CODE (type) == METHOD_TYPE)
11132 error ("function `%s' cannot be declared `mutable'", name);
11133 RIDBIT_RESET (RID_MUTABLE, specbits);
11137 error ("static `%s' cannot be declared `mutable'", name);
11138 RIDBIT_RESET (RID_MUTABLE, specbits);
11140 else if (type_quals & TYPE_QUAL_CONST)
11142 error ("const `%s' cannot be declared `mutable'", name);
11143 RIDBIT_RESET (RID_MUTABLE, specbits);
11147 if (declarator == NULL_TREE
11148 || TREE_CODE (declarator) == IDENTIFIER_NODE
11149 || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
11150 && (TREE_CODE (type) == FUNCTION_TYPE
11151 || TREE_CODE (type) == METHOD_TYPE)))
11153 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11155 error ("template-id `%D' used as a declarator", declarator);
11156 declarator = dname;
11159 /* Unexpected declarator format. */
11162 /* If this is declaring a typedef name, return a TYPE_DECL. */
11164 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
11168 /* Note that the grammar rejects storage classes
11169 in typenames, fields or parameters. */
11170 if (current_lang_name == lang_name_java)
11171 TYPE_FOR_JAVA (type) = 1;
11173 if (decl_context == FIELD)
11175 if (constructor_name_p (declarator, current_class_type))
11176 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
11178 decl = build_lang_decl (TYPE_DECL, declarator, type);
11182 decl = build_decl (TYPE_DECL, declarator, type);
11183 if (in_namespace || ctype)
11184 cp_error_at ("typedef name may not be a nested-name-specifier",
11186 if (!current_function_decl)
11187 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
11190 /* If the user declares "typedef struct {...} foo" then the
11191 struct will have an anonymous name. Fill that name in now.
11192 Nothing can refer to it, so nothing needs know about the name
11194 if (type != error_mark_node
11196 && TYPE_NAME (type)
11197 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11198 && TYPE_ANONYMOUS_P (type)
11199 /* Don't do this if there are attributes. */
11200 && (!attrlist || !*attrlist)
11201 && cp_type_quals (type) == TYPE_UNQUALIFIED)
11203 tree oldname = TYPE_NAME (type);
11206 /* Replace the anonymous name with the real name everywhere. */
11207 lookup_tag_reverse (type, declarator);
11208 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
11209 if (TYPE_NAME (t) == oldname)
11210 TYPE_NAME (t) = decl;
11212 if (TYPE_LANG_SPECIFIC (type))
11213 TYPE_WAS_ANONYMOUS (type) = 1;
11215 /* If this is a typedef within a template class, the nested
11216 type is a (non-primary) template. The name for the
11217 template needs updating as well. */
11218 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
11219 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
11220 = TYPE_IDENTIFIER (type);
11222 /* FIXME remangle member functions; member functions of a
11223 type with external linkage have external linkage. */
11228 if (ctype == NULL_TREE)
11230 if (TREE_CODE (type) != METHOD_TYPE)
11231 cp_error_at ("invalid type qualifier for non-member function type", decl);
11233 ctype = TYPE_METHOD_BASETYPE (type);
11235 if (ctype != NULL_TREE)
11236 grok_method_quals (ctype, decl, quals);
11239 if (RIDBIT_SETP (RID_SIGNED, specbits)
11240 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
11241 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
11243 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
11244 inlinep, friendp, raises != NULL_TREE);
11249 /* Detect the case of an array type of unspecified size
11250 which came, as such, direct from a typedef name.
11251 We must copy the type, so that the array's domain can be
11252 individually set by the object's initializer. */
11254 if (type && typedef_type
11255 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
11256 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
11257 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
11259 /* Detect where we're using a typedef of function type to declare a
11260 function. last_function_parms will not be set, so we must create
11263 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
11265 tree decls = NULL_TREE;
11268 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
11270 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
11272 TREE_CHAIN (decl) = decls;
11276 last_function_parms = nreverse (decls);
11279 /* If this is a type name (such as, in a cast or sizeof),
11280 compute the type and return it now. */
11282 if (decl_context == TYPENAME)
11284 /* Note that the grammar rejects storage classes
11285 in typenames, fields or parameters. */
11286 if (type_quals != TYPE_UNQUALIFIED)
11287 type_quals = TYPE_UNQUALIFIED;
11289 /* Special case: "friend class foo" looks like a TYPENAME context. */
11292 if (type_quals != TYPE_UNQUALIFIED)
11294 error ("type qualifiers specified for friend class declaration");
11295 type_quals = TYPE_UNQUALIFIED;
11299 error ("`inline' specified for friend class declaration");
11305 /* Don't allow friend declaration without a class-key. */
11306 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11307 pedwarn ("template parameters cannot be friends");
11308 else if (TREE_CODE (type) == TYPENAME_TYPE)
11309 pedwarn ("friend declaration requires class-key, "
11310 "i.e. `friend class %T::%D'",
11311 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
11313 pedwarn ("friend declaration requires class-key, "
11314 "i.e. `friend %#T'",
11318 /* Only try to do this stuff if we didn't already give up. */
11319 if (type != integer_type_node)
11321 /* A friendly class? */
11322 if (current_class_type)
11323 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type));
11325 error ("trying to make class `%T' a friend of global scope",
11328 type = void_type_node;
11333 if (ctype == NULL_TREE)
11335 if (TREE_CODE (type) != METHOD_TYPE)
11336 error ("invalid qualifiers on non-member function type");
11338 ctype = TYPE_METHOD_BASETYPE (type);
11342 tree dummy = build_decl (TYPE_DECL, declarator, type);
11343 grok_method_quals (ctype, dummy, quals);
11344 type = TREE_TYPE (dummy);
11350 else if (declarator == NULL_TREE && decl_context != PARM
11351 && decl_context != CATCHPARM
11352 && TREE_CODE (type) != UNION_TYPE
11355 error ("abstract declarator `%T' used as declaration", type);
11356 declarator = make_anon_name ();
11359 /* `void' at top level (not within pointer)
11360 is allowed only in typedefs or type names.
11361 We don't complain about parms either, but that is because
11362 a better error message can be made later. */
11364 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
11367 error ("unnamed variable or field declared void");
11368 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
11370 if (IDENTIFIER_OPNAME_P (declarator))
11373 error ("variable or field `%s' declared void", name);
11376 error ("variable or field declared void");
11377 type = integer_type_node;
11380 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
11381 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
11383 if (decl_context == PARM || decl_context == CATCHPARM)
11385 if (ctype || in_namespace)
11386 error ("cannot use `::' in parameter declaration");
11388 /* A parameter declared as an array of T is really a pointer to T.
11389 One declared as a function is really a pointer to a function.
11390 One declared as a member is really a pointer to member. */
11392 if (TREE_CODE (type) == ARRAY_TYPE)
11394 /* Transfer const-ness of array into that of type pointed to. */
11395 type = build_pointer_type (TREE_TYPE (type));
11396 type_quals = TYPE_UNQUALIFIED;
11398 else if (TREE_CODE (type) == FUNCTION_TYPE)
11399 type = build_pointer_type (type);
11400 else if (TREE_CODE (type) == OFFSET_TYPE)
11401 type = build_pointer_type (type);
11405 register tree decl;
11407 if (decl_context == PARM)
11409 decl = cp_build_parm_decl (declarator, type);
11411 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
11412 inlinep, friendp, raises != NULL_TREE);
11414 else if (decl_context == FIELD)
11416 if (type == error_mark_node)
11418 /* Happens when declaring arrays of sizes which
11419 are error_mark_node, for example. */
11422 else if (in_namespace && !friendp)
11424 /* Something like struct S { int N::j; }; */
11425 error ("invalid use of `::'");
11428 else if (TREE_CODE (type) == FUNCTION_TYPE)
11431 tree function_context;
11433 /* We catch the others as conflicts with the builtin
11435 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
11437 error ("function `%D' cannot be declared friend",
11444 if (ctype == NULL_TREE)
11445 ctype = current_class_type;
11447 if (ctype == NULL_TREE)
11449 error ("can't make `%D' into a method -- not in a class",
11451 return void_type_node;
11454 /* ``A union may [ ... ] not [ have ] virtual functions.''
11456 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
11458 error ("function `%D' declared virtual inside a union",
11460 return void_type_node;
11463 if (declarator == ansi_opname (NEW_EXPR)
11464 || declarator == ansi_opname (VEC_NEW_EXPR)
11465 || declarator == ansi_opname (DELETE_EXPR)
11466 || declarator == ansi_opname (VEC_DELETE_EXPR))
11470 error ("`%D' cannot be declared virtual, since it is always static",
11475 else if (staticp < 2)
11476 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11477 TYPE_ARG_TYPES (type));
11480 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11481 function_context = (ctype != NULL_TREE) ?
11482 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
11483 publicp = (! friendp || ! staticp)
11484 && function_context == NULL_TREE;
11485 decl = grokfndecl (ctype, type,
11486 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
11487 ? declarator : dname,
11489 virtualp, flags, quals, raises,
11490 friendp ? -1 : 0, friendp, publicp, inlinep,
11491 funcdef_flag, template_count, in_namespace);
11492 if (decl == NULL_TREE)
11495 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11496 /* The decl and setting of decl_attr is also turned off. */
11497 decl = build_decl_attribute_variant (decl, decl_attr);
11500 /* [class.conv.ctor]
11502 A constructor declared without the function-specifier
11503 explicit that can be called with a single parameter
11504 specifies a conversion from the type of its first
11505 parameter to the type of its class. Such a constructor
11506 is called a converting constructor. */
11507 if (explicitp == 2)
11508 DECL_NONCONVERTING_P (decl) = 1;
11509 else if (DECL_CONSTRUCTOR_P (decl))
11511 /* The constructor can be called with exactly one
11512 parameter if there is at least one parameter, and
11513 any subsequent parameters have default arguments.
11514 Ignore any compiler-added parms. */
11515 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
11517 if (arg_types == void_list_node
11519 && TREE_CHAIN (arg_types)
11520 && TREE_CHAIN (arg_types) != void_list_node
11521 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
11522 DECL_NONCONVERTING_P (decl) = 1;
11525 else if (TREE_CODE (type) == METHOD_TYPE)
11527 /* We only get here for friend declarations of
11528 members of other classes. */
11529 /* All method decls are public, so tell grokfndecl to set
11530 TREE_PUBLIC, also. */
11531 decl = grokfndecl (ctype, type, declarator, declarator,
11532 virtualp, flags, quals, raises,
11533 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
11534 template_count, in_namespace);
11535 if (decl == NULL_TREE)
11538 else if (!staticp && ! processing_template_decl
11539 && !COMPLETE_TYPE_P (complete_type (type))
11540 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
11543 error ("field `%D' has incomplete type", declarator);
11545 error ("name `%T' has incomplete type", type);
11547 /* If we're instantiating a template, tell them which
11548 instantiation made the field's type be incomplete. */
11549 if (current_class_type
11550 && TYPE_NAME (current_class_type)
11551 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
11552 && declspecs && TREE_VALUE (declspecs)
11553 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
11554 error (" in instantiation of template `%T'",
11555 current_class_type);
11557 type = error_mark_node;
11564 error ("`%s' is neither function nor member function; cannot be declared friend",
11565 IDENTIFIER_POINTER (declarator));
11573 /* Friends are treated specially. */
11574 if (ctype == current_class_type)
11575 warning ("member functions are implicitly friends of their class");
11578 tree t = NULL_TREE;
11579 if (decl && DECL_NAME (decl))
11581 if (template_class_depth (current_class_type) == 0)
11584 = check_explicit_specialization
11586 template_count, 2 * (funcdef_flag != 0) + 4);
11587 if (decl == error_mark_node)
11588 return error_mark_node;
11591 t = do_friend (ctype, declarator, decl,
11592 last_function_parms, *attrlist,
11593 flags, quals, funcdef_flag);
11595 if (t && funcdef_flag)
11598 return void_type_node;
11602 /* Structure field. It may not be a function, except for C++ */
11604 if (decl == NULL_TREE)
11610 /* An attempt is being made to initialize a non-static
11611 member. But, from [class.mem]:
11613 4 A member-declarator can contain a
11614 constant-initializer only if it declares a static
11615 member (_class.static_) of integral or enumeration
11616 type, see _class.static.data_.
11618 This used to be relatively common practice, but
11619 the rest of the compiler does not correctly
11620 handle the initialization unless the member is
11621 static so we make it static below. */
11622 pedwarn ("ISO C++ forbids initialization of member `%D'",
11624 pedwarn ("making `%D' static", declarator);
11628 if (uses_template_parms (type))
11629 /* We'll check at instantiation time. */
11631 else if (check_static_variable_definition (declarator,
11633 /* If we just return the declaration, crashes
11634 will sometimes occur. We therefore return
11635 void_type_node, as if this was a friend
11636 declaration, to cause callers to completely
11637 ignore this declaration. */
11638 return void_type_node;
11641 /* 9.2p13 [class.mem] */
11642 if (constructor_name_p (declarator, current_class_type)
11643 /* The standard does not allow non-static data members
11644 here either, but we agreed at the 10/99 meeting
11645 to change that in TC 1 so that they are allowed in
11646 classes with no user-defined constructors. */
11648 pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
11653 /* C++ allows static class members. All other work
11654 for this is done by grokfield. */
11655 decl = build_lang_decl (VAR_DECL, declarator, type);
11656 TREE_STATIC (decl) = 1;
11657 /* In class context, 'static' means public access. */
11658 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
11662 decl = build_decl (FIELD_DECL, declarator, type);
11663 DECL_NONADDRESSABLE_P (decl) = bitfield;
11664 if (RIDBIT_SETP (RID_MUTABLE, specbits))
11666 DECL_MUTABLE_P (decl) = 1;
11667 RIDBIT_RESET (RID_MUTABLE, specbits);
11671 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
11672 inlinep, friendp, raises != NULL_TREE);
11675 else if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
11677 tree original_name;
11683 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
11684 original_name = dname;
11686 original_name = declarator;
11688 if (RIDBIT_SETP (RID_AUTO, specbits))
11689 error ("storage class `auto' invalid for function `%s'", name);
11690 else if (RIDBIT_SETP (RID_REGISTER, specbits))
11691 error ("storage class `register' invalid for function `%s'", name);
11692 else if (RIDBIT_SETP (RID_THREAD, specbits))
11693 error ("storage class `__thread' invalid for function `%s'", name);
11695 /* Function declaration not at top level.
11696 Storage classes other than `extern' are not allowed
11697 and `extern' makes no difference. */
11698 if (! toplevel_bindings_p ()
11699 && (RIDBIT_SETP (RID_STATIC, specbits)
11700 || RIDBIT_SETP (RID_INLINE, specbits))
11703 if (RIDBIT_SETP (RID_STATIC, specbits))
11704 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
11706 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
11709 if (ctype == NULL_TREE)
11713 error ("virtual non-class function `%s'", name);
11717 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
11718 type = build_cplus_method_type (ctype, TREE_TYPE (type),
11719 TYPE_ARG_TYPES (type));
11721 /* Record presence of `static'. */
11722 publicp = (ctype != NULL_TREE
11723 || RIDBIT_SETP (RID_EXTERN, specbits)
11724 || !RIDBIT_SETP (RID_STATIC, specbits));
11726 decl = grokfndecl (ctype, type, original_name, declarator,
11727 virtualp, flags, quals, raises,
11729 publicp, inlinep, funcdef_flag,
11730 template_count, in_namespace);
11731 if (decl == NULL_TREE)
11736 int invalid_static = 0;
11738 /* Don't allow a static member function in a class, and forbid
11739 declaring main to be static. */
11740 if (TREE_CODE (type) == METHOD_TYPE)
11742 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
11743 invalid_static = 1;
11745 else if (current_function_decl)
11747 /* FIXME need arm citation */
11748 error ("cannot declare static function inside another function");
11749 invalid_static = 1;
11752 if (invalid_static)
11755 RIDBIT_RESET (RID_STATIC, specbits);
11761 /* It's a variable. */
11763 /* An uninitialized decl with `extern' is a reference. */
11764 decl = grokvardecl (type, declarator, &specbits,
11766 (type_quals & TYPE_QUAL_CONST) != 0,
11767 ctype ? ctype : in_namespace);
11768 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
11769 inlinep, friendp, raises != NULL_TREE);
11773 DECL_CONTEXT (decl) = ctype;
11776 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
11778 RIDBIT_RESET (RID_STATIC, specbits);
11780 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
11782 error ("static member `%D' declared `register'", decl);
11783 RIDBIT_RESET (RID_REGISTER, specbits);
11785 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
11787 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
11789 RIDBIT_RESET (RID_EXTERN, specbits);
11794 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
11796 /* Record `register' declaration for warnings on &
11797 and in case doing stupid register allocation. */
11799 if (RIDBIT_SETP (RID_REGISTER, specbits))
11800 DECL_REGISTER (decl) = 1;
11802 if (RIDBIT_SETP (RID_EXTERN, specbits))
11803 DECL_THIS_EXTERN (decl) = 1;
11805 if (RIDBIT_SETP (RID_STATIC, specbits))
11806 DECL_THIS_STATIC (decl) = 1;
11808 /* Record constancy and volatility. There's no need to do this
11809 when processing a template; we'll do this for the instantiated
11810 declaration based on the type of DECL. */
11811 if (!processing_template_decl)
11812 c_apply_type_quals_to_decl (type_quals, decl);
11818 /* Subroutine of start_function. Ensure that each of the parameter
11819 types (as listed in PARMS) is complete, as is required for a
11820 function definition. */
11823 require_complete_types_for_parms (tree parms)
11825 for (; parms; parms = TREE_CHAIN (parms))
11827 if (VOID_TYPE_P (TREE_TYPE (parms)))
11828 /* grokparms will have already issued an error */
11829 TREE_TYPE (parms) = error_mark_node;
11830 else if (complete_type_or_else (TREE_TYPE (parms), parms))
11831 layout_decl (parms, 0);
11833 TREE_TYPE (parms) = error_mark_node;
11837 /* Returns nonzero if T is a local variable. */
11840 local_variable_p (tree t)
11842 if ((TREE_CODE (t) == VAR_DECL
11843 /* A VAR_DECL with a context that is a _TYPE is a static data
11845 && !TYPE_P (CP_DECL_CONTEXT (t))
11846 /* Any other non-local variable must be at namespace scope. */
11847 && !DECL_NAMESPACE_SCOPE_P (t))
11848 || (TREE_CODE (t) == PARM_DECL))
11854 /* Returns nonzero if T is an automatic local variable or a label.
11855 (These are the declarations that need to be remapped when the code
11856 containing them is duplicated.) */
11859 nonstatic_local_decl_p (tree t)
11861 return ((local_variable_p (t) && !TREE_STATIC (t))
11862 || TREE_CODE (t) == LABEL_DECL
11863 || TREE_CODE (t) == RESULT_DECL);
11866 /* Like local_variable_p, but suitable for use as a tree-walking
11870 local_variable_p_walkfn (tree* tp,
11871 int* walk_subtrees ATTRIBUTE_UNUSED ,
11872 void* data ATTRIBUTE_UNUSED )
11874 return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
11875 ? *tp : NULL_TREE);
11878 /* Check that ARG, which is a default-argument expression for a
11879 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11880 something goes wrong. DECL may also be a _TYPE node, rather than a
11881 DECL, if there is no DECL available. */
11884 check_default_argument (tree decl, tree arg)
11889 if (TREE_CODE (arg) == DEFAULT_ARG)
11890 /* We get a DEFAULT_ARG when looking at an in-class declaration
11891 with a default argument. Ignore the argument for now; we'll
11892 deal with it after the class is complete. */
11895 if (processing_template_decl || uses_template_parms (arg))
11896 /* We don't do anything checking until instantiation-time. Note
11897 that there may be uninstantiated arguments even for an
11898 instantiated function, since default arguments are not
11899 instantiated until they are needed. */
11908 decl_type = TREE_TYPE (decl);
11910 if (arg == error_mark_node
11911 || decl == error_mark_node
11912 || TREE_TYPE (arg) == error_mark_node
11913 || decl_type == error_mark_node)
11914 /* Something already went wrong. There's no need to check
11916 return error_mark_node;
11918 /* [dcl.fct.default]
11920 A default argument expression is implicitly converted to the
11922 if (!TREE_TYPE (arg)
11923 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
11926 error ("default argument for `%#D' has type `%T'",
11927 decl, TREE_TYPE (arg));
11929 error ("default argument for parameter of type `%T' has type `%T'",
11930 decl_type, TREE_TYPE (arg));
11932 return error_mark_node;
11935 /* [dcl.fct.default]
11937 Local variables shall not be used in default argument
11940 The keyword `this' shall not be used in a default argument of a
11941 member function. */
11942 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
11946 error ("default argument `%E' uses local variable `%D'",
11948 return error_mark_node;
11955 /* Decode the list of parameter types for a function type.
11956 Given the list of things declared inside the parens,
11957 return a list of types.
11959 We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
11960 flag. If unset, we append void_list_node. A parmlist declared
11961 as `(void)' is accepted as the empty parmlist.
11963 Also set last_function_parms to the chain of PARM_DECLs. */
11966 grokparms (tree first_parm)
11968 tree result = NULL_TREE;
11969 tree decls = NULL_TREE;
11970 int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
11974 my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
11976 for (parm = first_parm; parm != NULL_TREE; parm = chain)
11978 tree type = NULL_TREE;
11979 tree decl = TREE_VALUE (parm);
11980 tree init = TREE_PURPOSE (parm);
11983 chain = TREE_CHAIN (parm);
11984 /* @@ weak defense against parse errors. */
11985 if (TREE_CODE (decl) != VOID_TYPE
11986 && TREE_CODE (decl) != TREE_LIST)
11988 /* Give various messages as the need arises. */
11989 if (TREE_CODE (decl) == STRING_CST)
11990 error ("invalid string constant `%E'", decl);
11991 else if (TREE_CODE (decl) == INTEGER_CST)
11992 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
11996 if (parm == void_list_node)
11999 split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
12000 decl = grokdeclarator (TREE_VALUE (decl), specs,
12001 PARM, init != NULL_TREE, &attrs);
12002 if (! decl || TREE_TYPE (decl) == error_mark_node)
12006 cplus_decl_attributes (&decl, attrs, 0);
12008 type = TREE_TYPE (decl);
12009 if (VOID_TYPE_P (type))
12011 if (same_type_p (type, void_type_node)
12012 && !DECL_NAME (decl) && !result && !chain && !ellipsis)
12013 /* this is a parmlist of `(void)', which is ok. */
12015 cxx_incomplete_type_error (decl, type);
12016 /* It's not a good idea to actually create parameters of
12017 type `void'; other parts of the compiler assume that a
12018 void type terminates the parameter list. */
12019 type = error_mark_node;
12020 TREE_TYPE (decl) = error_mark_node;
12023 if (type != error_mark_node)
12025 /* Top-level qualifiers on the parameters are
12026 ignored for function types. */
12027 type = TYPE_MAIN_VARIANT (type);
12028 if (TREE_CODE (type) == METHOD_TYPE)
12030 error ("parameter `%D' invalidly declared method type", decl);
12031 type = build_pointer_type (type);
12032 TREE_TYPE (decl) = type;
12034 else if (TREE_CODE (type) == OFFSET_TYPE)
12036 error ("parameter `%D' invalidly declared offset type", decl);
12037 type = build_pointer_type (type);
12038 TREE_TYPE (decl) = type;
12040 else if (abstract_virtuals_error (decl, type))
12041 any_error = 1; /* Seems like a good idea. */
12042 else if (POINTER_TYPE_P (type))
12044 /* [dcl.fct]/6, parameter types cannot contain pointers
12045 (references) to arrays of unknown bound. */
12046 tree t = TREE_TYPE (type);
12047 int ptr = TYPE_PTR_P (type);
12051 if (TYPE_PTR_P (t))
12053 else if (TREE_CODE (t) != ARRAY_TYPE)
12055 else if (!TYPE_DOMAIN (t))
12059 if (TREE_CODE (t) == ARRAY_TYPE)
12060 error ("parameter `%D' includes %s to array of unknown bound `%T'",
12061 decl, ptr ? "pointer" : "reference", t);
12064 if (!any_error && init)
12065 init = check_default_argument (decl, init);
12070 TREE_CHAIN (decl) = decls;
12072 result = tree_cons (init, type, result);
12074 decls = nreverse (decls);
12075 result = nreverse (result);
12077 result = chainon (result, void_list_node);
12078 last_function_parms = decls;
12084 /* D is a constructor or overloaded `operator='.
12086 Let T be the class in which D is declared. Then, this function
12089 -1 if D's is an ill-formed constructor or copy assignment operator
12090 whose first parameter is of type `T'.
12091 0 if D is not a copy constructor or copy assignment
12093 1 if D is a copy constructor or copy assignment operator whose
12094 first parameter is a reference to const qualified T.
12095 2 if D is a copy constructor or copy assignment operator whose
12096 first parameter is a reference to non-const qualified T.
12098 This function can be used as a predicate. Positive values indicate
12099 a copy constructor and nonzero values indicate a copy assignment
12109 my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
12111 if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
12112 /* Instantiations of template member functions are never copy
12113 functions. Note that member functions of templated classes are
12114 represented as template functions internally, and we must
12115 accept those as copy functions. */
12118 args = FUNCTION_FIRST_USER_PARMTYPE (d);
12122 arg_type = TREE_VALUE (args);
12124 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
12126 /* Pass by value copy assignment operator. */
12129 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
12130 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
12132 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
12138 args = TREE_CHAIN (args);
12140 if (args && args != void_list_node && !TREE_PURPOSE (args))
12141 /* There are more non-optional args. */
12147 /* Remember any special properties of member function DECL. */
12149 void grok_special_member_properties (tree decl)
12151 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
12152 ; /* Not special. */
12153 else if (DECL_CONSTRUCTOR_P (decl))
12155 int ctor = copy_fn_p (decl);
12161 A non-template constructor for class X is a copy
12162 constructor if its first parameter is of type X&, const
12163 X&, volatile X& or const volatile X&, and either there
12164 are no other parameters or else all other parameters have
12165 default arguments. */
12166 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
12168 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
12170 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
12171 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
12173 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
12177 A non-template assignment operator for class X is a copy
12178 assignment operator if its parameter is of type X, X&, const
12179 X&, volatile X& or const volatile X&. */
12181 int assop = copy_fn_p (decl);
12185 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12187 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12188 if (DECL_PURE_VIRTUAL_P (decl))
12189 TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
12194 /* Check a constructor DECL has the correct form. Complains
12195 if the class has a constructor of the form X(X). */
12198 grok_ctor_properties (tree ctype, tree decl)
12200 int ctor_parm = copy_fn_p (decl);
12206 A declaration of a constructor for a class X is ill-formed if
12207 its first parameter is of type (optionally cv-qualified) X
12208 and either there are no other parameters or else all other
12209 parameters have default arguments.
12211 We *don't* complain about member template instantiations that
12212 have this form, though; they can occur as we try to decide
12213 what constructor to use during overload resolution. Since
12214 overload resolution will never prefer such a constructor to
12215 the non-template copy constructor (which is either explicitly
12216 or implicitly defined), there's no need to worry about their
12217 existence. Theoretically, they should never even be
12218 instantiated, but that's hard to forestall. */
12219 error ("invalid constructor; you probably meant `%T (const %T&)'",
12221 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
12228 /* An operator with this code is unary, but can also be binary. */
12231 ambi_op_p (enum tree_code code)
12233 return (code == INDIRECT_REF
12234 || code == ADDR_EXPR
12235 || code == CONVERT_EXPR
12236 || code == NEGATE_EXPR
12237 || code == PREINCREMENT_EXPR
12238 || code == PREDECREMENT_EXPR);
12241 /* An operator with this name can only be unary. */
12244 unary_op_p (enum tree_code code)
12246 return (code == TRUTH_NOT_EXPR
12247 || code == BIT_NOT_EXPR
12248 || code == COMPONENT_REF
12249 || code == TYPE_EXPR);
12252 /* Do a little sanity-checking on how they declared their operator. */
12255 grok_op_properties (tree decl, int friendp)
12257 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
12259 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
12260 tree name = DECL_NAME (decl);
12261 enum tree_code operator_code;
12264 /* Count the number of arguments. */
12265 for (argtype = argtypes, arity = 0;
12266 argtype && argtype != void_list_node;
12267 argtype = TREE_CHAIN (argtype))
12270 if (current_class_type == NULL_TREE)
12273 if (DECL_CONV_FN_P (decl))
12274 operator_code = TYPE_EXPR;
12278 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12279 if (ansi_opname (CODE) == name) \
12281 operator_code = (CODE); \
12284 else if (ansi_assopname (CODE) == name) \
12286 operator_code = (CODE); \
12287 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12291 #include "operators.def"
12292 #undef DEF_OPERATOR
12297 my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
12298 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12302 switch (operator_code)
12305 TYPE_OVERLOADS_CALL_EXPR (current_class_type) = 1;
12309 TYPE_OVERLOADS_ARRAY_REF (current_class_type) = 1;
12312 case COMPONENT_REF:
12314 TYPE_OVERLOADS_ARROW (current_class_type) = 1;
12318 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
12322 TYPE_GETS_DELETE (current_class_type) |= 1;
12326 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
12329 case VEC_DELETE_EXPR:
12330 TYPE_GETS_DELETE (current_class_type) |= 2;
12338 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
12340 /* When the compiler encounters the definition of A::operator new, it
12341 doesn't look at the class declaration to find out if it's static. */
12343 revert_static_member_fn (decl);
12345 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
12347 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
12350 revert_static_member_fn (decl);
12352 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
12356 /* An operator function must either be a non-static member function
12357 or have at least one parameter of a class, a reference to a class,
12358 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12359 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
12361 if (operator_code == TYPE_EXPR
12362 || operator_code == CALL_EXPR
12363 || operator_code == COMPONENT_REF
12364 || operator_code == ARRAY_REF
12365 || operator_code == NOP_EXPR)
12366 error ("`%D' must be a nonstatic member function", decl);
12371 if (DECL_STATIC_FUNCTION_P (decl))
12372 error ("`%D' must be either a non-static member function or a non-member function", decl);
12375 for (; TREE_CODE (TREE_VALUE (p)) != VOID_TYPE ; p = TREE_CHAIN (p))
12377 tree arg = TREE_VALUE (p);
12378 if (TREE_CODE (arg) == REFERENCE_TYPE)
12379 arg = TREE_TYPE (arg);
12381 /* This lets bad template code slip through. */
12382 if (IS_AGGR_TYPE (arg)
12383 || TREE_CODE (arg) == ENUMERAL_TYPE
12384 || TREE_CODE (arg) == TEMPLATE_TYPE_PARM
12385 || TREE_CODE (arg) == BOUND_TEMPLATE_TEMPLATE_PARM)
12389 ("`%D' must have an argument of class or enumerated type",
12396 if (operator_code == CALL_EXPR)
12397 return; /* No restrictions on args. */
12399 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
12401 tree t = TREE_TYPE (name);
12404 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
12405 const char *what = 0;
12408 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
12410 if (TREE_CODE (t) == VOID_TYPE)
12412 else if (t == current_class_type)
12413 what = "the same type";
12414 /* Don't force t to be complete here. */
12415 else if (IS_AGGR_TYPE (t)
12416 && COMPLETE_TYPE_P (t)
12417 && DERIVED_FROM_P (t, current_class_type))
12418 what = "a base class";
12421 warning ("conversion to %s%s will never use a type conversion operator",
12422 ref ? "a reference to " : "", what);
12425 if (operator_code == COND_EXPR)
12428 error ("ISO C++ prohibits overloading operator ?:");
12430 else if (ambi_op_p (operator_code))
12433 /* We pick the one-argument operator codes by default, so
12434 we don't have to change anything. */
12436 else if (arity == 2)
12438 /* If we thought this was a unary operator, we now know
12439 it to be a binary operator. */
12440 switch (operator_code)
12443 operator_code = MULT_EXPR;
12447 operator_code = BIT_AND_EXPR;
12451 operator_code = PLUS_EXPR;
12455 operator_code = MINUS_EXPR;
12458 case PREINCREMENT_EXPR:
12459 operator_code = POSTINCREMENT_EXPR;
12462 case PREDECREMENT_EXPR:
12463 operator_code = POSTDECREMENT_EXPR;
12470 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
12472 if ((operator_code == POSTINCREMENT_EXPR
12473 || operator_code == POSTDECREMENT_EXPR)
12474 && ! processing_template_decl
12475 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
12478 error ("postfix `%D' must take `int' as its argument",
12482 ("postfix `%D' must take `int' as its second argument",
12489 error ("`%D' must take either zero or one argument", decl);
12491 error ("`%D' must take either one or two arguments", decl);
12494 /* More Effective C++ rule 6. */
12496 && (operator_code == POSTINCREMENT_EXPR
12497 || operator_code == POSTDECREMENT_EXPR
12498 || operator_code == PREINCREMENT_EXPR
12499 || operator_code == PREDECREMENT_EXPR))
12501 tree arg = TREE_VALUE (argtypes);
12502 tree ret = TREE_TYPE (TREE_TYPE (decl));
12503 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
12504 arg = TREE_TYPE (arg);
12505 arg = TYPE_MAIN_VARIANT (arg);
12506 if (operator_code == PREINCREMENT_EXPR
12507 || operator_code == PREDECREMENT_EXPR)
12509 if (TREE_CODE (ret) != REFERENCE_TYPE
12510 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
12512 warning ("prefix `%D' should return `%T'", decl,
12513 build_reference_type (arg));
12517 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
12518 warning ("postfix `%D' should return `%T'", decl, arg);
12522 else if (unary_op_p (operator_code))
12527 error ("`%D' must take `void'", decl);
12529 error ("`%D' must take exactly one argument", decl);
12532 else /* if (binary_op_p (operator_code)) */
12537 error ("`%D' must take exactly one argument", decl);
12539 error ("`%D' must take exactly two arguments", decl);
12542 /* More Effective C++ rule 7. */
12544 && (operator_code == TRUTH_ANDIF_EXPR
12545 || operator_code == TRUTH_ORIF_EXPR
12546 || operator_code == COMPOUND_EXPR))
12547 warning ("user-defined `%D' always evaluates both arguments",
12551 /* Effective C++ rule 23. */
12554 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12555 && (operator_code == PLUS_EXPR
12556 || operator_code == MINUS_EXPR
12557 || operator_code == TRUNC_DIV_EXPR
12558 || operator_code == MULT_EXPR
12559 || operator_code == TRUNC_MOD_EXPR)
12560 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12561 warning ("`%D' should return by value", decl);
12563 /* [over.oper]/8 */
12564 for (; argtypes && argtypes != void_list_node;
12565 argtypes = TREE_CHAIN (argtypes))
12566 if (TREE_PURPOSE (argtypes))
12568 TREE_PURPOSE (argtypes) = NULL_TREE;
12569 if (operator_code == POSTINCREMENT_EXPR
12570 || operator_code == POSTDECREMENT_EXPR)
12573 pedwarn ("`%D' cannot have default arguments", decl);
12576 error ("`%D' cannot have default arguments", decl);
12582 static const char *
12583 tag_name (enum tag_types code)
12600 /* Get the struct, enum or union (CODE says which) with tag NAME.
12601 Define the tag as a forward-reference if it is not defined.
12603 C++: If a class derivation is given, process it here, and report
12604 an error if multiple derivation declarations are not identical.
12606 If this is a definition, come in through xref_tag and only look in
12607 the current frame for the name (since C++ allows new names in any
12611 xref_tag (enum tag_types tag_code, tree name, tree attributes,
12614 enum tree_code code;
12615 register tree ref, t;
12616 struct cp_binding_level *b = current_binding_level;
12617 tree context = NULL_TREE;
12623 code = RECORD_TYPE;
12629 code = ENUMERAL_TYPE;
12635 /* If a cross reference is requested, look up the type
12636 already defined for this tag and return it. */
12640 name = TYPE_IDENTIFIER (t);
12643 t = IDENTIFIER_TYPE_VALUE (name);
12645 /* Warn about 'friend struct Inherited;' doing the wrong thing. */
12646 if (t && globalize && TREE_CODE (t) == TYPENAME_TYPE)
12648 static int explained;
12651 warning ("`%s %T' declares a new type at namespace scope",
12652 tag_name (tag_code), name);
12654 warning (" names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'",
12655 tag_name (tag_code),
12656 constructor_name (current_class_type),
12657 TYPE_IDENTIFIER (t));
12659 /* We need to remove the class scope binding for the
12660 TYPENAME_TYPE as otherwise poplevel_class gets confused. */
12661 for (shadowed = b->class_shadowed;
12663 shadowed = TREE_CHAIN (shadowed))
12664 if (TREE_TYPE (shadowed) == TYPE_NAME (t))
12666 TREE_PURPOSE (shadowed) = NULL_TREE;
12671 if (t && TREE_CODE (t) != code && TREE_CODE (t) != TEMPLATE_TYPE_PARM
12672 && TREE_CODE (t) != BOUND_TEMPLATE_TEMPLATE_PARM)
12677 /* If we know we are defining this tag, only look it up in
12678 this scope and don't try to find it as a type. */
12679 ref = lookup_tag (code, name, b, 1);
12685 ref = follow_tag_typedef (t);
12687 /* [dcl.type.elab] If the identifier resolves to a
12688 typedef-name or a template type-parameter, the
12689 elaborated-type-specifier is ill-formed. */
12692 pedwarn ("using typedef-name `%D' after `%s'",
12693 TYPE_NAME (t), tag_name (tag_code));
12696 else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM)
12697 error ("using template type parameter `%T' after `%s'",
12698 t, tag_name (tag_code));
12701 ref = lookup_tag (code, name, b, 0);
12705 /* Try finding it as a type declaration. If that wins,
12707 ref = lookup_name (name, 1);
12709 if (ref != NULL_TREE
12710 && processing_template_decl
12711 && DECL_CLASS_TEMPLATE_P (ref)
12712 && template_class_depth (current_class_type) == 0)
12713 /* Since GLOBALIZE is true, we're declaring a global
12714 template, so we want this type. */
12715 ref = DECL_TEMPLATE_RESULT (ref);
12717 if (ref && TREE_CODE (ref) == TYPE_DECL
12718 && TREE_CODE (TREE_TYPE (ref)) == code)
12719 ref = TREE_TYPE (ref);
12724 if (ref && current_class_type
12725 && template_class_depth (current_class_type)
12726 && PROCESSING_REAL_TEMPLATE_DECL_P ())
12728 /* Since GLOBALIZE is nonzero, we are not looking at a
12729 definition of this tag. Since, in addition, we are currently
12730 processing a (member) template declaration of a template
12731 class, we must be very careful; consider:
12738 { template <class V>
12739 friend struct S1; };
12741 Here, the S2::S1 declaration should not be confused with the
12742 outer declaration. In particular, the inner version should
12743 have a template parameter of level 2, not level 1. This
12744 would be particularly important if the member declaration
12747 template <class V = U> friend struct S1;
12749 say, when we should tsubst into `U' when instantiating
12750 S2. On the other hand, when presented with:
12760 we must find the inner binding eventually. We
12761 accomplish this by making sure that the new type we
12762 create to represent this declaration has the right
12764 context = TYPE_CONTEXT (ref);
12771 /* If no such tag is yet defined, create a forward-reference node
12772 and record it as the "definition".
12773 When a real declaration of this type is found,
12774 the forward-reference will be altered into a real type. */
12775 if (code == ENUMERAL_TYPE)
12777 error ("use of enum `%#D' without previous declaration", name);
12779 ref = make_node (ENUMERAL_TYPE);
12781 /* Give the type a default layout like unsigned int
12782 to avoid crashing if it does not get defined. */
12783 TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
12784 TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
12785 TYPE_USER_ALIGN (ref) = 0;
12786 TREE_UNSIGNED (ref) = 1;
12787 TYPE_PRECISION (ref) = TYPE_PRECISION (unsigned_type_node);
12788 TYPE_MIN_VALUE (ref) = TYPE_MIN_VALUE (unsigned_type_node);
12789 TYPE_MAX_VALUE (ref) = TYPE_MAX_VALUE (unsigned_type_node);
12791 /* Enable us to recognize when a type is created in class context.
12792 To do nested classes correctly, this should probably be cleared
12793 out when we leave this classes scope. Currently this in only
12794 done in `start_enum'. */
12796 pushtag (name, ref, globalize);
12800 struct cp_binding_level *old_b = class_binding_level;
12802 ref = make_aggr_type (code);
12803 TYPE_CONTEXT (ref) = context;
12805 #ifdef NONNESTED_CLASSES
12806 /* Class types don't nest the way enums do. */
12807 class_binding_level = (struct cp_binding_level *)0;
12809 pushtag (name, ref, globalize);
12810 class_binding_level = old_b;
12815 if (!globalize && processing_template_decl && IS_AGGR_TYPE (ref))
12816 redeclare_class_template (ref, current_template_parms);
12819 TYPE_ATTRIBUTES (ref) = attributes;
12825 xref_tag_from_type (tree old, tree id, int globalize)
12827 enum tag_types tag_kind;
12829 if (TREE_CODE (old) == RECORD_TYPE)
12830 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12832 tag_kind = union_type;
12834 if (id == NULL_TREE)
12835 id = TYPE_IDENTIFIER (old);
12837 return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize);
12840 /* REF is a type (named NAME), for which we have just seen some
12841 baseclasses. BINFO is a list of those baseclasses; the
12842 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
12843 the base-class. CODE_TYPE_NODE indicates whether REF is a class,
12844 struct, or union. */
12847 xref_basetypes (tree ref, tree binfo)
12849 /* In the declaration `A : X, Y, ... Z' we mark all the types
12850 (A, X, Y, ..., Z) so we can check for duplicates. */
12855 enum tag_types tag_code;
12857 if (TREE_CODE (ref) == UNION_TYPE)
12859 error ("derived union `%T' invalid", ref);
12863 tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
12865 /* First, make sure that any templates in base-classes are
12866 instantiated. This ensures that if we call ourselves recursively
12867 we do not get confused about which classes are marked and which
12872 tree basetype = TREE_VALUE (*basep);
12873 if (!(processing_template_decl && uses_template_parms (basetype))
12874 && !complete_type_or_else (basetype, NULL))
12875 /* An incomplete type. Remove it form the list. */
12876 *basep = TREE_CHAIN (*basep);
12878 basep = &TREE_CHAIN (*basep);
12881 SET_CLASSTYPE_MARKED (ref);
12882 BINFO_BASETYPES (TYPE_BINFO (ref)) = binfos
12883 = make_tree_vec (list_length (binfo));
12885 for (i = 0; binfo; binfo = TREE_CHAIN (binfo))
12887 /* The base of a derived struct is public by default. */
12889 = (TREE_PURPOSE (binfo) == access_public_node
12890 || TREE_PURPOSE (binfo) == access_public_virtual_node
12891 || (tag_code != class_type
12892 && (TREE_PURPOSE (binfo) == access_default_node
12893 || TREE_PURPOSE (binfo) == access_default_virtual_node)));
12895 = (TREE_PURPOSE (binfo) == access_protected_node
12896 || TREE_PURPOSE (binfo) == access_protected_virtual_node);
12898 = (TREE_PURPOSE (binfo) == access_private_virtual_node
12899 || TREE_PURPOSE (binfo) == access_protected_virtual_node
12900 || TREE_PURPOSE (binfo) == access_public_virtual_node
12901 || TREE_PURPOSE (binfo) == access_default_virtual_node);
12902 tree basetype = TREE_VALUE (binfo);
12905 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
12906 basetype = TREE_TYPE (basetype);
12908 || (TREE_CODE (basetype) != RECORD_TYPE
12909 && TREE_CODE (basetype) != TYPENAME_TYPE
12910 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
12911 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
12913 error ("base type `%T' fails to be a struct or class type",
12914 TREE_VALUE (binfo));
12918 if (CLASSTYPE_MARKED (basetype))
12920 if (basetype == ref)
12921 error ("recursive type `%T' undefined", basetype);
12923 error ("duplicate base type `%T' invalid", basetype);
12927 if (TYPE_FOR_JAVA (basetype)
12928 && (current_lang_depth () == 0))
12929 TYPE_FOR_JAVA (ref) = 1;
12931 /* Note that the BINFO records which describe individual
12932 inheritances are *not* shared in the lattice! They
12933 cannot be shared because a given baseclass may be
12934 inherited with different `accessibility' by different
12935 derived classes. (Each BINFO record describing an
12936 individual inheritance contains flags which say what
12937 the `accessibility' of that particular inheritance is.) */
12940 = make_binfo (size_zero_node, basetype,
12941 CLASS_TYPE_P (basetype)
12942 ? TYPE_BINFO_VTABLE (basetype) : NULL_TREE,
12943 CLASS_TYPE_P (basetype)
12944 ? TYPE_BINFO_VIRTUALS (basetype) : NULL_TREE);
12946 TREE_VEC_ELT (binfos, i) = base_binfo;
12947 TREE_VIA_PUBLIC (base_binfo) = via_public;
12948 TREE_VIA_PROTECTED (base_binfo) = via_protected;
12949 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
12950 BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref);
12952 /* We need to unshare the binfos now so that lookups during class
12953 definition work. */
12954 unshare_base_binfos (base_binfo);
12956 SET_CLASSTYPE_MARKED (basetype);
12958 /* We are free to modify these bits because they are meaningless
12959 at top level, and BASETYPE is a top-level type. */
12960 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
12962 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
12963 /* Converting to a virtual base class requires looking
12964 up the offset of the virtual base. */
12965 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
12968 if (CLASS_TYPE_P (basetype))
12970 TYPE_HAS_NEW_OPERATOR (ref)
12971 |= TYPE_HAS_NEW_OPERATOR (basetype);
12972 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12973 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12974 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12975 /* If the base-class uses multiple inheritance, so do we. */
12976 TYPE_USES_MULTIPLE_INHERITANCE (ref)
12977 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
12978 /* Likewise, if converting to a base of the base may require
12979 code, then we may need to generate code to convert to a
12981 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
12982 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
12988 TREE_VEC_LENGTH (binfos) = i;
12990 BINFO_BASETYPES (TYPE_BINFO (ref)) = NULL_TREE;
12994 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
12995 /* If there is more than one non-empty they cannot be at the same
12997 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
13000 /* Unmark all the types. */
13002 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (TREE_VEC_ELT (binfos, i)));
13003 CLEAR_CLASSTYPE_MARKED (ref);
13005 /* Now that we know all the base-classes, set up the list of virtual
13007 get_vbase_types (ref);
13011 /* Begin compiling the definition of an enumeration type.
13012 NAME is its name (or null if anonymous).
13013 Returns the type object, as yet incomplete.
13014 Also records info about it so that build_enumerator
13015 may be used to declare the individual values as they are read. */
13018 start_enum (tree name)
13020 register tree enumtype = NULL_TREE;
13021 struct cp_binding_level *b = current_binding_level;
13023 /* If this is the real definition for a previous forward reference,
13024 fill in the contents in the same object that used to be the
13025 forward reference. */
13027 if (name != NULL_TREE)
13028 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
13030 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
13032 error ("multiple definition of `%#T'", enumtype);
13033 cp_error_at ("previous definition here", enumtype);
13034 /* Clear out TYPE_VALUES, and start again. */
13035 TYPE_VALUES (enumtype) = NULL_TREE;
13039 enumtype = make_node (ENUMERAL_TYPE);
13040 pushtag (name, enumtype, 0);
13046 /* After processing and defining all the values of an enumeration type,
13047 install their decls in the enumeration type and finish it off.
13048 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
13051 finish_enum (tree enumtype)
13062 /* We built up the VALUES in reverse order. */
13063 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
13067 Following the closing brace of an enum-specifier, each
13068 enumerator has the type of its enumeration. Prior to the
13069 closing brace, the type of each enumerator is the type of
13070 its initializing value. */
13071 for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13072 TREE_TYPE (TREE_VALUE (pair)) = enumtype;
13074 /* For an enum defined in a template, all further processing is
13075 postponed until the template is instantiated. */
13076 if (processing_template_decl)
13078 if (at_function_scope_p ())
13079 add_stmt (build_min (TAG_DEFN, enumtype));
13083 /* Figure out what the minimum and maximum values of the enumerators
13085 if (TYPE_VALUES (enumtype))
13087 minnode = maxnode = NULL_TREE;
13089 for (pair = TYPE_VALUES (enumtype);
13091 pair = TREE_CHAIN (pair))
13095 value = DECL_INITIAL (TREE_VALUE (pair));
13098 minnode = maxnode = value;
13099 else if (tree_int_cst_lt (maxnode, value))
13101 else if (tree_int_cst_lt (value, minnode))
13106 minnode = maxnode = integer_zero_node;
13108 /* Compute the number of bits require to represent all values of the
13109 enumeration. We must do this before the type of MINNODE and
13110 MAXNODE are transformed, since min_precision relies on the
13111 TREE_TYPE of the value it is passed. */
13112 unsignedp = tree_int_cst_sgn (minnode) >= 0;
13113 lowprec = min_precision (minnode, unsignedp);
13114 highprec = min_precision (maxnode, unsignedp);
13115 precision = MAX (lowprec, highprec);
13117 /* Set the TREE_TYPE for the values as well. That's so that when we
13118 call decl_constant_value we get an entity of the right type (but
13119 with the constant value). In addition, transform the TYPE_VALUES
13120 list to contain the values, rather than the CONST_DECLs for them. */
13121 for (pair = TYPE_VALUES (enumtype); pair; pair = TREE_CHAIN (pair))
13123 tree value = DECL_INITIAL (TREE_VALUE (pair));
13125 TREE_TYPE (value) = enumtype;
13126 TREE_VALUE (pair) = value;
13129 /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE according to `precision'. */
13130 TYPE_SIZE (enumtype) = NULL_TREE;
13131 TYPE_PRECISION (enumtype) = precision;
13133 fixup_unsigned_type (enumtype);
13135 fixup_signed_type (enumtype);
13137 if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node)))
13138 /* Use the width of the narrowest normal C type which is wide
13140 TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size
13143 TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
13145 TYPE_SIZE (enumtype) = NULL_TREE;
13146 layout_type (enumtype);
13148 /* Fix up all variant types of this enum type. */
13149 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13151 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13152 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
13153 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
13154 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
13155 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
13156 TYPE_MODE (t) = TYPE_MODE (enumtype);
13157 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
13158 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
13159 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
13160 TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
13163 /* Finish debugging output for this type. */
13164 rest_of_type_compilation (enumtype, namespace_bindings_p ());
13167 /* Build and install a CONST_DECL for an enumeration constant of the
13168 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13169 Assignment of sequential values by default is handled here. */
13172 build_enumerator (tree name, tree value, tree enumtype)
13179 /* Remove no-op casts from the value. */
13181 STRIP_TYPE_NOPS (value);
13183 if (! processing_template_decl)
13185 /* Validate and default VALUE. */
13186 if (value != NULL_TREE)
13188 value = decl_constant_value (value);
13190 if (TREE_CODE (value) == INTEGER_CST)
13192 value = default_conversion (value);
13193 constant_expression_warning (value);
13197 error ("enumerator value for `%D' not integer constant", name);
13202 /* Default based on previous value. */
13203 if (value == NULL_TREE && ! processing_template_decl)
13207 if (TYPE_VALUES (enumtype))
13209 /* The next value is the previous value ... */
13210 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13211 /* ... plus one. */
13212 value = cp_build_binary_op (PLUS_EXPR,
13216 if (tree_int_cst_lt (value, prev_value))
13217 error ("overflow in enumeration values at `%D'", name);
13220 value = integer_zero_node;
13223 /* Remove no-op casts from the value. */
13225 STRIP_TYPE_NOPS (value);
13227 /* To fix MAX_VAL enum consts. (bkoz) */
13228 TREE_TYPE (value) = integer_type_node;
13232 /* We always have to copy here; not all INTEGER_CSTs are unshared.
13233 Even in other cases, we will later (in finish_enum) be setting
13234 the type of VALUE. But, we don't need to make a copy if this
13235 VALUE is one of the enumeration constants for this same
13236 enumeration type. */
13237 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13238 if (TREE_VALUE (values) == value)
13240 /* If we didn't break out of the loop, then we do need a copy. */
13241 if (!values && value)
13242 value = copy_node (value);
13244 /* C++ associates enums with global, function, or class declarations. */
13245 context = current_scope ();
13247 /* Build the actual enumeration constant. Note that the enumeration
13248 constants have the type of their initializers until the
13249 enumeration is complete:
13253 Following the closing brace of an enum-specifier, each enumer-
13254 ator has the type of its enumeration. Prior to the closing
13255 brace, the type of each enumerator is the type of its
13256 initializing value.
13258 In finish_enum we will reset the type. Of course, if we're
13259 processing a template, there may be no value. */
13260 type = value ? TREE_TYPE (value) : NULL_TREE;
13262 if (context && context == current_class_type)
13263 /* This enum declaration is local to the class. We need the full
13264 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
13265 decl = build_lang_decl (CONST_DECL, name, type);
13267 /* It's a global enum, or it's local to a function. (Note local to
13268 a function could mean local to a class method. */
13269 decl = build_decl (CONST_DECL, name, type);
13271 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
13272 DECL_INITIAL (decl) = value;
13273 TREE_READONLY (decl) = 1;
13275 if (context && context == current_class_type)
13276 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13277 on the TYPE_FIELDS list for `S'. (That's so that you can say
13278 things like `S::i' later.) */
13279 finish_member_declaration (decl);
13283 /* Add this enumeration constant to the list for this type. */
13284 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13288 /* We're defining DECL. Make sure that it's type is OK. */
13291 check_function_type (tree decl, tree current_function_parms)
13293 tree fntype = TREE_TYPE (decl);
13294 tree return_type = complete_type (TREE_TYPE (fntype));
13296 /* In a function definition, arg types must be complete. */
13297 require_complete_types_for_parms (current_function_parms);
13299 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13301 error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
13303 /* Make it return void instead, but don't change the
13304 type of the DECL_RESULT, in case we have a named return value. */
13305 if (TREE_CODE (fntype) == METHOD_TYPE)
13307 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
13309 = build_cplus_method_type (ctype,
13311 FUNCTION_ARG_CHAIN (decl));
13315 = build_function_type (void_type_node,
13316 TYPE_ARG_TYPES (TREE_TYPE (decl)));
13318 = build_exception_variant (fntype,
13319 TYPE_RAISES_EXCEPTIONS (fntype));
13322 abstract_virtuals_error (decl, TREE_TYPE (fntype));
13325 /* Create the FUNCTION_DECL for a function definition.
13326 DECLSPECS and DECLARATOR are the parts of the declaration;
13327 they describe the function's name and the type it returns,
13328 but twisted together in a fashion that parallels the syntax of C.
13330 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13331 DECLARATOR is really the DECL for the function we are about to
13332 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13333 indicating that the function is an inline defined in-class.
13335 This function creates a binding context for the function body
13336 as well as setting up the FUNCTION_DECL in current_function_decl.
13338 Returns 1 on success. If the DECLARATOR is not suitable for a function
13339 (it defines a datum instead), we return 0, which tells
13340 yyparse to report a parse error.
13342 For C++, we must first check whether that datum makes any sense.
13343 For example, "class A local_a(1,2);" means that variable local_a
13344 is an aggregate of type A, which should have a constructor
13345 applied to it with the argument list [1, 2]. */
13348 start_function (tree declspecs, tree declarator, tree attrs, int flags)
13351 tree ctype = NULL_TREE;
13354 int doing_friend = 0;
13355 struct cp_binding_level *bl;
13356 tree current_function_parms;
13358 /* Sanity check. */
13359 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
13360 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
13362 /* This should only be done once on the top most decl. */
13363 if (have_extern_spec)
13365 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
13366 have_extern_spec = false;
13369 if (flags & SF_PRE_PARSED)
13371 decl1 = declarator;
13373 fntype = TREE_TYPE (decl1);
13374 if (TREE_CODE (fntype) == METHOD_TYPE)
13375 ctype = TYPE_METHOD_BASETYPE (fntype);
13377 /* ISO C++ 11.4/5. A friend function defined in a class is in
13378 the (lexical) scope of the class in which it is defined. */
13379 if (!ctype && DECL_FRIEND_P (decl1))
13381 ctype = DECL_FRIEND_CONTEXT (decl1);
13383 /* CTYPE could be null here if we're dealing with a template;
13384 for example, `inline friend float foo()' inside a template
13385 will have no CTYPE set. */
13386 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13392 last_function_parms = DECL_ARGUMENTS (decl1);
13396 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, NULL);
13397 /* If the declarator is not suitable for a function definition,
13398 cause a syntax error. */
13399 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13402 cplus_decl_attributes (&decl1, attrs, 0);
13404 /* If #pragma weak was used, mark the decl weak now. */
13405 if (current_binding_level == global_binding_level)
13406 maybe_apply_pragma_weak (decl1);
13408 fntype = TREE_TYPE (decl1);
13410 restype = TREE_TYPE (fntype);
13411 if (CLASS_TYPE_P (restype) && !CLASSTYPE_GOT_SEMICOLON (restype))
13413 error ("semicolon missing after declaration of `%#T'", restype);
13414 shadow_tag (build_tree_list (NULL_TREE, restype));
13415 CLASSTYPE_GOT_SEMICOLON (restype) = 1;
13416 if (TREE_CODE (fntype) == FUNCTION_TYPE)
13417 fntype = build_function_type (integer_type_node,
13418 TYPE_ARG_TYPES (fntype));
13420 fntype = build_cplus_method_type (build_type_variant (TYPE_METHOD_BASETYPE (fntype), TREE_READONLY (decl1), TREE_SIDE_EFFECTS (decl1)),
13422 TYPE_ARG_TYPES (fntype));
13423 TREE_TYPE (decl1) = fntype;
13426 if (TREE_CODE (fntype) == METHOD_TYPE)
13427 ctype = TYPE_METHOD_BASETYPE (fntype);
13428 else if (DECL_MAIN_P (decl1))
13430 /* If this doesn't return integer_type, complain. */
13431 if (TREE_TYPE (TREE_TYPE (decl1)) != integer_type_node)
13433 if (pedantic || warn_return_type)
13434 pedwarn ("return type for `main' changed to `int'");
13435 TREE_TYPE (decl1) = fntype = default_function_type;
13440 if (DECL_DECLARED_INLINE_P (decl1)
13441 && lookup_attribute ("noinline", attrs))
13442 warning_with_decl (decl1,
13443 "inline function `%s' given attribute noinline");
13445 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13446 /* This is a constructor, we must ensure that any default args
13447 introduced by this definition are propagated to the clones
13448 now. The clones are used directly in overload resolution. */
13449 adjust_clone_args (decl1);
13451 /* Sometimes we don't notice that a function is a static member, and
13452 build a METHOD_TYPE for it. Fix that up now. */
13453 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13454 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
13456 revert_static_member_fn (decl1);
13457 last_function_parms = TREE_CHAIN (last_function_parms);
13461 /* Warn if function was previously implicitly declared
13462 (but not if we warned then). */
13463 if (! warn_implicit
13464 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
13465 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
13467 /* Set up current_class_type, and enter the scope of the class, if
13470 push_nested_class (ctype, 1);
13471 else if (DECL_STATIC_FUNCTION_P (decl1))
13472 push_nested_class (DECL_CONTEXT (decl1), 2);
13474 /* Now that we have entered the scope of the class, we must restore
13475 the bindings for any template parameters surrounding DECL1, if it
13476 is an inline member template. (Order is important; consider the
13477 case where a template parameter has the same name as a field of
13478 the class.) It is not until after this point that
13479 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13480 if (flags & SF_INCLASS_INLINE)
13481 maybe_begin_member_template_processing (decl1);
13483 /* Effective C++ rule 15. */
13485 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13486 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13487 warning ("`operator=' should return a reference to `*this'");
13489 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13490 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13491 if (!DECL_INITIAL (decl1))
13492 DECL_INITIAL (decl1) = error_mark_node;
13494 /* This function exists in static storage.
13495 (This does not mean `static' in the C sense!) */
13496 TREE_STATIC (decl1) = 1;
13498 /* We must call push_template_decl after current_class_type is set
13499 up. (If we are processing inline definitions after exiting a
13500 class scope, current_class_type will be NULL_TREE until set above
13501 by push_nested_class.) */
13502 if (processing_template_decl)
13503 decl1 = push_template_decl (decl1);
13505 /* We are now in the scope of the function being defined. */
13506 current_function_decl = decl1;
13508 /* Save the parm names or decls from this function's declarator
13509 where store_parm_decls will find them. */
13510 current_function_parms = last_function_parms;
13512 /* Make sure the parameter and return types are reasonable. When
13513 you declare a function, these types can be incomplete, but they
13514 must be complete when you define the function. */
13515 if (! processing_template_decl)
13516 check_function_type (decl1, current_function_parms);
13518 /* Build the return declaration for the function. */
13519 restype = TREE_TYPE (fntype);
13520 /* Promote the value to int before returning it. */
13521 if (c_promoting_integer_type_p (restype))
13522 restype = type_promotes_to (restype);
13523 if (DECL_RESULT (decl1) == NULL_TREE)
13525 DECL_RESULT (decl1)
13526 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
13527 c_apply_type_quals_to_decl (cp_type_quals (restype),
13528 DECL_RESULT (decl1));
13531 /* Initialize RTL machinery. We cannot do this until
13532 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13533 even when processing a template; this is how we get
13534 CFUN set up, and our per-function variables initialized.
13535 FIXME factor out the non-RTL stuff. */
13536 bl = current_binding_level;
13537 init_function_start (decl1, input_filename, lineno);
13538 current_binding_level = bl;
13540 /* Even though we're inside a function body, we still don't want to
13541 call expand_expr to calculate the size of a variable-sized array.
13542 We haven't necessarily assigned RTL to all variables yet, so it's
13543 not safe to try to expand expressions involving them. */
13544 immediate_size_expand = 0;
13545 cfun->x_dont_save_pending_sizes_p = 1;
13547 /* Start the statement-tree, start the tree now. */
13548 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
13550 /* Let the user know we're compiling this function. */
13551 announce_function (decl1);
13553 /* Record the decl so that the function name is defined.
13554 If we already have a decl for this name, and it is a FUNCTION_DECL,
13555 use the old decl. */
13556 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13558 /* A specialization is not used to guide overload resolution. */
13559 if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
13560 && ! DECL_FUNCTION_MEMBER_P (decl1))
13561 decl1 = pushdecl (decl1);
13564 /* We need to set the DECL_CONTEXT. */
13565 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13566 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13567 /* And make sure we have enough default args. */
13568 check_default_args (decl1);
13570 fntype = TREE_TYPE (decl1);
13573 /* Reset these in case the call to pushdecl changed them. */
13574 current_function_decl = decl1;
13575 cfun->decl = decl1;
13577 /* If we are (erroneously) defining a function that we have already
13578 defined before, wipe out what we knew before. */
13579 if (!DECL_PENDING_INLINE_P (decl1))
13580 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13582 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13584 /* We know that this was set up by `grokclassfn'. We do not
13585 wait until `store_parm_decls', since evil parse errors may
13586 never get us to that point. Here we keep the consistency
13587 between `current_class_type' and `current_class_ptr'. */
13588 tree t = DECL_ARGUMENTS (decl1);
13590 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
13592 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
13595 cp_function_chain->x_current_class_ref
13596 = build_indirect_ref (t, NULL);
13597 cp_function_chain->x_current_class_ptr = t;
13599 /* Constructors and destructors need to know whether they're "in
13600 charge" of initializing virtual base classes. */
13601 t = TREE_CHAIN (t);
13602 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13604 current_in_charge_parm = t;
13605 t = TREE_CHAIN (t);
13607 if (DECL_HAS_VTT_PARM_P (decl1))
13609 if (DECL_NAME (t) != vtt_parm_identifier)
13611 current_vtt_parm = t;
13615 if (DECL_INTERFACE_KNOWN (decl1))
13617 tree ctx = decl_function_context (decl1);
13619 if (DECL_NOT_REALLY_EXTERN (decl1))
13620 DECL_EXTERNAL (decl1) = 0;
13622 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
13623 && TREE_PUBLIC (ctx))
13624 /* This is a function in a local class in an extern inline
13626 comdat_linkage (decl1);
13628 /* If this function belongs to an interface, it is public.
13629 If it belongs to someone else's interface, it is also external.
13630 This only affects inlines and template instantiations. */
13631 else if (interface_unknown == 0
13632 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13633 || flag_alt_external_templates))
13635 if (DECL_DECLARED_INLINE_P (decl1)
13636 || DECL_TEMPLATE_INSTANTIATION (decl1)
13637 || processing_template_decl)
13639 DECL_EXTERNAL (decl1)
13641 || (DECL_DECLARED_INLINE_P (decl1)
13642 && ! flag_implement_inlines
13643 && !DECL_VINDEX (decl1)));
13645 /* For WIN32 we also want to put these in linkonce sections. */
13646 maybe_make_one_only (decl1);
13649 DECL_EXTERNAL (decl1) = 0;
13650 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13651 DECL_INTERFACE_KNOWN (decl1) = 1;
13653 else if (interface_unknown && interface_only
13654 && (! DECL_TEMPLATE_INSTANTIATION (decl1)
13655 || flag_alt_external_templates))
13657 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13658 interface, we will have interface_only set but not
13659 interface_known. In that case, we don't want to use the normal
13660 heuristics because someone will supply a #pragma implementation
13661 elsewhere, and deducing it here would produce a conflict. */
13662 comdat_linkage (decl1);
13663 DECL_EXTERNAL (decl1) = 0;
13664 DECL_INTERFACE_KNOWN (decl1) = 1;
13665 DECL_DEFER_OUTPUT (decl1) = 1;
13669 /* This is a definition, not a reference.
13670 So clear DECL_EXTERNAL. */
13671 DECL_EXTERNAL (decl1) = 0;
13673 if ((DECL_DECLARED_INLINE_P (decl1)
13674 || DECL_TEMPLATE_INSTANTIATION (decl1))
13675 && ! DECL_INTERFACE_KNOWN (decl1)
13676 /* Don't try to defer nested functions for now. */
13677 && ! decl_function_context (decl1))
13678 DECL_DEFER_OUTPUT (decl1) = 1;
13680 DECL_INTERFACE_KNOWN (decl1) = 1;
13684 current_binding_level->parm_flag = 1;
13688 if (DECL_DESTRUCTOR_P (decl1))
13690 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
13691 DECL_CONTEXT (dtor_label) = current_function_decl;
13694 start_fname_decls ();
13696 store_parm_decls (current_function_parms);
13701 /* Store the parameter declarations into the current function declaration.
13702 This is called after parsing the parameter declarations, before
13703 digesting the body of the function.
13705 Also install to binding contour return value identifier, if any. */
13708 store_parm_decls (tree current_function_parms)
13710 register tree fndecl = current_function_decl;
13711 register tree parm;
13713 /* This is a chain of any other decls that came in among the parm
13714 declarations. If a parm is declared with enum {foo, bar} x;
13715 then CONST_DECLs for foo and bar are put here. */
13716 tree nonparms = NULL_TREE;
13718 if (current_function_parms)
13720 /* This case is when the function was defined with an ANSI prototype.
13721 The parms already have decls, so we need not do anything here
13722 except record them as in effect
13723 and complain if any redundant old-style parm decls were written. */
13725 tree specparms = current_function_parms;
13728 /* Must clear this because it might contain TYPE_DECLs declared
13730 storedecls (NULL_TREE);
13732 /* If we're doing semantic analysis, then we'll call pushdecl
13733 for each of these. We must do them in reverse order so that
13734 they end in the correct forward order. */
13735 specparms = nreverse (specparms);
13737 for (parm = specparms; parm; parm = next)
13739 next = TREE_CHAIN (parm);
13740 if (TREE_CODE (parm) == PARM_DECL)
13742 if (DECL_NAME (parm) == NULL_TREE
13743 || TREE_CODE (parm) != VOID_TYPE)
13746 error ("parameter `%D' declared void", parm);
13750 /* If we find an enum constant or a type tag,
13751 put it aside for the moment. */
13752 TREE_CHAIN (parm) = NULL_TREE;
13753 nonparms = chainon (nonparms, parm);
13757 /* Get the decls in their original chain order and record in the
13758 function. This is all and only the PARM_DECLs that were
13759 pushed into scope by the loop above. */
13760 DECL_ARGUMENTS (fndecl) = getdecls ();
13761 storetags (gettags ());
13764 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13766 /* Now store the final chain of decls for the arguments
13767 as the decl-chain of the current lexical scope.
13768 Put the enumerators in as well, at the front so that
13769 DECL_ARGUMENTS is not modified. */
13770 storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
13772 /* Do the starting of the exception specifications, if we have any. */
13773 if (flag_exceptions && !processing_template_decl
13774 && flag_enforce_eh_specs
13775 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
13776 current_eh_spec_block = begin_eh_spec_block ();
13780 /* We have finished doing semantic analysis on DECL, but have not yet
13781 generated RTL for its body. Save away our current state, so that
13782 when we want to generate RTL later we know what to do. */
13785 save_function_data (tree decl)
13787 struct language_function *f;
13789 /* Save the language-specific per-function data so that we can
13790 get it back when we really expand this function. */
13791 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
13795 f = ((struct language_function *)
13796 ggc_alloc (sizeof (struct language_function)));
13797 memcpy (f, cp_function_chain, sizeof (struct language_function));
13798 DECL_SAVED_FUNCTION_DATA (decl) = f;
13800 /* Clear out the bits we don't need. */
13801 f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
13802 f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
13803 f->x_named_label_uses = NULL;
13804 f->bindings = NULL;
13805 f->x_local_names = NULL;
13807 /* When we get back here again, we will be expanding. */
13808 f->x_expanding_p = 1;
13810 /* If we've already decided that we cannot inline this function, we
13811 must remember that fact when we actually go to expand the
13813 if (current_function_cannot_inline)
13815 f->cannot_inline = current_function_cannot_inline;
13816 DECL_INLINE (decl) = 0;
13820 /* Add a note to mark the beginning of the main body of the constructor.
13821 This is used to set up the data structures for the cleanup regions for
13822 fully-constructed bases and members. */
13825 begin_constructor_body (void)
13829 /* Add a note to mark the end of the main body of the constructor. This is
13830 used to end the cleanup regions for fully-constructed bases and
13834 finish_constructor_body (void)
13838 /* Do all the processing for the beginning of a destructor; set up the
13839 vtable pointers and cleanups for bases and members. */
13842 begin_destructor_body (void)
13845 tree compound_stmt;
13847 /* If the dtor is empty, and we know there is not any possible
13848 way we could use any vtable entries, before they are possibly
13849 set by a base class dtor, we don't have to setup the vtables,
13850 as we know that any base class dtor will set up any vtables
13851 it needs. We avoid MI, because one base class dtor can do a
13852 virtual dispatch to an overridden function that would need to
13853 have a non-related vtable set up, we cannot avoid setting up
13854 vtables in that case. We could change this to see if there
13855 is just one vtable.
13857 ??? In the destructor for a class, the vtables are set
13858 appropriately for that class. There will be no non-related
13859 vtables. jason 2001-12-11. */
13860 if_stmt = begin_if_stmt ();
13862 /* If it is not safe to avoid setting up the vtables, then
13863 someone will change the condition to be boolean_true_node.
13864 (Actually, for now, we do not have code to set the condition
13865 appropriately, so we just assume that we always need to
13866 initialize the vtables.) */
13867 finish_if_stmt_cond (boolean_true_node, if_stmt);
13869 compound_stmt = begin_compound_stmt (/*has_no_scope=*/0);
13871 /* Make all virtual function table pointers in non-virtual base
13872 classes point to CURRENT_CLASS_TYPE's virtual function
13874 initialize_vtbl_ptrs (current_class_ptr);
13876 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt);
13877 finish_then_clause (if_stmt);
13880 /* And insert cleanups for our bases and members so that they
13881 will be properly destroyed if we throw. */
13882 push_base_cleanups ();
13885 /* At the end of every destructor we generate code to delete the object if
13886 necessary. Do that now. */
13889 finish_destructor_body (void)
13893 /* Any return from a destructor will end up here; that way all base
13894 and member cleanups will be run when the function returns. */
13895 add_stmt (build_stmt (LABEL_STMT, dtor_label));
13897 /* In a virtual destructor, we must call delete. */
13898 if (DECL_VIRTUAL_P (current_function_decl))
13901 tree virtual_size = cxx_sizeof (current_class_type);
13905 At the point of definition of a virtual destructor (including
13906 an implicit definition), non-placement operator delete shall
13907 be looked up in the scope of the destructor's class and if
13908 found shall be accessible and unambiguous. */
13909 exprstmt = build_op_delete_call
13910 (DELETE_EXPR, current_class_ptr, virtual_size,
13911 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
13913 if_stmt = begin_if_stmt ();
13914 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
13915 current_in_charge_parm,
13918 finish_expr_stmt (exprstmt);
13919 finish_then_clause (if_stmt);
13924 /* Do the necessary processing for the beginning of a function body, which
13925 in this case includes member-initializers, but not the catch clauses of
13926 a function-try-block. Currently, this means opening a binding level
13927 for the member-initializers (in a ctor) and member cleanups (in a dtor).
13928 In other functions, this isn't necessary, but it doesn't hurt. */
13931 begin_function_body (void)
13935 if (processing_template_decl)
13936 /* Do nothing now. */;
13938 /* Always keep the BLOCK node associated with the outermost pair of
13939 curly braces of a function. These are needed for correct
13940 operation of dwarfout.c. */
13941 keep_next_level (1);
13943 stmt = begin_compound_stmt (0);
13944 COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
13946 if (processing_template_decl)
13947 /* Do nothing now. */;
13948 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13949 begin_constructor_body ();
13950 else if (DECL_DESTRUCTOR_P (current_function_decl))
13951 begin_destructor_body ();
13956 /* Do the processing for the end of a function body. Currently, this means
13957 closing out the cleanups for fully-constructed bases and members, and in
13958 the case of the destructor, deleting the object if desired. Again, this
13959 is only meaningful for [cd]tors, since they are the only functions where
13960 there is a significant distinction between the main body and any
13961 function catch clauses. Handling, say, main() return semantics here
13962 would be wrong, as flowing off the end of a function catch clause for
13963 main() would also need to return 0. */
13966 finish_function_body (tree compstmt)
13968 /* Close the block. */
13969 finish_compound_stmt (0, compstmt);
13971 if (processing_template_decl)
13972 /* Do nothing now. */;
13973 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13974 finish_constructor_body ();
13975 else if (DECL_DESTRUCTOR_P (current_function_decl))
13976 finish_destructor_body ();
13979 /* Finish up a function declaration and compile that function
13980 all the way to assembler language output. The free the storage
13981 for the function definition.
13983 FLAGS is a bitwise or of the following values:
13985 We just finished processing the body of an in-class inline
13986 function definition. (This processing will have taken place
13987 after the class definition is complete.) */
13990 finish_function (int flags)
13992 register tree fndecl = current_function_decl;
13993 tree fntype, ctype = NULL_TREE;
13994 int inclass_inline = (flags & 2) != 0;
13997 /* When we get some parse errors, we can end up without a
13998 current_function_decl, so cope. */
13999 if (fndecl == NULL_TREE)
14000 return error_mark_node;
14002 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
14003 && DECL_VIRTUAL_P (fndecl)
14004 && !processing_template_decl)
14006 tree fnclass = DECL_CONTEXT (fndecl);
14007 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
14008 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
14011 nested = function_depth > 1;
14012 fntype = TREE_TYPE (fndecl);
14014 /* TREE_READONLY (fndecl) = 1;
14015 This caused &foo to be of type ptr-to-const-function
14016 which then got a warning when stored in a ptr-to-function variable. */
14018 my_friendly_assert (building_stmt_tree (), 20000911);
14020 finish_fname_decls ();
14022 /* For a cloned function, we've already got all the code we need;
14023 there's no need to add any extra bits. */
14024 if (!DECL_CLONED_FUNCTION_P (fndecl))
14026 if (DECL_MAIN_P (current_function_decl))
14028 /* Make it so that `main' always returns 0 by default. */
14030 finish_return_stmt (integer_one_node);
14032 finish_return_stmt (integer_zero_node);
14036 /* Finish dealing with exception specifiers. */
14037 if (flag_exceptions && !processing_template_decl
14038 && flag_enforce_eh_specs
14039 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
14040 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14041 (TREE_TYPE (current_function_decl)),
14042 current_eh_spec_block);
14045 /* If we're saving up tree structure, tie off the function now. */
14046 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
14048 /* This must come after expand_function_end because cleanups might
14049 have declarations (from inline functions) that need to go into
14050 this function's blocks. */
14052 /* If the current binding level isn't the outermost binding level
14053 for this function, either there is a bug, or we have experienced
14054 syntax errors and the statement tree is malformed. */
14055 if (current_binding_level->parm_flag != 1)
14057 /* Make sure we have already experienced errors. */
14058 if (errorcount == 0)
14061 /* Throw away the broken statement tree and extra binding
14063 DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
14065 while (current_binding_level->parm_flag != 1)
14067 if (current_binding_level->parm_flag == 2)
14068 pop_nested_class ();
14070 poplevel (0, 0, 0);
14073 poplevel (1, 0, 1);
14075 /* Set up the named return value optimization, if we can. Here, we
14076 eliminate the copy from the nrv into the RESULT_DECL and any cleanup
14077 for the nrv. genrtl_start_function and declare_return_variable
14078 handle making the nrv and RESULT_DECL share space. */
14079 if (current_function_return_value)
14081 tree r = current_function_return_value;
14082 /* This is only worth doing for fns that return in memory--and
14083 simpler, since we don't have to worry about promoted modes. */
14084 if (r != error_mark_node
14085 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
14087 DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
14088 walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
14089 nullify_returns_r, r);
14092 /* Clear it so genrtl_start_function and declare_return_variable
14093 know we're not optimizing. */
14094 current_function_return_value = NULL_TREE;
14097 /* Remember that we were in class scope. */
14098 if (current_class_name)
14099 ctype = current_class_type;
14101 /* Must mark the RESULT_DECL as being in this function. */
14102 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14104 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14105 to the FUNCTION_DECL node itself. */
14106 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14108 /* Save away current state, if appropriate. */
14109 if (!processing_template_decl)
14110 save_function_data (fndecl);
14112 /* If this function calls `setjmp' it cannot be inlined. When
14113 `longjmp' is called it is not guaranteed to restore the value of
14114 local variables that have been modified since the call to
14115 `setjmp'. So, if were to inline this function into some caller
14116 `c', then when we `longjmp', we might not restore all variables
14117 in `c'. (It might seem, at first blush, that there's no way for
14118 this function to modify local variables in `c', but their
14119 addresses may have been stored somewhere accessible to this
14121 if (!processing_template_decl && calls_setjmp_p (fndecl))
14122 DECL_UNINLINABLE (fndecl) = 1;
14124 /* Complain if there's just no return statement. */
14125 if (warn_return_type
14126 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
14127 && !current_function_returns_value && !current_function_returns_null
14128 /* Don't complain if we abort or throw. */
14129 && !current_function_returns_abnormally
14130 && !DECL_NAME (DECL_RESULT (fndecl))
14131 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
14132 inline function, as we might never be compiled separately. */
14133 && (DECL_INLINE (fndecl) || processing_template_decl))
14134 warning ("no return statement in function returning non-void");
14136 /* Clear out memory we no longer need. */
14137 free_after_parsing (cfun);
14138 /* Since we never call rest_of_compilation, we never clear
14139 CFUN. Do so explicitly. */
14140 free_after_compilation (cfun);
14143 /* If this is an in-class inline definition, we may have to pop the
14144 bindings for the template parameters that we added in
14145 maybe_begin_member_template_processing when start_function was
14147 if (inclass_inline)
14148 maybe_end_member_template_processing ();
14150 /* Leave the scope of the class. */
14152 pop_nested_class ();
14158 /* Let the error reporting routines know that we're outside a
14159 function. For a nested function, this value is used in
14160 cxx_pop_function_context and then reset via pop_function_context. */
14161 current_function_decl = NULL_TREE;
14166 /* Create the FUNCTION_DECL for a function definition.
14167 DECLSPECS and DECLARATOR are the parts of the declaration;
14168 they describe the return type and the name of the function,
14169 but twisted together in a fashion that parallels the syntax of C.
14171 This function creates a binding context for the function body
14172 as well as setting up the FUNCTION_DECL in current_function_decl.
14174 Returns a FUNCTION_DECL on success.
14176 If the DECLARATOR is not suitable for a function (it defines a datum
14177 instead), we return 0, which tells yyparse to report a parse error.
14179 May return void_type_node indicating that this method is actually
14180 a friend. See grokfield for more details.
14182 Came here with a `.pushlevel' .
14184 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14185 CHANGES TO CODE IN `grokfield'. */
14188 start_method (tree declspecs, tree declarator, tree attrlist)
14190 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14193 if (fndecl == error_mark_node)
14194 return error_mark_node;
14196 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14198 error ("invalid member function declaration");
14199 return error_mark_node;
14203 cplus_decl_attributes (&fndecl, attrlist, 0);
14205 /* Pass friends other than inline friend functions back. */
14206 if (fndecl == void_type_node)
14209 if (DECL_IN_AGGR_P (fndecl))
14211 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
14213 if (DECL_CONTEXT (fndecl)
14214 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
14215 error ("`%D' is already defined in class `%T'", fndecl,
14216 DECL_CONTEXT (fndecl));
14218 return void_type_node;
14221 check_template_shadow (fndecl);
14223 DECL_DECLARED_INLINE_P (fndecl) = 1;
14225 if (flag_default_inline)
14226 DECL_INLINE (fndecl) = 1;
14228 /* We process method specializations in finish_struct_1. */
14229 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14230 fndecl = push_template_decl (fndecl);
14232 if (! DECL_FRIEND_P (fndecl))
14234 if (TREE_CHAIN (fndecl))
14236 fndecl = copy_node (fndecl);
14237 TREE_CHAIN (fndecl) = NULL_TREE;
14239 grok_special_member_properties (fndecl);
14242 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
14244 /* Make a place for the parms */
14246 current_binding_level->parm_flag = 1;
14248 DECL_IN_AGGR_P (fndecl) = 1;
14252 /* Go through the motions of finishing a function definition.
14253 We don't compile this method until after the whole class has
14256 FINISH_METHOD must return something that looks as though it
14257 came from GROKFIELD (since we are defining a method, after all).
14259 This is called after parsing the body of the function definition.
14260 STMTS is the chain of statements that makes up the function body.
14262 DECL is the ..._DECL that `start_method' provided. */
14265 finish_method (tree decl)
14267 register tree fndecl = decl;
14270 register tree link;
14272 if (decl == void_type_node)
14275 old_initial = DECL_INITIAL (fndecl);
14277 /* Undo the level for the parms (from start_method).
14278 This is like poplevel, but it causes nothing to be
14279 saved. Saving information here confuses symbol-table
14280 output routines. Besides, this information will
14281 be correctly output when this method is actually
14284 /* Clear out the meanings of the local variables of this level;
14285 also record in each decl which block it belongs to. */
14287 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
14289 if (DECL_NAME (link) != NULL_TREE)
14290 pop_binding (DECL_NAME (link), link);
14291 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
14292 DECL_CONTEXT (link) = NULL_TREE;
14295 poplevel (0, 0, 0);
14297 DECL_INITIAL (fndecl) = old_initial;
14299 /* We used to check if the context of FNDECL was different from
14300 current_class_type as another way to get inside here. This didn't work
14301 for String.cc in libg++. */
14302 if (DECL_FRIEND_P (fndecl))
14304 CLASSTYPE_INLINE_FRIENDS (current_class_type)
14305 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
14306 decl = void_type_node;
14313 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14314 we can lay it out later, when and if its type becomes complete. */
14317 maybe_register_incomplete_var (tree var)
14319 my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
14321 /* Keep track of variables with incomplete types. */
14322 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14323 && DECL_EXTERNAL (var))
14325 tree inner_type = TREE_TYPE (var);
14327 while (TREE_CODE (inner_type) == ARRAY_TYPE)
14328 inner_type = TREE_TYPE (inner_type);
14329 inner_type = TYPE_MAIN_VARIANT (inner_type);
14331 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14332 /* RTTI TD entries are created while defining the type_info. */
14333 || (TYPE_LANG_SPECIFIC (inner_type)
14334 && TYPE_BEING_DEFINED (inner_type)))
14335 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
14339 /* Called when a class type (given by TYPE) is defined. If there are
14340 any existing VAR_DECLs whose type hsa been completed by this
14341 declaration, update them now. */
14344 complete_vars (tree type)
14346 tree *list = &incomplete_vars;
14348 my_friendly_assert (CLASS_TYPE_P (type), 20020406);
14351 if (same_type_p (type, TREE_PURPOSE (*list)))
14353 tree var = TREE_VALUE (*list);
14354 /* Complete the type of the variable. The VAR_DECL itself
14355 will be laid out in expand_expr. */
14356 complete_type (TREE_TYPE (var));
14357 /* Remove this entry from the list. */
14358 *list = TREE_CHAIN (*list);
14361 list = &TREE_CHAIN (*list);
14365 /* If DECL is of a type which needs a cleanup, build that cleanup
14369 cxx_maybe_build_cleanup (tree decl)
14371 tree type = TREE_TYPE (decl);
14373 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14375 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14378 if (TREE_CODE (type) == ARRAY_TYPE)
14382 cxx_mark_addressable (decl);
14383 rval = build_unary_op (ADDR_EXPR, decl, 0);
14386 /* Optimize for space over speed here. */
14387 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
14388 || flag_expensive_optimizations)
14389 flags |= LOOKUP_NONVIRTUAL;
14391 rval = build_delete (TREE_TYPE (rval), rval,
14392 sfk_complete_destructor, flags, 0);
14394 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
14395 && ! TYPE_HAS_DESTRUCTOR (type))
14396 rval = build_compound_expr (tree_cons (NULL_TREE, rval,
14397 build_tree_list (NULL_TREE, build_vbase_delete (type, decl))));
14404 /* When a stmt has been parsed, this function is called. */
14409 /* Always assume this statement was not an expression statement. If
14410 it actually was an expression statement, its our callers
14411 responsibility to fix this up. */
14412 last_expr_type = NULL_TREE;
14415 /* DECL was originally constructed as a non-static member function,
14416 but turned out to be static. Update it accordingly. */
14419 revert_static_member_fn (tree decl)
14422 tree function = TREE_TYPE (decl);
14423 tree args = TYPE_ARG_TYPES (function);
14425 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
14426 != TYPE_UNQUALIFIED)
14427 error ("static member function `%#D' declared with type qualifiers",
14430 args = TREE_CHAIN (args);
14431 tmp = build_function_type (TREE_TYPE (function), args);
14432 tmp = build_qualified_type (tmp, cp_type_quals (function));
14433 tmp = build_exception_variant (tmp,
14434 TYPE_RAISES_EXCEPTIONS (function));
14435 TREE_TYPE (decl) = tmp;
14436 if (DECL_ARGUMENTS (decl))
14437 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
14438 DECL_STATIC_FUNCTION_P (decl) = 1;
14441 /* Initialize the variables used during compilation of a C++
14445 cxx_push_function_context (struct function * f)
14447 struct language_function *p
14448 = ((struct language_function *)
14449 ggc_alloc_cleared (sizeof (struct language_function)));
14452 /* It takes an explicit call to expand_body to generate RTL for a
14456 /* Whenever we start a new function, we destroy temporaries in the
14458 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
14461 /* Free the language-specific parts of F, now that we've finished
14462 compiling the function. */
14465 cxx_pop_function_context (struct function * f)
14470 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14471 one of the language-independent trees. */
14473 enum cp_tree_node_structure_enum
14474 cp_tree_node_structure (union lang_tree_node * t)
14476 switch (TREE_CODE (&t->generic))
14478 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
14479 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
14480 case CPLUS_BINDING: return TS_CP_BINDING;
14481 case OVERLOAD: return TS_CP_OVERLOAD;
14482 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
14483 case PTRMEM_CST: return TS_CP_PTRMEM;
14484 case BASELINK: return TS_CP_BASELINK;
14485 case WRAPPER: return TS_CP_WRAPPER;
14486 case SRCLOC: return TS_CP_SRCLOC;
14487 default: return TS_CP_GENERIC;
14491 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
14492 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
14495 identifier_global_value (tree t)
14497 return IDENTIFIER_GLOBAL_VALUE (t);
14500 /* Build the void_list_node (void_type_node having been created). */
14502 build_void_list_node (void)
14504 tree t = build_tree_list (NULL_TREE, void_type_node);
14505 TREE_PARMLIST (t) = 1;
14510 cp_missing_noreturn_ok_p (tree decl)
14512 /* A missing noreturn is ok for the `main' function. */
14513 return DECL_MAIN_P (decl);
14516 #include "gt-cp-decl.h"
14517 #include "gtype-cp.h"