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, 2004 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"
50 #include "diagnostic.h"
53 #include "tree-flow.h"
55 static tree grokparms (cp_parameter_declarator *, tree *);
56 static const char *redeclaration_error_message (tree, tree);
58 static int decl_jump_unsafe (tree);
59 static void require_complete_types_for_parms (tree);
60 static int ambi_op_p (enum tree_code);
61 static int unary_op_p (enum tree_code);
62 static void push_local_name (tree);
63 static tree grok_reference_init (tree, tree, tree, tree *);
64 static tree grokfndecl (tree, tree, tree, tree, tree, int,
65 enum overload_flags, tree,
66 tree, int, int, int, int, int, int, tree);
67 static tree grokvardecl (tree, tree, cp_decl_specifier_seq *, int, int, tree);
68 static void record_unknown_type (tree, const char *);
69 static tree builtin_function_1 (const char *, tree, tree, int,
70 enum built_in_class, const char *,
72 static tree build_library_fn_1 (tree, enum tree_code, tree);
73 static int member_function_or_else (tree, tree, enum overload_flags);
74 static void bad_specifiers (tree, const char *, int, int, int, int,
76 static void check_for_uninitialized_const_var (tree);
77 static hashval_t typename_hash (const void *);
78 static int typename_compare (const void *, const void *);
79 static tree local_variable_p_walkfn (tree *, int *, void *);
80 static tree record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types code);
82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
83 static int walk_globals_r (tree, void*);
84 static int walk_vtables_r (tree, void*);
85 static tree make_label_decl (tree, int);
86 static void use_label (tree);
87 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
89 static void check_previous_goto (struct named_label_use_list *);
90 static void check_switch_goto (struct cp_binding_level *);
91 static void check_previous_gotos (tree);
92 static void pop_label (tree, tree);
93 static void pop_labels (tree);
94 static void maybe_deduce_size_from_array_init (tree, tree);
95 static void layout_var_decl (tree);
96 static void maybe_commonize_var (tree);
97 static tree check_initializer (tree, tree, int, tree *);
98 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
99 static void save_function_data (tree);
100 static void check_function_type (tree, tree);
101 static void begin_constructor_body (void);
102 static void finish_constructor_body (void);
103 static void begin_destructor_body (void);
104 static void finish_destructor_body (void);
105 static tree create_array_type_for_decl (tree, tree, tree);
106 static tree get_atexit_node (void);
107 static tree get_dso_handle_node (void);
108 static tree start_cleanup_fn (void);
109 static void end_cleanup_fn (void);
110 static tree cp_make_fname_decl (tree, int);
111 static void initialize_predefined_identifiers (void);
112 static tree check_special_function_return_type
113 (special_function_kind, tree, tree);
114 static tree push_cp_library_fn (enum tree_code, tree);
115 static tree build_cp_library_fn (tree, enum tree_code, tree);
116 static void store_parm_decls (tree);
117 static void initialize_local_var (tree, tree);
118 static void expand_static_init (tree, tree);
119 static tree next_initializable_field (tree);
120 static tree reshape_init (tree, tree *);
121 static tree build_typename_type (tree, tree, tree);
123 /* Erroneous argument lists can use this *IFF* they do not modify it. */
124 tree error_mark_list;
126 /* The following symbols are subsumed in the cp_global_trees array, and
127 listed here individually for documentation purposes.
130 tree wchar_decl_node;
132 tree vtable_entry_type;
133 tree delta_type_node;
134 tree __t_desc_type_node;
135 tree ti_desc_type_node;
136 tree bltn_desc_type_node, ptr_desc_type_node;
137 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
138 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
139 tree ptm_desc_type_node;
140 tree base_desc_type_node;
142 tree class_type_node;
143 tree unknown_type_node;
145 Array type `vtable_entry_type[]'
148 tree vtbl_ptr_type_node;
155 A FUNCTION_DECL which can call `abort'. Not necessarily the
156 one that the user will declare, but sufficient to be called
157 by routines that want to abort the program.
161 The FUNCTION_DECL for the default `::operator delete'.
163 tree global_delete_fndecl;
166 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
171 tree cp_global_trees[CPTI_MAX];
173 /* Indicates that there is a type value in some namespace, although
174 that is not necessarily in scope at the moment. */
176 tree global_type_node;
178 /* The node that holds the "name" of the global scope. */
179 tree global_scope_name;
181 /* Used only for jumps to as-yet undefined labels, since jumps to
182 defined labels can have their validity checked immediately. */
184 struct named_label_use_list GTY(())
186 struct cp_binding_level *binding_level;
189 location_t o_goto_locus;
190 struct named_label_use_list *next;
193 #define named_label_uses cp_function_chain->x_named_label_uses
195 #define local_names cp_function_chain->x_local_names
197 /* A list of objects which have constructors or destructors
198 which reside in the global scope. The decl is stored in
199 the TREE_VALUE slot and the initializer is stored
200 in the TREE_PURPOSE slot. */
201 tree static_aggregates;
205 /* A node for the integer constants 2, and 3. */
207 tree integer_two_node, integer_three_node;
209 /* A list of all LABEL_DECLs in the function that have names. Here so
210 we can clear out their names' definitions at the end of the
211 function, and so we can check the validity of jumps to these labels. */
213 struct named_label_list GTY(())
215 struct cp_binding_level *binding_level;
220 struct named_label_list *next;
221 unsigned int in_try_scope : 1;
222 unsigned int in_catch_scope : 1;
225 #define named_labels cp_function_chain->x_named_labels
227 /* The number of function bodies which we are currently processing.
228 (Zero if we are at namespace scope, one inside the body of a
229 function, two inside the body of a function in a local class, etc.) */
232 /* States indicating how grokdeclarator() should handle declspecs marked
233 with __attribute__((deprecated)). An object declared as
234 __attribute__((deprecated)) suppresses warnings of uses of other
237 enum deprecated_states {
242 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
244 /* True if a declaration with an `extern' linkage specifier is being
246 bool have_extern_spec;
249 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
250 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
251 time the VAR_DECL was declared, the type was incomplete. */
253 static GTY(()) tree incomplete_vars;
255 /* Returns the kind of template specialization we are currently
256 processing, given that it's declaration contained N_CLASS_SCOPES
257 explicit scope qualifications. */
260 current_tmpl_spec_kind (int n_class_scopes)
262 int n_template_parm_scopes = 0;
263 int seen_specialization_p = 0;
264 int innermost_specialization_p = 0;
265 struct cp_binding_level *b;
267 /* Scan through the template parameter scopes. */
268 for (b = current_binding_level;
269 b->kind == sk_template_parms;
272 /* If we see a specialization scope inside a parameter scope,
273 then something is wrong. That corresponds to a declaration
276 template <class T> template <> ...
278 which is always invalid since [temp.expl.spec] forbids the
279 specialization of a class member template if the enclosing
280 class templates are not explicitly specialized as well. */
281 if (b->explicit_spec_p)
283 if (n_template_parm_scopes == 0)
284 innermost_specialization_p = 1;
286 seen_specialization_p = 1;
288 else if (seen_specialization_p == 1)
289 return tsk_invalid_member_spec;
291 ++n_template_parm_scopes;
294 /* Handle explicit instantiations. */
295 if (processing_explicit_instantiation)
297 if (n_template_parm_scopes != 0)
298 /* We've seen a template parameter list during an explicit
299 instantiation. For example:
301 template <class T> template void f(int);
303 This is erroneous. */
304 return tsk_invalid_expl_inst;
306 return tsk_expl_inst;
309 if (n_template_parm_scopes < n_class_scopes)
310 /* We've not seen enough template headers to match all the
311 specialized classes present. For example:
313 template <class T> void R<T>::S<T>::f(int);
315 This is invalid; there needs to be one set of template
316 parameters for each class. */
317 return tsk_insufficient_parms;
318 else if (n_template_parm_scopes == n_class_scopes)
319 /* We're processing a non-template declaration (even though it may
320 be a member of a template class.) For example:
322 template <class T> void S<T>::f(int);
324 The `class T' maches the `S<T>', leaving no template headers
325 corresponding to the `f'. */
327 else if (n_template_parm_scopes > n_class_scopes + 1)
328 /* We've got too many template headers. For example:
330 template <> template <class T> void f (T);
332 There need to be more enclosing classes. */
333 return tsk_excessive_parms;
335 /* This must be a template. It's of the form:
337 template <class T> template <class U> void S<T>::f(U);
339 This is a specialization if the innermost level was a
340 specialization; otherwise it's just a definition of the
342 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
345 /* Exit the current scope. */
353 /* When a label goes out of scope, check to see if that label was used
354 in a valid manner, and issue any appropriate warnings or errors. */
357 pop_label (tree label, tree old_value)
359 if (!processing_template_decl)
361 if (DECL_INITIAL (label) == NULL_TREE)
365 cp_error_at ("label `%D' used but not defined", label);
366 location.file = input_filename;
368 /* Avoid crashing later. */
369 define_label (location, DECL_NAME (label));
371 else if (warn_unused_label && !TREE_USED (label))
372 cp_warning_at ("label `%D' defined but not used", label);
375 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
378 /* At the end of a function, all labels declared within the function
379 go out of scope. BLOCK is the top-level block for the
383 pop_labels (tree block)
385 struct named_label_list *link;
387 /* Clear out the definitions of all label names, since their scopes
389 for (link = named_labels; link; link = link->next)
391 pop_label (link->label_decl, link->old_value);
392 /* Put the labels into the "variables" of the top-level block,
393 so debugger can see them. */
394 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
395 BLOCK_VARS (block) = link->label_decl;
401 /* Exit a binding level.
402 Pop the level off, and restore the state of the identifier-decl mappings
403 that were in effect when this level was entered.
405 If KEEP == 1, this level had explicit declarations, so
406 and create a "block" (a BLOCK node) for the level
407 to record its declarations and subblocks for symbol table output.
409 If FUNCTIONBODY is nonzero, this level is the body of a function,
410 so create a block as if KEEP were set and also clear out all
413 If REVERSE is nonzero, reverse the order of decls before putting
414 them into the BLOCK. */
417 poplevel (int keep, int reverse, int functionbody)
420 /* The chain of decls was accumulated in reverse order.
421 Put it into forward order, just for cleanliness. */
423 int tmp = functionbody;
424 int real_functionbody;
428 int leaving_for_scope;
431 timevar_push (TV_NAME_LOOKUP);
436 my_friendly_assert (current_binding_level->kind != sk_class, 19990916);
438 real_functionbody = (current_binding_level->kind == sk_cleanup
439 ? ((functionbody = 0), tmp) : functionbody);
440 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
442 my_friendly_assert (!current_binding_level->class_shadowed,
445 /* We used to use KEEP == 2 to indicate that the new block should go
446 at the beginning of the list of blocks at this binding level,
447 rather than the end. This hack is no longer used. */
448 my_friendly_assert (keep == 0 || keep == 1, 0);
450 if (current_binding_level->keep)
453 /* Any uses of undefined labels, and any defined labels, now operate
454 under constraints of next binding contour. */
455 if (cfun && !functionbody)
457 struct cp_binding_level *level_chain;
458 level_chain = current_binding_level->level_chain;
461 struct named_label_use_list *uses;
462 struct named_label_list *labels;
463 for (labels = named_labels; labels; labels = labels->next)
464 if (labels->binding_level == current_binding_level)
467 if (current_binding_level->kind == sk_try)
468 labels->in_try_scope = 1;
469 if (current_binding_level->kind == sk_catch)
470 labels->in_catch_scope = 1;
471 for (decl = labels->names_in_scope; decl;
472 decl = TREE_CHAIN (decl))
473 if (decl_jump_unsafe (decl))
474 labels->bad_decls = tree_cons (NULL_TREE, decl,
476 labels->binding_level = level_chain;
477 labels->names_in_scope = level_chain->names;
480 for (uses = named_label_uses; uses; uses = uses->next)
481 if (uses->binding_level == current_binding_level)
483 uses->binding_level = level_chain;
484 uses->names_in_scope = level_chain->names;
489 /* Get the decls in the order they were written.
490 Usually current_binding_level->names is in reverse order.
491 But parameter decls were previously put in forward order. */
494 current_binding_level->names
495 = decls = nreverse (current_binding_level->names);
497 decls = current_binding_level->names;
499 /* When not in function-at-a-time mode, expand_end_bindings will
500 warn about unused variables. But, in function-at-a-time mode
501 expand_end_bindings is not passed the list of variables in the
502 current scope, and therefore no warning is emitted. So, we
503 explicitly warn here. */
504 if (!processing_template_decl)
505 warn_about_unused_variables (getdecls ());
507 /* If there were any declarations or structure tags in that level,
508 or if this level is a function body,
509 create a BLOCK to record them for the life of this function. */
511 if (keep == 1 || functionbody)
512 block = make_node (BLOCK);
513 if (block != NULL_TREE)
515 BLOCK_VARS (block) = decls;
516 BLOCK_SUBBLOCKS (block) = subblocks;
519 /* In each subblock, record that this is its superior. */
521 for (link = subblocks; link; link = TREE_CHAIN (link))
522 BLOCK_SUPERCONTEXT (link) = block;
524 /* We still support the old for-scope rules, whereby the variables
525 in a for-init statement were in scope after the for-statement
526 ended. We only use the new rules if flag_new_for_scope is
529 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
531 /* Remove declarations for all the DECLs in this level. */
532 for (link = decls; link; link = TREE_CHAIN (link))
534 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
537 cxx_binding *outer_binding
538 = IDENTIFIER_BINDING (DECL_NAME (link))->previous;
542 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
544 ns_binding = NULL_TREE;
547 && outer_binding->scope == current_binding_level->level_chain)
548 /* We have something like:
553 and we are leaving the `for' scope. There's no reason to
554 keep the binding of the inner `i' in this case. */
555 pop_binding (DECL_NAME (link), link);
556 else if ((outer_binding
557 && (TREE_CODE (outer_binding->value) == TYPE_DECL))
558 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
559 /* Here, we have something like:
567 We must pop the for-scope binding so we know what's a
568 type and what isn't. */
569 pop_binding (DECL_NAME (link), link);
572 /* Mark this VAR_DECL as dead so that we can tell we left it
573 there only for backward compatibility. */
574 DECL_DEAD_FOR_LOCAL (link) = 1;
576 /* Keep track of what should have happened when we
577 popped the binding. */
578 if (outer_binding && outer_binding->value)
579 DECL_SHADOWED_FOR_VAR (link) = outer_binding->value;
581 /* Add it to the list of dead variables in the next
582 outermost binding to that we can remove these when we
583 leave that binding. */
584 current_binding_level->level_chain->dead_vars_from_for
585 = tree_cons (NULL_TREE, link,
586 current_binding_level->level_chain->
589 /* Although we don't pop the cxx_binding, we do clear
590 its SCOPE since the scope is going away now. */
591 IDENTIFIER_BINDING (DECL_NAME (link))->scope = NULL;
596 /* Remove the binding. */
598 if (TREE_CODE (decl) == TREE_LIST)
599 decl = TREE_VALUE (decl);
601 pop_binding (DECL_NAME (decl), decl);
602 else if (TREE_CODE (decl) == OVERLOAD)
603 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
609 /* Remove declarations for any `for' variables from inner scopes
610 that we kept around. */
611 for (link = current_binding_level->dead_vars_from_for;
612 link; link = TREE_CHAIN (link))
613 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
615 /* Restore the IDENTIFIER_TYPE_VALUEs. */
616 for (link = current_binding_level->type_shadowed;
617 link; link = TREE_CHAIN (link))
618 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
620 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
621 for (link = current_binding_level->shadowed_labels;
623 link = TREE_CHAIN (link))
624 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
626 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
627 list if a `using' declaration put them there. The debugging
628 back-ends won't understand OVERLOAD, so we remove them here.
629 Because the BLOCK_VARS are (temporarily) shared with
630 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
631 popped all the bindings. */
636 for (d = &BLOCK_VARS (block); *d; )
638 if (TREE_CODE (*d) == TREE_LIST)
639 *d = TREE_CHAIN (*d);
641 d = &TREE_CHAIN (*d);
645 /* If the level being exited is the top level of a function,
646 check over all the labels. */
649 /* Since this is the top level block of a function, the vars are
650 the function's parameters. Don't leave them in the BLOCK
651 because they are found in the FUNCTION_DECL instead. */
652 BLOCK_VARS (block) = 0;
656 kind = current_binding_level->kind;
657 if (kind == sk_cleanup)
661 /* If this is a temporary binding created for a cleanup, then we'll
662 have pushed a statement list level. Pop that, create a new
663 BIND_EXPR for the block, and insert it into the stream. */
664 stmt = pop_stmt_list (current_binding_level->statement_list);
665 stmt = c_build_bind_expr (block, stmt);
671 DECL_INITIAL (current_function_decl) = block;
673 current_binding_level->blocks
674 = chainon (current_binding_level->blocks, block);
676 /* If we did not make a block for the level just exited,
677 any blocks made for inner levels
678 (since they cannot be recorded as subblocks in that level)
679 must be carried forward so they will later become subblocks
680 of something else. */
682 current_binding_level->blocks
683 = chainon (current_binding_level->blocks, subblocks);
685 /* Each and every BLOCK node created here in `poplevel' is important
686 (e.g. for proper debugging information) so if we created one
687 earlier, mark it as "used". */
689 TREE_USED (block) = 1;
691 /* All temporary bindings created for cleanups are popped silently. */
692 if (kind == sk_cleanup)
695 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
698 /* Delete the node BLOCK from the current binding level.
699 This is used for the block inside a stmt expr ({...})
700 so that the block can be reinserted where appropriate. */
703 delete_block (tree block)
706 if (current_binding_level->blocks == block)
707 current_binding_level->blocks = TREE_CHAIN (block);
708 for (t = current_binding_level->blocks; t;)
710 if (TREE_CHAIN (t) == block)
711 TREE_CHAIN (t) = TREE_CHAIN (block);
715 TREE_CHAIN (block) = NULL_TREE;
716 /* Clear TREE_USED which is always set by poplevel.
717 The flag is set again if insert_block is called. */
718 TREE_USED (block) = 0;
721 /* Insert BLOCK at the end of the list of subblocks of the
722 current binding level. This is used when a BIND_EXPR is expanded,
723 to handle the BLOCK node inside the BIND_EXPR. */
726 insert_block (tree block)
728 TREE_USED (block) = 1;
729 current_binding_level->blocks
730 = chainon (current_binding_level->blocks, block);
733 /* Set the BLOCK node for the innermost scope
734 (the one we are currently in). */
737 set_block (tree block ATTRIBUTE_UNUSED )
739 /* The RTL expansion machinery requires us to provide this callback,
740 but it is not applicable in function-at-a-time mode. */
743 /* Returns nonzero if T is a virtual function table. */
746 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
748 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
751 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
755 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
757 return (TREE_CODE (t) == TYPE_DECL
758 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
759 && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
762 struct walk_globals_data {
768 /* Walk the vtable declarations in NAMESPACE. Whenever one is found
769 for which P returns nonzero, call F with its address. If any call
770 to F returns a nonzero value, return a nonzero value. */
773 walk_vtables_r (tree namespace, void* data)
775 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
776 walk_globals_fn f = wgd->f;
778 tree decl = NAMESPACE_LEVEL (namespace)->vtables;
781 for (; decl ; decl = TREE_CHAIN (decl))
782 result |= (*f) (&decl, d);
787 /* Walk the vtable declarations. Whenever one is found for which P
788 returns nonzero, call F with its address. If any call to F
789 returns a nonzero value, return a nonzero value. */
791 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
793 struct walk_globals_data wgd;
798 return walk_namespaces (walk_vtables_r, &wgd);
801 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
802 itself, calling F for each. The DATA is passed to F as well. */
805 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
808 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
810 result |= (*f) (namespace, data);
812 for (; current; current = TREE_CHAIN (current))
813 result |= walk_namespaces_r (current, f, data);
818 /* Walk all the namespaces, calling F for each. The DATA is passed to
822 walk_namespaces (walk_namespaces_fn f, void* data)
824 return walk_namespaces_r (global_namespace, f, data);
827 /* Walk the global declarations in NAMESPACE. Whenever one is found
828 for which P returns nonzero, call F with its address. If any call
829 to F returns a nonzero value, return a nonzero value. */
832 walk_globals_r (tree namespace, void* data)
834 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
835 walk_globals_pred p = wgd->p;
836 walk_globals_fn f = wgd->f;
841 t = &NAMESPACE_LEVEL (namespace)->names;
848 result |= (*f) (t, d);
850 /* If F changed *T, then *T still points at the next item to
853 t = &TREE_CHAIN (*t);
859 /* Walk the global declarations. Whenever one is found for which P
860 returns true, call F with its address. If any call to F
861 returns true, return true. */
864 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
866 struct walk_globals_data wgd;
871 return walk_namespaces (walk_globals_r, &wgd);
874 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
875 DATA is non-NULL, this is the last time we will call
876 wrapup_global_declarations for this NAMESPACE. */
879 wrapup_globals_for_namespace (tree namespace, void* data)
881 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
882 varray_type statics = level->static_decls;
883 tree *vec = &VARRAY_TREE (statics, 0);
884 int len = VARRAY_ACTIVE_SIZE (statics);
885 int last_time = (data != 0);
889 check_global_declarations (vec, len);
893 /* Write out any globals that need to be output. */
894 return wrapup_global_declarations (vec, len);
898 /* In C++, you don't have to write `struct S' to refer to `S'; you
899 can just use `S'. We accomplish this by creating a TYPE_DECL as
900 if the user had written `typedef struct S S'. Create and return
901 the TYPE_DECL for TYPE. */
904 create_implicit_typedef (tree name, tree type)
908 decl = build_decl (TYPE_DECL, name, type);
909 DECL_ARTIFICIAL (decl) = 1;
910 /* There are other implicit type declarations, like the one *within*
911 a class that allows you to write `S::S'. We must distinguish
913 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
914 TYPE_NAME (type) = decl;
919 /* Remember a local name for name-mangling purposes. */
922 push_local_name (tree decl)
927 timevar_push (TV_NAME_LOOKUP);
929 VARRAY_TREE_INIT (local_names, 8, "local_names");
931 name = DECL_NAME (decl);
933 nelts = VARRAY_ACTIVE_SIZE (local_names);
934 for (i = 0; i < nelts; i++)
936 t = VARRAY_TREE (local_names, i);
937 if (DECL_NAME (t) == name)
939 if (!DECL_LANG_SPECIFIC (decl))
940 retrofit_lang_decl (decl);
941 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
942 if (DECL_LANG_SPECIFIC (t))
943 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
945 DECL_DISCRIMINATOR (decl) = 1;
947 VARRAY_TREE (local_names, i) = decl;
948 timevar_pop (TV_NAME_LOOKUP);
953 VARRAY_PUSH_TREE (local_names, decl);
954 timevar_pop (TV_NAME_LOOKUP);
957 /* Subroutine of duplicate_decls: return truthvalue of whether
958 or not types of these decls match.
960 For C++, we must compare the parameter list so that `int' can match
961 `int&' in a parameter position, but `int&' is not confused with
965 decls_match (tree newdecl, tree olddecl)
969 if (newdecl == olddecl)
972 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
973 /* If the two DECLs are not even the same kind of thing, we're not
974 interested in their types. */
977 if (TREE_CODE (newdecl) == FUNCTION_DECL)
979 tree f1 = TREE_TYPE (newdecl);
980 tree f2 = TREE_TYPE (olddecl);
981 tree p1 = TYPE_ARG_TYPES (f1);
982 tree p2 = TYPE_ARG_TYPES (f2);
984 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
985 && ! (DECL_EXTERN_C_P (newdecl)
986 && DECL_EXTERN_C_P (olddecl)))
989 if (TREE_CODE (f1) != TREE_CODE (f2))
992 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
994 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
995 && (DECL_BUILT_IN (olddecl)
996 #ifndef NO_IMPLICIT_EXTERN_C
997 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
998 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1002 types_match = self_promoting_args_p (p1);
1003 if (p1 == void_list_node)
1004 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1006 #ifndef NO_IMPLICIT_EXTERN_C
1007 else if (p1 == NULL_TREE
1008 && (DECL_EXTERN_C_P (olddecl)
1009 && DECL_IN_SYSTEM_HEADER (olddecl)
1010 && !DECL_CLASS_SCOPE_P (olddecl))
1011 && (DECL_EXTERN_C_P (newdecl)
1012 && DECL_IN_SYSTEM_HEADER (newdecl)
1013 && !DECL_CLASS_SCOPE_P (newdecl)))
1015 types_match = self_promoting_args_p (p2);
1016 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1020 types_match = compparms (p1, p2);
1025 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1027 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1028 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1031 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1032 DECL_TEMPLATE_PARMS (olddecl)))
1035 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1036 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1037 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1039 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1040 DECL_TEMPLATE_RESULT (newdecl));
1044 if (TREE_TYPE (newdecl) == error_mark_node)
1045 types_match = TREE_TYPE (olddecl) == error_mark_node;
1046 else if (TREE_TYPE (olddecl) == NULL_TREE)
1047 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1048 else if (TREE_TYPE (newdecl) == NULL_TREE)
1051 types_match = comptypes (TREE_TYPE (newdecl),
1052 TREE_TYPE (olddecl),
1053 COMPARE_REDECLARATION);
1059 /* If NEWDECL is `static' and an `extern' was seen previously,
1060 warn about it. OLDDECL is the previous declaration.
1062 Note that this does not apply to the C++ case of declaring
1063 a variable `extern const' and then later `const'.
1065 Don't complain about built-in functions, since they are beyond
1066 the user's control. */
1069 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1073 if (TREE_CODE (newdecl) == TYPE_DECL
1074 || TREE_CODE (newdecl) == TEMPLATE_DECL
1075 || TREE_CODE (newdecl) == CONST_DECL
1076 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1079 /* Don't get confused by static member functions; that's a different
1081 if (TREE_CODE (newdecl) == FUNCTION_DECL
1082 && DECL_STATIC_FUNCTION_P (newdecl))
1085 /* If the old declaration was `static', or the new one isn't, then
1086 then everything is OK. */
1087 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1090 /* It's OK to declare a builtin function as `static'. */
1091 if (TREE_CODE (olddecl) == FUNCTION_DECL
1092 && DECL_ARTIFICIAL (olddecl))
1095 name = DECL_ASSEMBLER_NAME (newdecl);
1096 pedwarn ("`%D' was declared `extern' and later `static'", newdecl);
1097 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
1100 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1101 If the redeclaration is invalid, a diagnostic is issued, and the
1102 error_mark_node is returned. Otherwise, OLDDECL is returned.
1104 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1108 duplicate_decls (tree newdecl, tree olddecl)
1110 unsigned olddecl_uid = DECL_UID (olddecl);
1111 int olddecl_friend = 0, types_match = 0;
1112 int new_defines_function = 0;
1114 if (newdecl == olddecl)
1117 types_match = decls_match (newdecl, olddecl);
1119 /* If either the type of the new decl or the type of the old decl is an
1120 error_mark_node, then that implies that we have already issued an
1121 error (earlier) for some bogus type specification, and in that case,
1122 it is rather pointless to harass the user with yet more error message
1123 about the same declaration, so just pretend the types match here. */
1124 if (TREE_TYPE (newdecl) == error_mark_node
1125 || TREE_TYPE (olddecl) == error_mark_node)
1128 if (DECL_P (olddecl)
1129 && TREE_CODE (newdecl) == FUNCTION_DECL
1130 && TREE_CODE (olddecl) == FUNCTION_DECL
1131 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1133 if (DECL_DECLARED_INLINE_P (newdecl)
1134 && DECL_UNINLINABLE (newdecl)
1135 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1136 /* Already warned elsewhere. */;
1137 else if (DECL_DECLARED_INLINE_P (olddecl)
1138 && DECL_UNINLINABLE (olddecl)
1139 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1140 /* Already warned. */;
1141 else if (DECL_DECLARED_INLINE_P (newdecl)
1142 && DECL_UNINLINABLE (olddecl)
1143 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1145 warning ("%Jfunction '%D' redeclared as inline", newdecl, newdecl);
1146 warning ("%Jprevious declaration of '%D' with attribute noinline",
1149 else if (DECL_DECLARED_INLINE_P (olddecl)
1150 && DECL_UNINLINABLE (newdecl)
1151 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1153 warning ("%Jfunction '%D' redeclared with attribute noinline",
1155 warning ("%Jprevious declaration of '%D' was inline",
1160 /* Check for redeclaration and other discrepancies. */
1161 if (TREE_CODE (olddecl) == FUNCTION_DECL
1162 && DECL_ARTIFICIAL (olddecl))
1164 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1166 /* Avoid warnings redeclaring anticipated built-ins. */
1167 if (DECL_ANTICIPATED (olddecl))
1170 /* If you declare a built-in or predefined function name as static,
1171 the old definition is overridden, but optionally warn this was a
1172 bad choice of name. */
1173 if (! TREE_PUBLIC (newdecl))
1176 warning ("shadowing %s function `%#D'",
1177 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1179 /* Discard the old built-in function. */
1182 /* If the built-in is not ansi, then programs can override
1183 it even globally without an error. */
1184 else if (! DECL_BUILT_IN (olddecl))
1185 warning ("library function `%#D' redeclared as non-function `%#D'",
1189 error ("declaration of `%#D'", newdecl);
1190 error ("conflicts with built-in declaration `%#D'",
1195 else if (!types_match)
1197 /* Avoid warnings redeclaring anticipated built-ins. */
1198 if (DECL_ANTICIPATED (olddecl))
1200 /* Deal with fileptr_type_node. FILE type is not known
1201 at the time we create the builtins. */
1204 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1205 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1207 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1210 else if (TREE_VALUE (t2) == fileptr_type_node)
1212 tree t = TREE_VALUE (t1);
1214 if (TREE_CODE (t) == POINTER_TYPE
1215 && TYPE_NAME (TREE_TYPE (t))
1216 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1217 == get_identifier ("FILE")
1218 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1220 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1222 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1223 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1224 types_match = decls_match (newdecl, olddecl);
1226 return duplicate_decls (newdecl, olddecl);
1227 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1230 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1233 else if ((DECL_EXTERN_C_P (newdecl)
1234 && DECL_EXTERN_C_P (olddecl))
1235 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1236 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1238 /* A near match; override the builtin. */
1240 if (TREE_PUBLIC (newdecl))
1242 warning ("new declaration `%#D'", newdecl);
1243 warning ("ambiguates built-in declaration `%#D'",
1246 else if (warn_shadow)
1247 warning ("shadowing %s function `%#D'",
1248 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1252 /* Discard the old built-in function. */
1255 /* Replace the old RTL to avoid problems with inlining. */
1256 COPY_DECL_RTL (newdecl, olddecl);
1258 /* Even if the types match, prefer the new declarations type
1259 for anticipated built-ins, for exception lists, etc... */
1260 else if (DECL_ANTICIPATED (olddecl))
1262 tree type = TREE_TYPE (newdecl);
1263 tree attribs = (*targetm.merge_type_attributes)
1264 (TREE_TYPE (olddecl), type);
1266 type = cp_build_type_attribute_variant (type, attribs);
1267 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1270 /* Whether or not the builtin can throw exceptions has no
1271 bearing on this declarator. */
1272 TREE_NOTHROW (olddecl) = 0;
1274 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1276 /* If a builtin function is redeclared as `static', merge
1277 the declarations, but make the original one static. */
1278 DECL_THIS_STATIC (olddecl) = 1;
1279 TREE_PUBLIC (olddecl) = 0;
1281 /* Make the old declaration consistent with the new one so
1282 that all remnants of the builtin-ness of this function
1283 will be banished. */
1284 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1285 COPY_DECL_RTL (newdecl, olddecl);
1288 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1290 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1291 && TREE_CODE (newdecl) != TYPE_DECL
1292 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1293 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1294 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1295 && TREE_CODE (olddecl) != TYPE_DECL
1296 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1297 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1300 /* We do nothing special here, because C++ does such nasty
1301 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1302 get shadowed, and know that if we need to find a TYPE_DECL
1303 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1304 slot of the identifier. */
1308 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1309 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1310 || (TREE_CODE (olddecl) == FUNCTION_DECL
1311 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1314 error ("`%#D' redeclared as different kind of symbol", newdecl);
1315 if (TREE_CODE (olddecl) == TREE_LIST)
1316 olddecl = TREE_VALUE (olddecl);
1317 cp_error_at ("previous declaration of `%#D'", olddecl);
1319 return error_mark_node;
1321 else if (!types_match)
1323 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1324 /* These are certainly not duplicate declarations; they're
1325 from different scopes. */
1328 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1330 /* The name of a class template may not be declared to refer to
1331 any other template, class, function, object, namespace, value,
1332 or type in the same scope. */
1333 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1334 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1336 error ("declaration of template `%#D'", newdecl);
1337 cp_error_at ("conflicts with previous declaration `%#D'",
1340 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1341 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1342 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1343 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1344 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1345 DECL_TEMPLATE_PARMS (olddecl))
1346 /* Template functions can be disambiguated by
1348 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1349 TREE_TYPE (TREE_TYPE (olddecl))))
1351 error ("new declaration `%#D'", newdecl);
1352 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1356 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1358 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1360 error ("declaration of C function `%#D' conflicts with",
1362 cp_error_at ("previous declaration `%#D' here", olddecl);
1364 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1365 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1367 error ("new declaration `%#D'", newdecl);
1368 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1375 error ("conflicting declaration '%#D'", newdecl);
1376 cp_error_at ("'%D' has a previous declaration as `%#D'",
1381 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1382 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1383 && (!DECL_TEMPLATE_INFO (newdecl)
1384 || (DECL_TI_TEMPLATE (newdecl)
1385 != DECL_TI_TEMPLATE (olddecl))))
1386 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1387 && (!DECL_TEMPLATE_INFO (olddecl)
1388 || (DECL_TI_TEMPLATE (olddecl)
1389 != DECL_TI_TEMPLATE (newdecl))))))
1390 /* It's OK to have a template specialization and a non-template
1391 with the same type, or to have specializations of two
1392 different templates with the same type. Note that if one is a
1393 specialization, and the other is an instantiation of the same
1394 template, that we do not exit at this point. That situation
1395 can occur if we instantiate a template class, and then
1396 specialize one of its methods. This situation is valid, but
1397 the declarations must be merged in the usual way. */
1399 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1400 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1401 && !DECL_USE_TEMPLATE (newdecl))
1402 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1403 && !DECL_USE_TEMPLATE (olddecl))))
1404 /* One of the declarations is a template instantiation, and the
1405 other is not a template at all. That's OK. */
1407 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
1408 && DECL_NAMESPACE_ALIAS (newdecl)
1409 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
1410 /* In [namespace.alias] we have:
1412 In a declarative region, a namespace-alias-definition can be
1413 used to redefine a namespace-alias declared in that declarative
1414 region to refer only to the namespace to which it already
1417 Therefore, if we encounter a second alias directive for the same
1418 alias, we can just ignore the second directive. */
1422 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1425 error (errmsg, newdecl);
1426 if (DECL_NAME (olddecl) != NULL_TREE)
1427 cp_error_at ((DECL_INITIAL (olddecl)
1428 && namespace_bindings_p ())
1429 ? "`%#D' previously defined here"
1430 : "`%#D' previously declared here", olddecl);
1431 return error_mark_node;
1433 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1434 && DECL_INITIAL (olddecl) != NULL_TREE
1435 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1436 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1438 /* Prototype decl follows defn w/o prototype. */
1439 cp_warning_at ("prototype for `%#D'", newdecl);
1440 warning ("%Jfollows non-prototype definition here", olddecl);
1442 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1443 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1445 /* extern "C" int foo ();
1446 int foo () { bar (); }
1448 if (current_lang_depth () == 0)
1449 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1452 cp_error_at ("previous declaration of `%#D' with %L linkage",
1453 olddecl, DECL_LANGUAGE (olddecl));
1454 error ("conflicts with new declaration with %L linkage",
1455 DECL_LANGUAGE (newdecl));
1459 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1461 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1463 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1464 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1467 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1468 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1470 for (; t1 && t1 != void_list_node;
1471 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1472 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1474 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1477 pedwarn ("default argument given for parameter %d of `%#D'",
1479 cp_pedwarn_at ("after previous specification in `%#D'",
1484 error ("default argument given for parameter %d of `%#D'",
1486 cp_error_at ("after previous specification in `%#D'",
1491 if (DECL_DECLARED_INLINE_P (newdecl)
1492 && ! DECL_DECLARED_INLINE_P (olddecl)
1493 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1495 warning ("`%#D' was used before it was declared inline", newdecl);
1496 warning ("%Jprevious non-inline declaration here", olddecl);
1501 /* Do not merge an implicit typedef with an explicit one. In:
1505 typedef class A A __attribute__ ((foo));
1507 the attribute should apply only to the typedef. */
1508 if (TREE_CODE (olddecl) == TYPE_DECL
1509 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1510 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1513 /* If new decl is `static' and an `extern' was seen previously,
1515 warn_extern_redeclared_static (newdecl, olddecl);
1517 /* We have committed to returning 1 at this point. */
1518 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1520 /* Now that functions must hold information normally held
1521 by field decls, there is extra work to do so that
1522 declaration information does not get destroyed during
1524 if (DECL_VINDEX (olddecl))
1525 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1526 if (DECL_CONTEXT (olddecl))
1527 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1528 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1529 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1530 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1531 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1532 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
1533 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1534 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1535 SET_OVERLOADED_OPERATOR_CODE
1536 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1537 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1539 /* Optionally warn about more than one declaration for the same
1540 name, but don't warn about a function declaration followed by a
1542 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1543 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1544 /* Don't warn about extern decl followed by definition. */
1545 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1546 /* Don't warn about friends, let add_friend take care of it. */
1547 && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
1549 warning ("redundant redeclaration of `%D' in same scope", newdecl);
1550 cp_warning_at ("previous declaration of `%D'", olddecl);
1554 /* Deal with C++: must preserve virtual function table size. */
1555 if (TREE_CODE (olddecl) == TYPE_DECL)
1557 tree newtype = TREE_TYPE (newdecl);
1558 tree oldtype = TREE_TYPE (olddecl);
1560 if (newtype != error_mark_node && oldtype != error_mark_node
1561 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1562 CLASSTYPE_FRIEND_CLASSES (newtype)
1563 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1565 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1568 /* Copy all the DECL_... slots specified in the new decl
1569 except for any that we copy here from the old type. */
1570 DECL_ATTRIBUTES (newdecl)
1571 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1573 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1575 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
1576 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1577 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1578 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1580 /* If the new declaration is a definition, update the file and
1581 line information on the declaration. */
1582 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
1583 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
1585 DECL_SOURCE_LOCATION (olddecl)
1586 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
1587 = DECL_SOURCE_LOCATION (newdecl);
1588 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1589 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl))
1590 = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl));
1593 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1595 DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl))
1596 |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl));
1597 DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl))
1598 |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl));
1606 /* Automatically handles default parameters. */
1607 tree oldtype = TREE_TYPE (olddecl);
1610 /* Merge the data types specified in the two decls. */
1611 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1613 /* If merge_types produces a non-typedef type, just use the old type. */
1614 if (TREE_CODE (newdecl) == TYPE_DECL
1615 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1618 if (TREE_CODE (newdecl) == VAR_DECL)
1620 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1621 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1622 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1623 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1626 /* Do this after calling `merge_types' so that default
1627 parameters don't confuse us. */
1628 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1629 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
1630 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
1632 TREE_TYPE (newdecl) = build_exception_variant (newtype,
1633 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
1634 TREE_TYPE (olddecl) = build_exception_variant (newtype,
1635 TYPE_RAISES_EXCEPTIONS (oldtype));
1637 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
1638 && DECL_SOURCE_LINE (olddecl) != 0
1640 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
1641 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
1643 error ("declaration of `%F' throws different exceptions",
1645 cp_error_at ("than previous declaration `%F'", olddecl);
1648 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1650 /* Lay the type out, unless already done. */
1651 if (! same_type_p (newtype, oldtype)
1652 && TREE_TYPE (newdecl) != error_mark_node
1653 && !(processing_template_decl && uses_template_parms (newdecl)))
1654 layout_type (TREE_TYPE (newdecl));
1656 if ((TREE_CODE (newdecl) == VAR_DECL
1657 || TREE_CODE (newdecl) == PARM_DECL
1658 || TREE_CODE (newdecl) == RESULT_DECL
1659 || TREE_CODE (newdecl) == FIELD_DECL
1660 || TREE_CODE (newdecl) == TYPE_DECL)
1661 && !(processing_template_decl && uses_template_parms (newdecl)))
1662 layout_decl (newdecl, 0);
1664 /* Merge the type qualifiers. */
1665 if (TREE_READONLY (newdecl))
1666 TREE_READONLY (olddecl) = 1;
1667 if (TREE_THIS_VOLATILE (newdecl))
1668 TREE_THIS_VOLATILE (olddecl) = 1;
1670 /* Merge the initialization information. */
1671 if (DECL_INITIAL (newdecl) == NULL_TREE
1672 && DECL_INITIAL (olddecl) != NULL_TREE)
1674 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1675 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1676 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1677 && DECL_LANG_SPECIFIC (newdecl)
1678 && DECL_LANG_SPECIFIC (olddecl))
1680 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1681 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1685 /* Merge the section attribute.
1686 We want to issue an error if the sections conflict but that must be
1687 done later in decl_attributes since we are called before attributes
1689 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1690 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1692 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1694 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1695 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1696 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1697 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1698 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1699 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1700 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1701 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1702 /* Keep the old RTL. */
1703 COPY_DECL_RTL (olddecl, newdecl);
1705 else if (TREE_CODE (newdecl) == VAR_DECL
1706 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1708 /* Keep the old RTL. We cannot keep the old RTL if the old
1709 declaration was for an incomplete object and the new
1710 declaration is not since many attributes of the RTL will
1712 COPY_DECL_RTL (olddecl, newdecl);
1715 /* If cannot merge, then use the new type and qualifiers,
1716 and don't preserve the old rtl. */
1719 /* Clean out any memory we had of the old declaration. */
1720 tree oldstatic = value_member (olddecl, static_aggregates);
1722 TREE_VALUE (oldstatic) = error_mark_node;
1724 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1725 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1726 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1727 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1730 /* Merge the storage class information. */
1731 merge_weak (newdecl, olddecl);
1733 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1734 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1735 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1736 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1737 if (! DECL_EXTERNAL (olddecl))
1738 DECL_EXTERNAL (newdecl) = 0;
1740 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1742 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1743 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1744 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1745 DECL_TEMPLATE_INSTANTIATED (newdecl)
1746 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1747 /* Don't really know how much of the language-specific
1748 values we should copy from old to new. */
1749 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1750 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1751 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1752 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1753 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1754 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1755 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1756 olddecl_friend = DECL_FRIEND_P (olddecl);
1758 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1759 if (TREE_CODE (newdecl) == FUNCTION_DECL
1760 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1762 DECL_BEFRIENDING_CLASSES (newdecl)
1763 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1764 DECL_BEFRIENDING_CLASSES (olddecl));
1765 /* DECL_THUNKS is only valid for virtual functions,
1766 otherwise it is a DECL_FRIEND_CONTEXT. */
1767 if (DECL_VIRTUAL_P (newdecl))
1768 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1772 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1774 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1775 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1777 /* If newdecl is not a specialization, then it is not a
1778 template-related function at all. And that means that we
1779 should have exited above, returning 0. */
1780 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
1783 if (TREE_USED (olddecl))
1784 /* From [temp.expl.spec]:
1786 If a template, a member template or the member of a class
1787 template is explicitly specialized then that
1788 specialization shall be declared before the first use of
1789 that specialization that would cause an implicit
1790 instantiation to take place, in every translation unit in
1791 which such a use occurs. */
1792 error ("explicit specialization of %D after first use",
1795 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1797 /* [temp.expl.spec/14] We don't inline explicit specialization
1798 just because the primary template says so. */
1802 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1803 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1805 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1807 /* If either decl says `inline', this fn is inline, unless
1808 its definition was passed already. */
1809 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1810 DECL_INLINE (olddecl) = 1;
1811 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1813 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1814 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1817 /* Preserve abstractness on cloned [cd]tors. */
1818 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1822 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1823 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1824 COPY_DECL_RTL (newdecl, olddecl);
1826 if (! types_match || new_defines_function)
1828 /* These need to be copied so that the names are available.
1829 Note that if the types do match, we'll preserve inline
1830 info and other bits, but if not, we won't. */
1831 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1832 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1834 if (new_defines_function)
1835 /* If defining a function declared with other language
1836 linkage, use the previously declared language linkage. */
1837 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1838 else if (types_match)
1840 /* If redeclaring a builtin function, and not a definition,
1841 it stays built in. */
1842 if (DECL_BUILT_IN (olddecl))
1844 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1845 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1846 /* If we're keeping the built-in definition, keep the rtl,
1847 regardless of declaration matches. */
1848 COPY_DECL_RTL (olddecl, newdecl);
1851 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1852 /* Don't clear out the arguments if we're redefining a function. */
1853 if (DECL_ARGUMENTS (olddecl))
1854 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1857 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1858 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1860 /* Now preserve various other info from the definition. */
1861 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1862 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1863 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1864 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1866 /* If either declaration has a nondefault visibility, use it. */
1867 if (DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT)
1869 if (DECL_VISIBILITY (newdecl) != VISIBILITY_DEFAULT
1870 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1872 warning ("%J'%D': visibility attribute ignored because it",
1874 warning ("%Jconflicts with previous declaration here", olddecl);
1876 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1879 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1883 function_size = sizeof (struct tree_decl);
1885 memcpy ((char *) olddecl + sizeof (struct tree_common),
1886 (char *) newdecl + sizeof (struct tree_common),
1887 function_size - sizeof (struct tree_common));
1889 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
1890 /* If newdecl is a template instantiation, it is possible that
1891 the following sequence of events has occurred:
1893 o A friend function was declared in a class template. The
1894 class template was instantiated.
1896 o The instantiation of the friend declaration was
1897 recorded on the instantiation list, and is newdecl.
1899 o Later, however, instantiate_class_template called pushdecl
1900 on the newdecl to perform name injection. But, pushdecl in
1901 turn called duplicate_decls when it discovered that another
1902 declaration of a global function with the same name already
1905 o Here, in duplicate_decls, we decided to clobber newdecl.
1907 If we're going to do that, we'd better make sure that
1908 olddecl, and not newdecl, is on the list of
1909 instantiations so that if we try to do the instantiation
1910 again we won't get the clobbered declaration. */
1911 reregister_specialization (newdecl,
1912 DECL_TI_TEMPLATE (newdecl),
1917 memcpy ((char *) olddecl + sizeof (struct tree_common),
1918 (char *) newdecl + sizeof (struct tree_common),
1919 sizeof (struct tree_decl) - sizeof (struct tree_common)
1920 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1923 DECL_UID (olddecl) = olddecl_uid;
1925 DECL_FRIEND_P (olddecl) = 1;
1927 /* NEWDECL contains the merged attribute lists.
1928 Update OLDDECL to be the same. */
1929 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1931 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1932 so that encode_section_info has a chance to look at the new decl
1933 flags and attributes. */
1934 if (DECL_RTL_SET_P (olddecl)
1935 && (TREE_CODE (olddecl) == FUNCTION_DECL
1936 || (TREE_CODE (olddecl) == VAR_DECL
1937 && TREE_STATIC (olddecl))))
1938 make_decl_rtl (olddecl, NULL);
1943 /* Return zero if the declaration NEWDECL is valid
1944 when the declaration OLDDECL (assumed to be for the same name)
1945 has already been seen.
1946 Otherwise return an error message format string with a %s
1947 where the identifier should go. */
1950 redeclaration_error_message (tree newdecl, tree olddecl)
1952 if (TREE_CODE (newdecl) == TYPE_DECL)
1954 /* Because C++ can put things into name space for free,
1955 constructs like "typedef struct foo { ... } foo"
1956 would look like an erroneous redeclaration. */
1957 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
1960 return "redefinition of `%#D'";
1962 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1964 /* If this is a pure function, its olddecl will actually be
1965 the original initialization to `0' (which we force to call
1966 abort()). Don't complain about redefinition in this case. */
1967 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
1970 /* If both functions come from different namespaces, this is not
1971 a redeclaration - this is a conflict with a used function. */
1972 if (DECL_NAMESPACE_SCOPE_P (olddecl)
1973 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
1974 return "`%D' conflicts with used function";
1976 /* We'll complain about linkage mismatches in
1977 warn_extern_redeclared_static. */
1979 /* Defining the same name twice is no good. */
1980 if (DECL_INITIAL (olddecl) != NULL_TREE
1981 && DECL_INITIAL (newdecl) != NULL_TREE)
1983 if (DECL_NAME (olddecl) == NULL_TREE)
1984 return "`%#D' not declared in class";
1986 return "redefinition of `%#D'";
1990 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1994 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1996 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
1997 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
1998 return "redefinition of `%#D'";
2002 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2003 || (DECL_TEMPLATE_RESULT (newdecl)
2004 == DECL_TEMPLATE_RESULT (olddecl)))
2007 nt = DECL_TEMPLATE_RESULT (newdecl);
2008 if (DECL_TEMPLATE_INFO (nt))
2009 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2010 ot = DECL_TEMPLATE_RESULT (olddecl);
2011 if (DECL_TEMPLATE_INFO (ot))
2012 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2013 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2014 return "redefinition of `%#D'";
2018 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2020 /* Objects declared at top level: */
2021 /* If at least one is a reference, it's ok. */
2022 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2024 /* Reject two definitions. */
2025 return "redefinition of `%#D'";
2029 /* Objects declared with block scope: */
2030 /* Reject two definitions, and reject a definition
2031 together with an external reference. */
2032 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2033 return "redeclaration of `%#D'";
2038 /* Create a new label, named ID. */
2041 make_label_decl (tree id, int local_p)
2045 decl = build_decl (LABEL_DECL, id, void_type_node);
2047 DECL_CONTEXT (decl) = current_function_decl;
2048 DECL_MODE (decl) = VOIDmode;
2049 C_DECLARED_LABEL_FLAG (decl) = local_p;
2051 /* Say where one reference is to the label, for the sake of the
2052 error if it is not defined. */
2053 DECL_SOURCE_LOCATION (decl) = input_location;
2055 /* Record the fact that this identifier is bound to this label. */
2056 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2061 /* Record this label on the list of used labels so that we can check
2062 at the end of the function to see whether or not the label was
2063 actually defined, and so we can check when the label is defined whether
2064 this use is valid. */
2067 use_label (tree decl)
2069 if (named_label_uses == NULL
2070 || named_label_uses->names_in_scope != current_binding_level->names
2071 || named_label_uses->label_decl != decl)
2073 struct named_label_use_list *new_ent;
2074 new_ent = ggc_alloc (sizeof (struct named_label_use_list));
2075 new_ent->label_decl = decl;
2076 new_ent->names_in_scope = current_binding_level->names;
2077 new_ent->binding_level = current_binding_level;
2078 new_ent->o_goto_locus = input_location;
2079 new_ent->next = named_label_uses;
2080 named_label_uses = new_ent;
2084 /* Look for a label named ID in the current function. If one cannot
2085 be found, create one. (We keep track of used, but undefined,
2086 labels, and complain about them at the end of a function.) */
2089 lookup_label (tree id)
2092 struct named_label_list *ent;
2094 timevar_push (TV_NAME_LOOKUP);
2095 /* You can't use labels at global scope. */
2096 if (current_function_decl == NULL_TREE)
2098 error ("label `%E' referenced outside of any function", id);
2099 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2102 /* See if we've already got this label. */
2103 decl = IDENTIFIER_LABEL_VALUE (id);
2104 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2105 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2107 /* Record this label on the list of labels used in this function.
2108 We do this before calling make_label_decl so that we get the
2109 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2110 ent = ggc_alloc_cleared (sizeof (struct named_label_list));
2111 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2112 ent->next = named_labels;
2115 /* We need a new label. */
2116 decl = make_label_decl (id, /*local_p=*/0);
2118 /* Now fill in the information we didn't have before. */
2119 ent->label_decl = decl;
2121 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2124 /* Declare a local label named ID. */
2127 declare_local_label (tree id)
2131 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2132 this scope we can restore the old value of
2133 IDENTIFIER_TYPE_VALUE. */
2134 current_binding_level->shadowed_labels
2135 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2136 current_binding_level->shadowed_labels);
2137 /* Look for the label. */
2138 decl = make_label_decl (id, /*local_p=*/1);
2139 /* Now fill in the information we didn't have before. */
2140 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2145 /* Returns nonzero if it is ill-formed to jump past the declaration of
2146 DECL. Returns 2 if it's also a real problem. */
2149 decl_jump_unsafe (tree decl)
2151 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
2154 if (DECL_INITIAL (decl) == NULL_TREE
2155 && pod_type_p (TREE_TYPE (decl)))
2158 /* This is really only important if we're crossing an initialization.
2159 The POD stuff is just pedantry; why should it matter if the class
2160 contains a field of pointer to member type? */
2161 if (DECL_INITIAL (decl)
2162 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
2167 /* Check that a single previously seen jump to a newly defined label
2168 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2169 the jump context; NAMES are the names in scope in LEVEL at the jump
2170 context; FILE and LINE are the source position of the jump or 0. */
2173 check_previous_goto_1 (tree decl,
2174 struct cp_binding_level* level,
2175 tree names, const location_t *locus)
2179 struct cp_binding_level *b = current_binding_level;
2180 for (; b; b = b->level_chain)
2182 tree new_decls = b->names;
2183 tree old_decls = (b == level ? names : NULL_TREE);
2184 for (; new_decls != old_decls;
2185 new_decls = TREE_CHAIN (new_decls))
2187 int problem = decl_jump_unsafe (new_decls);
2194 pedwarn ("jump to label `%D'", decl);
2196 pedwarn ("jump to case label");
2199 pedwarn ("%H from here", locus);
2204 cp_error_at (" crosses initialization of `%#D'",
2207 cp_pedwarn_at (" enters scope of non-POD `%#D'",
2213 if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2218 pedwarn ("jump to label `%D'", decl);
2220 pedwarn ("jump to case label");
2223 pedwarn ("%H from here", locus);
2226 if (b->kind == sk_try)
2227 error (" enters try block");
2229 error (" enters catch block");
2236 check_previous_goto (struct named_label_use_list* use)
2238 check_previous_goto_1 (use->label_decl, use->binding_level,
2239 use->names_in_scope, &use->o_goto_locus);
2243 check_switch_goto (struct cp_binding_level* level)
2245 check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2248 /* Check that any previously seen jumps to a newly defined label DECL
2249 are OK. Called by define_label. */
2252 check_previous_gotos (tree decl)
2254 struct named_label_use_list **usep;
2256 if (! TREE_USED (decl))
2259 for (usep = &named_label_uses; *usep; )
2261 struct named_label_use_list *use = *usep;
2262 if (use->label_decl == decl)
2264 check_previous_goto (use);
2268 usep = &(use->next);
2272 /* Check that a new jump to a label DECL is OK. Called by
2273 finish_goto_stmt. */
2276 check_goto (tree decl)
2280 struct named_label_list *lab;
2282 /* We can't know where a computed goto is jumping. So we assume
2284 if (! DECL_P (decl))
2287 /* If the label hasn't been defined yet, defer checking. */
2288 if (! DECL_INITIAL (decl))
2294 for (lab = named_labels; lab; lab = lab->next)
2295 if (decl == lab->label_decl)
2298 /* If the label is not on named_labels it's a gcc local label, so
2299 it must be in an outer scope, so jumping to it is always OK. */
2303 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2306 cp_pedwarn_at ("jump to label `%D'", decl);
2307 pedwarn (" from here");
2311 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2313 tree b = TREE_VALUE (bad);
2314 int u = decl_jump_unsafe (b);
2316 if (u > 1 && DECL_ARTIFICIAL (b))
2317 /* Can't skip init of __exception_info. */
2318 error ("%J enters catch block", b);
2320 cp_error_at (" skips initialization of `%#D'", b);
2322 cp_pedwarn_at (" enters scope of non-POD `%#D'", b);
2325 if (lab->in_try_scope)
2326 error (" enters try block");
2327 else if (lab->in_catch_scope)
2328 error (" enters catch block");
2331 /* Define a label, specifying the location in the source file.
2332 Return the LABEL_DECL node for the label. */
2335 define_label (location_t location, tree name)
2337 tree decl = lookup_label (name);
2338 struct named_label_list *ent;
2339 struct cp_binding_level *p;
2341 timevar_push (TV_NAME_LOOKUP);
2342 for (ent = named_labels; ent; ent = ent->next)
2343 if (ent->label_decl == decl)
2346 /* After labels, make any new cleanups in the function go into their
2347 own new (temporary) binding contour. */
2348 for (p = current_binding_level;
2349 p->kind != sk_function_parms;
2351 p->more_cleanups_ok = 0;
2353 if (name == get_identifier ("wchar_t"))
2354 pedwarn ("label named wchar_t");
2356 if (DECL_INITIAL (decl) != NULL_TREE)
2357 error ("duplicate label `%D'", decl);
2360 /* Mark label as having been defined. */
2361 DECL_INITIAL (decl) = error_mark_node;
2362 /* Say where in the source. */
2363 DECL_SOURCE_LOCATION (decl) = location;
2366 ent->names_in_scope = current_binding_level->names;
2367 ent->binding_level = current_binding_level;
2369 check_previous_gotos (decl);
2372 timevar_pop (TV_NAME_LOOKUP);
2378 struct cp_binding_level *level;
2379 struct cp_switch *next;
2380 /* The SWITCH_STMT being built. */
2382 /* A splay-tree mapping the low element of a case range to the high
2383 element, or NULL_TREE if there is no high element. Used to
2384 determine whether or not a new case label duplicates an old case
2385 label. We need a tree, rather than simply a hash table, because
2386 of the GNU case range extension. */
2390 /* A stack of the currently active switch statements. The innermost
2391 switch statement is on the top of the stack. There is no need to
2392 mark the stack for garbage collection because it is only active
2393 during the processing of the body of a function, and we never
2394 collect at that point. */
2396 static struct cp_switch *switch_stack;
2398 /* Called right after a switch-statement condition is parsed.
2399 SWITCH_STMT is the switch statement being parsed. */
2402 push_switch (tree switch_stmt)
2404 struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2405 p->level = current_binding_level;
2406 p->next = switch_stack;
2407 p->switch_stmt = switch_stmt;
2408 p->cases = splay_tree_new (case_compare, NULL, NULL);
2415 struct cp_switch *cs = switch_stack;
2417 /* Emit warnings as needed. */
2418 c_do_switch_warnings (cs->cases, cs->switch_stmt);
2420 splay_tree_delete (cs->cases);
2421 switch_stack = switch_stack->next;
2425 /* Note that we've seen a definition of a case label, and complain if this
2426 is a bad place for one. */
2429 finish_case_label (tree low_value, tree high_value)
2432 struct cp_binding_level *p;
2434 if (processing_template_decl)
2438 /* For templates, just add the case label; we'll do semantic
2439 analysis at instantiation-time. */
2440 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2441 return add_stmt (build_case_label (low_value, high_value, label));
2444 /* Find the condition on which this switch statement depends. */
2445 cond = SWITCH_COND (switch_stack->switch_stmt);
2446 if (cond && TREE_CODE (cond) == TREE_LIST)
2447 cond = TREE_VALUE (cond);
2449 r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
2451 check_switch_goto (switch_stack->level);
2453 /* After labels, make any new cleanups in the function go into their
2454 own new (temporary) binding contour. */
2455 for (p = current_binding_level;
2456 p->kind != sk_function_parms;
2458 p->more_cleanups_ok = 0;
2463 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2466 typename_hash (const void* k)
2471 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2472 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2477 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2480 typename_compare (const void * k1, const void * k2)
2489 d1 = TYPE_NAME (t1);
2490 d2 = TYPE_NAME (t2);
2492 return (DECL_NAME (d1) == DECL_NAME (d2)
2493 && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
2494 && ((TREE_TYPE (t1) != NULL_TREE)
2495 == (TREE_TYPE (t2) != NULL_TREE))
2496 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2497 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
2500 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2501 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
2502 is non-NULL, this type is being created by the implicit typename
2503 extension, and BASE_TYPE is a type named `t' in some base class of
2504 `T' which depends on template parameters.
2506 Returns the new TYPENAME_TYPE. */
2508 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2511 build_typename_type (tree context, tree name, tree fullname)
2517 if (typename_htab == NULL)
2519 typename_htab = htab_create_ggc (61, &typename_hash,
2520 &typename_compare, NULL);
2523 /* Build the TYPENAME_TYPE. */
2524 t = make_aggr_type (TYPENAME_TYPE);
2525 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2526 TYPENAME_TYPE_FULLNAME (t) = fullname;
2528 /* Build the corresponding TYPE_DECL. */
2529 d = build_decl (TYPE_DECL, name, t);
2530 TYPE_NAME (TREE_TYPE (d)) = d;
2531 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2532 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2533 DECL_ARTIFICIAL (d) = 1;
2535 /* See if we already have this type. */
2536 e = htab_find_slot (typename_htab, t, INSERT);
2545 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
2546 unless an error occurs, in which case error_mark_node is returned.
2547 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2548 set, we return that, rather than the _TYPE it corresponds to, in
2549 other cases we look through the type decl. If TF_ERROR is set,
2550 complain about errors, otherwise be quiet. */
2553 make_typename_type (tree context, tree name, tsubst_flags_t complain)
2557 if (name == error_mark_node
2558 || context == NULL_TREE
2559 || context == error_mark_node)
2560 return error_mark_node;
2564 if (!(TYPE_LANG_SPECIFIC (name)
2565 && (CLASSTYPE_IS_TEMPLATE (name)
2566 || CLASSTYPE_USE_TEMPLATE (name))))
2567 name = TYPE_IDENTIFIER (name);
2569 /* Create a TEMPLATE_ID_EXPR for the type. */
2570 name = build_nt (TEMPLATE_ID_EXPR,
2571 CLASSTYPE_TI_TEMPLATE (name),
2572 CLASSTYPE_TI_ARGS (name));
2574 else if (TREE_CODE (name) == TYPE_DECL)
2575 name = DECL_NAME (name);
2579 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2581 name = TREE_OPERAND (name, 0);
2582 if (TREE_CODE (name) == TEMPLATE_DECL)
2583 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2585 if (TREE_CODE (name) == TEMPLATE_DECL)
2587 error ("`%D' used without template parameters", name);
2588 return error_mark_node;
2590 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802);
2592 if (TREE_CODE (context) == NAMESPACE_DECL)
2594 /* We can get here from typename_sub0 in the explicit_template_type
2595 expansion. Just fail. */
2596 if (complain & tf_error)
2597 error ("no class template named `%#T' in `%#T'",
2599 return error_mark_node;
2602 if (!dependent_type_p (context)
2603 || currently_open_class (context))
2605 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2607 tree tmpl = NULL_TREE;
2608 if (IS_AGGR_TYPE (context))
2609 tmpl = lookup_field (context, name, 0, false);
2610 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2612 if (complain & tf_error)
2613 error ("no class template named `%#T' in `%#T'",
2615 return error_mark_node;
2618 if (complain & tf_error)
2619 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2621 return lookup_template_class (tmpl,
2622 TREE_OPERAND (fullname, 1),
2624 /*entering_scope=*/0,
2625 tf_error | tf_warning | tf_user);
2631 if (!IS_AGGR_TYPE (context))
2633 if (complain & tf_error)
2634 error ("no type named `%#T' in `%#T'", name, context);
2635 return error_mark_node;
2638 t = lookup_field (context, name, 0, true);
2641 if (TREE_CODE (t) != TYPE_DECL)
2643 if (complain & tf_error)
2644 error ("no type named `%#T' in `%#T'", name, context);
2645 return error_mark_node;
2648 if (complain & tf_error)
2649 perform_or_defer_access_check (TYPE_BINFO (context), t);
2651 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2659 /* If the CONTEXT is not a template type, then either the field is
2660 there now or its never going to be. */
2661 if (!dependent_type_p (context))
2663 if (complain & tf_error)
2664 error ("no type named `%#T' in `%#T'", name, context);
2665 return error_mark_node;
2668 return build_typename_type (context, name, fullname);
2671 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
2672 unless an error occurs, in which case error_mark_node is returned.
2673 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2674 corresponds to. If COMPLAIN zero, don't complain about any errors
2678 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
2684 name = TYPE_IDENTIFIER (name);
2685 else if (DECL_P (name))
2686 name = DECL_NAME (name);
2687 if (TREE_CODE (name) != IDENTIFIER_NODE)
2690 if (!dependent_type_p (context)
2691 || currently_open_class (context))
2693 tree tmpl = NULL_TREE;
2695 if (IS_AGGR_TYPE (context))
2696 tmpl = lookup_field (context, name, 0, false);
2698 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2700 if (complain & tf_error)
2701 error ("no class template named `%#T' in `%#T'", name, context);
2702 return error_mark_node;
2705 if (complain & tf_error)
2706 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2711 /* Build the UNBOUND_CLASS_TEMPLATE. */
2712 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2713 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2714 TREE_TYPE (t) = NULL_TREE;
2716 /* Build the corresponding TEMPLATE_DECL. */
2717 d = build_decl (TEMPLATE_DECL, name, t);
2718 TYPE_NAME (TREE_TYPE (d)) = d;
2719 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2720 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2721 DECL_ARTIFICIAL (d) = 1;
2728 /* Push the declarations of builtin types into the namespace.
2729 RID_INDEX is the index of the builtin type in the array
2730 RID_POINTERS. NAME is the name used when looking up the builtin
2731 type. TYPE is the _TYPE node for the builtin type. */
2734 record_builtin_type (enum rid rid_index,
2738 tree rname = NULL_TREE, tname = NULL_TREE;
2739 tree tdecl = NULL_TREE;
2741 if ((int) rid_index < (int) RID_MAX)
2742 rname = ridpointers[(int) rid_index];
2744 tname = get_identifier (name);
2746 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2747 eliminated. Built-in types should not be looked up name; their
2748 names are keywords that the parser can recognize. However, there
2749 is code in c-common.c that uses identifier_global_value to look
2750 up built-in types by name. */
2753 tdecl = build_decl (TYPE_DECL, tname, type);
2754 DECL_ARTIFICIAL (tdecl) = 1;
2755 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2761 tdecl = build_decl (TYPE_DECL, rname, type);
2762 DECL_ARTIFICIAL (tdecl) = 1;
2764 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2767 if (!TYPE_NAME (type))
2768 TYPE_NAME (type) = tdecl;
2771 debug_hooks->type_decl (tdecl, 0);
2774 /* Record one of the standard Java types.
2775 * Declare it as having the given NAME.
2776 * If SIZE > 0, it is the size of one of the integral types;
2777 * otherwise it is the negative of the size of one of the other types. */
2780 record_builtin_java_type (const char* name, int size)
2784 type = make_signed_type (size);
2785 else if (size > -32)
2786 { /* "__java_char" or ""__java_boolean". */
2787 type = make_unsigned_type (-size);
2788 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2791 { /* "__java_float" or ""__java_double". */
2792 type = make_node (REAL_TYPE);
2793 TYPE_PRECISION (type) = - size;
2796 record_builtin_type (RID_MAX, name, type);
2797 decl = TYPE_NAME (type);
2799 /* Suppress generate debug symbol entries for these types,
2800 since for normal C++ they are just clutter.
2801 However, push_lang_context undoes this if extern "Java" is seen. */
2802 DECL_IGNORED_P (decl) = 1;
2804 TYPE_FOR_JAVA (type) = 1;
2808 /* Push a type into the namespace so that the back-ends ignore it. */
2811 record_unknown_type (tree type, const char* name)
2813 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2814 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
2815 DECL_IGNORED_P (decl) = 1;
2816 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2817 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2818 TYPE_ALIGN (type) = 1;
2819 TYPE_USER_ALIGN (type) = 0;
2820 TYPE_MODE (type) = TYPE_MODE (void_type_node);
2823 /* An string for which we should create an IDENTIFIER_NODE at
2826 typedef struct predefined_identifier
2828 /* The name of the identifier. */
2829 const char *const name;
2830 /* The place where the IDENTIFIER_NODE should be stored. */
2832 /* Nonzero if this is the name of a constructor or destructor. */
2833 const int ctor_or_dtor_p;
2834 } predefined_identifier;
2836 /* Create all the predefined identifiers. */
2839 initialize_predefined_identifiers (void)
2841 const predefined_identifier *pid;
2843 /* A table of identifiers to create at startup. */
2844 static const predefined_identifier predefined_identifiers[] = {
2845 { "C++", &lang_name_cplusplus, 0 },
2846 { "C", &lang_name_c, 0 },
2847 { "Java", &lang_name_java, 0 },
2848 { CTOR_NAME, &ctor_identifier, 1 },
2849 { "__base_ctor", &base_ctor_identifier, 1 },
2850 { "__comp_ctor", &complete_ctor_identifier, 1 },
2851 { DTOR_NAME, &dtor_identifier, 1 },
2852 { "__comp_dtor", &complete_dtor_identifier, 1 },
2853 { "__base_dtor", &base_dtor_identifier, 1 },
2854 { "__deleting_dtor", &deleting_dtor_identifier, 1 },
2855 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2856 { "nelts", &nelts_identifier, 0 },
2857 { THIS_NAME, &this_identifier, 0 },
2858 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2859 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2860 { "_vptr", &vptr_identifier, 0 },
2861 { "__vtt_parm", &vtt_parm_identifier, 0 },
2862 { "::", &global_scope_name, 0 },
2863 { "std", &std_identifier, 0 },
2867 for (pid = predefined_identifiers; pid->name; ++pid)
2869 *pid->node = get_identifier (pid->name);
2870 if (pid->ctor_or_dtor_p)
2871 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2875 /* Create the predefined scalar types of C,
2876 and some nodes representing standard constants (0, 1, (void *)0).
2877 Initialize the global binding level.
2878 Make definitions for built-in primitive functions. */
2881 cxx_init_decl_processing (void)
2884 tree void_ftype_ptr;
2886 /* Create all the identifiers we need. */
2887 initialize_predefined_identifiers ();
2889 /* Create the global variables. */
2890 push_to_top_level ();
2892 current_function_decl = NULL_TREE;
2893 current_binding_level = NULL;
2894 /* Enter the global namespace. */
2895 my_friendly_assert (global_namespace == NULL_TREE, 375);
2896 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2898 begin_scope (sk_namespace, global_namespace);
2900 current_lang_name = NULL_TREE;
2902 /* Adjust various flags based on command-line settings. */
2903 if (!flag_permissive)
2904 flag_pedantic_errors = 1;
2905 if (!flag_no_inline)
2907 flag_inline_trees = 1;
2910 if (flag_inline_functions)
2912 flag_inline_trees = 2;
2913 flag_inline_functions = 0;
2916 /* Force minimum function alignment if using the least significant
2917 bit of function pointers to store the virtual bit. */
2918 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2919 && force_align_functions_log < 1)
2920 force_align_functions_log = 1;
2923 current_lang_name = lang_name_c;
2925 build_common_tree_nodes (flag_signed_char);
2927 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2928 TREE_TYPE (error_mark_list) = error_mark_node;
2930 /* Create the `std' namespace. */
2931 push_namespace (std_identifier);
2932 std_node = current_namespace;
2935 c_common_nodes_and_builtins ();
2937 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2938 java_short_type_node = record_builtin_java_type ("__java_short", 16);
2939 java_int_type_node = record_builtin_java_type ("__java_int", 32);
2940 java_long_type_node = record_builtin_java_type ("__java_long", 64);
2941 java_float_type_node = record_builtin_java_type ("__java_float", -32);
2942 java_double_type_node = record_builtin_java_type ("__java_double", -64);
2943 java_char_type_node = record_builtin_java_type ("__java_char", -16);
2944 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2946 integer_two_node = build_int_2 (2, 0);
2947 TREE_TYPE (integer_two_node) = integer_type_node;
2948 integer_three_node = build_int_2 (3, 0);
2949 TREE_TYPE (integer_three_node) = integer_type_node;
2951 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2952 truthvalue_type_node = boolean_type_node;
2953 truthvalue_false_node = boolean_false_node;
2954 truthvalue_true_node = boolean_true_node;
2956 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
2959 record_builtin_type (RID_MAX, NULL, string_type_node);
2962 delta_type_node = ptrdiff_type_node;
2963 vtable_index_type = ptrdiff_type_node;
2965 vtt_parm_type = build_pointer_type (const_ptr_type_node);
2966 void_ftype = build_function_type (void_type_node, void_list_node);
2967 void_ftype_ptr = build_function_type (void_type_node,
2968 tree_cons (NULL_TREE,
2972 = build_exception_variant (void_ftype_ptr, empty_except_spec);
2974 /* C++ extensions */
2976 unknown_type_node = make_node (UNKNOWN_TYPE);
2977 record_unknown_type (unknown_type_node, "unknown type");
2979 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
2980 TREE_TYPE (unknown_type_node) = unknown_type_node;
2982 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
2984 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
2985 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
2988 /* Make sure we get a unique function type, so we can give
2989 its pointer type a name. (This wins for gdb.) */
2990 tree vfunc_type = make_node (FUNCTION_TYPE);
2991 TREE_TYPE (vfunc_type) = integer_type_node;
2992 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
2993 layout_type (vfunc_type);
2995 vtable_entry_type = build_pointer_type (vfunc_type);
2997 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3000 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3001 layout_type (vtbl_type_node);
3002 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3003 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3004 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3005 layout_type (vtbl_ptr_type_node);
3006 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3008 push_namespace (get_identifier ("__cxxabiv1"));
3009 abi_node = current_namespace;
3012 global_type_node = make_node (LANG_TYPE);
3013 record_unknown_type (global_type_node, "global type");
3016 current_lang_name = lang_name_cplusplus;
3020 tree bad_alloc_type_node;
3021 tree bad_alloc_decl;
3022 tree newtype, deltype;
3023 tree ptr_ftype_sizetype;
3025 push_namespace (std_identifier);
3026 bad_alloc_id = get_identifier ("bad_alloc");
3027 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3028 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3030 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3031 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3032 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3036 = build_function_type (ptr_type_node,
3037 tree_cons (NULL_TREE,
3040 newtype = build_exception_variant
3041 (ptr_ftype_sizetype, add_exception_specifier
3042 (NULL_TREE, bad_alloc_type_node, -1));
3043 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3044 push_cp_library_fn (NEW_EXPR, newtype);
3045 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3046 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3047 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3051 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3053 /* Perform other language dependent initializations. */
3054 init_class_processing ();
3055 init_search_processing ();
3056 init_rtti_processing ();
3058 if (flag_exceptions)
3059 init_exception_processing ();
3061 if (! supports_one_only ())
3064 make_fname_decl = cp_make_fname_decl;
3065 start_fname_decls ();
3067 /* Show we use EH for cleanups. */
3068 if (flag_exceptions)
3069 using_eh_for_cleanups ();
3072 /* Generate an initializer for a function naming variable from
3073 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3074 filled in with the type of the init. */
3077 cp_fname_init (const char* name, tree *type_p)
3079 tree domain = NULL_TREE;
3081 tree init = NULL_TREE;
3086 length = strlen (name);
3087 domain = build_index_type (size_int (length));
3088 init = build_string (length + 1, name);
3091 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3092 type = build_cplus_array_type (type, domain);
3097 TREE_TYPE (init) = type;
3099 init = error_mark_node;
3104 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3105 decl, NAME is the initialization string and TYPE_DEP indicates whether
3106 NAME depended on the type of the function. We make use of that to detect
3107 __PRETTY_FUNCTION__ inside a template fn. This is being done
3108 lazily at the point of first use, so we mustn't push the decl now. */
3111 cp_make_fname_decl (tree id, int type_dep)
3113 const char *const name = (type_dep && processing_template_decl
3114 ? NULL : fname_as_string (type_dep));
3116 tree init = cp_fname_init (name, &type);
3117 tree decl = build_decl (VAR_DECL, id, type);
3120 free ((char *) name);
3122 /* As we're using pushdecl_with_scope, we must set the context. */
3123 DECL_CONTEXT (decl) = current_function_decl;
3124 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3126 TREE_STATIC (decl) = 1;
3127 TREE_READONLY (decl) = 1;
3128 DECL_ARTIFICIAL (decl) = 1;
3129 DECL_INITIAL (decl) = init;
3131 TREE_USED (decl) = 1;
3133 if (current_function_decl)
3135 struct cp_binding_level *b = current_binding_level;
3136 while (b->level_chain->kind != sk_function_parms)
3138 pushdecl_with_scope (decl, b);
3139 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3142 pushdecl_top_level_and_finish (decl, init);
3147 /* Make a definition for a builtin function named NAME in the current
3148 namespace, whose data type is TYPE and whose context is CONTEXT.
3149 TYPE should be a function type with argument types.
3151 CLASS and CODE tell later passes how to compile calls to this function.
3152 See tree.h for possible values.
3154 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3155 the name to be called if we can't opencode the function.
3156 If ATTRS is nonzero, use that for the function's attribute
3160 builtin_function_1 (const char* name,
3164 enum built_in_class class,
3165 const char* libname,
3168 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3169 DECL_BUILT_IN_CLASS (decl) = class;
3170 DECL_FUNCTION_CODE (decl) = code;
3171 DECL_CONTEXT (decl) = context;
3175 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3176 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3177 function in the namespace. */
3179 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3181 /* Warn if a function in the namespace for users
3182 is used without an occasion to consider it declared. */
3183 if (name[0] != '_' || name[1] != '_')
3184 DECL_ANTICIPATED (decl) = 1;
3186 /* Possibly apply some default attributes to this built-in function. */
3188 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3190 decl_attributes (&decl, NULL_TREE, 0);
3195 /* Entry point for the benefit of c_common_nodes_and_builtins.
3197 Make a definition for a builtin function named NAME and whose data type
3198 is TYPE. TYPE should be a function type with argument types. This
3199 function places the anticipated declaration in the global namespace
3200 and additionally in the std namespace if appropriate.
3202 CLASS and CODE tell later passes how to compile calls to this function.
3203 See tree.h for possible values.
3205 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3206 the name to be called if we can't opencode the function.
3208 If ATTRS is nonzero, use that for the function's attribute
3212 builtin_function (const char* name,
3215 enum built_in_class class,
3216 const char* libname,
3219 /* All builtins that don't begin with an '_' should additionally
3220 go in the 'std' namespace. */
3223 push_namespace (std_identifier);
3224 builtin_function_1 (name, type, std_node, code, class, libname, attrs);
3228 return builtin_function_1 (name, type, NULL_TREE, code,
3229 class, libname, attrs);
3232 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3233 function. Not called directly. */
3236 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3238 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3239 DECL_EXTERNAL (fn) = 1;
3240 TREE_PUBLIC (fn) = 1;
3241 DECL_ARTIFICIAL (fn) = 1;
3242 TREE_NOTHROW (fn) = 1;
3243 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3244 SET_DECL_LANGUAGE (fn, lang_c);
3248 /* Returns the _DECL for a library function with C linkage.
3249 We assume that such functions never throw; if this is incorrect,
3250 callers should unset TREE_NOTHROW. */
3253 build_library_fn (tree name, tree type)
3255 return build_library_fn_1 (name, ERROR_MARK, type);
3258 /* Returns the _DECL for a library function with C++ linkage. */
3261 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3263 tree fn = build_library_fn_1 (name, operator_code, type);
3264 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3265 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3266 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3270 /* Like build_library_fn, but takes a C string instead of an
3274 build_library_fn_ptr (const char* name, tree type)
3276 return build_library_fn (get_identifier (name), type);
3279 /* Like build_cp_library_fn, but takes a C string instead of an
3283 build_cp_library_fn_ptr (const char* name, tree type)
3285 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3288 /* Like build_library_fn, but also pushes the function so that we will
3289 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3292 push_library_fn (tree name, tree type)
3294 tree fn = build_library_fn (name, type);
3295 pushdecl_top_level (fn);
3299 /* Like build_cp_library_fn, but also pushes the function so that it
3300 will be found by normal lookup. */
3303 push_cp_library_fn (enum tree_code operator_code, tree type)
3305 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3312 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3316 push_void_library_fn (tree name, tree parmtypes)
3318 tree type = build_function_type (void_type_node, parmtypes);
3319 return push_library_fn (name, type);
3322 /* Like push_library_fn, but also note that this function throws
3323 and does not return. Used for __throw_foo and the like. */
3326 push_throw_library_fn (tree name, tree type)
3328 tree fn = push_library_fn (name, type);
3329 TREE_THIS_VOLATILE (fn) = 1;
3330 TREE_NOTHROW (fn) = 0;
3334 /* When we call finish_struct for an anonymous union, we create
3335 default copy constructors and such. But, an anonymous union
3336 shouldn't have such things; this function undoes the damage to the
3337 anonymous union type T.
3339 (The reason that we create the synthesized methods is that we don't
3340 distinguish `union { int i; }' from `typedef union { int i; } U'.
3341 The first is an anonymous union; the second is just an ordinary
3345 fixup_anonymous_aggr (tree t)
3349 /* Wipe out memory of synthesized methods. */
3350 TYPE_HAS_CONSTRUCTOR (t) = 0;
3351 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3352 TYPE_HAS_INIT_REF (t) = 0;
3353 TYPE_HAS_CONST_INIT_REF (t) = 0;
3354 TYPE_HAS_ASSIGN_REF (t) = 0;
3355 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3357 /* Splice the implicitly generated functions out of the TYPE_METHODS
3359 q = &TYPE_METHODS (t);
3362 if (DECL_ARTIFICIAL (*q))
3363 *q = TREE_CHAIN (*q);
3365 q = &TREE_CHAIN (*q);
3368 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3369 if (TYPE_METHODS (t))
3370 error ("%Jan anonymous union cannot have function members",
3371 TYPE_MAIN_DECL (t));
3373 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3374 assignment operators (because they cannot have these methods themselves).
3375 For anonymous unions this is already checked because they are not allowed
3376 in any union, otherwise we have to check it. */
3377 if (TREE_CODE (t) != UNION_TYPE)
3381 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3382 if (TREE_CODE (field) == FIELD_DECL)
3384 type = TREE_TYPE (field);
3385 if (CLASS_TYPE_P (type))
3387 if (TYPE_NEEDS_CONSTRUCTING (type))
3388 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3390 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3391 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3393 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3394 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3401 /* Make sure that a declaration with no declarator is well-formed, i.e.
3402 just declares a tagged type or anonymous union.
3404 Returns the type declared; or NULL_TREE if none. */
3407 check_tag_decl (cp_decl_specifier_seq *declspecs)
3409 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3410 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3411 /* If a class, struct, or enum type is declared by the DECLSPECS
3412 (i.e, if a class-specifier, enum-specifier, or non-typename
3413 elaborated-type-specifier appears in the DECLSPECS),
3414 DECLARED_TYPE is set to the corresponding type. */
3415 tree declared_type = NULL_TREE;
3416 bool error_p = false;
3418 if (declspecs->multiple_types_p)
3419 error ("multiple types in one declaration");
3420 else if (declspecs->redefined_builtin_type)
3422 if (!in_system_header)
3423 pedwarn ("redeclaration of C++ built-in type",
3424 declspecs->redefined_builtin_type);
3428 if (TYPE_P (declspecs->type)
3429 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3430 && IS_AGGR_TYPE (declspecs->type))
3431 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3432 declared_type = declspecs->type;
3433 else if (declspecs->type == error_mark_node)
3435 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3436 pedwarn ("declaration does not declare anything");
3437 /* Check for an anonymous union. */
3438 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3439 && TYPE_ANONYMOUS_P (declared_type))
3441 /* 7/3 In a simple-declaration, the optional init-declarator-list
3442 can be omitted only when declaring a class (clause 9) or
3443 enumeration (7.2), that is, when the decl-specifier-seq contains
3444 either a class-specifier, an elaborated-type-specifier with
3445 a class-key (9.1), or an enum-specifier. In these cases and
3446 whenever a class-specifier or enum-specifier is present in the
3447 decl-specifier-seq, the identifiers in these specifiers are among
3448 the names being declared by the declaration (as class-name,
3449 enum-names, or enumerators, depending on the syntax). In such
3450 cases, and except for the declaration of an unnamed bit-field (9.6),
3451 the decl-specifier-seq shall introduce one or more names into the
3452 program, or shall redeclare a name introduced by a previous
3453 declaration. [Example:
3454 enum { }; // ill-formed
3455 typedef class { }; // ill-formed
3459 error ("missing type-name in typedef-declaration");
3462 /* Anonymous unions are objects, so they can have specifiers. */;
3463 SET_ANON_AGGR_TYPE_P (declared_type);
3465 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3466 && !in_system_header)
3467 pedwarn ("ISO C++ prohibits anonymous structs");
3472 if (declspecs->specs[(int)ds_inline]
3473 || declspecs->specs[(int)ds_virtual])
3474 error ("`%s' can only be specified for functions",
3475 declspecs->specs[(int)ds_inline]
3476 ? "inline" : "virtual");
3478 && (!current_class_type
3479 || current_scope () != current_class_type))
3480 error ("`friend' can only be specified inside a class");
3481 else if (declspecs->specs[(int)ds_explicit])
3482 error ("`explicit' can only be specified for constructors");
3483 else if (declspecs->storage_class)
3484 error ("a storage class can only be specified for objects "
3486 else if (declspecs->specs[(int)ds_const]
3487 || declspecs->specs[(int)ds_volatile]
3488 || declspecs->specs[(int)ds_restrict]
3489 || declspecs->specs[(int)ds_thread])
3490 error ("qualifiers can only be specified for objects "
3494 return declared_type;
3497 /* Called when a declaration is seen that contains no names to declare.
3498 If its type is a reference to a structure, union or enum inherited
3499 from a containing scope, shadow that tag name for the current scope
3500 with a forward reference.
3501 If its type defines a new named structure or union
3502 or defines an enum, it is valid but we need not do anything here.
3503 Otherwise, it is an error.
3505 C++: may have to grok the declspecs to learn about static,
3506 complain for anonymous unions.
3508 Returns the TYPE declared -- or NULL_TREE if none. */
3511 shadow_tag (cp_decl_specifier_seq *declspecs)
3513 tree t = check_tag_decl (declspecs);
3518 maybe_process_partial_specialization (t);
3520 /* This is where the variables in an anonymous union are
3521 declared. An anonymous union declaration looks like:
3523 because there is no declarator after the union, the parser
3524 sends that declaration here. */
3525 if (ANON_AGGR_TYPE_P (t))
3527 fixup_anonymous_aggr (t);
3529 if (TYPE_FIELDS (t))
3531 tree decl = grokdeclarator (/*declarator=*/NULL,
3532 declspecs, NORMAL, 0, NULL);
3533 finish_anon_union (decl);
3540 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3543 groktypename (cp_decl_specifier_seq *type_specifiers,
3544 const cp_declarator *declarator)
3548 attrs = type_specifiers->attributes;
3549 type_specifiers->attributes = NULL_TREE;
3550 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3552 cplus_decl_attributes (&type, attrs, 0);
3556 /* Decode a declarator in an ordinary declaration or data definition.
3557 This is called as soon as the type information and variable name
3558 have been parsed, before parsing the initializer if any.
3559 Here we create the ..._DECL node, fill in its type,
3560 and put it on the list of decls for the current context.
3561 The ..._DECL node is returned as the value.
3563 Exception: for arrays where the length is not specified,
3564 the type is left null, to be filled in by `cp_finish_decl'.
3566 Function definitions do not come here; they go to start_function
3567 instead. However, external and forward declarations of functions
3568 do go through here. Structure field declarations are done by
3569 grokfield and not through here. */
3572 start_decl (const cp_declarator *declarator,
3573 cp_decl_specifier_seq *declspecs,
3576 tree prefix_attributes)
3582 /* This should only be done once on the top most decl. */
3583 if (have_extern_spec)
3585 declspecs->storage_class = sc_extern;
3586 have_extern_spec = false;
3589 /* An object declared as __attribute__((deprecated)) suppresses
3590 warnings of uses of other deprecated items. */
3591 if (lookup_attribute ("deprecated", attributes))
3592 deprecated_state = DEPRECATED_SUPPRESS;
3594 attributes = chainon (attributes, prefix_attributes);
3596 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3599 deprecated_state = DEPRECATED_NORMAL;
3601 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3604 type = TREE_TYPE (decl);
3606 if (type == error_mark_node)
3609 context = DECL_CONTEXT (decl);
3611 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
3612 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
3614 /* When parsing the initializer, lookup should use the object's
3616 push_decl_namespace (context);
3619 /* We are only interested in class contexts, later. */
3620 if (context && TREE_CODE (context) == NAMESPACE_DECL)
3621 context = NULL_TREE;
3624 /* Is it valid for this decl to have an initializer at all?
3625 If not, set INITIALIZED to zero, which will indirectly
3626 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3627 switch (TREE_CODE (decl))
3630 error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
3635 error ("function `%#D' is initialized like a variable", decl);
3645 if (! toplevel_bindings_p ()
3646 && DECL_EXTERNAL (decl))
3647 warning ("declaration of `%#D' has `extern' and is initialized",
3649 DECL_EXTERNAL (decl) = 0;
3650 if (toplevel_bindings_p ())
3651 TREE_STATIC (decl) = 1;
3653 /* Tell `pushdecl' this is an initialized decl
3654 even though we don't yet have the initializer expression.
3655 Also tell `cp_finish_decl' it may store the real initializer. */
3656 DECL_INITIAL (decl) = error_mark_node;
3659 /* Set attributes here so if duplicate decl, will have proper attributes. */
3660 cplus_decl_attributes (&decl, attributes, 0);
3662 /* If #pragma weak was used, mark the decl weak now. */
3663 if (global_scope_p (current_binding_level))
3664 maybe_apply_pragma_weak (decl);
3666 if (TREE_CODE (decl) == FUNCTION_DECL
3667 && DECL_DECLARED_INLINE_P (decl)
3668 && DECL_UNINLINABLE (decl)
3669 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3670 warning ("%Jinline function '%D' given attribute noinline", decl, decl);
3672 if (context && COMPLETE_TYPE_P (complete_type (context)))
3674 push_nested_class (context);
3676 if (TREE_CODE (decl) == VAR_DECL)
3678 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3679 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3680 error ("`%#D' is not a static member of `%#T'", decl, context);
3683 if (DECL_CONTEXT (field) != context)
3685 if (!same_type_p (DECL_CONTEXT (field), context))
3686 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3687 DECL_CONTEXT (field), DECL_NAME (decl),
3688 context, DECL_NAME (decl));
3689 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3691 /* Static data member are tricky; an in-class initialization
3692 still doesn't provide a definition, so the in-class
3693 declaration will have DECL_EXTERNAL set, but will have an
3694 initialization. Thus, duplicate_decls won't warn
3695 about this situation, and so we check here. */
3696 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3697 error ("duplicate initialization of %D", decl);
3698 if (duplicate_decls (decl, field))
3704 tree field = check_classfn (context, decl,
3705 (processing_template_decl
3706 > template_class_depth (context))
3707 ? current_template_parms
3709 if (field && duplicate_decls (decl, field))
3713 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3714 DECL_IN_AGGR_P (decl) = 0;
3715 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3716 || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3718 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3719 /* [temp.expl.spec] An explicit specialization of a static data
3720 member of a template is a definition if the declaration
3721 includes an initializer; otherwise, it is a declaration.
3723 We check for processing_specialization so this only applies
3724 to the new specialization syntax. */
3725 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3726 DECL_EXTERNAL (decl) = 1;
3729 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3730 pedwarn ("declaration of `%#D' outside of class is not definition",
3734 /* Enter this declaration into the symbol table. */
3735 tem = maybe_push_decl (decl);
3737 if (processing_template_decl)
3738 tem = push_template_decl (tem);
3739 if (tem == error_mark_node)
3740 return error_mark_node;
3742 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3743 /* Tell the back-end to use or not use .common as appropriate. If we say
3744 -fconserve-space, we want this to save .data space, at the expense of
3745 wrong semantics. If we say -fno-conserve-space, we want this to
3746 produce errors about redefs; to do this we force variables into the
3748 DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3749 || !DECL_THREAD_LOCAL (tem))
3750 && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3753 if (! processing_template_decl)
3760 start_decl_1 (tree decl)
3762 tree type = TREE_TYPE (decl);
3763 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3765 if (type == error_mark_node)
3769 /* Is it valid for this decl to have an initializer at all?
3770 If not, set INITIALIZED to zero, which will indirectly
3771 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3773 /* Don't allow initializations for incomplete types except for
3774 arrays which might be completed by the initialization. */
3775 if (COMPLETE_TYPE_P (complete_type (type)))
3776 ; /* A complete type is ok. */
3777 else if (TREE_CODE (type) != ARRAY_TYPE)
3779 error ("variable `%#D' has initializer but incomplete type",
3782 type = TREE_TYPE (decl) = error_mark_node;
3784 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3786 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3787 error ("elements of array `%#D' have incomplete type", decl);
3788 /* else we already gave an error in start_decl. */
3794 && TREE_CODE (decl) != TYPE_DECL
3795 && TREE_CODE (decl) != TEMPLATE_DECL
3796 && type != error_mark_node
3797 && IS_AGGR_TYPE (type)
3798 && ! DECL_EXTERNAL (decl))
3800 if ((! processing_template_decl || ! uses_template_parms (type))
3801 && !COMPLETE_TYPE_P (complete_type (type)))
3803 error ("aggregate `%#D' has incomplete type and cannot be defined",
3805 /* Change the type so that assemble_variable will give
3806 DECL an rtl we can live with: (mem (const_int 0)). */
3807 type = TREE_TYPE (decl) = error_mark_node;
3811 /* If any base type in the hierarchy of TYPE needs a constructor,
3812 then we set initialized to 1. This way any nodes which are
3813 created for the purposes of initializing this aggregate
3814 will live as long as it does. This is necessary for global
3815 aggregates which do not have their initializers processed until
3816 the end of the file. */
3817 initialized = TYPE_NEEDS_CONSTRUCTING (type);
3822 DECL_INITIAL (decl) = NULL_TREE;
3824 /* Create a new scope to hold this declaration if necessary.
3825 Whether or not a new scope is necessary cannot be determined
3826 until after the type has been completed; if the type is a
3827 specialization of a class template it is not until after
3828 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3829 will be set correctly. */
3830 maybe_push_cleanup_level (type);
3833 /* Handle initialization of references. DECL, TYPE, and INIT have the
3834 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
3835 but will be set to a new CLEANUP_STMT if a temporary is created
3836 that must be destroyed subsequently.
3838 Returns an initializer expression to use to initialize DECL, or
3839 NULL if the initialization can be performed statically.
3841 Quotes on semantics can be found in ARM 8.4.3. */
3844 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3848 if (init == NULL_TREE)
3850 if ((DECL_LANG_SPECIFIC (decl) == 0
3851 || DECL_IN_AGGR_P (decl) == 0)
3852 && ! DECL_THIS_EXTERN (decl))
3853 error ("`%D' declared as reference but not initialized", decl);
3857 if (TREE_CODE (init) == CONSTRUCTOR)
3859 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
3863 if (TREE_CODE (init) == TREE_LIST)
3864 init = build_x_compound_expr_from_list (init, "initializer");
3866 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
3867 init = convert_from_reference (init);
3869 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3870 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3871 /* Note: default conversion is only called in very special cases. */
3872 init = decay_conversion (init);
3874 /* Convert INIT to the reference type TYPE. This may involve the
3875 creation of a temporary, whose lifetime must be the same as that
3876 of the reference. If so, a DECL_STMT for the temporary will be
3877 added just after the DECL_STMT for DECL. That's why we don't set
3878 DECL_INITIAL for local references (instead assigning to them
3879 explicitly); we need to allow the temporary to be initialized
3881 tmp = initialize_reference (type, init, decl, cleanup);
3883 if (tmp == error_mark_node)
3885 else if (tmp == NULL_TREE)
3887 error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
3891 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3894 DECL_INITIAL (decl) = tmp;
3899 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3900 array until we finish parsing the initializer. If that's the
3901 situation we're in, update DECL accordingly. */
3904 maybe_deduce_size_from_array_init (tree decl, tree init)
3906 tree type = TREE_TYPE (decl);
3908 if (TREE_CODE (type) == ARRAY_TYPE
3909 && TYPE_DOMAIN (type) == NULL_TREE
3910 && TREE_CODE (decl) != TYPE_DECL)
3912 /* do_default is really a C-ism to deal with tentative definitions.
3913 But let's leave it here to ease the eventual merge. */
3914 int do_default = !DECL_EXTERNAL (decl);
3915 tree initializer = init ? init : DECL_INITIAL (decl);
3916 int failure = complete_array_type (type, initializer, do_default);
3919 error ("initializer fails to determine size of `%D'", decl);
3924 error ("array size missing in `%D'", decl);
3925 /* If a `static' var's size isn't known, make it extern as
3926 well as static, so it does not get allocated. If it's not
3927 `static', then don't mark it extern; finish_incomplete_decl
3928 will give it a default size and it will get allocated. */
3929 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3930 DECL_EXTERNAL (decl) = 1;
3933 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
3934 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3936 error ("zero-size array `%D'", decl);
3938 layout_decl (decl, 0);
3942 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3943 any appropriate error messages regarding the layout. */
3946 layout_var_decl (tree decl)
3948 tree type = TREE_TYPE (decl);
3950 tree ttype = target_type (type);
3953 /* If we haven't already layed out this declaration, do so now.
3954 Note that we must not call complete type for an external object
3955 because it's type might involve templates that we are not
3956 supposed to instantiate yet. (And it's perfectly valid to say
3957 `extern X x' for some incomplete type `X'.) */
3958 if (!DECL_EXTERNAL (decl))
3959 complete_type (type);
3960 if (!DECL_SIZE (decl)
3961 && TREE_TYPE (decl) != error_mark_node
3962 && (COMPLETE_TYPE_P (type)
3963 || (TREE_CODE (type) == ARRAY_TYPE
3964 && !TYPE_DOMAIN (type)
3965 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
3966 layout_decl (decl, 0);
3968 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
3970 /* An automatic variable with an incomplete type: that is an error.
3971 Don't talk about array types here, since we took care of that
3972 message in grokdeclarator. */
3973 error ("storage size of `%D' isn't known", decl);
3974 TREE_TYPE (decl) = error_mark_node;
3977 /* Keep this code around in case we later want to control debug info
3978 based on whether a type is "used". (jason 1999-11-11) */
3980 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
3981 /* Let debugger know it should output info for this type. */
3982 note_debug_info_needed (ttype);
3984 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
3985 note_debug_info_needed (DECL_CONTEXT (decl));
3988 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3989 && DECL_SIZE (decl) != NULL_TREE
3990 && ! TREE_CONSTANT (DECL_SIZE (decl)))
3992 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3993 constant_expression_warning (DECL_SIZE (decl));
3995 error ("storage size of `%D' isn't constant", decl);
3998 if (TREE_STATIC (decl)
3999 && !DECL_ARTIFICIAL (decl)
4000 && current_function_decl
4001 && DECL_CONTEXT (decl) == current_function_decl)
4002 push_local_name (decl);
4005 /* If a local static variable is declared in an inline function, or if
4006 we have a weak definition, we must endeavor to create only one
4007 instance of the variable at link-time. */
4010 maybe_commonize_var (tree decl)
4012 /* Static data in a function with comdat linkage also has comdat
4014 if (TREE_STATIC (decl)
4015 /* Don't mess with __FUNCTION__. */
4016 && ! DECL_ARTIFICIAL (decl)
4017 && DECL_FUNCTION_SCOPE_P (decl)
4018 /* Unfortunately, import_export_decl has not always been called
4019 before the function is processed, so we cannot simply check
4021 && (DECL_COMDAT (DECL_CONTEXT (decl))
4022 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4023 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4024 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4028 /* With weak symbols, we simply make the variable COMDAT;
4029 that will cause copies in multiple translations units to
4031 comdat_linkage (decl);
4035 if (DECL_INITIAL (decl) == NULL_TREE
4036 || DECL_INITIAL (decl) == error_mark_node)
4038 /* Without weak symbols, we can use COMMON to merge
4039 uninitialized variables. */
4040 TREE_PUBLIC (decl) = 1;
4041 DECL_COMMON (decl) = 1;
4045 /* While for initialized variables, we must use internal
4046 linkage -- which means that multiple copies will not
4048 TREE_PUBLIC (decl) = 0;
4049 DECL_COMMON (decl) = 0;
4050 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
4051 warning ("%J you can work around this by removing the initializer",
4056 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4057 /* Set it up again; we might have set DECL_INITIAL since the last
4059 comdat_linkage (decl);
4062 /* Issue an error message if DECL is an uninitialized const variable. */
4065 check_for_uninitialized_const_var (tree decl)
4067 tree type = TREE_TYPE (decl);
4069 /* ``Unless explicitly declared extern, a const object does not have
4070 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4072 if (TREE_CODE (decl) == VAR_DECL
4073 && TREE_CODE (type) != REFERENCE_TYPE
4074 && CP_TYPE_CONST_P (type)
4075 && !TYPE_NEEDS_CONSTRUCTING (type)
4076 && !DECL_INITIAL (decl))
4077 error ("uninitialized const `%D'", decl);
4080 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4081 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4082 initialized. If there are no more such fields, the return value
4086 next_initializable_field (tree field)
4089 && (TREE_CODE (field) != FIELD_DECL
4090 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4091 || DECL_ARTIFICIAL (field)))
4092 field = TREE_CHAIN (field);
4097 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4098 brace-enclosed aggregate initializer.
4100 *INITP is one of a list of initializers describing a brace-enclosed
4101 initializer for an entity of the indicated aggregate TYPE. It may
4102 not presently match the shape of the TYPE; for example:
4104 struct S { int a; int b; };
4105 struct S a[] = { 1, 2, 3, 4 };
4107 Here *INITP will point to TREE_LIST of four elements, rather than a
4108 list of two elements, each itself a list of two elements. This
4109 routine transforms INIT from the former form into the latter. The
4110 revised initializer is returned. */
4113 reshape_init (tree type, tree *initp)
4117 tree old_init_value;
4119 bool brace_enclosed_p;
4122 old_init_value = (TREE_CODE (*initp) == TREE_LIST
4123 ? TREE_VALUE (*initp) : old_init);
4125 my_friendly_assert (old_init_value, 20030723);
4127 /* If the initializer is brace-enclosed, pull initializers from the
4128 enclosed elements. Advance past the brace-enclosed initializer
4130 if (TREE_CODE (old_init_value) == CONSTRUCTOR
4131 && BRACE_ENCLOSED_INITIALIZER_P (old_init_value))
4133 *initp = TREE_CHAIN (old_init);
4134 TREE_CHAIN (old_init) = NULL_TREE;
4135 inits = CONSTRUCTOR_ELTS (old_init_value);
4137 brace_enclosed_p = true;
4142 brace_enclosed_p = false;
4145 /* A non-aggregate type is always initialized with a single
4147 if (!CP_AGGREGATE_TYPE_P (type))
4149 *initp = TREE_CHAIN (old_init);
4150 TREE_CHAIN (old_init) = NULL_TREE;
4151 /* It is invalid to initialize a non-aggregate type with a
4152 brace-enclosed initializer. */
4153 if (brace_enclosed_p)
4155 error ("brace-enclosed initializer used to initialize `%T'",
4157 if (TREE_CODE (old_init) == TREE_LIST)
4158 TREE_VALUE (old_init) = error_mark_node;
4160 old_init = error_mark_node;
4168 All implicit type conversions (clause _conv_) are considered when
4169 initializing the aggregate member with an initializer from an
4170 initializer-list. If the initializer can initialize a member,
4171 the member is initialized. Otherwise, if the member is itself a
4172 non-empty subaggregate, brace elision is assumed and the
4173 initializer is considered for the initialization of the first
4174 member of the subaggregate. */
4175 if (!brace_enclosed_p
4176 && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4178 *initp = TREE_CHAIN (old_init);
4179 TREE_CHAIN (old_init) = NULL_TREE;
4183 if (TREE_CODE (old_init_value) == STRING_CST
4184 && TREE_CODE (type) == ARRAY_TYPE
4185 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4187 /* [dcl.init.string]
4189 A char array (whether plain char, signed char, or unsigned char)
4190 can be initialized by a string-literal (optionally enclosed in
4191 braces); a wchar_t array can be initialized by a wide
4192 string-literal (optionally enclosed in braces). */
4193 new_init = old_init;
4194 /* Move past the initializer. */
4195 *initp = TREE_CHAIN (old_init);
4196 TREE_CHAIN (old_init) = NULL_TREE;
4200 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
4201 new_init = build_constructor (NULL_TREE, NULL_TREE);
4203 if (CLASS_TYPE_P (type))
4207 field = next_initializable_field (TYPE_FIELDS (type));
4213 An initializer for an aggregate member that is an
4214 empty class shall have the form of an empty
4215 initializer-list {}. */
4216 if (!brace_enclosed_p)
4218 error ("initializer for `%T' must be brace-enclosed",
4220 return error_mark_node;
4225 /* Loop through the initializable fields, gathering
4231 /* Handle designated initializers, as an extension. */
4232 if (TREE_PURPOSE (*initp))
4235 pedwarn ("ISO C++ does not allow designated initializers");
4236 field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4237 /*want_type=*/false);
4238 if (!field || TREE_CODE (field) != FIELD_DECL)
4239 error ("`%T' has no non-static data member named `%D'",
4240 type, TREE_PURPOSE (*initp));
4245 field_init = reshape_init (TREE_TYPE (field), initp);
4246 if (field_init == error_mark_node)
4247 return error_mark_node;
4248 TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4249 CONSTRUCTOR_ELTS (new_init) = field_init;
4252 When a union is initialized with a brace-enclosed
4253 initializer, the braces shall only contain an
4254 initializer for the first member of the union. */
4255 if (TREE_CODE (type) == UNION_TYPE)
4257 field = next_initializable_field (TREE_CHAIN (field));
4261 else if (TREE_CODE (type) == ARRAY_TYPE
4262 || TREE_CODE (type) == VECTOR_TYPE)
4267 /* If the bound of the array is known, take no more initializers
4268 than are allowed. */
4269 max_index = NULL_TREE;
4270 if (TREE_CODE (type) == ARRAY_TYPE)
4272 if (TYPE_DOMAIN (type))
4273 max_index = array_type_nelts (type);
4277 /* For a vector, the representation type is a struct
4278 containing a single member which is an array of the
4279 appropriate size. */
4280 tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4281 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4282 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4285 /* Loop through the array elements, gathering initializers. */
4286 for (index = size_zero_node;
4287 *initp && (!max_index || !tree_int_cst_lt (max_index, index));
4288 index = size_binop (PLUS_EXPR, index, size_one_node))
4292 element_init = reshape_init (TREE_TYPE (type), initp);
4293 if (element_init == error_mark_node)
4294 return error_mark_node;
4295 TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4296 CONSTRUCTOR_ELTS (new_init) = element_init;
4297 if (TREE_PURPOSE (element_init))
4299 tree next_index = TREE_PURPOSE (element_init);
4300 if (TREE_CODE (next_index) == IDENTIFIER_NODE)
4302 error ("name `%D' used in a GNU-style designated "
4303 "initializer for an array", next_index);
4304 TREE_PURPOSE (element_init) = NULL_TREE;
4314 /* The initializers were placed in reverse order in the
4316 CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4318 if (TREE_CODE (old_init) == TREE_LIST)
4319 new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4322 /* If this was a brace-enclosed initializer and all of the
4323 initializers were not used up, there is a problem. */
4324 if (brace_enclosed_p && *initp)
4325 error ("too many initializers for `%T'", type);
4330 /* Verify INIT (the initializer for DECL), and record the
4331 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4332 grok_reference_init.
4334 If the return value is non-NULL, it is an expression that must be
4335 evaluated dynamically to initialize DECL. */
4338 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4340 tree type = TREE_TYPE (decl);
4341 tree init_code = NULL;
4343 /* If `start_decl' didn't like having an initialization, ignore it now. */
4344 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4347 /* If an initializer is present, DECL_INITIAL has been
4348 error_mark_node, to indicate that an as-of-yet unevaluated
4349 initialization will occur. From now on, DECL_INITIAL reflects
4350 the static initialization -- if any -- of DECL. */
4351 DECL_INITIAL (decl) = NULL_TREE;
4353 /* Things that are going to be initialized need to have complete
4355 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4357 if (type == error_mark_node)
4358 /* We will have already complained. */
4360 else if (init && COMPLETE_TYPE_P (type)
4361 && !TREE_CONSTANT (TYPE_SIZE (type)))
4363 error ("variable-sized object `%D' may not be initialized", decl);
4366 else if (TREE_CODE (type) == ARRAY_TYPE
4367 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4369 error ("elements of array `%#D' have incomplete type", decl);
4372 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4374 error ("`%D' has incomplete type", decl);
4375 TREE_TYPE (decl) = error_mark_node;
4379 if (TREE_CODE (decl) == CONST_DECL)
4381 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
4383 DECL_INITIAL (decl) = init;
4385 my_friendly_assert (init != NULL_TREE, 149);
4388 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4389 init = grok_reference_init (decl, type, init, cleanup);
4392 if (TREE_CODE (init) == CONSTRUCTOR
4393 && BRACE_ENCLOSED_INITIALIZER_P (init))
4395 /* [dcl.init] paragraph 13,
4396 If T is a scalar type, then a declaration of the form
4401 reshape_init will complain about the extra braces,
4402 and doesn't do anything useful in the case where TYPE is
4403 scalar, so just don't call it. */
4404 if (CP_AGGREGATE_TYPE_P (type))
4405 init = reshape_init (type, &init);
4407 if ((*targetm.vector_opaque_p) (type))
4409 error ("opaque vector types cannot be initialized");
4410 init = error_mark_node;
4414 /* If DECL has an array type without a specific bound, deduce the
4415 array size from the initializer. */
4416 maybe_deduce_size_from_array_init (decl, init);
4417 type = TREE_TYPE (decl);
4419 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4421 if (TREE_CODE (type) == ARRAY_TYPE)
4422 goto initialize_aggr;
4423 else if (TREE_CODE (init) == CONSTRUCTOR
4424 && BRACE_ENCLOSED_INITIALIZER_P (init))
4426 if (TYPE_NON_AGGREGATE_CLASS (type))
4428 error ("`%D' must be initialized by constructor, not by `{...}'",
4430 init = error_mark_node;
4433 goto dont_use_constructor;
4437 int saved_stmts_are_full_exprs_p;
4440 saved_stmts_are_full_exprs_p = 0;
4441 if (building_stmt_tree ())
4443 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4444 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4446 init = build_aggr_init (decl, init, flags);
4447 if (building_stmt_tree ())
4448 current_stmt_tree ()->stmts_are_full_exprs_p =
4449 saved_stmts_are_full_exprs_p;
4455 dont_use_constructor:
4456 if (TREE_CODE (init) != TREE_VEC)
4458 init_code = store_init_value (decl, init);
4463 else if (DECL_EXTERNAL (decl))
4465 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4466 goto initialize_aggr;
4467 else if (IS_AGGR_TYPE (type))
4469 tree core_type = strip_array_types (type);
4471 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4472 error ("structure `%D' with uninitialized const members", decl);
4473 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4474 error ("structure `%D' with uninitialized reference members",
4477 check_for_uninitialized_const_var (decl);
4480 check_for_uninitialized_const_var (decl);
4482 if (init && init != error_mark_node)
4483 init_code = build (INIT_EXPR, type, decl, init);
4488 /* If DECL is not a local variable, give it RTL. */
4491 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4493 int toplev = toplevel_bindings_p ();
4496 /* Handle non-variables up front. */
4497 if (TREE_CODE (decl) != VAR_DECL)
4499 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4503 /* If we see a class member here, it should be a static data
4505 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4507 my_friendly_assert (TREE_STATIC (decl), 19990828);
4508 /* An in-class declaration of a static data member should be
4509 external; it is only a declaration, and not a definition. */
4510 if (init == NULL_TREE)
4511 my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
4514 /* Set the DECL_ASSEMBLER_NAME for the variable. */
4517 change_decl_assembler_name (decl, get_identifier (asmspec));
4518 /* The `register' keyword, when used together with an
4519 asm-specification, indicates that the variable should be
4520 placed in a particular register. */
4521 if (DECL_REGISTER (decl))
4522 DECL_HARD_REGISTER (decl) = 1;
4525 /* We don't create any RTL for local variables. */
4526 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4529 /* We defer emission of local statics until the corresponding
4530 DECL_STMT is expanded. */
4531 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4533 /* We try to defer namespace-scope static constants so that they are
4534 not emitted into the object file unnecessarily. */
4535 if (!DECL_VIRTUAL_P (decl)
4536 && TREE_READONLY (decl)
4537 && DECL_INITIAL (decl) != NULL_TREE
4538 && DECL_INITIAL (decl) != error_mark_node
4539 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4541 && !TREE_PUBLIC (decl))
4543 /* Fool with the linkage of static consts according to #pragma
4545 if (!interface_unknown && !TREE_PUBLIC (decl))
4547 TREE_PUBLIC (decl) = 1;
4548 DECL_EXTERNAL (decl) = interface_only;
4553 /* Likewise for template instantiations. */
4554 else if (DECL_COMDAT (decl))
4557 /* If we're deferring the variable, we only need to make RTL if
4558 there's an ASMSPEC. Otherwise, we'll lazily create it later when
4559 we need it. (There's no way to lazily create RTL for things that
4560 have assembly specs because the information about the specifier
4561 isn't stored in the tree, yet) */
4562 if (defer_p && asmspec)
4563 make_decl_rtl (decl, asmspec);
4564 /* If we're not deferring, go ahead and assemble the variable. */
4566 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4569 /* Generate code to initialize DECL (a local variable). */
4572 initialize_local_var (tree decl, tree init)
4574 tree type = TREE_TYPE (decl);
4577 my_friendly_assert (TREE_CODE (decl) == VAR_DECL
4578 || TREE_CODE (decl) == RESULT_DECL,
4580 my_friendly_assert (!TREE_STATIC (decl), 20021010);
4582 if (DECL_SIZE (decl) == NULL_TREE)
4584 /* If we used it already as memory, it must stay in memory. */
4585 DECL_INITIAL (decl) = NULL_TREE;
4586 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4589 if (DECL_SIZE (decl) && type != error_mark_node)
4593 /* Compute and store the initial value. */
4594 already_used = TREE_USED (decl) || TREE_USED (type);
4596 /* Perform the initialization. */
4599 int saved_stmts_are_full_exprs_p;
4601 my_friendly_assert (building_stmt_tree (), 20000906);
4602 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4603 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4604 finish_expr_stmt (init);
4605 current_stmt_tree ()->stmts_are_full_exprs_p =
4606 saved_stmts_are_full_exprs_p;
4609 /* Set this to 0 so we can tell whether an aggregate which was
4610 initialized was ever used. Don't do this if it has a
4611 destructor, so we don't complain about the 'resource
4612 allocation is initialization' idiom. Now set
4613 attribute((unused)) on types so decls of that type will be
4614 marked used. (see TREE_USED, above.) */
4615 if (TYPE_NEEDS_CONSTRUCTING (type)
4617 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4618 && DECL_NAME (decl))
4619 TREE_USED (decl) = 0;
4620 else if (already_used)
4621 TREE_USED (decl) = 1;
4624 /* Generate a cleanup, if necessary. */
4625 cleanup = cxx_maybe_build_cleanup (decl);
4626 if (DECL_SIZE (decl) && cleanup)
4627 finish_decl_cleanup (decl, cleanup);
4630 /* Finish processing of a declaration;
4631 install its line number and initial value.
4632 If the length of an array type is not known before,
4633 it must be determined now, from the initial value, or it is an error.
4635 INIT holds the value of an initializer that should be allowed to escape
4638 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4639 if the (init) syntax was used. */
4642 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4645 tree ttype = NULL_TREE;
4647 const char *asmspec = NULL;
4648 int was_readonly = 0;
4650 if (decl == error_mark_node)
4655 error ("assignment (not initialization) in declaration");
4659 my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);
4661 /* Assume no cleanup is required. */
4662 cleanup = NULL_TREE;
4664 /* If a name was specified, get the string. */
4665 if (global_scope_p (current_binding_level))
4666 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4668 asmspec = TREE_STRING_POINTER (asmspec_tree);
4670 if (init && TREE_CODE (init) == NAMESPACE_DECL)
4672 error ("cannot initialize `%D' to namespace `%D'",
4677 if (current_class_type
4678 && CP_DECL_CONTEXT (decl) == current_class_type
4679 && TYPE_BEING_DEFINED (current_class_type)
4680 && (DECL_INITIAL (decl) || init))
4681 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4683 if (TREE_CODE (decl) == VAR_DECL
4684 && DECL_CONTEXT (decl)
4685 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
4686 && DECL_CONTEXT (decl) != current_namespace
4689 /* Leave the namespace of the object. */
4690 pop_decl_namespace ();
4693 type = TREE_TYPE (decl);
4695 if (type == error_mark_node)
4698 if (TYPE_HAS_MUTABLE_P (type))
4699 TREE_READONLY (decl) = 0;
4701 if (processing_template_decl)
4703 /* Add this declaration to the statement-tree. */
4704 if (at_function_scope_p ())
4705 add_decl_stmt (decl);
4707 if (init && DECL_INITIAL (decl))
4708 DECL_INITIAL (decl) = init;
4709 if (TREE_CODE (decl) == VAR_DECL
4710 && !DECL_PRETTY_FUNCTION_P (decl)
4711 && !dependent_type_p (TREE_TYPE (decl)))
4712 maybe_deduce_size_from_array_init (decl, init);
4716 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4717 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
4719 /* Take care of TYPE_DECLs up front. */
4720 if (TREE_CODE (decl) == TYPE_DECL)
4722 if (type != error_mark_node
4723 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4725 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4726 warning ("shadowing previous type declaration of `%#D'", decl);
4727 set_identifier_type_value (DECL_NAME (decl), decl);
4730 /* If we have installed this as the canonical typedef for this
4731 type, and that type has not been defined yet, delay emitting
4732 the debug information for it, as we will emit it later. */
4733 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4734 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4735 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4737 rest_of_decl_compilation (decl, NULL,
4738 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
4742 if (TREE_CODE (decl) != FUNCTION_DECL)
4743 ttype = target_type (type);
4746 /* Currently, GNU C++ puts constants in text space, making them
4747 impossible to initialize. In the future, one would hope for
4748 an operating system which understood the difference between
4749 initialization and the running of a program. */
4750 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl))
4753 if (TYPE_NEEDS_CONSTRUCTING (type)
4754 || TREE_CODE (type) == REFERENCE_TYPE)
4755 TREE_READONLY (decl) = 0;
4758 if (TREE_CODE (decl) == VAR_DECL)
4760 /* Only PODs can have thread-local storage. Other types may require
4761 various kinds of non-trivial initialization. */
4762 if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4763 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4764 decl, TREE_TYPE (decl));
4765 /* Convert the initializer to the type of DECL, if we have not
4766 already initialized DECL. */
4767 if (!DECL_INITIALIZED_P (decl)
4768 /* If !DECL_EXTERNAL then DECL is being defined. In the
4769 case of a static data member initialized inside the
4770 class-specifier, there can be an initializer even if DECL
4771 is *not* defined. */
4772 && (!DECL_EXTERNAL (decl) || init))
4774 init = check_initializer (decl, init, flags, &cleanup);
4775 /* Thread-local storage cannot be dynamically initialized. */
4776 if (DECL_THREAD_LOCAL (decl) && init)
4778 error ("`%D' is thread-local and so cannot be dynamically "
4779 "initialized", decl);
4786 The memory occupied by any object of static storage
4787 duration is zero-initialized at program startup before
4788 any other initialization takes place.
4790 We cannot create an appropriate initializer until after
4791 the type of DECL is finalized. If DECL_INITIAL is set,
4792 then the DECL is statically initialized, and any
4793 necessary zero-initialization has already been performed. */
4794 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4795 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4796 /*nelts=*/NULL_TREE,
4797 /*static_storage_p=*/true);
4798 /* Remember that the initialization for this variable has
4800 DECL_INITIALIZED_P (decl) = 1;
4802 /* If the variable has an array type, lay out the type, even if
4803 there is no initializer. It is valid to index through the
4804 array, and we must get TYPE_ALIGN set correctly on the array
4806 else if (TREE_CODE (type) == ARRAY_TYPE)
4810 /* Add this declaration to the statement-tree. This needs to happen
4811 after the call to check_initializer so that the DECL_STMT for a
4812 reference temp is added before the DECL_STMT for the reference itself. */
4813 if (at_function_scope_p ())
4814 add_decl_stmt (decl);
4816 if (TREE_CODE (decl) == VAR_DECL)
4817 layout_var_decl (decl);
4819 /* Output the assembler code and/or RTL code for variables and functions,
4820 unless the type is an undefined structure or union.
4821 If not, it will get done when the type is completed. */
4822 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4824 if (TREE_CODE (decl) == VAR_DECL)
4825 maybe_commonize_var (decl);
4827 make_rtl_for_nonlocal_decl (decl, init, asmspec);
4829 if (TREE_CODE (type) == FUNCTION_TYPE
4830 || TREE_CODE (type) == METHOD_TYPE)
4831 abstract_virtuals_error (decl,
4832 strip_array_types (TREE_TYPE (type)));
4833 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
4835 /* If it's either a pointer or an array type, strip through all
4836 of them but the last one. If the last is an array type, issue
4837 an error if the element type is abstract. */
4838 while (POINTER_TYPE_P (TREE_TYPE (type))
4839 || TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
4840 type = TREE_TYPE (type);
4841 if (TREE_CODE (type) == ARRAY_TYPE)
4842 abstract_virtuals_error (decl, TREE_TYPE (type));
4845 abstract_virtuals_error (decl, type);
4847 if (TREE_CODE (decl) == FUNCTION_DECL
4848 || TREE_TYPE (decl) == error_mark_node)
4849 /* No initialization required. */
4851 else if (DECL_EXTERNAL (decl)
4852 && ! (DECL_LANG_SPECIFIC (decl)
4853 && DECL_NOT_REALLY_EXTERN (decl)))
4856 DECL_INITIAL (decl) = init;
4860 /* A variable definition. */
4861 if (DECL_FUNCTION_SCOPE_P (decl))
4863 /* This is a local declaration. */
4864 maybe_inject_for_scope_var (decl);
4865 /* Initialize the local variable. */
4866 if (processing_template_decl)
4868 if (init || DECL_INITIAL (decl) == error_mark_node)
4869 DECL_INITIAL (decl) = init;
4871 else if (!TREE_STATIC (decl))
4872 initialize_local_var (decl, init);
4875 if (TREE_STATIC (decl))
4876 expand_static_init (decl, init);
4880 /* Undo call to `pushclass' that was done in `start_decl'
4881 due to initialization of qualified member variable.
4882 I.e., Foo::x = 10; */
4884 tree context = CP_DECL_CONTEXT (decl);
4887 && (TREE_CODE (decl) == VAR_DECL
4888 /* We also have a pushclass done that we need to undo here
4889 if we're at top level and declare a method. */
4890 || TREE_CODE (decl) == FUNCTION_DECL)
4891 /* If size hasn't been set, we're still defining it,
4892 and therefore inside the class body; don't pop
4893 the binding level.. */
4894 && COMPLETE_TYPE_P (context)
4895 && context == current_class_type)
4896 pop_nested_class ();
4900 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4901 reference, insert it in the statement-tree now. */
4903 push_cleanup (decl, cleanup, false);
4908 TREE_READONLY (decl) = 1;
4910 /* If this was marked 'used', be sure it will be output. */
4911 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
4912 mark_decl_referenced (decl);
4915 /* This is here for a midend callback from c-common.c. */
4918 finish_decl (tree decl, tree init, tree asmspec_tree)
4920 cp_finish_decl (decl, init, asmspec_tree, 0);
4923 /* Returns a declaration for a VAR_DECL as if:
4925 extern "C" TYPE NAME;
4927 had been seen. Used to create compiler-generated global
4931 declare_global_var (tree name, tree type)
4935 push_to_top_level ();
4936 decl = build_decl (VAR_DECL, name, type);
4937 TREE_PUBLIC (decl) = 1;
4938 DECL_EXTERNAL (decl) = 1;
4939 DECL_ARTIFICIAL (decl) = 1;
4941 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
4942 pop_from_top_level ();
4947 /* Returns a pointer to the `atexit' function. Note that if
4948 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4949 `__cxa_atexit' function specified in the IA64 C++ ABI. */
4952 get_atexit_node (void)
4963 if (flag_use_cxa_atexit)
4965 /* The declaration for `__cxa_atexit' is:
4967 int __cxa_atexit (void (*)(void *), void *, void *)
4969 We build up the argument types and then then function type
4972 /* First, build the pointer-to-function type for the first
4974 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
4975 fn_type = build_function_type (void_type_node, arg_types);
4976 fn_ptr_type = build_pointer_type (fn_type);
4977 /* Then, build the rest of the argument types. */
4978 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
4979 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
4980 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
4981 /* And the final __cxa_atexit type. */
4982 fn_type = build_function_type (integer_type_node, arg_types);
4983 fn_ptr_type = build_pointer_type (fn_type);
4984 name = "__cxa_atexit";
4988 /* The declaration for `atexit' is:
4990 int atexit (void (*)());
4992 We build up the argument types and then then function type
4994 fn_type = build_function_type (void_type_node, void_list_node);
4995 fn_ptr_type = build_pointer_type (fn_type);
4996 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
4997 /* Build the final atexit type. */
4998 fn_type = build_function_type (integer_type_node, arg_types);
5002 /* Now, build the function declaration. */
5003 push_lang_context (lang_name_c);
5004 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5005 mark_used (atexit_fndecl);
5006 pop_lang_context ();
5007 atexit_node = decay_conversion (atexit_fndecl);
5012 /* Returns the __dso_handle VAR_DECL. */
5015 get_dso_handle_node (void)
5017 if (dso_handle_node)
5018 return dso_handle_node;
5020 /* Declare the variable. */
5021 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5024 return dso_handle_node;
5027 /* Begin a new function with internal linkage whose job will be simply
5028 to destroy some particular variable. */
5030 static GTY(()) int start_cleanup_cnt;
5033 start_cleanup_fn (void)
5035 int old_interface_only = interface_only;
5036 int old_interface_unknown = interface_unknown;
5042 push_to_top_level ();
5044 /* No need to mangle this. */
5045 push_lang_context (lang_name_c);
5048 interface_unknown = 1;
5050 /* Build the parameter-types. */
5051 parmtypes = void_list_node;
5052 /* Functions passed to __cxa_atexit take an additional parameter.
5053 We'll just ignore it. After we implement the new calling
5054 convention for destructors, we can eliminate the use of
5055 additional cleanup functions entirely in the -fnew-abi case. */
5056 if (flag_use_cxa_atexit)
5057 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5058 /* Build the function type itself. */
5059 fntype = build_function_type (void_type_node, parmtypes);
5060 /* Build the name of the function. */
5061 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5062 /* Build the function declaration. */
5063 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5064 /* It's a function with internal linkage, generated by the
5066 TREE_PUBLIC (fndecl) = 0;
5067 DECL_ARTIFICIAL (fndecl) = 1;
5068 /* Make the function `inline' so that it is only emitted if it is
5069 actually needed. It is unlikely that it will be inlined, since
5070 it is only called via a function pointer, but we avoid unnecessary
5071 emissions this way. */
5072 DECL_INLINE (fndecl) = 1;
5073 DECL_DECLARED_INLINE_P (fndecl) = 1;
5074 DECL_INTERFACE_KNOWN (fndecl) = 1;
5075 /* Build the parameter. */
5076 if (flag_use_cxa_atexit)
5080 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5081 DECL_CONTEXT (parmdecl) = fndecl;
5082 TREE_USED (parmdecl) = 1;
5083 DECL_ARGUMENTS (fndecl) = parmdecl;
5087 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5089 interface_unknown = old_interface_unknown;
5090 interface_only = old_interface_only;
5092 pop_lang_context ();
5094 return current_function_decl;
5097 /* Finish the cleanup function begun by start_cleanup_fn. */
5100 end_cleanup_fn (void)
5102 expand_or_defer_fn (finish_function (0));
5104 pop_from_top_level ();
5107 /* Generate code to handle the destruction of DECL, an object with
5108 static storage duration. */
5111 register_dtor_fn (tree decl)
5118 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5121 /* Call build_cleanup before we enter the anonymous function so that
5122 any access checks will be done relative to the current scope,
5123 rather than the scope of the anonymous function. */
5124 build_cleanup (decl);
5126 /* Now start the function. */
5127 cleanup = start_cleanup_fn ();
5129 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5130 to the original function, rather than the anonymous one. That
5131 will make the back-end think that nested functions are in use,
5132 which causes confusion. */
5134 push_deferring_access_checks (dk_no_check);
5135 fcall = build_cleanup (decl);
5136 pop_deferring_access_checks ();
5138 /* Create the body of the anonymous function. */
5139 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5140 finish_expr_stmt (fcall);
5141 finish_compound_stmt (compound_stmt);
5144 /* Call atexit with the cleanup function. */
5145 cxx_mark_addressable (cleanup);
5146 mark_used (cleanup);
5147 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5148 if (flag_use_cxa_atexit)
5150 args = tree_cons (NULL_TREE,
5151 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5153 args = tree_cons (NULL_TREE, null_pointer_node, args);
5154 args = tree_cons (NULL_TREE, cleanup, args);
5157 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5158 finish_expr_stmt (build_function_call (get_atexit_node (), args));
5161 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5162 is its initializer. Generate code to handle the construction
5163 and destruction of DECL. */
5166 expand_static_init (tree decl, tree init)
5168 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
5169 my_friendly_assert (TREE_STATIC (decl), 20021010);
5171 /* Some variables require no initialization. */
5173 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5174 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5177 if (! toplevel_bindings_p ())
5179 /* Emit code to perform this initialization but once. */
5186 /* Emit code to perform this initialization but once. This code
5189 static int guard = 0;
5191 // Do initialization.
5193 // Register variable for destruction at end of program.
5196 Note that the `temp' variable is only set to 1 *after* the
5197 initialization is complete. This ensures that an exception,
5198 thrown during the construction, will cause the variable to
5199 reinitialized when we pass through this code again, as per:
5203 If the initialization exits by throwing an exception, the
5204 initialization is not complete, so it will be tried again
5205 the next time control enters the declaration.
5207 In theory, this process should be thread-safe, too; multiple
5208 threads should not be able to initialize the variable more
5209 than once. We don't yet attempt to ensure thread-safety. */
5211 /* Create the guard variable. */
5212 guard = get_guard (decl);
5214 /* Begin the conditional initialization. */
5215 if_stmt = begin_if_stmt ();
5216 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5217 then_clause = begin_compound_stmt (0);
5219 /* Do the initialization itself. */
5220 assignment = init ? init : NULL_TREE;
5222 /* Once the assignment is complete, set TEMP to 1. Since the
5223 construction of the static object is complete at this point,
5224 we want to make sure TEMP is set to 1 even if a temporary
5225 constructed during the initialization throws an exception
5226 when it is destroyed. So, we combine the initialization and
5227 the assignment to TEMP into a single expression, ensuring
5228 that when we call finish_expr_stmt the cleanups will not be
5229 run until after TEMP is set to 1. */
5230 guard_init = set_guard (guard);
5232 assignment = build_compound_expr (assignment, guard_init);
5234 assignment = guard_init;
5235 finish_expr_stmt (assignment);
5237 /* Use atexit to register a function for destroying this static
5239 register_dtor_fn (decl);
5241 finish_compound_stmt (then_clause);
5242 finish_then_clause (if_stmt);
5243 finish_if_stmt (if_stmt);
5246 static_aggregates = tree_cons (init, decl, static_aggregates);
5250 /* Make TYPE a complete type based on INITIAL_VALUE.
5251 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5252 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
5255 complete_array_type (tree type, tree initial_value, int do_default)
5257 tree maxindex = NULL_TREE;
5262 /* An array of character type can be initialized from a
5263 brace-enclosed string constant. */
5264 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
5265 && TREE_CODE (initial_value) == CONSTRUCTOR
5266 && CONSTRUCTOR_ELTS (initial_value)
5267 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
5269 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
5270 initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
5272 /* Note MAXINDEX is really the maximum index, one less than the
5274 if (TREE_CODE (initial_value) == STRING_CST)
5277 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5278 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
5281 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5283 tree elts = CONSTRUCTOR_ELTS (initial_value);
5285 maxindex = ssize_int (-1);
5286 for (; elts; elts = TREE_CHAIN (elts))
5288 if (TREE_PURPOSE (elts))
5289 maxindex = TREE_PURPOSE (elts);
5291 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
5293 maxindex = copy_node (maxindex);
5297 /* Make an error message unless that happened already. */
5298 if (initial_value != error_mark_node)
5301 initial_value = NULL_TREE;
5303 /* Prevent further error messages. */
5304 maxindex = build_int_2 (0, 0);
5311 maxindex = build_int_2 (0, 0);
5321 domain = build_index_type (maxindex);
5322 TYPE_DOMAIN (type) = domain;
5324 if (! TREE_TYPE (maxindex))
5325 TREE_TYPE (maxindex) = domain;
5327 itype = TREE_TYPE (initial_value);
5330 if (itype && !TYPE_DOMAIN (itype))
5331 TYPE_DOMAIN (itype) = domain;
5332 /* The type of the main variant should never be used for arrays
5333 of different sizes. It should only ever be completed with the
5334 size of the array. */
5335 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
5336 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
5338 elt_type = TREE_TYPE (type);
5339 TYPE_NEEDS_CONSTRUCTING (type)
5340 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
5341 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5342 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
5345 /* Lay out the type now that we can get the real answer. */
5352 /* Return zero if something is declared to be a member of type
5353 CTYPE when in the context of CUR_TYPE. STRING is the error
5354 message to print in that case. Otherwise, quietly return 1. */
5357 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5359 if (ctype && ctype != cur_type)
5361 if (flags == DTOR_FLAG)
5362 error ("destructor for alien class `%T' cannot be a member",
5365 error ("constructor for alien class `%T' cannot be a member",
5372 /* Subroutine of `grokdeclarator'. */
5374 /* Generate errors possibly applicable for a given set of specifiers.
5375 This is for ARM $7.1.2. */
5378 bad_specifiers (tree object,
5387 error ("`%D' declared as a `virtual' %s", object, type);
5389 error ("`%D' declared as an `inline' %s", object, type);
5391 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5394 cp_error_at ("`%D' declared as a friend", object);
5396 && (TREE_CODE (object) == TYPE_DECL
5397 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5398 && !TYPE_REFFN_P (TREE_TYPE (object))
5399 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5400 cp_error_at ("`%D' declared with an exception specification", object);
5403 /* CTYPE is class type, or null if non-class.
5404 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5406 DECLARATOR is the function's name.
5407 PARMS is a chain of PARM_DECLs for the function.
5408 VIRTUALP is truthvalue of whether the function is virtual or not.
5409 FLAGS are to be passed through to `grokclassfn'.
5410 QUALS are qualifiers indicating whether the function is `const'
5412 RAISES is a list of exceptions that this function can raise.
5413 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5414 not look, and -1 if we should not call `grokclassfn' at all.
5416 Returns `NULL_TREE' if something goes wrong, after issuing
5417 applicable error messages. */
5420 grokfndecl (tree ctype,
5424 tree orig_declarator,
5426 enum overload_flags flags,
5438 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5439 int has_default_arg = 0;
5443 type = build_exception_variant (type, raises);
5445 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5446 DECL_ARGUMENTS (decl) = parms;
5447 /* Propagate volatile out from type to decl. */
5448 if (TYPE_VOLATILE (type))
5449 TREE_THIS_VOLATILE (decl) = 1;
5451 /* If this decl has namespace scope, set that up. */
5453 set_decl_namespace (decl, in_namespace, friendp);
5455 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5457 /* `main' and builtins have implicit 'C' linkage. */
5458 if ((MAIN_NAME_P (declarator)
5459 || (IDENTIFIER_LENGTH (declarator) > 10
5460 && IDENTIFIER_POINTER (declarator)[0] == '_'
5461 && IDENTIFIER_POINTER (declarator)[1] == '_'
5462 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5463 && current_lang_name == lang_name_cplusplus
5464 && ctype == NULL_TREE
5465 /* NULL_TREE means global namespace. */
5466 && DECL_CONTEXT (decl) == NULL_TREE)
5467 SET_DECL_LANGUAGE (decl, lang_c);
5469 /* Should probably propagate const out from type to decl I bet (mrs). */
5472 DECL_STATIC_FUNCTION_P (decl) = 1;
5473 DECL_CONTEXT (decl) = ctype;
5477 DECL_CONTEXT (decl) = ctype;
5479 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5481 if (processing_template_decl)
5482 error ("cannot declare `::main' to be a template");
5484 error ("cannot declare `::main' to be inline");
5486 error ("cannot declare `::main' to be static");
5487 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5489 error ("`main' must return `int'");
5494 /* Members of anonymous types and local classes have no linkage; make
5495 them internal. If a typedef is made later, this will be changed. */
5496 if (ctype && (TYPE_ANONYMOUS_P (ctype)
5497 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5502 /* [basic.link]: A name with no linkage (notably, the name of a class
5503 or enumeration declared in a local scope) shall not be used to
5504 declare an entity with linkage.
5506 Only check this for public decls for now. See core 319, 389. */
5507 t = no_linkage_check (TREE_TYPE (decl));
5510 if (TYPE_ANONYMOUS_P (t))
5512 if (DECL_EXTERN_C_P (decl))
5513 /* Allow this; it's pretty common in C. */;
5516 pedwarn ("non-local function `%#D' uses anonymous type",
5518 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5520 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5525 pedwarn ("non-local function `%#D' uses local type `%T'",
5530 TREE_PUBLIC (decl) = publicp;
5533 DECL_INTERFACE_KNOWN (decl) = 1;
5534 DECL_NOT_REALLY_EXTERN (decl) = 1;
5537 /* If the declaration was declared inline, mark it as such. */
5539 DECL_DECLARED_INLINE_P (decl) = 1;
5540 /* We inline functions that are explicitly declared inline, or, when
5541 the user explicitly asks us to, all functions. */
5542 if (DECL_DECLARED_INLINE_P (decl)
5543 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5544 DECL_INLINE (decl) = 1;
5546 DECL_EXTERNAL (decl) = 1;
5547 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
5549 error ("%smember function `%D' cannot have `%T' method qualifier",
5550 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
5554 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5555 grok_op_properties (decl, friendp, /*complain=*/true);
5557 if (ctype && decl_function_context (decl))
5558 DECL_NO_STATIC_CHAIN (decl) = 1;
5560 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5561 if (TREE_PURPOSE (t)
5562 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5564 has_default_arg = 1;
5569 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5573 ("defining explicit specialization `%D' in friend declaration",
5577 tree fns = TREE_OPERAND (orig_declarator, 0);
5578 tree args = TREE_OPERAND (orig_declarator, 1);
5580 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5582 /* Something like `template <class T> friend void f<T>()'. */
5583 error ("invalid use of template-id `%D' in declaration of primary template",
5589 /* A friend declaration of the form friend void f<>(). Record
5590 the information in the TEMPLATE_ID_EXPR. */
5591 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5593 if (TREE_CODE (fns) == COMPONENT_REF)
5595 /* Due to bison parser ickiness, we will have already looked
5596 up an operator_name or PFUNCNAME within the current class
5597 (see template_id in parse.y). If the current class contains
5598 such a name, we'll get a COMPONENT_REF here. Undo that. */
5600 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5601 == current_class_type, 20001120);
5602 fns = TREE_OPERAND (fns, 1);
5604 my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5605 || TREE_CODE (fns) == OVERLOAD, 20001120);
5606 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5608 if (has_default_arg)
5610 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
5617 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
5625 /* Make the init_value nonzero so pushdecl knows this is not
5626 tentative. error_mark_node is replaced later with the BLOCK. */
5627 DECL_INITIAL (decl) = error_mark_node;
5629 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5630 TREE_NOTHROW (decl) = 1;
5632 /* Caller will do the rest of this. */
5636 if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
5637 DECL_CONSTRUCTOR_P (decl) = 1;
5639 /* Function gets the ugly name, field gets the nice one. This call
5640 may change the type of the function (because of default
5642 if (ctype != NULL_TREE)
5643 grokclassfn (ctype, decl, flags, quals);
5645 decl = check_explicit_specialization (orig_declarator, decl,
5647 2 * (funcdef_flag != 0) +
5648 4 * (friendp != 0));
5649 if (decl == error_mark_node)
5652 if (ctype != NULL_TREE
5653 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5658 old_decl = check_classfn (ctype, decl,
5659 (processing_template_decl
5660 > template_class_depth (ctype))
5661 ? current_template_parms
5664 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5665 /* Because grokfndecl is always supposed to return a
5666 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5667 here. We depend on our callers to figure out that its
5668 really a template that's being returned. */
5669 old_decl = DECL_TEMPLATE_RESULT (old_decl);
5671 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5672 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5673 /* Remove the `this' parm added by grokclassfn.
5674 XXX Isn't this done in start_function, too? */
5675 revert_static_member_fn (decl);
5676 if (old_decl && DECL_ARTIFICIAL (old_decl))
5677 error ("definition of implicitly-declared `%D'", old_decl);
5684 /* Since we've smashed OLD_DECL to its
5685 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
5686 if (TREE_CODE (decl) == TEMPLATE_DECL)
5687 decl = DECL_TEMPLATE_RESULT (decl);
5689 /* Attempt to merge the declarations. This can fail, in
5690 the case of some invalid specialization declarations. */
5691 pop_p = push_scope (ctype);
5692 ok = duplicate_decls (decl, old_decl);
5697 error ("no `%#D' member function declared in class `%T'",
5705 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
5708 if (ctype == NULL_TREE || check)
5712 DECL_VIRTUAL_P (decl) = 1;
5717 /* Create a VAR_DECL named NAME with the indicated TYPE.
5719 If SCOPE is non-NULL, it is the class type or namespace containing
5720 the variable. If SCOPE is NULL, the variable should is created in
5721 the innermost enclosings scope. */
5724 grokvardecl (tree type,
5726 cp_decl_specifier_seq *declspecs,
5733 my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
5736 /* Compute the scope in which to place the variable. */
5739 /* An explicit "extern" specifier indicates a namespace-scope
5741 if (declspecs->storage_class == sc_extern)
5742 scope = current_namespace;
5743 else if (!at_function_scope_p ())
5745 scope = current_scope ();
5747 scope = current_namespace;
5752 && (/* If the variable is a namespace-scope variable declared in a
5753 template, we need DECL_LANG_SPECIFIC. */
5754 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
5755 /* Similarly for namespace-scope variables with language linkage
5757 || (TREE_CODE (scope) == NAMESPACE_DECL
5758 && current_lang_name != lang_name_cplusplus)
5759 /* Similarly for static data members. */
5761 decl = build_lang_decl (VAR_DECL, name, type);
5763 decl = build_decl (VAR_DECL, name, type);
5765 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
5766 set_decl_namespace (decl, scope, 0);
5768 DECL_CONTEXT (decl) = scope;
5770 if (declspecs->storage_class == sc_extern)
5772 DECL_THIS_EXTERN (decl) = 1;
5773 DECL_EXTERNAL (decl) = !initialized;
5776 /* In class context, static means one per class,
5777 public access, and static storage. */
5778 if (DECL_CLASS_SCOPE_P (decl))
5780 TREE_PUBLIC (decl) = 1;
5781 TREE_STATIC (decl) = 1;
5782 DECL_EXTERNAL (decl) = 0;
5784 /* At top level, either `static' or no s.c. makes a definition
5785 (perhaps tentative), and absence of `static' makes it public. */
5786 else if (toplevel_bindings_p ())
5788 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
5789 && (DECL_THIS_EXTERN (decl) || ! constp));
5790 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5792 /* Not at top level, only `static' makes a static definition. */
5795 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
5796 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5799 if (declspecs->specs[(int)ds_thread])
5801 if (targetm.have_tls)
5802 DECL_THREAD_LOCAL (decl) = 1;
5804 /* A mere warning is sure to result in improper semantics
5805 at runtime. Don't bother to allow this to compile. */
5806 error ("thread-local storage not supported for this target");
5809 if (TREE_PUBLIC (decl))
5811 /* [basic.link]: A name with no linkage (notably, the name of a class
5812 or enumeration declared in a local scope) shall not be used to
5813 declare an entity with linkage.
5815 Only check this for public decls for now. */
5816 tree t = no_linkage_check (TREE_TYPE (decl));
5819 if (TYPE_ANONYMOUS_P (t))
5821 if (DECL_EXTERN_C_P (decl))
5822 /* Allow this; it's pretty common in C. */;
5825 pedwarn ("non-local variable `%#D' uses anonymous type",
5827 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5829 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5834 pedwarn ("non-local variable `%#D' uses local type `%T'",
5842 /* Create and return a canonical pointer to member function type, for
5843 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
5846 build_ptrmemfunc_type (tree type)
5850 tree unqualified_variant = NULL_TREE;
5852 if (type == error_mark_node)
5855 /* If a canonical type already exists for this type, use it. We use
5856 this method instead of type_hash_canon, because it only does a
5857 simple equality check on the list of field members. */
5859 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
5862 /* Make sure that we always have the unqualified pointer-to-member
5864 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5866 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
5868 t = make_aggr_type (RECORD_TYPE);
5869 /* Let the front-end know this is a pointer to member function... */
5870 TYPE_PTRMEMFUNC_FLAG (t) = 1;
5871 /* ... and not really an aggregate. */
5872 SET_IS_AGGR_TYPE (t, 0);
5874 field = build_decl (FIELD_DECL, pfn_identifier, type);
5877 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
5878 TREE_CHAIN (field) = fields;
5881 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
5883 /* Zap out the name so that the back-end will give us the debugging
5884 information for this anonymous RECORD_TYPE. */
5885 TYPE_NAME (t) = NULL_TREE;
5887 /* If this is not the unqualified form of this pointer-to-member
5888 type, set the TYPE_MAIN_VARIANT for this type to be the
5889 unqualified type. Since they are actually RECORD_TYPEs that are
5890 not variants of each other, we must do this manually. */
5891 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5893 t = build_qualified_type (t, cp_type_quals (type));
5894 TYPE_MAIN_VARIANT (t) = unqualified_variant;
5895 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
5896 TYPE_NEXT_VARIANT (unqualified_variant) = t;
5899 /* Cache this pointer-to-member type so that we can find it again
5901 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
5906 /* Create and return a pointer to data member type. */
5909 build_ptrmem_type (tree class_type, tree member_type)
5911 if (TREE_CODE (member_type) == METHOD_TYPE)
5915 arg_types = TYPE_ARG_TYPES (member_type);
5916 class_type = (cp_build_qualified_type
5918 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
5920 = build_method_type_directly (class_type,
5921 TREE_TYPE (member_type),
5922 TREE_CHAIN (arg_types));
5923 return build_ptrmemfunc_type (build_pointer_type (member_type));
5927 my_friendly_assert (TREE_CODE (member_type) != FUNCTION_TYPE,
5929 return build_offset_type (class_type, member_type);
5933 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5934 Check to see that the definition is valid. Issue appropriate error
5935 messages. Return 1 if the definition is particularly bad, or 0
5939 check_static_variable_definition (tree decl, tree type)
5941 /* Motion 10 at San Diego: If a static const integral data member is
5942 initialized with an integral constant expression, the initializer
5943 may appear either in the declaration (within the class), or in
5944 the definition, but not both. If it appears in the class, the
5945 member is a member constant. The file-scope definition is always
5947 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
5949 error ("invalid in-class initialization of static data member of non-integral type `%T'",
5951 /* If we just return the declaration, crashes will sometimes
5952 occur. We therefore return void_type_node, as if this were a
5953 friend declaration, to cause callers to completely ignore
5954 this declaration. */
5957 else if (!CP_TYPE_CONST_P (type))
5958 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
5960 else if (pedantic && !INTEGRAL_TYPE_P (type))
5961 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
5966 /* Given the SIZE (i.e., number of elements) in an array, compute an
5967 appropriate index type for the array. If non-NULL, NAME is the
5968 name of the thing being declared. */
5971 compute_array_index_type (tree name, tree size)
5973 tree type = TREE_TYPE (size);
5976 /* The array bound must be an integer type. */
5977 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
5980 error ("size of array `%D' has non-integral type `%T'", name, type);
5982 error ("size of array has non-integral type `%T'", type);
5983 size = integer_one_node;
5984 type = TREE_TYPE (size);
5987 if (abi_version_at_least (2)
5988 /* We should only handle value dependent expressions specially. */
5989 ? value_dependent_expression_p (size)
5990 /* But for abi-1, we handled all instances in templates. This
5991 effects the manglings produced. */
5992 : processing_template_decl)
5993 return build_index_type (build_min (MINUS_EXPR, sizetype,
5994 size, integer_one_node));
5996 /* The size might be the result of a cast. */
5997 STRIP_TYPE_NOPS (size);
5999 /* It might be a const variable or enumeration constant. */
6000 size = decl_constant_value (size);
6002 /* Normally, the array-bound will be a constant. */
6003 if (TREE_CODE (size) == INTEGER_CST)
6005 /* Check to see if the array bound overflowed. Make that an
6006 error, no matter how generous we're being. */
6007 int old_flag_pedantic_errors = flag_pedantic_errors;
6008 int old_pedantic = pedantic;
6009 pedantic = flag_pedantic_errors = 1;
6010 constant_expression_warning (size);
6011 pedantic = old_pedantic;
6012 flag_pedantic_errors = old_flag_pedantic_errors;
6014 /* An array must have a positive number of elements. */
6015 if (INT_CST_LT (size, integer_zero_node))
6018 error ("size of array `%D' is negative", name);
6020 error ("size of array is negative");
6021 size = integer_one_node;
6023 /* As an extension we allow zero-sized arrays. We always allow
6024 them in system headers because glibc uses them. */
6025 else if (integer_zerop (size) && pedantic && !in_system_header)
6028 pedwarn ("ISO C++ forbids zero-size array `%D'", name);
6030 pedwarn ("ISO C++ forbids zero-size array");
6033 else if (TREE_CONSTANT (size))
6035 /* `(int) &fn' is not a valid array bound. */
6037 error ("size of array `%D' is not an integral constant-expression",
6040 error ("size of array is not an integral constant-expression");
6045 pedwarn ("ISO C++ forbids variable-size array `%D'", name);
6047 pedwarn ("ISO C++ forbids variable-size array");
6050 if (processing_template_decl && !TREE_CONSTANT (size))
6051 /* A variable sized array. */
6052 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6055 /* Compute the index of the largest element in the array. It is
6056 one less than the number of elements in the array. */
6058 = fold (cp_build_binary_op (MINUS_EXPR,
6059 cp_convert (ssizetype, size),
6060 cp_convert (ssizetype, integer_one_node)));
6061 if (!TREE_CONSTANT (itype))
6062 /* A variable sized array. */
6063 itype = variable_size (itype);
6064 /* Make sure that there was no overflow when creating to a signed
6065 index type. (For example, on a 32-bit machine, an array with
6066 size 2^32 - 1 is too big.) */
6067 else if (TREE_OVERFLOW (itype))
6069 error ("overflow in array dimension");
6070 TREE_OVERFLOW (itype) = 0;
6074 /* Create and return the appropriate index type. */
6075 return build_index_type (itype);
6078 /* Returns the scope (if any) in which the entity declared by
6079 DECLARATOR will be located. If the entity was declared with an
6080 unqualified name, NULL_TREE is returned. */
6083 get_scope_of_declarator (const cp_declarator *declarator)
6085 while (declarator && declarator->kind != cdk_id)
6086 declarator = declarator->declarator;
6088 /* If the declarator-id is a SCOPE_REF, the scope in which the
6089 declaration occurs is the first operand. */
6091 && declarator->u.id.name
6092 && TREE_CODE (declarator->u.id.name) == SCOPE_REF)
6093 return TREE_OPERAND (declarator->u.id.name, 0);
6095 /* Otherwise, the declarator is not a quablified name; the entity will
6096 be declared in the current scope. */
6100 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6101 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6105 create_array_type_for_decl (tree name, tree type, tree size)
6107 tree itype = NULL_TREE;
6108 const char* error_msg;
6110 /* If things have already gone awry, bail now. */
6111 if (type == error_mark_node || size == error_mark_node)
6112 return error_mark_node;
6114 /* Assume that everything will go OK. */
6117 /* There are some types which cannot be array elements. */
6118 switch (TREE_CODE (type))
6121 error_msg = "array of void";
6125 error_msg = "array of functions";
6128 case REFERENCE_TYPE:
6129 error_msg = "array of references";
6133 error_msg = "array of function members";
6140 /* If something went wrong, issue an error-message and return. */
6144 error ("declaration of `%D' as %s", name, error_msg);
6146 error ("creating %s", error_msg);
6148 return error_mark_node;
6153 The constant expressions that specify the bounds of the arrays
6154 can be omitted only for the first member of the sequence. */
6155 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6158 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
6161 error ("multidimensional array must have bounds for all dimensions except the first");
6163 return error_mark_node;
6166 /* Figure out the index type for the array. */
6168 itype = compute_array_index_type (name, size);
6170 return build_cplus_array_type (type, itype);
6173 /* Check that it's OK to declare a function with the indicated TYPE.
6174 SFK indicates the kind of special function (if any) that this
6175 function is. OPTYPE is the type given in a conversion operator
6176 declaration. Returns the actual return type of the function; that
6177 may be different than TYPE if an error occurs, or for certain
6178 special functions. */
6181 check_special_function_return_type (special_function_kind sfk,
6187 case sfk_constructor:
6189 error ("return type specification for constructor invalid");
6191 type = void_type_node;
6194 case sfk_destructor:
6196 error ("return type specification for destructor invalid");
6197 type = void_type_node;
6200 case sfk_conversion:
6201 if (type && !same_type_p (type, optype))
6202 error ("operator `%T' declared to return `%T'", optype, type);
6204 pedwarn ("return type specified for `operator %T'", optype);
6216 /* Given declspecs and a declarator (abstract or otherwise), determine
6217 the name and type of the object declared and construct a DECL node
6220 DECLSPECS is a chain of tree_list nodes whose value fields
6221 are the storage classes and type specifiers.
6223 DECL_CONTEXT says which syntactic context this declaration is in:
6224 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6225 FUNCDEF for a function definition. Like NORMAL but a few different
6226 error messages in each case. Return value may be zero meaning
6227 this definition is too screwy to try to parse.
6228 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6229 handle member functions (which have FIELD context).
6230 Return value may be zero meaning this definition is too screwy to
6232 PARM for a parameter declaration (either within a function prototype
6233 or before a function body). Make a PARM_DECL, or return void_type_node.
6234 CATCHPARM for a parameter declaration before a catch clause.
6235 TYPENAME if for a typename (in a cast or sizeof).
6236 Don't make a DECL node; just return the ..._TYPE node.
6237 FIELD for a struct or union field; make a FIELD_DECL.
6238 BITFIELD for a field with specified width.
6239 INITIALIZED is 1 if the decl has an initializer.
6241 ATTRLIST is a pointer to the list of attributes, which may be NULL
6242 if there are none; *ATTRLIST may be modified if attributes from inside
6243 the declarator should be applied to the declaration.
6245 When this function is called, scoping variables (such as
6246 CURRENT_CLASS_TYPE) should reflect the scope in which the
6247 declaration occurs, not the scope in which the new declaration will
6248 be placed. For example, on:
6252 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6253 should not be `S'. */
6256 grokdeclarator (const cp_declarator *declarator,
6257 cp_decl_specifier_seq *declspecs,
6258 enum decl_context decl_context,
6262 tree type = NULL_TREE;
6265 int virtualp, explicitp, friendp, inlinep, staticp;
6266 int explicit_int = 0;
6267 int explicit_char = 0;
6268 int defaulted_int = 0;
6269 tree dependant_name = NULL_TREE;
6271 tree typedef_decl = NULL_TREE;
6272 const char *name = NULL;
6273 tree typedef_type = NULL_TREE;
6274 int funcdef_flag = 0;
6275 cp_declarator_kind innermost_code = cdk_error;
6278 /* See the code below that used this. */
6279 tree decl_attr = NULL_TREE;
6282 /* Keep track of what sort of function is being processed
6283 so that we can warn about default return values, or explicit
6284 return values which do not match prescribed defaults. */
6285 special_function_kind sfk = sfk_none;
6287 tree dname = NULL_TREE;
6288 tree ctor_return_type = NULL_TREE;
6289 enum overload_flags flags = NO_SPECIAL;
6290 tree quals = NULL_TREE;
6291 tree raises = NULL_TREE;
6292 int template_count = 0;
6293 tree returned_attrs = NULL_TREE;
6294 tree parms = NULL_TREE;
6295 const cp_declarator *id_declarator;
6296 /* The unqualified name of the declarator; either an
6297 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6298 tree unqualified_id;
6299 /* The class type, if any, in which this entity is located,
6300 or NULL_TREE if none. Note that this value may be different from
6301 the current class type; for example if an attempt is made to declare
6302 "A::f" inside "B", this value will be "A". */
6303 tree ctype = current_class_type;
6304 /* The NAMESPACE_DECL for the namespace in which this entity is
6305 located. If an unqualified name is used to declare the entity,
6306 this value will be NULL_TREE, even if the entity is located at
6308 tree in_namespace = NULL_TREE;
6311 if (decl_context == FUNCDEF)
6312 funcdef_flag = 1, decl_context = NORMAL;
6313 else if (decl_context == MEMFUNCDEF)
6314 funcdef_flag = -1, decl_context = FIELD;
6315 else if (decl_context == BITFIELD)
6316 bitfield = 1, decl_context = FIELD;
6318 /* Look inside a declarator for the name being declared
6319 and get it as a string, for an error message. */
6320 for (id_declarator = declarator;
6322 id_declarator = id_declarator->declarator)
6324 if (id_declarator->kind != cdk_id)
6325 innermost_code = id_declarator->kind;
6327 switch (id_declarator->kind)
6330 if (id_declarator->declarator
6331 && id_declarator->declarator->kind == cdk_id)
6333 sfk = id_declarator->declarator->u.id.sfk;
6334 if (sfk == sfk_destructor)
6341 tree decl = id_declarator->u.id.name;
6344 if (TREE_CODE (decl) == SCOPE_REF)
6346 tree qualifying_scope = TREE_OPERAND (decl, 0);
6348 /* It is valid to write:
6350 class C { void f(); };
6354 The standard is not clear about whether `typedef const C D' is
6355 legal; as of 2002-09-15 the committee is considering
6356 that question. EDG 3.0 allows that syntax.
6357 Therefore, we do as well. */
6358 if (qualifying_scope && TYPE_P (qualifying_scope))
6360 ctype = TYPE_MAIN_VARIANT (qualifying_scope);
6361 if (innermost_code != cdk_function
6362 && current_class_type
6363 && !UNIQUELY_DERIVED_FROM_P (ctype,
6364 current_class_type))
6366 error ("type `%T' is not derived from type `%T'",
6367 ctype, current_class_type);
6370 TREE_OPERAND (decl, 0) = ctype;
6372 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6373 in_namespace = qualifying_scope;
6374 decl = TREE_OPERAND (decl, 1);
6376 if (TREE_CODE (decl) == BASELINK)
6377 decl = BASELINK_FUNCTIONS (decl);
6378 switch (TREE_CODE (decl))
6382 tree type = TREE_OPERAND (decl, 0);
6383 type = constructor_name (type);
6384 name = IDENTIFIER_POINTER (type);
6388 case TEMPLATE_ID_EXPR:
6390 tree fns = TREE_OPERAND (decl, 0);
6393 if (TREE_CODE (dname) == COMPONENT_REF)
6394 dname = TREE_OPERAND (dname, 1);
6395 if (TREE_CODE (dname) != IDENTIFIER_NODE)
6397 my_friendly_assert (is_overloaded_fn (dname),
6399 dname = DECL_NAME (get_first_fn (dname));
6404 case IDENTIFIER_NODE:
6405 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6408 if (C_IS_RESERVED_WORD (dname))
6410 error ("declarator-id missing; using reserved word `%D'",
6412 name = IDENTIFIER_POINTER (dname);
6414 else if (!IDENTIFIER_TYPENAME_P (dname))
6415 name = IDENTIFIER_POINTER (dname);
6418 my_friendly_assert (flags == NO_SPECIAL, 154);
6419 flags = TYPENAME_FLAG;
6420 ctor_return_type = TREE_TYPE (dname);
6421 sfk = sfk_conversion;
6422 if (is_typename_at_global_scope (dname))
6423 name = IDENTIFIER_POINTER (dname);
6425 name = "<invalid operator>";
6430 dname = constructor_name (TREE_TYPE (decl));
6431 name = IDENTIFIER_POINTER (dname);
6452 if (id_declarator->kind == cdk_id)
6456 /* A function definition's declarator must have the form of
6457 a function declarator. */
6459 if (funcdef_flag && innermost_code != cdk_function)
6462 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6463 && innermost_code != cdk_function
6464 && ! (ctype && !declspecs->any_specifiers_p))
6466 error ("declaration of `%D' as non-function", dname);
6467 return void_type_node;
6470 /* Anything declared one level down from the top level
6471 must be one of the parameters of a function
6472 (because the body is at least two levels down). */
6474 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6475 by not allowing C++ class definitions to specify their parameters
6476 with xdecls (must be spec.d in the parmlist).
6478 Since we now wait to push a class scope until we are sure that
6479 we are in a legitimate method context, we must set oldcname
6480 explicitly (since current_class_name is not yet alive).
6482 We also want to avoid calling this a PARM if it is in a namespace. */
6484 if (decl_context == NORMAL && !toplevel_bindings_p ())
6486 struct cp_binding_level *b = current_binding_level;
6487 current_binding_level = b->level_chain;
6488 if (current_binding_level != 0 && toplevel_bindings_p ())
6489 decl_context = PARM;
6490 current_binding_level = b;
6494 name = decl_context == PARM ? "parameter" : "type name";
6496 /* If there were multiple types specified in the decl-specifier-seq,
6497 issue an error message. */
6498 if (declspecs->multiple_types_p)
6499 error ("two or more data types in declaration of `%s'", name);
6500 /* Extract the basic type from the decl-specifier-seq. */
6501 type = declspecs->type;
6502 if (type == error_mark_node)
6504 /* If the entire declaration is itself tagged as deprecated then
6505 suppress reports of deprecated items. */
6506 if (type && TREE_DEPRECATED (type)
6507 && deprecated_state != DEPRECATED_SUPPRESS)
6508 warn_deprecated_use (type);
6509 if (type && TREE_CODE (type) == TYPE_DECL)
6511 typedef_decl = type;
6512 type = TREE_TYPE (typedef_decl);
6514 /* No type at all: default to `int', and set DEFAULTED_INT
6515 because it was not a user-defined typedef. */
6516 if (type == NULL_TREE
6517 && (declspecs->specs[(int)ds_signed]
6518 || declspecs->specs[(int)ds_unsigned]
6519 || declspecs->specs[(int)ds_long]
6520 || declspecs->specs[(int)ds_short]))
6522 /* These imply 'int'. */
6523 type = integer_type_node;
6527 explicit_int = declspecs->explicit_int_p;
6528 explicit_char = declspecs->explicit_char_p;
6530 /* Check for repeated decl-specifiers. */
6531 for (ds = ds_first; ds != ds_last; ++ds)
6533 unsigned count = declspecs->specs[(int)ds];
6536 /* The "long" specifier is a special case because of
6541 error ("`long long long' is too long for GCC");
6542 else if (pedantic && !in_system_header && warn_long_long)
6543 pedwarn ("ISO C++ does not support `long long'");
6547 else if (declspecs->specs[(int)ds] > 1)
6548 error ("duplicate decl-specifier");
6552 /* See the code below that used this. */
6554 decl_attr = DECL_ATTRIBUTES (typedef_decl);
6556 typedef_type = type;
6559 if (sfk != sfk_none)
6560 type = check_special_function_return_type (sfk, type,
6562 else if (type == NULL_TREE)
6568 /* We handle `main' specially here, because 'main () { }' is so
6569 common. With no options, it is allowed. With -Wreturn-type,
6570 it is a warning. It is only an error with -pedantic-errors. */
6571 is_main = (funcdef_flag
6572 && dname && MAIN_NAME_P (dname)
6573 && ctype == NULL_TREE
6574 && in_namespace == NULL_TREE
6575 && current_namespace == global_namespace);
6577 if (in_system_header || flag_ms_extensions)
6578 /* Allow it, sigh. */;
6579 else if (pedantic || ! is_main)
6580 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
6582 else if (warn_return_type)
6583 warning ("ISO C++ forbids declaration of `%s' with no type",
6586 type = integer_type_node;
6591 /* Now process the modifiers that were specified
6592 and check for invalid combinations. */
6594 /* Long double is a special combination. */
6595 if (declspecs->specs[(int)ds_long]
6596 && TYPE_MAIN_VARIANT (type) == double_type_node)
6598 declspecs->specs[(int)ds_long] = 0;
6599 type = build_qualified_type (long_double_type_node,
6600 cp_type_quals (type));
6603 /* Check all other uses of type modifiers. */
6605 if (declspecs->specs[(int)ds_unsigned]
6606 || declspecs->specs[(int)ds_signed]
6607 || declspecs->specs[(int)ds_long]
6608 || declspecs->specs[(int)ds_short])
6612 if (TREE_CODE (type) == REAL_TYPE)
6613 error ("short, signed or unsigned invalid for `%s'", name);
6614 else if (TREE_CODE (type) != INTEGER_TYPE)
6615 error ("long, short, signed or unsigned invalid for `%s'", name);
6616 else if (declspecs->specs[(int)ds_long]
6617 && declspecs->specs[(int)ds_short])
6618 error ("long and short specified together for `%s'", name);
6619 else if ((declspecs->specs[(int)ds_long]
6620 || declspecs->specs[(int)ds_short])
6622 error ("long or short specified with char for `%s'", name);
6623 else if ((declspecs->specs[(int)ds_long]
6624 || declspecs->specs[(int)ds_short])
6625 && TREE_CODE (type) == REAL_TYPE)
6626 error ("long or short specified with floating type for `%s'", name);
6627 else if (declspecs->specs[(int)ds_signed]
6628 && declspecs->specs[(int)ds_unsigned])
6629 error ("signed and unsigned given together for `%s'", name);
6633 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6635 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
6637 if (flag_pedantic_errors)
6642 /* Discard the type modifiers if they are invalid. */
6645 declspecs->specs[(int)ds_unsigned] = 0;
6646 declspecs->specs[(int)ds_signed] = 0;
6647 declspecs->specs[(int)ds_long] = 0;
6648 declspecs->specs[(int)ds_short] = 0;
6653 if (declspecs->specs[(int)ds_complex]
6654 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
6656 error ("complex invalid for `%s'", name);
6657 declspecs->specs[(int)ds_complex] = 0;
6660 /* Decide whether an integer type is signed or not.
6661 Optionally treat bitfields as signed by default. */
6662 if (declspecs->specs[(int)ds_unsigned]
6665 It is implementation-defined whether a plain (neither
6666 explicitly signed or unsigned) char, short, int, or long
6667 bit-field is signed or unsigned.
6669 Naturally, we extend this to long long as well. Note that
6670 this does not include wchar_t. */
6671 || (bitfield && !flag_signed_bitfields
6672 && !declspecs->specs[(int)ds_signed]
6673 /* A typedef for plain `int' without `signed' can be
6674 controlled just like plain `int', but a typedef for
6675 `signed int' cannot be so controlled. */
6677 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
6678 && (TREE_CODE (type) == INTEGER_TYPE
6679 || TREE_CODE (type) == CHAR_TYPE)
6680 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
6683 type = long_long_unsigned_type_node;
6684 else if (declspecs->specs[(int)ds_long])
6685 type = long_unsigned_type_node;
6686 else if (declspecs->specs[(int)ds_short])
6687 type = short_unsigned_type_node;
6688 else if (type == char_type_node)
6689 type = unsigned_char_type_node;
6690 else if (typedef_decl)
6691 type = c_common_unsigned_type (type);
6693 type = unsigned_type_node;
6695 else if (declspecs->specs[(int)ds_signed]
6696 && type == char_type_node)
6697 type = signed_char_type_node;
6699 type = long_long_integer_type_node;
6700 else if (declspecs->specs[(int)ds_long])
6701 type = long_integer_type_node;
6702 else if (declspecs->specs[(int)ds_short])
6703 type = short_integer_type_node;
6705 if (declspecs->specs[(int)ds_complex])
6707 /* If we just have "complex", it is equivalent to
6708 "complex double", but if any modifiers at all are specified it is
6709 the complex form of TYPE. E.g, "complex short" is
6710 "complex short int". */
6712 if (defaulted_int && ! longlong
6713 && ! (declspecs->specs[(int)ds_long]
6714 || declspecs->specs[(int)ds_short]
6715 || declspecs->specs[(int)ds_signed]
6716 || declspecs->specs[(int)ds_unsigned]))
6717 type = complex_double_type_node;
6718 else if (type == integer_type_node)
6719 type = complex_integer_type_node;
6720 else if (type == float_type_node)
6721 type = complex_float_type_node;
6722 else if (type == double_type_node)
6723 type = complex_double_type_node;
6724 else if (type == long_double_type_node)
6725 type = complex_long_double_type_node;
6727 type = build_complex_type (type);
6730 type_quals = TYPE_UNQUALIFIED;
6731 if (declspecs->specs[(int)ds_const])
6732 type_quals |= TYPE_QUAL_CONST;
6733 if (declspecs->specs[(int)ds_volatile])
6734 type_quals |= TYPE_QUAL_VOLATILE;
6735 if (declspecs->specs[(int)ds_restrict])
6736 type_quals |= TYPE_QUAL_RESTRICT;
6737 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
6738 error ("qualifiers are not allowed on declaration of `operator %T'",
6741 type_quals |= cp_type_quals (type);
6742 type = cp_build_qualified_type_real
6743 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
6744 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
6745 /* We might have ignored or rejected some of the qualifiers. */
6746 type_quals = cp_type_quals (type);
6749 inlinep = !! declspecs->specs[(int)ds_inline];
6750 virtualp = !! declspecs->specs[(int)ds_virtual];
6751 explicitp = !! declspecs->specs[(int)ds_explicit];
6753 if (declspecs->storage_class == sc_static)
6754 staticp = 1 + (decl_context == FIELD);
6756 if (virtualp && staticp == 2)
6758 error ("member `%D' cannot be declared both virtual and static",
6762 friendp = !! declspecs->specs[(int)ds_friend];
6764 if (dependant_name && !friendp)
6766 error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
6767 return void_type_node;
6770 /* Issue errors about use of storage classes for parameters. */
6771 if (decl_context == PARM)
6773 if (declspecs->specs[(int)ds_typedef])
6774 error ("typedef declaration invalid in parameter declaration");
6775 else if (declspecs->storage_class == sc_static
6776 || declspecs->storage_class == sc_extern
6777 || declspecs->specs[(int)ds_thread])
6778 error ("storage class specifiers invalid in parameter declarations");
6781 /* Give error if `virtual' is used outside of class declaration. */
6783 && (current_class_name == NULL_TREE || decl_context != FIELD))
6785 error ("virtual outside class declaration");
6789 /* Static anonymous unions are dealt with here. */
6790 if (staticp && decl_context == TYPENAME
6792 && ANON_AGGR_TYPE_P (declspecs->type))
6793 decl_context = FIELD;
6795 /* Warn about storage classes that are invalid for certain
6796 kinds of declarations (parameters, typenames, etc.). */
6797 if (declspecs->multiple_storage_classes_p)
6798 error ("multiple storage classes in declaration of `%s'", name);
6799 else if (decl_context != NORMAL
6800 && declspecs->storage_class != sc_none
6801 && declspecs->storage_class != sc_mutable)
6803 if ((decl_context == PARM || decl_context == CATCHPARM)
6804 && (declspecs->storage_class == sc_register
6805 || declspecs->storage_class == sc_auto))
6807 else if (declspecs->specs[(int)ds_typedef])
6809 else if (decl_context == FIELD
6810 /* C++ allows static class elements. */
6811 && declspecs->storage_class == sc_static)
6812 /* C++ also allows inlines and signed and unsigned elements,
6813 but in those cases we don't come in here. */
6817 if (decl_context == FIELD)
6819 tree tmp = NULL_TREE;
6824 /* Avoid trying to get an operand off an identifier node. */
6825 if (declarator->kind != cdk_id)
6826 tmp = declarator->declarator->u.id.name;
6828 tmp = declarator->u.id.name;
6829 op = IDENTIFIER_OPNAME_P (tmp);
6830 if (IDENTIFIER_TYPENAME_P (tmp))
6832 if (is_typename_at_global_scope (tmp))
6833 name = IDENTIFIER_POINTER (tmp);
6835 name = "<invalid operator>";
6838 error ("storage class specified for %s `%s'",
6839 op ? "member operator" : "field",
6844 if (decl_context == PARM || decl_context == CATCHPARM)
6845 error ("storage class specified for parameter `%s'", name);
6847 error ("storage class specified for typename");
6849 if (declspecs->storage_class == sc_register
6850 || declspecs->storage_class == sc_auto
6851 || declspecs->storage_class == sc_extern
6852 || declspecs->specs[(int)ds_thread])
6853 declspecs->storage_class = sc_none;
6856 else if (declspecs->storage_class == sc_extern && initialized
6859 if (toplevel_bindings_p ())
6861 /* It's common practice (and completely valid) to have a const
6862 be initialized and declared extern. */
6863 if (!(type_quals & TYPE_QUAL_CONST))
6864 warning ("`%s' initialized and declared `extern'", name);
6867 error ("`%s' has both `extern' and initializer", name);
6869 else if (declspecs->storage_class == sc_extern && funcdef_flag
6870 && ! toplevel_bindings_p ())
6871 error ("nested function `%s' declared `extern'", name);
6872 else if (toplevel_bindings_p ())
6874 if (declspecs->storage_class == sc_auto)
6875 error ("top-level declaration of `%s' specifies `auto'", name);
6877 else if (declspecs->specs[(int)ds_thread]
6878 && declspecs->storage_class != sc_extern
6879 && declspecs->storage_class != sc_static)
6881 error ("function-scope `%s' implicitly auto and declared `__thread'",
6883 declspecs->specs[(int)ds_thread] = 0;
6886 if (declspecs->storage_class && friendp)
6887 error ("storage class specifiers invalid in friend function declarations");
6890 unqualified_id = NULL_TREE;
6893 unqualified_id = id_declarator->u.id.name;
6894 if (TREE_CODE (unqualified_id) == SCOPE_REF)
6895 unqualified_id = TREE_OPERAND (unqualified_id, 1);
6896 if (TREE_CODE (unqualified_id) == BASELINK)
6897 unqualified_id = BASELINK_FUNCTIONS (unqualified_id);
6898 switch (TREE_CODE (unqualified_id))
6902 = constructor_name (TREE_OPERAND (unqualified_id, 0));
6907 = constructor_name (TREE_TYPE (unqualified_id));
6910 case IDENTIFIER_NODE:
6911 case TEMPLATE_ID_EXPR:
6919 /* Determine the type of the entity declared by recurring on the
6922 declarator && declarator->kind != cdk_id;
6923 declarator = declarator->declarator)
6925 const cp_declarator *inner_declarator;
6928 if (type == error_mark_node)
6929 return error_mark_node;
6931 inner_declarator = declarator->declarator;
6933 attrs = declarator->attributes;
6939 if (declarator == NULL || declarator->kind == cdk_id)
6940 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
6941 if (declarator->kind == cdk_function)
6942 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
6943 if (declarator->kind == cdk_array)
6944 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
6945 returned_attrs = decl_attributes (&type,
6946 chainon (returned_attrs, attrs),
6950 switch (declarator->kind)
6953 type = create_array_type_for_decl (dname, type,
6954 declarator->u.array.bounds);
6955 if (inner_declarator
6956 && (inner_declarator->kind == cdk_pointer
6957 || inner_declarator->kind == cdk_reference
6958 || inner_declarator->kind == cdk_ptrmem))
6959 /* We can never complete an array type which is the
6960 target of a pointer, so go ahead and lay it out. */
6969 /* Declaring a function type.
6970 Make sure we have a valid type for the function to return. */
6972 /* We now know that the TYPE_QUALS don't apply to the
6973 decl, but to its return type. */
6974 type_quals = TYPE_UNQUALIFIED;
6976 /* Warn about some types functions can't return. */
6978 if (TREE_CODE (type) == FUNCTION_TYPE)
6980 error ("`%s' declared as function returning a function", name);
6981 type = integer_type_node;
6983 if (TREE_CODE (type) == ARRAY_TYPE)
6985 error ("`%s' declared as function returning an array", name);
6986 type = integer_type_node;
6989 /* Pick up type qualifiers which should be applied to `this'. */
6990 quals = declarator->u.function.qualifiers;
6992 /* Pick up the exception specifications. */
6993 raises = declarator->u.function.exception_specification;
6995 /* Say it's a definition only for the CALL_EXPR
6996 closest to the identifier. */
6997 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
6999 if (ctype == NULL_TREE
7000 && decl_context == FIELD
7002 && (friendp == 0 || dname == current_class_name))
7003 ctype = current_class_type;
7005 if (ctype && sfk == sfk_conversion)
7006 TYPE_HAS_CONVERSION (ctype) = 1;
7007 if (ctype && (sfk == sfk_constructor
7008 || sfk == sfk_destructor))
7010 /* We are within a class's scope. If our declarator name
7011 is the same as the class name, and we are defining
7012 a function, then it is a constructor/destructor, and
7013 therefore returns a void type. */
7015 if (flags == DTOR_FLAG)
7017 /* ISO C++ 12.4/2. A destructor may not be
7018 declared const or volatile. A destructor may
7021 error ("destructor cannot be static member function");
7024 error ("destructors may not be `%E'",
7025 TREE_VALUE (quals));
7028 if (decl_context == FIELD)
7030 if (! member_function_or_else (ctype,
7033 return void_type_node;
7036 else /* It's a constructor. */
7040 /* ISO C++ 12.1. A constructor may not be
7041 declared const or volatile. A constructor may
7042 not be virtual. A constructor may not be
7045 error ("constructor cannot be static member function");
7048 pedwarn ("constructors cannot be declared virtual");
7053 error ("constructors may not be `%E'",
7054 TREE_VALUE (quals));
7057 if (decl_context == FIELD)
7059 if (! member_function_or_else (ctype,
7062 return void_type_node;
7063 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7064 if (sfk != sfk_constructor)
7068 if (decl_context == FIELD)
7074 error ("can't initialize friend function `%s'", name);
7077 /* Cannot be both friend and virtual. */
7078 error ("virtual functions cannot be friends");
7081 if (decl_context == NORMAL)
7082 error ("friend declaration not in class definition");
7083 if (current_function_decl && funcdef_flag)
7084 error ("can't define friend function `%s' in a local class definition",
7088 arg_types = grokparms (declarator->u.function.parameters,
7091 if (inner_declarator
7092 && inner_declarator->kind == cdk_id
7093 && inner_declarator->u.id.sfk == sfk_destructor
7094 && arg_types != void_list_node)
7096 error ("destructors may not have parameters");
7097 arg_types = void_list_node;
7101 type = build_function_type (type, arg_types);
7108 /* Filter out pointers-to-references and references-to-references.
7109 We can get these if a TYPE_DECL is used. */
7111 if (TREE_CODE (type) == REFERENCE_TYPE)
7113 error (declarator->kind == cdk_reference
7114 ? "cannot declare reference to `%#T'"
7115 : "cannot declare pointer to `%#T'", type);
7116 type = TREE_TYPE (type);
7118 else if (VOID_TYPE_P (type))
7120 if (declarator->kind == cdk_reference)
7121 error ("cannot declare reference to `%#T'", type);
7122 else if (declarator->kind == cdk_ptrmem)
7123 error ("cannot declare pointer to `%#T' member", type);
7126 /* We now know that the TYPE_QUALS don't apply to the decl,
7127 but to the target of the pointer. */
7128 type_quals = TYPE_UNQUALIFIED;
7130 if (declarator->kind == cdk_ptrmem
7131 && (TREE_CODE (type) == FUNCTION_TYPE
7132 || (quals && TREE_CODE (type) == METHOD_TYPE)))
7134 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7135 grok_method_quals (declarator->u.pointer.class_type,
7137 type = TREE_TYPE (dummy);
7141 if (declarator->kind == cdk_reference)
7143 if (!VOID_TYPE_P (type))
7144 type = build_reference_type (type);
7146 else if (TREE_CODE (type) == METHOD_TYPE)
7147 type = build_ptrmemfunc_type (build_pointer_type (type));
7148 else if (declarator->kind == cdk_ptrmem)
7149 type = build_ptrmem_type (declarator->u.pointer.class_type,
7152 type = build_pointer_type (type);
7154 /* Process a list of type modifier keywords (such as
7155 const or volatile) that were given inside the `*' or `&'. */
7157 if (declarator->u.pointer.qualifiers)
7165 for (typemodlist = declarator->u.pointer.qualifiers; typemodlist;
7166 typemodlist = TREE_CHAIN (typemodlist))
7168 tree qualifier = TREE_VALUE (typemodlist);
7170 if (qualifier == ridpointers[(int) RID_CONST])
7173 type_quals |= TYPE_QUAL_CONST;
7175 else if (qualifier == ridpointers[(int) RID_VOLATILE])
7178 type_quals |= TYPE_QUAL_VOLATILE;
7180 else if (qualifier == ridpointers[(int) RID_RESTRICT])
7183 type_quals |= TYPE_QUAL_RESTRICT;
7188 error ("invalid type modifier within pointer declarator");
7192 pedwarn ("duplicate `const'");
7194 pedwarn ("duplicate `volatile'");
7196 pedwarn ("duplicate `restrict'");
7197 type = cp_build_qualified_type (type, type_quals);
7198 type_quals = cp_type_quals (type);
7211 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7212 && TREE_CODE (type) != FUNCTION_TYPE
7213 && TREE_CODE (type) != METHOD_TYPE)
7215 error ("template-id `%D' used as a declarator",
7217 unqualified_id = dname;
7220 /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7221 otherwise, we would not have exited the loop above. */
7223 && TREE_CODE (declarator->u.id.name) == SCOPE_REF
7224 /* If the qualifying scope was invalid, it will have been set to
7226 && TREE_OPERAND (declarator->u.id.name, 0)
7227 && TYPE_P (TREE_OPERAND (declarator->u.id.name, 0)))
7231 ctype = TREE_OPERAND (declarator->u.id.name, 0);
7233 ctype = TYPE_MAIN_VARIANT (ctype);
7235 while (t != NULL_TREE && CLASS_TYPE_P (t))
7237 /* You're supposed to have one `template <...>' for every
7238 template class, but you don't need one for a full
7239 specialization. For example:
7241 template <class T> struct S{};
7242 template <> struct S<int> { void f(); };
7243 void S<int>::f () {}
7245 is correct; there shouldn't be a `template <>' for the
7246 definition of `S<int>::f'. */
7247 if (CLASSTYPE_TEMPLATE_INFO (t)
7248 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
7249 || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
7250 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7251 template_count += 1;
7253 t = TYPE_MAIN_DECL (t);
7254 t = DECL_CONTEXT (t);
7257 if (ctype == current_class_type)
7263 Is this ill-formed? */
7266 pedwarn ("extra qualification `%T::' on member `%s' ignored",
7269 else if (TREE_CODE (type) == FUNCTION_TYPE)
7271 tree sname = TREE_OPERAND (declarator->u.id.name, 1);
7273 if (TREE_CODE (sname) == IDENTIFIER_NODE
7274 && NEW_DELETE_OPNAME_P (sname))
7275 /* Overloaded operator new and operator delete
7276 are always static functions. */
7278 else if (current_class_type == NULL_TREE || friendp)
7280 = build_method_type_directly (ctype,
7282 TYPE_ARG_TYPES (type));
7285 error ("cannot declare member function `%T::%s' within `%T'",
7286 ctype, name, current_class_type);
7287 return error_mark_node;
7290 else if (declspecs->specs[(int)ds_typedef]
7291 || COMPLETE_TYPE_P (complete_type (ctype)))
7293 /* Have to move this code elsewhere in this function.
7294 this code is used for i.e., typedef int A::M; M *pm;
7296 It is? How? jason 10/2/94 */
7298 if (current_class_type)
7300 error ("cannot declare member `%T::%s' within `%T'",
7301 ctype, name, current_class_type);
7302 return void_type_node;
7307 cxx_incomplete_type_error (NULL_TREE, ctype);
7308 return error_mark_node;
7315 *attrlist = chainon (returned_attrs, *attrlist);
7317 attrlist = &returned_attrs;
7320 /* Now TYPE has the actual type. */
7322 /* Did array size calculations overflow? */
7324 if (TREE_CODE (type) == ARRAY_TYPE
7325 && COMPLETE_TYPE_P (type)
7326 && TREE_OVERFLOW (TYPE_SIZE (type)))
7328 error ("size of array `%s' is too large", name);
7329 /* If we proceed with the array type as it is, we'll eventually
7330 crash in tree_low_cst(). */
7331 type = error_mark_node;
7334 if ((decl_context == FIELD || decl_context == PARM)
7335 && !processing_template_decl
7336 && variably_modified_type_p (type))
7338 if (decl_context == FIELD)
7339 error ("data member may not have variably modified type `%T'", type);
7341 error ("parameter may not have variably modified type `%T'", type);
7342 type = error_mark_node;
7345 if (explicitp == 1 || (explicitp && friendp))
7347 /* [dcl.fct.spec] The explicit specifier shall only be used in
7348 declarations of constructors within a class definition. */
7349 error ("only declarations of constructors can be `explicit'");
7353 if (declspecs->storage_class == sc_mutable)
7355 if (decl_context != FIELD || friendp)
7357 error ("non-member `%s' cannot be declared `mutable'", name);
7358 declspecs->storage_class = sc_none;
7360 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7362 error ("non-object member `%s' cannot be declared `mutable'", name);
7363 declspecs->storage_class = sc_none;
7365 else if (TREE_CODE (type) == FUNCTION_TYPE
7366 || TREE_CODE (type) == METHOD_TYPE)
7368 error ("function `%s' cannot be declared `mutable'", name);
7369 declspecs->storage_class = sc_none;
7373 error ("static `%s' cannot be declared `mutable'", name);
7374 declspecs->storage_class = sc_none;
7376 else if (type_quals & TYPE_QUAL_CONST)
7378 error ("const `%s' cannot be declared `mutable'", name);
7379 declspecs->storage_class = sc_none;
7383 /* If this is declaring a typedef name, return a TYPE_DECL. */
7384 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7388 /* Note that the grammar rejects storage classes
7389 in typenames, fields or parameters. */
7390 if (current_lang_name == lang_name_java)
7391 TYPE_FOR_JAVA (type) = 1;
7393 if (decl_context == FIELD)
7395 if (constructor_name_p (unqualified_id, current_class_type))
7396 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7398 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7402 decl = build_decl (TYPE_DECL, unqualified_id, type);
7403 if (in_namespace || ctype)
7404 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7405 if (!current_function_decl)
7406 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7409 /* If the user declares "typedef struct {...} foo" then the
7410 struct will have an anonymous name. Fill that name in now.
7411 Nothing can refer to it, so nothing needs know about the name
7413 if (type != error_mark_node
7416 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7417 && TYPE_ANONYMOUS_P (type)
7418 /* Don't do this if there are attributes. */
7419 && (!attrlist || !*attrlist)
7420 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7422 tree oldname = TYPE_NAME (type);
7425 /* Replace the anonymous name with the real name everywhere. */
7426 lookup_tag_reverse (type, unqualified_id);
7427 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7428 if (TYPE_NAME (t) == oldname)
7429 TYPE_NAME (t) = decl;
7431 if (TYPE_LANG_SPECIFIC (type))
7432 TYPE_WAS_ANONYMOUS (type) = 1;
7434 /* If this is a typedef within a template class, the nested
7435 type is a (non-primary) template. The name for the
7436 template needs updating as well. */
7437 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7438 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7439 = TYPE_IDENTIFIER (type);
7441 /* FIXME remangle member functions; member functions of a
7442 type with external linkage have external linkage. */
7447 if (ctype == NULL_TREE)
7449 if (TREE_CODE (type) != METHOD_TYPE)
7450 error ("%Jinvalid type qualifier for non-member function type",
7453 ctype = TYPE_METHOD_BASETYPE (type);
7455 if (ctype != NULL_TREE)
7456 grok_method_quals (ctype, decl, quals);
7459 if (declspecs->specs[(int)ds_signed]
7460 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7461 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7463 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
7464 inlinep, friendp, raises != NULL_TREE);
7469 /* Detect the case of an array type of unspecified size
7470 which came, as such, direct from a typedef name.
7471 We must copy the type, so that the array's domain can be
7472 individually set by the object's initializer. */
7474 if (type && typedef_type
7475 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7476 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7477 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7479 /* Detect where we're using a typedef of function type to declare a
7480 function. PARMS will not be set, so we must create it now. */
7482 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7484 tree decls = NULL_TREE;
7487 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7489 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7491 TREE_CHAIN (decl) = decls;
7495 parms = nreverse (decls);
7498 /* If this is a type name (such as, in a cast or sizeof),
7499 compute the type and return it now. */
7501 if (decl_context == TYPENAME)
7503 /* Note that the grammar rejects storage classes
7504 in typenames, fields or parameters. */
7505 if (type_quals != TYPE_UNQUALIFIED)
7506 type_quals = TYPE_UNQUALIFIED;
7508 /* Special case: "friend class foo" looks like a TYPENAME context. */
7511 if (type_quals != TYPE_UNQUALIFIED)
7513 error ("type qualifiers specified for friend class declaration");
7514 type_quals = TYPE_UNQUALIFIED;
7518 error ("`inline' specified for friend class declaration");
7524 /* Don't allow friend declaration without a class-key. */
7525 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7526 pedwarn ("template parameters cannot be friends");
7527 else if (TREE_CODE (type) == TYPENAME_TYPE)
7528 pedwarn ("friend declaration requires class-key, "
7529 "i.e. `friend class %T::%D'",
7530 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7532 pedwarn ("friend declaration requires class-key, "
7533 "i.e. `friend %#T'",
7537 /* Only try to do this stuff if we didn't already give up. */
7538 if (type != integer_type_node)
7540 /* A friendly class? */
7541 if (current_class_type)
7542 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7545 error ("trying to make class `%T' a friend of global scope",
7548 type = void_type_node;
7553 if (ctype == NULL_TREE)
7555 if (TREE_CODE (type) != METHOD_TYPE)
7556 error ("invalid qualifiers on non-member function type");
7558 ctype = TYPE_METHOD_BASETYPE (type);
7562 tree dummy = build_decl (TYPE_DECL, unqualified_id, type);
7563 grok_method_quals (ctype, dummy, quals);
7564 type = TREE_TYPE (dummy);
7570 else if (unqualified_id == NULL_TREE && decl_context != PARM
7571 && decl_context != CATCHPARM
7572 && TREE_CODE (type) != UNION_TYPE
7575 error ("abstract declarator `%T' used as declaration", type);
7576 unqualified_id = make_anon_name ();
7579 /* `void' at top level (not within pointer)
7580 is allowed only in typedefs or type names.
7581 We don't complain about parms either, but that is because
7582 a better error message can be made later. */
7584 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
7586 if (! unqualified_id)
7587 error ("unnamed variable or field declared void");
7588 else if (TREE_CODE (unqualified_id) == IDENTIFIER_NODE)
7590 if (IDENTIFIER_OPNAME_P (unqualified_id))
7593 error ("variable or field `%s' declared void", name);
7596 error ("variable or field declared void");
7597 type = integer_type_node;
7600 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7601 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
7603 if (decl_context == PARM || decl_context == CATCHPARM)
7605 if (ctype || in_namespace)
7606 error ("cannot use `::' in parameter declaration");
7608 /* A parameter declared as an array of T is really a pointer to T.
7609 One declared as a function is really a pointer to a function.
7610 One declared as a member is really a pointer to member. */
7612 if (TREE_CODE (type) == ARRAY_TYPE)
7614 /* Transfer const-ness of array into that of type pointed to. */
7615 type = build_pointer_type (TREE_TYPE (type));
7616 type_quals = TYPE_UNQUALIFIED;
7618 else if (TREE_CODE (type) == FUNCTION_TYPE)
7619 type = build_pointer_type (type);
7625 if (decl_context == PARM)
7627 decl = cp_build_parm_decl (unqualified_id, type);
7629 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
7630 inlinep, friendp, raises != NULL_TREE);
7632 else if (decl_context == FIELD)
7634 /* The C99 flexible array extension. */
7635 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
7636 && TYPE_DOMAIN (type) == NULL_TREE)
7638 tree itype = compute_array_index_type (dname, integer_zero_node);
7639 type = build_cplus_array_type (TREE_TYPE (type), itype);
7642 if (type == error_mark_node)
7644 /* Happens when declaring arrays of sizes which
7645 are error_mark_node, for example. */
7648 else if (in_namespace && !friendp)
7650 /* Something like struct S { int N::j; }; */
7651 error ("invalid use of `::'");
7654 else if (TREE_CODE (type) == FUNCTION_TYPE)
7657 tree function_context;
7659 /* We catch the others as conflicts with the builtin
7661 if (friendp && unqualified_id == ridpointers[(int) RID_SIGNED])
7663 error ("function `%D' cannot be declared friend",
7670 if (ctype == NULL_TREE)
7671 ctype = current_class_type;
7673 if (ctype == NULL_TREE)
7675 error ("can't make `%D' into a method -- not in a class",
7677 return void_type_node;
7680 /* ``A union may [ ... ] not [ have ] virtual functions.''
7682 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
7684 error ("function `%D' declared virtual inside a union",
7686 return void_type_node;
7689 if (NEW_DELETE_OPNAME_P (unqualified_id))
7693 error ("`%D' cannot be declared virtual, since it is always static",
7698 else if (staticp < 2)
7699 type = build_method_type_directly (ctype,
7701 TYPE_ARG_TYPES (type));
7704 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
7705 function_context = (ctype != NULL_TREE) ?
7706 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
7707 publicp = (! friendp || ! staticp)
7708 && function_context == NULL_TREE;
7709 decl = grokfndecl (ctype, type,
7710 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7711 ? unqualified_id : dname,
7714 virtualp, flags, quals, raises,
7715 friendp ? -1 : 0, friendp, publicp, inlinep,
7716 funcdef_flag, template_count, in_namespace);
7717 if (decl == NULL_TREE)
7720 /* This clobbers the attrs stored in `decl' from `attrlist'. */
7721 /* The decl and setting of decl_attr is also turned off. */
7722 decl = build_decl_attribute_variant (decl, decl_attr);
7725 /* [class.conv.ctor]
7727 A constructor declared without the function-specifier
7728 explicit that can be called with a single parameter
7729 specifies a conversion from the type of its first
7730 parameter to the type of its class. Such a constructor
7731 is called a converting constructor. */
7733 DECL_NONCONVERTING_P (decl) = 1;
7734 else if (DECL_CONSTRUCTOR_P (decl))
7736 /* The constructor can be called with exactly one
7737 parameter if there is at least one parameter, and
7738 any subsequent parameters have default arguments.
7739 Ignore any compiler-added parms. */
7740 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
7742 if (arg_types == void_list_node
7744 && TREE_CHAIN (arg_types)
7745 && TREE_CHAIN (arg_types) != void_list_node
7746 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
7747 DECL_NONCONVERTING_P (decl) = 1;
7750 else if (TREE_CODE (type) == METHOD_TYPE)
7752 /* We only get here for friend declarations of
7753 members of other classes. */
7754 /* All method decls are public, so tell grokfndecl to set
7755 TREE_PUBLIC, also. */
7756 decl = grokfndecl (ctype, type,
7757 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7758 ? unqualified_id : dname,
7761 virtualp, flags, quals, raises,
7762 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
7763 template_count, in_namespace);
7764 if (decl == NULL_TREE)
7767 else if (!staticp && !dependent_type_p (type)
7768 && !COMPLETE_TYPE_P (complete_type (type))
7769 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
7772 error ("field `%D' has incomplete type", unqualified_id);
7774 error ("name `%T' has incomplete type", type);
7776 /* If we're instantiating a template, tell them which
7777 instantiation made the field's type be incomplete. */
7778 if (current_class_type
7779 && TYPE_NAME (current_class_type)
7780 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
7782 && declspecs->type == type)
7783 error (" in instantiation of template `%T'",
7784 current_class_type);
7786 type = error_mark_node;
7793 error ("`%E' is neither function nor member function; "
7794 "cannot be declared friend", unqualified_id);
7802 /* Friends are treated specially. */
7803 if (ctype == current_class_type)
7804 warning ("member functions are implicitly friends of their class");
7805 else if (decl && DECL_NAME (decl))
7807 if (template_class_depth (current_class_type) == 0)
7809 decl = check_explicit_specialization
7810 (unqualified_id, decl, template_count,
7811 2 * (funcdef_flag != 0) + 4);
7812 if (decl == error_mark_node)
7813 return error_mark_node;
7816 decl = do_friend (ctype, unqualified_id, decl,
7817 *attrlist, flags, quals, funcdef_flag);
7821 return void_type_node;
7824 /* Structure field. It may not be a function, except for C++. */
7826 if (decl == NULL_TREE)
7832 /* An attempt is being made to initialize a non-static
7833 member. But, from [class.mem]:
7835 4 A member-declarator can contain a
7836 constant-initializer only if it declares a static
7837 member (_class.static_) of integral or enumeration
7838 type, see _class.static.data_.
7840 This used to be relatively common practice, but
7841 the rest of the compiler does not correctly
7842 handle the initialization unless the member is
7843 static so we make it static below. */
7844 pedwarn ("ISO C++ forbids initialization of member `%D'",
7846 pedwarn ("making `%D' static", unqualified_id);
7850 if (uses_template_parms (type))
7851 /* We'll check at instantiation time. */
7853 else if (check_static_variable_definition (unqualified_id,
7855 /* If we just return the declaration, crashes
7856 will sometimes occur. We therefore return
7857 void_type_node, as if this was a friend
7858 declaration, to cause callers to completely
7859 ignore this declaration. */
7860 return void_type_node;
7865 /* C++ allows static class members. All other work
7866 for this is done by grokfield. */
7867 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
7868 TREE_STATIC (decl) = 1;
7869 /* In class context, 'static' means public access. */
7870 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
7874 decl = build_decl (FIELD_DECL, unqualified_id, type);
7875 DECL_NONADDRESSABLE_P (decl) = bitfield;
7876 if (declspecs->storage_class == sc_mutable)
7878 DECL_MUTABLE_P (decl) = 1;
7879 declspecs->storage_class = sc_none;
7883 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
7884 inlinep, friendp, raises != NULL_TREE);
7887 else if (TREE_CODE (type) == FUNCTION_TYPE
7888 || TREE_CODE (type) == METHOD_TYPE)
7893 if (!unqualified_id)
7896 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
7897 original_name = dname;
7899 original_name = unqualified_id;
7901 if (declspecs->storage_class == sc_auto)
7902 error ("storage class `auto' invalid for function `%s'", name);
7903 else if (declspecs->storage_class == sc_register)
7904 error ("storage class `register' invalid for function `%s'", name);
7905 else if (declspecs->specs[(int)ds_thread])
7906 error ("storage class `__thread' invalid for function `%s'", name);
7908 /* Function declaration not at top level.
7909 Storage classes other than `extern' are not allowed
7910 and `extern' makes no difference. */
7911 if (! toplevel_bindings_p ()
7912 && (declspecs->storage_class == sc_static
7913 || declspecs->specs[(int)ds_inline])
7916 if (declspecs->storage_class == sc_static)
7917 pedwarn ("`static' specified invalid for function `%s' declared out of global scope", name);
7919 pedwarn ("`inline' specifier invalid for function `%s' declared out of global scope", name);
7922 if (ctype == NULL_TREE)
7926 error ("virtual non-class function `%s'", name);
7930 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
7931 && !NEW_DELETE_OPNAME_P (original_name))
7932 type = build_method_type_directly (ctype,
7934 TYPE_ARG_TYPES (type));
7936 /* Record presence of `static'. */
7937 publicp = (ctype != NULL_TREE
7938 || declspecs->storage_class == sc_extern
7939 || declspecs->storage_class != sc_static);
7941 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
7942 virtualp, flags, quals, raises,
7944 publicp, inlinep, funcdef_flag,
7945 template_count, in_namespace);
7946 if (decl == NULL_TREE)
7951 int invalid_static = 0;
7953 /* Don't allow a static member function in a class, and forbid
7954 declaring main to be static. */
7955 if (TREE_CODE (type) == METHOD_TYPE)
7957 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
7960 else if (current_function_decl)
7962 /* FIXME need arm citation */
7963 error ("cannot declare static function inside another function");
7970 declspecs->storage_class = sc_none;
7976 /* It's a variable. */
7978 /* An uninitialized decl with `extern' is a reference. */
7979 decl = grokvardecl (type, unqualified_id,
7982 (type_quals & TYPE_QUAL_CONST) != 0,
7983 ctype ? ctype : in_namespace);
7984 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
7985 inlinep, friendp, raises != NULL_TREE);
7989 DECL_CONTEXT (decl) = ctype;
7992 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
7994 declspecs->storage_class = sc_none;
7996 if (declspecs->storage_class == sc_register && TREE_STATIC (decl))
7998 error ("static member `%D' declared `register'", decl);
7999 declspecs->storage_class = sc_none;
8001 if (declspecs->storage_class == sc_extern && pedantic)
8003 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
8005 declspecs->storage_class = sc_none;
8010 /* Record `register' declaration for warnings on &
8011 and in case doing stupid register allocation. */
8013 if (declspecs->storage_class == sc_register)
8014 DECL_REGISTER (decl) = 1;
8015 else if (declspecs->storage_class == sc_extern)
8016 DECL_THIS_EXTERN (decl) = 1;
8017 else if (declspecs->storage_class == sc_static)
8018 DECL_THIS_STATIC (decl) = 1;
8020 /* Record constancy and volatility. There's no need to do this
8021 when processing a template; we'll do this for the instantiated
8022 declaration based on the type of DECL. */
8023 if (!processing_template_decl)
8024 c_apply_type_quals_to_decl (type_quals, decl);
8030 /* Subroutine of start_function. Ensure that each of the parameter
8031 types (as listed in PARMS) is complete, as is required for a
8032 function definition. */
8035 require_complete_types_for_parms (tree parms)
8037 for (; parms; parms = TREE_CHAIN (parms))
8039 if (VOID_TYPE_P (TREE_TYPE (parms)))
8040 /* grokparms will have already issued an error. */
8041 TREE_TYPE (parms) = error_mark_node;
8042 else if (complete_type_or_else (TREE_TYPE (parms), parms))
8044 layout_decl (parms, 0);
8045 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8050 /* Returns nonzero if T is a local variable. */
8053 local_variable_p (tree t)
8055 if ((TREE_CODE (t) == VAR_DECL
8056 /* A VAR_DECL with a context that is a _TYPE is a static data
8058 && !TYPE_P (CP_DECL_CONTEXT (t))
8059 /* Any other non-local variable must be at namespace scope. */
8060 && !DECL_NAMESPACE_SCOPE_P (t))
8061 || (TREE_CODE (t) == PARM_DECL))
8067 /* Returns nonzero if T is an automatic local variable or a label.
8068 (These are the declarations that need to be remapped when the code
8069 containing them is duplicated.) */
8072 nonstatic_local_decl_p (tree t)
8074 return ((local_variable_p (t) && !TREE_STATIC (t))
8075 || TREE_CODE (t) == LABEL_DECL
8076 || TREE_CODE (t) == RESULT_DECL);
8079 /* Like local_variable_p, but suitable for use as a tree-walking
8083 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8084 void *data ATTRIBUTE_UNUSED)
8086 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8088 else if (TYPE_P (*tp))
8095 /* Check that ARG, which is a default-argument expression for a
8096 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8097 something goes wrong. DECL may also be a _TYPE node, rather than a
8098 DECL, if there is no DECL available. */
8101 check_default_argument (tree decl, tree arg)
8106 if (TREE_CODE (arg) == DEFAULT_ARG)
8107 /* We get a DEFAULT_ARG when looking at an in-class declaration
8108 with a default argument. Ignore the argument for now; we'll
8109 deal with it after the class is complete. */
8112 if (processing_template_decl || uses_template_parms (arg))
8113 /* We don't do anything checking until instantiation-time. Note
8114 that there may be uninstantiated arguments even for an
8115 instantiated function, since default arguments are not
8116 instantiated until they are needed. */
8125 decl_type = TREE_TYPE (decl);
8127 if (arg == error_mark_node
8128 || decl == error_mark_node
8129 || TREE_TYPE (arg) == error_mark_node
8130 || decl_type == error_mark_node)
8131 /* Something already went wrong. There's no need to check
8133 return error_mark_node;
8135 /* [dcl.fct.default]
8137 A default argument expression is implicitly converted to the
8139 if (!TREE_TYPE (arg)
8140 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
8143 error ("default argument for `%#D' has type `%T'",
8144 decl, TREE_TYPE (arg));
8146 error ("default argument for parameter of type `%T' has type `%T'",
8147 decl_type, TREE_TYPE (arg));
8149 return error_mark_node;
8152 /* [dcl.fct.default]
8154 Local variables shall not be used in default argument
8157 The keyword `this' shall not be used in a default argument of a
8159 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8163 error ("default argument `%E' uses local variable `%D'",
8165 return error_mark_node;
8172 /* Decode the list of parameter types for a function type.
8173 Given the list of things declared inside the parens,
8174 return a list of types.
8176 If this parameter does not end with an ellipsis, we append
8179 *PARMS is set to the chain of PARM_DECLs created. */
8182 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8184 tree result = NULL_TREE;
8185 tree decls = NULL_TREE;
8186 int ellipsis = !first_parm || first_parm->ellipsis_p;
8187 cp_parameter_declarator *parm;
8190 for (parm = first_parm; parm != NULL; parm = parm->next)
8192 tree type = NULL_TREE;
8193 tree init = parm->default_argument;
8197 if (parm == no_parameters)
8200 attrs = parm->decl_specifiers.attributes;
8201 parm->decl_specifiers.attributes = NULL_TREE;
8202 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8203 PARM, init != NULL_TREE, &attrs);
8204 if (! decl || TREE_TYPE (decl) == error_mark_node)
8208 cplus_decl_attributes (&decl, attrs, 0);
8210 type = TREE_TYPE (decl);
8211 if (VOID_TYPE_P (type))
8213 if (same_type_p (type, void_type_node)
8214 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8215 /* this is a parmlist of `(void)', which is ok. */
8217 cxx_incomplete_type_error (decl, type);
8218 /* It's not a good idea to actually create parameters of
8219 type `void'; other parts of the compiler assume that a
8220 void type terminates the parameter list. */
8221 type = error_mark_node;
8222 TREE_TYPE (decl) = error_mark_node;
8225 if (type != error_mark_node)
8227 /* If this type is passed by invisible reference, make the PARM_DECL
8228 reflect that so that alias analysis knows that the actual object
8229 is external to the function. */
8230 if (TREE_ADDRESSABLE (type))
8231 decl = build_decl (PARM_DECL, DECL_NAME (decl),
8232 build_reference_type (type));
8234 /* Top-level qualifiers on the parameters are
8235 ignored for function types. */
8236 type = cp_build_qualified_type (type, 0);
8237 if (TREE_CODE (type) == METHOD_TYPE)
8239 error ("parameter `%D' invalidly declared method type", decl);
8240 type = build_pointer_type (type);
8241 TREE_TYPE (decl) = type;
8243 else if (abstract_virtuals_error (decl, type))
8244 any_error = 1; /* Seems like a good idea. */
8245 else if (POINTER_TYPE_P (type))
8247 /* [dcl.fct]/6, parameter types cannot contain pointers
8248 (references) to arrays of unknown bound. */
8249 tree t = TREE_TYPE (type);
8250 int ptr = TYPE_PTR_P (type);
8256 else if (TREE_CODE (t) != ARRAY_TYPE)
8258 else if (!TYPE_DOMAIN (t))
8262 if (TREE_CODE (t) == ARRAY_TYPE)
8263 error ("parameter `%D' includes %s to array of unknown bound `%T'",
8264 decl, ptr ? "pointer" : "reference", t);
8267 if (!any_error && init)
8268 init = check_default_argument (type, init);
8273 TREE_CHAIN (decl) = decls;
8275 result = tree_cons (init, type, result);
8277 decls = nreverse (decls);
8278 result = nreverse (result);
8280 result = chainon (result, void_list_node);
8287 /* D is a constructor or overloaded `operator='.
8289 Let T be the class in which D is declared. Then, this function
8292 -1 if D's is an ill-formed constructor or copy assignment operator
8293 whose first parameter is of type `T'.
8294 0 if D is not a copy constructor or copy assignment
8296 1 if D is a copy constructor or copy assignment operator whose
8297 first parameter is a reference to const qualified T.
8298 2 if D is a copy constructor or copy assignment operator whose
8299 first parameter is a reference to non-const qualified T.
8301 This function can be used as a predicate. Positive values indicate
8302 a copy constructor and nonzero values indicate a copy assignment
8312 my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
8314 if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
8315 /* Instantiations of template member functions are never copy
8316 functions. Note that member functions of templated classes are
8317 represented as template functions internally, and we must
8318 accept those as copy functions. */
8321 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8325 arg_type = TREE_VALUE (args);
8327 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8329 /* Pass by value copy assignment operator. */
8332 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8333 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8335 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8341 args = TREE_CHAIN (args);
8343 if (args && args != void_list_node && !TREE_PURPOSE (args))
8344 /* There are more non-optional args. */
8350 /* Remember any special properties of member function DECL. */
8352 void grok_special_member_properties (tree decl)
8354 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8355 ; /* Not special. */
8356 else if (DECL_CONSTRUCTOR_P (decl))
8358 int ctor = copy_fn_p (decl);
8364 A non-template constructor for class X is a copy
8365 constructor if its first parameter is of type X&, const
8366 X&, volatile X& or const volatile X&, and either there
8367 are no other parameters or else all other parameters have
8368 default arguments. */
8369 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8371 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8373 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8374 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8376 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8380 A non-template assignment operator for class X is a copy
8381 assignment operator if its parameter is of type X, X&, const
8382 X&, volatile X& or const volatile X&. */
8384 int assop = copy_fn_p (decl);
8388 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8390 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8391 if (DECL_PURE_VIRTUAL_P (decl))
8392 TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8397 /* Check a constructor DECL has the correct form. Complains
8398 if the class has a constructor of the form X(X). */
8401 grok_ctor_properties (tree ctype, tree decl)
8403 int ctor_parm = copy_fn_p (decl);
8409 A declaration of a constructor for a class X is ill-formed if
8410 its first parameter is of type (optionally cv-qualified) X
8411 and either there are no other parameters or else all other
8412 parameters have default arguments.
8414 We *don't* complain about member template instantiations that
8415 have this form, though; they can occur as we try to decide
8416 what constructor to use during overload resolution. Since
8417 overload resolution will never prefer such a constructor to
8418 the non-template copy constructor (which is either explicitly
8419 or implicitly defined), there's no need to worry about their
8420 existence. Theoretically, they should never even be
8421 instantiated, but that's hard to forestall. */
8422 error ("invalid constructor; you probably meant `%T (const %T&)'",
8430 /* An operator with this code is unary, but can also be binary. */
8433 ambi_op_p (enum tree_code code)
8435 return (code == INDIRECT_REF
8436 || code == ADDR_EXPR
8437 || code == CONVERT_EXPR
8438 || code == NEGATE_EXPR
8439 || code == PREINCREMENT_EXPR
8440 || code == PREDECREMENT_EXPR);
8443 /* An operator with this name can only be unary. */
8446 unary_op_p (enum tree_code code)
8448 return (code == TRUTH_NOT_EXPR
8449 || code == BIT_NOT_EXPR
8450 || code == COMPONENT_REF
8451 || code == TYPE_EXPR);
8454 /* DECL is a declaration for an overloaded operator. Returns true if
8455 the declaration is valid; false otherwise. If COMPLAIN is true,
8456 errors are issued for invalid declarations. */
8459 grok_op_properties (tree decl, int friendp, bool complain)
8461 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8463 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8464 tree name = DECL_NAME (decl);
8465 enum tree_code operator_code;
8469 /* Assume that the declaration is valid. */
8472 /* Count the number of arguments. */
8473 for (argtype = argtypes, arity = 0;
8474 argtype && argtype != void_list_node;
8475 argtype = TREE_CHAIN (argtype))
8478 if (current_class_type == NULL_TREE)
8481 if (DECL_CONV_FN_P (decl))
8482 operator_code = TYPE_EXPR;
8486 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8487 if (ansi_opname (CODE) == name) \
8489 operator_code = (CODE); \
8492 else if (ansi_assopname (CODE) == name) \
8494 operator_code = (CODE); \
8495 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8499 #include "operators.def"
8505 my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
8506 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8510 switch (operator_code)
8513 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8517 TYPE_GETS_DELETE (current_class_type) |= 1;
8521 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8524 case VEC_DELETE_EXPR:
8525 TYPE_GETS_DELETE (current_class_type) |= 2;
8533 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8534 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8535 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8536 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8539 /* An operator function must either be a non-static member function
8540 or have at least one parameter of a class, a reference to a class,
8541 an enumeration, or a reference to an enumeration. 13.4.0.6 */
8542 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8544 if (operator_code == TYPE_EXPR
8545 || operator_code == CALL_EXPR
8546 || operator_code == COMPONENT_REF
8547 || operator_code == ARRAY_REF
8548 || operator_code == NOP_EXPR)
8549 error ("`%D' must be a nonstatic member function", decl);
8554 if (DECL_STATIC_FUNCTION_P (decl))
8555 error ("`%D' must be either a non-static member function or a non-member function", decl);
8557 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8559 tree arg = non_reference (TREE_VALUE (p));
8560 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8561 because these checks are performed even on
8562 template functions. */
8563 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8567 if (!p || p == void_list_node)
8572 error ("`%D' must have an argument of class or "
8580 /* There are no restrictions on the arguments to an overloaded
8582 if (operator_code == CALL_EXPR)
8585 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
8587 tree t = TREE_TYPE (name);
8590 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8591 const char *what = 0;
8594 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8596 if (TREE_CODE (t) == VOID_TYPE)
8598 else if (t == current_class_type)
8599 what = "the same type";
8600 /* Don't force t to be complete here. */
8601 else if (IS_AGGR_TYPE (t)
8602 && COMPLETE_TYPE_P (t)
8603 && DERIVED_FROM_P (t, current_class_type))
8604 what = "a base class";
8606 if (what && warn_conversion)
8607 warning ("conversion to %s%s will never use a type conversion operator",
8608 ref ? "a reference to " : "", what);
8611 if (operator_code == COND_EXPR)
8614 error ("ISO C++ prohibits overloading operator ?:");
8616 else if (ambi_op_p (operator_code))
8619 /* We pick the one-argument operator codes by default, so
8620 we don't have to change anything. */
8622 else if (arity == 2)
8624 /* If we thought this was a unary operator, we now know
8625 it to be a binary operator. */
8626 switch (operator_code)
8629 operator_code = MULT_EXPR;
8633 operator_code = BIT_AND_EXPR;
8637 operator_code = PLUS_EXPR;
8641 operator_code = MINUS_EXPR;
8644 case PREINCREMENT_EXPR:
8645 operator_code = POSTINCREMENT_EXPR;
8648 case PREDECREMENT_EXPR:
8649 operator_code = POSTDECREMENT_EXPR;
8656 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8658 if ((operator_code == POSTINCREMENT_EXPR
8659 || operator_code == POSTDECREMENT_EXPR)
8660 && ! processing_template_decl
8661 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8664 error ("postfix `%D' must take `int' as its argument",
8668 ("postfix `%D' must take `int' as its second argument",
8675 error ("`%D' must take either zero or one argument", decl);
8677 error ("`%D' must take either one or two arguments", decl);
8680 /* More Effective C++ rule 6. */
8682 && (operator_code == POSTINCREMENT_EXPR
8683 || operator_code == POSTDECREMENT_EXPR
8684 || operator_code == PREINCREMENT_EXPR
8685 || operator_code == PREDECREMENT_EXPR))
8687 tree arg = TREE_VALUE (argtypes);
8688 tree ret = TREE_TYPE (TREE_TYPE (decl));
8689 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
8690 arg = TREE_TYPE (arg);
8691 arg = TYPE_MAIN_VARIANT (arg);
8692 if (operator_code == PREINCREMENT_EXPR
8693 || operator_code == PREDECREMENT_EXPR)
8695 if (TREE_CODE (ret) != REFERENCE_TYPE
8696 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
8698 warning ("prefix `%D' should return `%T'", decl,
8699 build_reference_type (arg));
8703 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
8704 warning ("postfix `%D' should return `%T'", decl, arg);
8708 else if (unary_op_p (operator_code))
8713 error ("`%D' must take `void'", decl);
8715 error ("`%D' must take exactly one argument", decl);
8718 else /* if (binary_op_p (operator_code)) */
8723 error ("`%D' must take exactly one argument", decl);
8725 error ("`%D' must take exactly two arguments", decl);
8728 /* More Effective C++ rule 7. */
8730 && (operator_code == TRUTH_ANDIF_EXPR
8731 || operator_code == TRUTH_ORIF_EXPR
8732 || operator_code == COMPOUND_EXPR))
8733 warning ("user-defined `%D' always evaluates both arguments",
8737 /* Effective C++ rule 23. */
8740 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
8741 && (operator_code == PLUS_EXPR
8742 || operator_code == MINUS_EXPR
8743 || operator_code == TRUNC_DIV_EXPR
8744 || operator_code == MULT_EXPR
8745 || operator_code == TRUNC_MOD_EXPR)
8746 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
8747 warning ("`%D' should return by value", decl);
8750 for (; argtypes && argtypes != void_list_node;
8751 argtypes = TREE_CHAIN (argtypes))
8752 if (TREE_PURPOSE (argtypes))
8754 TREE_PURPOSE (argtypes) = NULL_TREE;
8755 if (operator_code == POSTINCREMENT_EXPR
8756 || operator_code == POSTDECREMENT_EXPR)
8759 pedwarn ("`%D' cannot have default arguments", decl);
8762 error ("`%D' cannot have default arguments", decl);
8771 tag_name (enum tag_types code)
8788 /* Name lookup in an elaborated-type-specifier (after the keyword
8789 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
8790 elaborated-type-specifier is invalid, issue a diagnostic and return
8791 error_mark_node; otherwise, return the *_TYPE to which it referred.
8792 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
8795 check_elaborated_type_specifier (enum tag_types tag_code,
8797 bool allow_template_p)
8803 struct S { struct S *p; };
8805 name lookup will find the TYPE_DECL for the implicit "S::S"
8806 typedef. Adjust for that here. */
8807 if (DECL_SELF_REFERENCE_P (decl))
8808 decl = TYPE_NAME (TREE_TYPE (decl));
8810 type = TREE_TYPE (decl);
8814 If the identifier resolves to a typedef-name or a template
8815 type-parameter, the elaborated-type-specifier is ill-formed.
8817 In other words, the only legitimate declaration to use in the
8818 elaborated type specifier is the implicit typedef created when
8819 the type is declared. */
8820 if (!DECL_IMPLICIT_TYPEDEF_P (decl))
8822 error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code));
8823 return IS_AGGR_TYPE (type) ? type : error_mark_node;
8826 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8828 error ("using template type parameter `%T' after `%s'",
8829 type, tag_name (tag_code));
8830 return error_mark_node;
8832 else if (TREE_CODE (type) != RECORD_TYPE
8833 && TREE_CODE (type) != UNION_TYPE
8834 && tag_code != enum_type)
8836 error ("`%T' referred to as `%s'", type, tag_name (tag_code));
8837 return error_mark_node;
8839 else if (TREE_CODE (type) != ENUMERAL_TYPE
8840 && tag_code == enum_type)
8842 error ("`%T' referred to as enum", type);
8843 return error_mark_node;
8845 else if (!allow_template_p
8846 && TREE_CODE (type) == RECORD_TYPE
8847 && CLASSTYPE_IS_TEMPLATE (type))
8849 /* If a class template appears as elaborated type specifier
8850 without a template header such as:
8852 template <class T> class C {};
8853 void f(class C); // No template header here
8855 then the required template argument is missing. */
8857 error ("template argument required for `%s %T'",
8858 tag_name (tag_code),
8859 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
8860 return error_mark_node;
8866 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8867 Define the tag as a forward-reference if it is not defined.
8869 If a declaration is given, process it here, and report an error if
8870 multiple declarations are not identical.
8872 GLOBALIZE is false when this is also a definition. Only look in
8873 the current frame for the name (since C++ allows new names in any
8876 TEMPLATE_HEADER_P is true when this declaration is preceded by
8877 a set of template parameters. */
8880 xref_tag (enum tag_types tag_code, tree name,
8881 bool globalize, bool template_header_p)
8883 enum tree_code code;
8885 struct cp_binding_level *b = current_binding_level;
8886 tree context = NULL_TREE;
8888 timevar_push (TV_NAME_LOOKUP);
8890 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
8902 code = ENUMERAL_TYPE;
8910 /* If we know we are defining this tag, only look it up in
8911 this scope and don't try to find it as a type. */
8912 t = lookup_tag (code, name, b, 1);
8916 tree decl = lookup_name (name, 2);
8918 if (decl && DECL_CLASS_TEMPLATE_P (decl))
8919 decl = DECL_TEMPLATE_RESULT (decl);
8921 if (decl && TREE_CODE (decl) == TYPE_DECL)
8923 /* Two cases we need to consider when deciding if a class
8924 template is allowed as an elaborated type specifier:
8925 1. It is a self reference to its own class.
8926 2. It comes with a template header.
8930 template <class T> class C {
8931 class C *c1; // DECL_SELF_REFERENCE_P is true
8934 template <class U> class C; // template_header_p is true
8935 template <class T> class C<T>::D {
8936 class C *c2; // DECL_SELF_REFERENCE_P is true
8939 t = check_elaborated_type_specifier (tag_code,
8942 | DECL_SELF_REFERENCE_P (decl));
8943 if (t == error_mark_node)
8944 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8949 if (t && current_class_type
8950 && template_class_depth (current_class_type)
8951 && template_header_p)
8953 /* Since GLOBALIZE is nonzero, we are not looking at a
8954 definition of this tag. Since, in addition, we are currently
8955 processing a (member) template declaration of a template
8956 class, we must be very careful; consider:
8963 { template <class V>
8964 friend struct S1; };
8966 Here, the S2::S1 declaration should not be confused with the
8967 outer declaration. In particular, the inner version should
8968 have a template parameter of level 2, not level 1. This
8969 would be particularly important if the member declaration
8972 template <class V = U> friend struct S1;
8974 say, when we should tsubst into `U' when instantiating
8975 S2. On the other hand, when presented with:
8985 we must find the inner binding eventually. We
8986 accomplish this by making sure that the new type we
8987 create to represent this declaration has the right
8989 context = TYPE_CONTEXT (t);
8996 /* If no such tag is yet defined, create a forward-reference node
8997 and record it as the "definition".
8998 When a real declaration of this type is found,
8999 the forward-reference will be altered into a real type. */
9000 if (code == ENUMERAL_TYPE)
9002 error ("use of enum `%#D' without previous declaration", name);
9003 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9007 t = make_aggr_type (code);
9008 TYPE_CONTEXT (t) = context;
9009 pushtag (name, t, globalize);
9014 if (!globalize && processing_template_decl && IS_AGGR_TYPE (t))
9015 redeclare_class_template (t, current_template_parms);
9016 else if (!processing_template_decl
9018 && CLASSTYPE_IS_TEMPLATE (t))
9020 error ("redeclaration of `%T' as a non-template", t);
9021 t = error_mark_node;
9025 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9029 xref_tag_from_type (tree old, tree id, int globalize)
9031 enum tag_types tag_kind;
9033 if (TREE_CODE (old) == RECORD_TYPE)
9034 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9036 tag_kind = union_type;
9038 if (id == NULL_TREE)
9039 id = TYPE_IDENTIFIER (old);
9041 return xref_tag (tag_kind, id, globalize, false);
9044 /* REF is a type (named NAME), for which we have just seen some
9045 baseclasses. BASE_LIST is a list of those baseclasses; the
9046 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
9047 the base-class. TREE_VIA_VIRTUAL indicates virtual
9048 inheritance. CODE_TYPE_NODE indicates whether REF is a class,
9049 struct, or union. */
9052 xref_basetypes (tree ref, tree base_list)
9054 /* In the declaration `A : X, Y, ... Z' we mark all the types
9055 (A, X, Y, ..., Z) so we can check for duplicates. */
9059 enum tag_types tag_code;
9061 if (ref == error_mark_node)
9064 if (TREE_CODE (ref) == UNION_TYPE)
9066 error ("derived union `%T' invalid", ref);
9070 tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
9072 /* First, make sure that any templates in base-classes are
9073 instantiated. This ensures that if we call ourselves recursively
9074 we do not get confused about which classes are marked and which
9079 tree basetype = TREE_VALUE (*basep);
9080 if (!(processing_template_decl && uses_template_parms (basetype))
9081 && !complete_type_or_else (basetype, NULL))
9082 /* An incomplete type. Remove it from the list. */
9083 *basep = TREE_CHAIN (*basep);
9085 basep = &TREE_CHAIN (*basep);
9088 SET_CLASSTYPE_MARKED (ref);
9089 i = list_length (base_list);
9092 tree binfo = TYPE_BINFO (ref);
9093 tree binfos = make_tree_vec (i);
9094 tree accesses = make_tree_vec (i);
9096 BINFO_BASETYPES (binfo) = binfos;
9097 BINFO_BASEACCESSES (binfo) = accesses;
9099 for (i = 0; base_list; base_list = TREE_CHAIN (base_list))
9101 tree access = TREE_PURPOSE (base_list);
9102 int via_virtual = TREE_VIA_VIRTUAL (base_list);
9103 tree basetype = TREE_VALUE (base_list);
9106 if (access == access_default_node)
9107 /* The base of a derived struct is public by default. */
9108 access = (tag_code == class_type
9109 ? access_private_node : access_public_node);
9111 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
9112 basetype = TREE_TYPE (basetype);
9114 || (TREE_CODE (basetype) != RECORD_TYPE
9115 && TREE_CODE (basetype) != TYPENAME_TYPE
9116 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9117 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
9119 error ("base type `%T' fails to be a struct or class type",
9124 if (CLASSTYPE_MARKED (basetype))
9126 if (basetype == ref)
9127 error ("recursive type `%T' undefined", basetype);
9129 error ("duplicate base type `%T' invalid", basetype);
9133 if (TYPE_FOR_JAVA (basetype)
9134 && (current_lang_depth () == 0))
9135 TYPE_FOR_JAVA (ref) = 1;
9137 if (CLASS_TYPE_P (basetype))
9139 base_binfo = TYPE_BINFO (basetype);
9140 /* This flag will be in the binfo of the base type, we must
9141 clear it after copying the base binfos. */
9142 BINFO_DEPENDENT_BASE_P (base_binfo)
9143 = dependent_type_p (basetype);
9146 base_binfo = make_binfo (size_zero_node, basetype,
9147 NULL_TREE, NULL_TREE);
9149 TREE_VEC_ELT (binfos, i) = base_binfo;
9150 TREE_VEC_ELT (accesses, i) = access;
9151 /* This flag will be in the binfo of the base type, we must
9152 clear it after copying the base binfos. */
9153 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
9155 SET_CLASSTYPE_MARKED (basetype);
9157 /* We are free to modify these bits because they are meaningless
9158 at top level, and BASETYPE is a top-level type. */
9159 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
9161 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
9162 /* Converting to a virtual base class requires looking
9163 up the offset of the virtual base. */
9164 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9167 if (CLASS_TYPE_P (basetype))
9169 TYPE_HAS_NEW_OPERATOR (ref)
9170 |= TYPE_HAS_NEW_OPERATOR (basetype);
9171 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9172 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9173 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9174 /* If the base-class uses multiple inheritance, so do we. */
9175 TYPE_USES_MULTIPLE_INHERITANCE (ref)
9176 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
9177 /* Likewise, if converting to a base of the base may require
9178 code, then we may need to generate code to convert to a
9180 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
9181 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
9186 TREE_VEC_LENGTH (accesses) = TREE_VEC_LENGTH (binfos) = i;
9188 BINFO_BASEACCESSES (binfo) = BINFO_BASETYPES (binfo) = NULL_TREE;
9192 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
9193 /* If there is more than one non-empty they cannot be at the same
9195 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9199 /* Copy the base binfos, collect the virtual bases and set the
9200 inheritance order chain. */
9201 copy_base_binfos (TYPE_BINFO (ref), ref, NULL_TREE);
9202 CLASSTYPE_VBASECLASSES (ref) = nreverse (CLASSTYPE_VBASECLASSES (ref));
9204 if (TYPE_FOR_JAVA (ref))
9206 if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
9207 error ("Java class '%T' cannot have multiple bases", ref);
9208 if (CLASSTYPE_VBASECLASSES (ref))
9209 error ("Java class '%T' cannot have virtual bases", ref);
9212 /* Unmark all the types. */
9215 tree basetype = BINFO_TYPE (BINFO_BASETYPE (TYPE_BINFO (ref), i));
9217 CLEAR_CLASSTYPE_MARKED (basetype);
9218 if (CLASS_TYPE_P (basetype))
9220 TREE_VIA_VIRTUAL (TYPE_BINFO (basetype)) = 0;
9221 BINFO_DEPENDENT_BASE_P (TYPE_BINFO (basetype)) = 0;
9224 CLEAR_CLASSTYPE_MARKED (ref);
9228 /* Begin compiling the definition of an enumeration type.
9229 NAME is its name (or null if anonymous).
9230 Returns the type object, as yet incomplete.
9231 Also records info about it so that build_enumerator
9232 may be used to declare the individual values as they are read. */
9235 start_enum (tree name)
9237 tree enumtype = NULL_TREE;
9238 struct cp_binding_level *b = current_binding_level;
9240 /* If this is the real definition for a previous forward reference,
9241 fill in the contents in the same object that used to be the
9242 forward reference. */
9244 if (name != NULL_TREE)
9245 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
9247 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9249 error ("multiple definition of `%#T'", enumtype);
9250 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9251 /* Clear out TYPE_VALUES, and start again. */
9252 TYPE_VALUES (enumtype) = NULL_TREE;
9256 enumtype = make_node (ENUMERAL_TYPE);
9257 pushtag (name, enumtype, 0);
9263 /* After processing and defining all the values of an enumeration type,
9264 install their decls in the enumeration type and finish it off.
9265 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9268 finish_enum (tree enumtype)
9280 integer_type_kind itk;
9281 tree underlying_type = NULL_TREE;
9283 /* We built up the VALUES in reverse order. */
9284 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9286 /* For an enum defined in a template, just set the type of the values;
9287 all further processing is postponed until the template is
9288 instantiated. We need to set the type so that tsubst of a CONST_DECL
9290 if (processing_template_decl)
9292 for (values = TYPE_VALUES (enumtype);
9294 values = TREE_CHAIN (values))
9295 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9296 if (at_function_scope_p ())
9297 add_stmt (build_min (TAG_DEFN, enumtype));
9301 /* Determine the minimum and maximum values of the enumerators. */
9302 if (TYPE_VALUES (enumtype))
9304 minnode = maxnode = NULL_TREE;
9306 for (values = TYPE_VALUES (enumtype);
9308 values = TREE_CHAIN (values))
9310 decl = TREE_VALUE (values);
9312 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9313 each enumerator has the type of its enumeration. Prior to the
9314 closing brace, the type of each enumerator is the type of its
9315 initializing value. */
9316 TREE_TYPE (decl) = enumtype;
9318 /* Update the minimum and maximum values, if appropriate. */
9319 value = DECL_INITIAL (decl);
9320 /* Figure out what the minimum and maximum values of the
9323 minnode = maxnode = value;
9324 else if (tree_int_cst_lt (maxnode, value))
9326 else if (tree_int_cst_lt (value, minnode))
9329 /* Set the TREE_TYPE for the values as well. That's so that when
9330 we call decl_constant_value we get an entity of the right type
9331 (but with the constant value). But first make a copy so we
9332 don't clobber shared INTEGER_CSTs. */
9333 if (TREE_TYPE (value) != enumtype)
9335 value = DECL_INITIAL (decl) = copy_node (value);
9336 TREE_TYPE (value) = enumtype;
9343 If the enumerator-list is empty, the underlying type is as if
9344 the enumeration had a single enumerator with value 0. */
9345 minnode = maxnode = integer_zero_node;
9347 /* Compute the number of bits require to represent all values of the
9348 enumeration. We must do this before the type of MINNODE and
9349 MAXNODE are transformed, since min_precision relies on the
9350 TREE_TYPE of the value it is passed. */
9351 unsignedp = tree_int_cst_sgn (minnode) >= 0;
9352 lowprec = min_precision (minnode, unsignedp);
9353 highprec = min_precision (maxnode, unsignedp);
9354 precision = MAX (lowprec, highprec);
9356 /* Determine the underlying type of the enumeration.
9360 The underlying type of an enumeration is an integral type that
9361 can represent all the enumerator values defined in the
9362 enumeration. It is implementation-defined which integral type is
9363 used as the underlying type for an enumeration except that the
9364 underlying type shall not be larger than int unless the value of
9365 an enumerator cannot fit in an int or unsigned int.
9367 We use "int" or an "unsigned int" as the underlying type, even if
9368 a smaller integral type would work, unless the user has
9369 explicitly requested that we use the smallest possible type. */
9370 for (itk = (flag_short_enums ? itk_char : itk_int);
9374 underlying_type = integer_types[itk];
9375 if (TYPE_PRECISION (underlying_type) >= precision
9376 && TYPE_UNSIGNED (underlying_type) == unsignedp)
9379 if (itk == itk_none)
9383 IF no integral type can represent all the enumerator values, the
9384 enumeration is ill-formed. */
9385 error ("no integral type can represent all of the enumerator values "
9386 "for `%T'", enumtype);
9387 precision = TYPE_PRECISION (long_long_integer_type_node);
9388 underlying_type = integer_types[itk_unsigned_long_long];
9391 /* Compute the minium and maximum values for the type.
9395 For an enumeration where emin is the smallest enumerator and emax
9396 is the largest, the values of the enumeration are the values of the
9397 underlying type in the range bmin to bmax, where bmin and bmax are,
9398 respectively, the smallest and largest values of the smallest bit-
9399 field that can store emin and emax. */
9400 TYPE_PRECISION (enumtype) = precision;
9401 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9405 The value of sizeof() applied to an enumeration type, an object
9406 of an enumeration type, or an enumerator, is the value of sizeof()
9407 applied to the underlying type. */
9408 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9409 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9410 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9411 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9412 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9413 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9415 /* Convert each of the enumerators to the type of the underlying
9416 type of the enumeration. */
9417 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9419 decl = TREE_VALUE (values);
9420 value = perform_implicit_conversion (underlying_type,
9421 DECL_INITIAL (decl));
9422 TREE_TYPE (value) = enumtype;
9423 DECL_INITIAL (decl) = value;
9424 TREE_VALUE (values) = value;
9427 /* Fix up all variant types of this enum type. */
9428 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9430 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9431 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9432 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9433 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9434 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9435 TYPE_MODE (t) = TYPE_MODE (enumtype);
9436 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9437 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9438 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9439 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9442 /* Finish debugging output for this type. */
9443 rest_of_type_compilation (enumtype, namespace_bindings_p ());
9446 /* Build and install a CONST_DECL for an enumeration constant of the
9447 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9448 Assignment of sequential values by default is handled here. */
9451 build_enumerator (tree name, tree value, tree enumtype)
9457 /* Remove no-op casts from the value. */
9459 STRIP_TYPE_NOPS (value);
9461 if (! processing_template_decl)
9463 /* Validate and default VALUE. */
9464 if (value != NULL_TREE)
9466 value = decl_constant_value (value);
9468 if (TREE_CODE (value) == INTEGER_CST)
9470 value = perform_integral_promotions (value);
9471 constant_expression_warning (value);
9475 error ("enumerator value for `%D' not integer constant", name);
9480 /* Default based on previous value. */
9481 if (value == NULL_TREE)
9485 if (TYPE_VALUES (enumtype))
9487 /* The next value is the previous value ... */
9488 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9490 value = cp_build_binary_op (PLUS_EXPR,
9494 if (tree_int_cst_lt (value, prev_value))
9495 error ("overflow in enumeration values at `%D'", name);
9498 value = integer_zero_node;
9501 /* Remove no-op casts from the value. */
9502 STRIP_TYPE_NOPS (value);
9505 /* C++ associates enums with global, function, or class declarations. */
9506 context = current_scope ();
9508 context = current_namespace;
9510 /* Build the actual enumeration constant. Note that the enumeration
9511 constants have the type of their initializers until the
9512 enumeration is complete:
9516 Following the closing brace of an enum-specifier, each enumer-
9517 ator has the type of its enumeration. Prior to the closing
9518 brace, the type of each enumerator is the type of its
9521 In finish_enum we will reset the type. Of course, if we're
9522 processing a template, there may be no value. */
9523 type = value ? TREE_TYPE (value) : NULL_TREE;
9525 if (context && context == current_class_type)
9526 /* This enum declaration is local to the class. We need the full
9527 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
9528 decl = build_lang_decl (CONST_DECL, name, type);
9530 /* It's a global enum, or it's local to a function. (Note local to
9531 a function could mean local to a class method. */
9532 decl = build_decl (CONST_DECL, name, type);
9534 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9535 TREE_CONSTANT (decl) = 1;
9536 TREE_INVARIANT (decl) = 1;
9537 TREE_READONLY (decl) = 1;
9538 DECL_INITIAL (decl) = value;
9540 if (context && context == current_class_type)
9541 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9542 on the TYPE_FIELDS list for `S'. (That's so that you can say
9543 things like `S::i' later.) */
9544 finish_member_declaration (decl);
9548 /* Add this enumeration constant to the list for this type. */
9549 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
9553 /* We're defining DECL. Make sure that it's type is OK. */
9556 check_function_type (tree decl, tree current_function_parms)
9558 tree fntype = TREE_TYPE (decl);
9559 tree return_type = complete_type (TREE_TYPE (fntype));
9561 /* In a function definition, arg types must be complete. */
9562 require_complete_types_for_parms (current_function_parms);
9564 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
9566 error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
9568 /* Make it return void instead, but don't change the
9569 type of the DECL_RESULT, in case we have a named return value. */
9570 if (TREE_CODE (fntype) == METHOD_TYPE)
9572 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
9574 = build_method_type_directly (ctype,
9576 FUNCTION_ARG_CHAIN (decl));
9580 = build_function_type (void_type_node,
9581 TYPE_ARG_TYPES (TREE_TYPE (decl)));
9583 = build_exception_variant (fntype,
9584 TYPE_RAISES_EXCEPTIONS (fntype));
9587 abstract_virtuals_error (decl, TREE_TYPE (fntype));
9590 /* Create the FUNCTION_DECL for a function definition.
9591 DECLSPECS and DECLARATOR are the parts of the declaration;
9592 they describe the function's name and the type it returns,
9593 but twisted together in a fashion that parallels the syntax of C.
9595 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9596 DECLARATOR is really the DECL for the function we are about to
9597 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9598 indicating that the function is an inline defined in-class.
9600 This function creates a binding context for the function body
9601 as well as setting up the FUNCTION_DECL in current_function_decl.
9603 For C++, we must first check whether that datum makes any sense.
9604 For example, "class A local_a(1,2);" means that variable local_a
9605 is an aggregate of type A, which should have a constructor
9606 applied to it with the argument list [1, 2]. */
9609 start_preparsed_function (tree decl1, tree attrs, int flags)
9611 tree ctype = NULL_TREE;
9614 int doing_friend = 0;
9615 struct cp_binding_level *bl;
9616 tree current_function_parms;
9619 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
9620 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
9622 fntype = TREE_TYPE (decl1);
9623 if (TREE_CODE (fntype) == METHOD_TYPE)
9624 ctype = TYPE_METHOD_BASETYPE (fntype);
9626 /* ISO C++ 11.4/5. A friend function defined in a class is in
9627 the (lexical) scope of the class in which it is defined. */
9628 if (!ctype && DECL_FRIEND_P (decl1))
9630 ctype = DECL_FRIEND_CONTEXT (decl1);
9632 /* CTYPE could be null here if we're dealing with a template;
9633 for example, `inline friend float foo()' inside a template
9634 will have no CTYPE set. */
9635 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
9641 if (DECL_DECLARED_INLINE_P (decl1)
9642 && lookup_attribute ("noinline", attrs))
9643 warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
9645 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
9646 /* This is a constructor, we must ensure that any default args
9647 introduced by this definition are propagated to the clones
9648 now. The clones are used directly in overload resolution. */
9649 adjust_clone_args (decl1);
9651 /* Sometimes we don't notice that a function is a static member, and
9652 build a METHOD_TYPE for it. Fix that up now. */
9653 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
9654 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
9656 revert_static_member_fn (decl1);
9660 /* Set up current_class_type, and enter the scope of the class, if
9663 push_nested_class (ctype);
9664 else if (DECL_STATIC_FUNCTION_P (decl1))
9665 push_nested_class (DECL_CONTEXT (decl1));
9667 /* Now that we have entered the scope of the class, we must restore
9668 the bindings for any template parameters surrounding DECL1, if it
9669 is an inline member template. (Order is important; consider the
9670 case where a template parameter has the same name as a field of
9671 the class.) It is not until after this point that
9672 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
9673 if (flags & SF_INCLASS_INLINE)
9674 maybe_begin_member_template_processing (decl1);
9676 /* Effective C++ rule 15. */
9678 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9679 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
9680 warning ("`operator=' should return a reference to `*this'");
9682 /* Make the init_value nonzero so pushdecl knows this is not tentative.
9683 error_mark_node is replaced below (in poplevel) with the BLOCK. */
9684 if (!DECL_INITIAL (decl1))
9685 DECL_INITIAL (decl1) = error_mark_node;
9687 /* This function exists in static storage.
9688 (This does not mean `static' in the C sense!) */
9689 TREE_STATIC (decl1) = 1;
9691 /* We must call push_template_decl after current_class_type is set
9692 up. (If we are processing inline definitions after exiting a
9693 class scope, current_class_type will be NULL_TREE until set above
9694 by push_nested_class.) */
9695 if (processing_template_decl)
9696 decl1 = push_template_decl (decl1);
9698 /* We are now in the scope of the function being defined. */
9699 current_function_decl = decl1;
9701 /* Save the parm names or decls from this function's declarator
9702 where store_parm_decls will find them. */
9703 current_function_parms = DECL_ARGUMENTS (decl1);
9705 /* Make sure the parameter and return types are reasonable. When
9706 you declare a function, these types can be incomplete, but they
9707 must be complete when you define the function. */
9708 if (! processing_template_decl)
9709 check_function_type (decl1, current_function_parms);
9711 /* Build the return declaration for the function. */
9712 restype = TREE_TYPE (fntype);
9713 /* Promote the value to int before returning it. */
9714 if (c_promoting_integer_type_p (restype))
9715 restype = type_promotes_to (restype);
9716 if (DECL_RESULT (decl1) == NULL_TREE)
9719 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
9720 c_apply_type_quals_to_decl (cp_type_quals (restype),
9721 DECL_RESULT (decl1));
9724 /* Initialize RTL machinery. We cannot do this until
9725 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
9726 even when processing a template; this is how we get
9727 CFUN set up, and our per-function variables initialized.
9728 FIXME factor out the non-RTL stuff. */
9729 bl = current_binding_level;
9730 allocate_struct_function (decl1);
9731 current_binding_level = bl;
9733 /* Even though we're inside a function body, we still don't want to
9734 call expand_expr to calculate the size of a variable-sized array.
9735 We haven't necessarily assigned RTL to all variables yet, so it's
9736 not safe to try to expand expressions involving them. */
9737 immediate_size_expand = 0;
9738 cfun->x_dont_save_pending_sizes_p = 1;
9740 /* Start the statement-tree, start the tree now. */
9741 DECL_SAVED_TREE (decl1) = push_stmt_list ();
9743 /* Let the user know we're compiling this function. */
9744 announce_function (decl1);
9746 /* Record the decl so that the function name is defined.
9747 If we already have a decl for this name, and it is a FUNCTION_DECL,
9748 use the old decl. */
9749 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
9751 /* A specialization is not used to guide overload resolution. */
9752 if (!DECL_FUNCTION_MEMBER_P (decl1)
9753 && !(DECL_USE_TEMPLATE (decl1) &&
9754 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
9756 tree olddecl = pushdecl (decl1);
9758 if (olddecl == error_mark_node)
9759 /* If something went wrong when registering the declaration,
9760 use DECL1; we have to have a FUNCTION_DECL to use when
9761 parsing the body of the function. */
9764 /* Otherwise, OLDDECL is either a previous declaration of
9765 the same function or DECL1 itself. */
9770 /* We need to set the DECL_CONTEXT. */
9771 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
9772 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
9773 /* And make sure we have enough default args. */
9774 check_default_args (decl1);
9776 fntype = TREE_TYPE (decl1);
9779 /* Reset these in case the call to pushdecl changed them. */
9780 current_function_decl = decl1;
9783 /* If we are (erroneously) defining a function that we have already
9784 defined before, wipe out what we knew before. */
9785 if (!DECL_PENDING_INLINE_P (decl1))
9786 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
9788 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
9790 /* We know that this was set up by `grokclassfn'. We do not
9791 wait until `store_parm_decls', since evil parse errors may
9792 never get us to that point. Here we keep the consistency
9793 between `current_class_type' and `current_class_ptr'. */
9794 tree t = DECL_ARGUMENTS (decl1);
9796 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
9798 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
9801 cp_function_chain->x_current_class_ref
9802 = build_indirect_ref (t, NULL);
9803 cp_function_chain->x_current_class_ptr = t;
9805 /* Constructors and destructors need to know whether they're "in
9806 charge" of initializing virtual base classes. */
9808 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
9810 current_in_charge_parm = t;
9813 if (DECL_HAS_VTT_PARM_P (decl1))
9815 if (DECL_NAME (t) != vtt_parm_identifier)
9817 current_vtt_parm = t;
9821 if (DECL_INTERFACE_KNOWN (decl1))
9823 tree ctx = decl_function_context (decl1);
9825 if (DECL_NOT_REALLY_EXTERN (decl1))
9826 DECL_EXTERNAL (decl1) = 0;
9828 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
9829 && TREE_PUBLIC (ctx))
9830 /* This is a function in a local class in an extern inline
9832 comdat_linkage (decl1);
9834 /* If this function belongs to an interface, it is public.
9835 If it belongs to someone else's interface, it is also external.
9836 This only affects inlines and template instantiations. */
9837 else if (interface_unknown == 0
9838 && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9840 if (DECL_DECLARED_INLINE_P (decl1)
9841 || DECL_TEMPLATE_INSTANTIATION (decl1)
9842 || processing_template_decl)
9844 DECL_EXTERNAL (decl1)
9846 || (DECL_DECLARED_INLINE_P (decl1)
9847 && ! flag_implement_inlines
9848 && !DECL_VINDEX (decl1)));
9850 /* For WIN32 we also want to put these in linkonce sections. */
9851 maybe_make_one_only (decl1);
9854 DECL_EXTERNAL (decl1) = 0;
9855 DECL_NOT_REALLY_EXTERN (decl1) = 0;
9856 DECL_INTERFACE_KNOWN (decl1) = 1;
9858 else if (interface_unknown && interface_only
9859 && ! DECL_TEMPLATE_INSTANTIATION (decl1))
9861 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
9862 interface, we will have interface_only set but not
9863 interface_known. In that case, we don't want to use the normal
9864 heuristics because someone will supply a #pragma implementation
9865 elsewhere, and deducing it here would produce a conflict. */
9866 comdat_linkage (decl1);
9867 DECL_EXTERNAL (decl1) = 0;
9868 DECL_INTERFACE_KNOWN (decl1) = 1;
9869 DECL_DEFER_OUTPUT (decl1) = 1;
9873 /* This is a definition, not a reference.
9874 So clear DECL_EXTERNAL. */
9875 DECL_EXTERNAL (decl1) = 0;
9877 if ((DECL_DECLARED_INLINE_P (decl1)
9878 || DECL_TEMPLATE_INSTANTIATION (decl1))
9879 && ! DECL_INTERFACE_KNOWN (decl1)
9880 /* Don't try to defer nested functions for now. */
9881 && ! decl_function_context (decl1))
9882 DECL_DEFER_OUTPUT (decl1) = 1;
9884 DECL_INTERFACE_KNOWN (decl1) = 1;
9887 begin_scope (sk_function_parms, decl1);
9891 if (DECL_DESTRUCTOR_P (decl1))
9893 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
9894 DECL_CONTEXT (dtor_label) = current_function_decl;
9897 start_fname_decls ();
9899 store_parm_decls (current_function_parms);
9903 /* Like start_preparsed_function, except that instead of a
9904 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
9906 Returns 1 on success. If the DECLARATOR is not suitable for a function
9907 (it defines a datum instead), we return 0, which tells
9908 yyparse to report a parse error. */
9911 start_function (cp_decl_specifier_seq *declspecs,
9912 const cp_declarator *declarator,
9917 if (have_extern_spec)
9919 declspecs->storage_class = sc_extern;
9920 /* This should only be done once on the outermost decl. */
9921 have_extern_spec = false;
9924 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
9925 /* If the declarator is not suitable for a function definition,
9926 cause a syntax error. */
9927 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
9930 cplus_decl_attributes (&decl1, attrs, 0);
9932 /* If #pragma weak was used, mark the decl weak now. */
9933 if (global_scope_p (current_binding_level))
9934 maybe_apply_pragma_weak (decl1);
9936 if (DECL_MAIN_P (decl1))
9938 /* If this doesn't return integer_type, or a typedef to
9939 integer_type, complain. */
9940 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node))
9942 if (pedantic || warn_return_type)
9943 pedwarn ("return type for `main' changed to `int'");
9944 TREE_TYPE (decl1) = default_function_type;
9948 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
9953 /* Store the parameter declarations into the current function declaration.
9954 This is called after parsing the parameter declarations, before
9955 digesting the body of the function.
9957 Also install to binding contour return value identifier, if any. */
9960 store_parm_decls (tree current_function_parms)
9962 tree fndecl = current_function_decl;
9965 /* This is a chain of any other decls that came in among the parm
9966 declarations. If a parm is declared with enum {foo, bar} x;
9967 then CONST_DECLs for foo and bar are put here. */
9968 tree nonparms = NULL_TREE;
9970 if (current_function_parms)
9972 /* This case is when the function was defined with an ANSI prototype.
9973 The parms already have decls, so we need not do anything here
9974 except record them as in effect
9975 and complain if any redundant old-style parm decls were written. */
9977 tree specparms = current_function_parms;
9980 /* Must clear this because it might contain TYPE_DECLs declared
9982 current_binding_level->names = NULL;
9984 /* If we're doing semantic analysis, then we'll call pushdecl
9985 for each of these. We must do them in reverse order so that
9986 they end in the correct forward order. */
9987 specparms = nreverse (specparms);
9989 for (parm = specparms; parm; parm = next)
9991 next = TREE_CHAIN (parm);
9992 if (TREE_CODE (parm) == PARM_DECL)
9994 if (DECL_NAME (parm) == NULL_TREE
9995 || TREE_CODE (parm) != VOID_TYPE)
9998 error ("parameter `%D' declared void", parm);
10002 /* If we find an enum constant or a type tag,
10003 put it aside for the moment. */
10004 TREE_CHAIN (parm) = NULL_TREE;
10005 nonparms = chainon (nonparms, parm);
10009 /* Get the decls in their original chain order and record in the
10010 function. This is all and only the PARM_DECLs that were
10011 pushed into scope by the loop above. */
10012 DECL_ARGUMENTS (fndecl) = getdecls ();
10015 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10017 /* Now store the final chain of decls for the arguments
10018 as the decl-chain of the current lexical scope.
10019 Put the enumerators in as well, at the front so that
10020 DECL_ARGUMENTS is not modified. */
10021 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10023 /* Do the starting of the exception specifications, if we have any. */
10024 if (flag_exceptions && !processing_template_decl
10025 && flag_enforce_eh_specs
10026 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10027 current_eh_spec_block = begin_eh_spec_block ();
10031 /* We have finished doing semantic analysis on DECL, but have not yet
10032 generated RTL for its body. Save away our current state, so that
10033 when we want to generate RTL later we know what to do. */
10036 save_function_data (tree decl)
10038 struct language_function *f;
10040 /* Save the language-specific per-function data so that we can
10041 get it back when we really expand this function. */
10042 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
10046 f = ggc_alloc (sizeof (struct language_function));
10047 memcpy (f, cp_function_chain, sizeof (struct language_function));
10048 DECL_SAVED_FUNCTION_DATA (decl) = f;
10050 /* Clear out the bits we don't need. */
10051 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10052 f->x_named_label_uses = NULL;
10053 f->bindings = NULL;
10054 f->x_local_names = NULL;
10057 /* Add a note to mark the beginning of the main body of the constructor.
10058 This is used to set up the data structures for the cleanup regions for
10059 fully-constructed bases and members. */
10062 begin_constructor_body (void)
10066 /* Add a note to mark the end of the main body of the constructor. This is
10067 used to end the cleanup regions for fully-constructed bases and
10071 finish_constructor_body (void)
10075 /* Do all the processing for the beginning of a destructor; set up the
10076 vtable pointers and cleanups for bases and members. */
10079 begin_destructor_body (void)
10082 tree compound_stmt;
10084 /* If the dtor is empty, and we know there is not any possible
10085 way we could use any vtable entries, before they are possibly
10086 set by a base class dtor, we don't have to setup the vtables,
10087 as we know that any base class dtor will set up any vtables
10088 it needs. We avoid MI, because one base class dtor can do a
10089 virtual dispatch to an overridden function that would need to
10090 have a non-related vtable set up, we cannot avoid setting up
10091 vtables in that case. We could change this to see if there
10092 is just one vtable.
10094 ??? In the destructor for a class, the vtables are set
10095 appropriately for that class. There will be no non-related
10096 vtables. jason 2001-12-11. */
10097 if_stmt = begin_if_stmt ();
10099 /* If it is not safe to avoid setting up the vtables, then
10100 someone will change the condition to be boolean_true_node.
10101 (Actually, for now, we do not have code to set the condition
10102 appropriately, so we just assume that we always need to
10103 initialize the vtables.) */
10104 finish_if_stmt_cond (boolean_true_node, if_stmt);
10106 compound_stmt = begin_compound_stmt (0);
10108 /* Make all virtual function table pointers in non-virtual base
10109 classes point to CURRENT_CLASS_TYPE's virtual function
10111 initialize_vtbl_ptrs (current_class_ptr);
10113 finish_compound_stmt (compound_stmt);
10114 finish_then_clause (if_stmt);
10115 finish_if_stmt (if_stmt);
10117 /* And insert cleanups for our bases and members so that they
10118 will be properly destroyed if we throw. */
10119 push_base_cleanups ();
10122 /* At the end of every destructor we generate code to delete the object if
10123 necessary. Do that now. */
10126 finish_destructor_body (void)
10130 /* Any return from a destructor will end up here; that way all base
10131 and member cleanups will be run when the function returns. */
10132 add_stmt (build_stmt (LABEL_EXPR, dtor_label));
10134 /* In a virtual destructor, we must call delete. */
10135 if (DECL_VIRTUAL_P (current_function_decl))
10138 tree virtual_size = cxx_sizeof (current_class_type);
10142 At the point of definition of a virtual destructor (including
10143 an implicit definition), non-placement operator delete shall
10144 be looked up in the scope of the destructor's class and if
10145 found shall be accessible and unambiguous. */
10146 exprstmt = build_op_delete_call
10147 (DELETE_EXPR, current_class_ptr, virtual_size,
10148 /*global_p=*/false, NULL_TREE);
10150 if_stmt = begin_if_stmt ();
10151 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
10152 current_in_charge_parm,
10155 finish_expr_stmt (exprstmt);
10156 finish_then_clause (if_stmt);
10157 finish_if_stmt (if_stmt);
10161 /* Do the necessary processing for the beginning of a function body, which
10162 in this case includes member-initializers, but not the catch clauses of
10163 a function-try-block. Currently, this means opening a binding level
10164 for the member-initializers (in a ctor) and member cleanups (in a dtor).
10165 In other functions, this isn't necessary, but it doesn't hurt. */
10168 begin_function_body (void)
10172 if (processing_template_decl)
10173 /* Do nothing now. */;
10175 /* Always keep the BLOCK node associated with the outermost pair of
10176 curly braces of a function. These are needed for correct
10177 operation of dwarfout.c. */
10178 keep_next_level (true);
10180 stmt = begin_compound_stmt (BCS_FN_BODY);
10182 if (processing_template_decl)
10183 /* Do nothing now. */;
10184 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10185 begin_constructor_body ();
10186 else if (DECL_DESTRUCTOR_P (current_function_decl))
10187 begin_destructor_body ();
10192 /* Do the processing for the end of a function body. Currently, this means
10193 closing out the cleanups for fully-constructed bases and members, and in
10194 the case of the destructor, deleting the object if desired. Again, this
10195 is only meaningful for [cd]tors, since they are the only functions where
10196 there is a significant distinction between the main body and any
10197 function catch clauses. Handling, say, main() return semantics here
10198 would be wrong, as flowing off the end of a function catch clause for
10199 main() would also need to return 0. */
10202 finish_function_body (tree compstmt)
10204 /* Close the block. */
10205 finish_compound_stmt (compstmt);
10207 if (processing_template_decl)
10208 /* Do nothing now. */;
10209 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10210 finish_constructor_body ();
10211 else if (DECL_DESTRUCTOR_P (current_function_decl))
10212 finish_destructor_body ();
10215 /* Finish up a function declaration and compile that function
10216 all the way to assembler language output. The free the storage
10217 for the function definition.
10219 FLAGS is a bitwise or of the following values:
10221 We just finished processing the body of an in-class inline
10222 function definition. (This processing will have taken place
10223 after the class definition is complete.) */
10226 finish_function (int flags)
10228 tree fndecl = current_function_decl;
10229 tree fntype, ctype = NULL_TREE;
10230 int inclass_inline = (flags & 2) != 0;
10233 /* When we get some parse errors, we can end up without a
10234 current_function_decl, so cope. */
10235 if (fndecl == NULL_TREE)
10236 return error_mark_node;
10238 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10239 && DECL_VIRTUAL_P (fndecl)
10240 && !processing_template_decl)
10242 tree fnclass = DECL_CONTEXT (fndecl);
10243 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10244 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10247 nested = function_depth > 1;
10248 fntype = TREE_TYPE (fndecl);
10250 /* TREE_READONLY (fndecl) = 1;
10251 This caused &foo to be of type ptr-to-const-function
10252 which then got a warning when stored in a ptr-to-function variable. */
10254 my_friendly_assert (building_stmt_tree (), 20000911);
10256 /* For a cloned function, we've already got all the code we need;
10257 there's no need to add any extra bits. */
10258 if (!DECL_CLONED_FUNCTION_P (fndecl))
10260 if (DECL_MAIN_P (current_function_decl))
10262 /* Make it so that `main' always returns 0 by default. */
10264 finish_return_stmt (integer_one_node);
10266 finish_return_stmt (integer_zero_node);
10270 /* Finish dealing with exception specifiers. */
10271 if (flag_exceptions && !processing_template_decl
10272 && flag_enforce_eh_specs
10273 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10274 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10275 (TREE_TYPE (current_function_decl)),
10276 current_eh_spec_block);
10279 /* If we're saving up tree structure, tie off the function now. */
10280 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10282 finish_fname_decls ();
10284 /* If this function can't throw any exceptions, remember that. */
10285 if (!processing_template_decl
10286 && !cp_function_chain->can_throw
10287 && !flag_non_call_exceptions)
10288 TREE_NOTHROW (fndecl) = 1;
10290 /* This must come after expand_function_end because cleanups might
10291 have declarations (from inline functions) that need to go into
10292 this function's blocks. */
10294 /* If the current binding level isn't the outermost binding level
10295 for this function, either there is a bug, or we have experienced
10296 syntax errors and the statement tree is malformed. */
10297 if (current_binding_level->kind != sk_function_parms)
10299 /* Make sure we have already experienced errors. */
10300 if (errorcount == 0)
10303 /* Throw away the broken statement tree and extra binding
10305 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10307 while (current_binding_level->kind != sk_function_parms)
10309 if (current_binding_level->kind == sk_class)
10310 pop_nested_class ();
10312 poplevel (0, 0, 0);
10315 poplevel (1, 0, 1);
10317 /* Statements should always be full-expressions at the outermost set
10318 of curly braces for a function. */
10319 my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
10321 /* Set up the named return value optimization, if we can. Candidate
10322 variables are selected in check_return_value. */
10323 if (current_function_return_value)
10325 tree r = current_function_return_value;
10328 if (r != error_mark_node
10329 /* This is only worth doing for fns that return in memory--and
10330 simpler, since we don't have to worry about promoted modes. */
10331 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10332 /* Only allow this for variables declared in the outer scope of
10333 the function so we know that their lifetime always ends with a
10334 return; see g++.dg/opt/nrv6.C. We could be more flexible if
10335 we were to do this optimization in tree-ssa. */
10336 && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)))
10337 /* Skip the artificial function body block. */
10338 && (outer = BLOCK_SUBBLOCKS (outer))
10339 && chain_member (r, BLOCK_VARS (outer)))
10340 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10342 current_function_return_value = NULL_TREE;
10345 /* Remember that we were in class scope. */
10346 if (current_class_name)
10347 ctype = current_class_type;
10349 /* Must mark the RESULT_DECL as being in this function. */
10350 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10352 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10353 to the FUNCTION_DECL node itself. */
10354 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10356 /* Save away current state, if appropriate. */
10357 if (!processing_template_decl)
10358 save_function_data (fndecl);
10360 /* Complain if there's just no return statement. */
10361 if (warn_return_type
10362 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10363 && !dependent_type_p (TREE_TYPE (fntype))
10364 && !current_function_returns_value && !current_function_returns_null
10365 /* Don't complain if we abort or throw. */
10366 && !current_function_returns_abnormally
10367 && !DECL_NAME (DECL_RESULT (fndecl)))
10369 /* Enable this for all functions until bug 14107 is fixed properly. */
10370 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
10371 inline function, as we might never be compiled separately. */
10372 && (DECL_INLINE (fndecl) || processing_template_decl))
10374 warning ("no return statement in function returning non-void");
10376 /* Store the end of the function, so that we get good line number
10377 info for the epilogue. */
10378 cfun->function_end_locus = input_location;
10380 /* Genericize before inlining. */
10381 if (!processing_template_decl)
10383 cp_genericize (fndecl);
10385 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
10386 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10389 /* We're leaving the context of this function, so zap cfun. It's still in
10390 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
10392 current_function_decl = NULL;
10394 /* If this is an in-class inline definition, we may have to pop the
10395 bindings for the template parameters that we added in
10396 maybe_begin_member_template_processing when start_function was
10398 if (inclass_inline)
10399 maybe_end_member_template_processing ();
10401 /* Leave the scope of the class. */
10403 pop_nested_class ();
10409 /* Let the error reporting routines know that we're outside a
10410 function. For a nested function, this value is used in
10411 cxx_pop_function_context and then reset via pop_function_context. */
10412 current_function_decl = NULL_TREE;
10417 /* Create the FUNCTION_DECL for a function definition.
10418 DECLSPECS and DECLARATOR are the parts of the declaration;
10419 they describe the return type and the name of the function,
10420 but twisted together in a fashion that parallels the syntax of C.
10422 This function creates a binding context for the function body
10423 as well as setting up the FUNCTION_DECL in current_function_decl.
10425 Returns a FUNCTION_DECL on success.
10427 If the DECLARATOR is not suitable for a function (it defines a datum
10428 instead), we return 0, which tells yyparse to report a parse error.
10430 May return void_type_node indicating that this method is actually
10431 a friend. See grokfield for more details.
10433 Came here with a `.pushlevel' .
10435 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10436 CHANGES TO CODE IN `grokfield'. */
10439 start_method (cp_decl_specifier_seq *declspecs,
10440 const cp_declarator *declarator, tree attrlist)
10442 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10445 if (fndecl == error_mark_node)
10446 return error_mark_node;
10448 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10450 error ("invalid member function declaration");
10451 return error_mark_node;
10455 cplus_decl_attributes (&fndecl, attrlist, 0);
10457 /* Pass friends other than inline friend functions back. */
10458 if (fndecl == void_type_node)
10461 if (DECL_IN_AGGR_P (fndecl))
10463 if (DECL_CONTEXT (fndecl)
10464 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10465 error ("`%D' is already defined in class `%T'", fndecl,
10466 DECL_CONTEXT (fndecl));
10467 return void_type_node;
10470 check_template_shadow (fndecl);
10472 DECL_DECLARED_INLINE_P (fndecl) = 1;
10473 if (flag_default_inline)
10474 DECL_INLINE (fndecl) = 1;
10476 /* We process method specializations in finish_struct_1. */
10477 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10479 fndecl = push_template_decl (fndecl);
10480 if (fndecl == error_mark_node)
10484 if (! DECL_FRIEND_P (fndecl))
10486 if (TREE_CHAIN (fndecl))
10488 fndecl = copy_node (fndecl);
10489 TREE_CHAIN (fndecl) = NULL_TREE;
10491 grok_special_member_properties (fndecl);
10494 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10496 /* Make a place for the parms. */
10497 begin_scope (sk_function_parms, fndecl);
10499 DECL_IN_AGGR_P (fndecl) = 1;
10503 /* Go through the motions of finishing a function definition.
10504 We don't compile this method until after the whole class has
10507 FINISH_METHOD must return something that looks as though it
10508 came from GROKFIELD (since we are defining a method, after all).
10510 This is called after parsing the body of the function definition.
10511 STMTS is the chain of statements that makes up the function body.
10513 DECL is the ..._DECL that `start_method' provided. */
10516 finish_method (tree decl)
10518 tree fndecl = decl;
10523 if (decl == void_type_node)
10526 old_initial = DECL_INITIAL (fndecl);
10528 /* Undo the level for the parms (from start_method).
10529 This is like poplevel, but it causes nothing to be
10530 saved. Saving information here confuses symbol-table
10531 output routines. Besides, this information will
10532 be correctly output when this method is actually
10535 /* Clear out the meanings of the local variables of this level;
10536 also record in each decl which block it belongs to. */
10538 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
10540 if (DECL_NAME (link) != NULL_TREE)
10541 pop_binding (DECL_NAME (link), link);
10542 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
10543 DECL_CONTEXT (link) = NULL_TREE;
10546 poplevel (0, 0, 0);
10548 DECL_INITIAL (fndecl) = old_initial;
10550 /* We used to check if the context of FNDECL was different from
10551 current_class_type as another way to get inside here. This didn't work
10552 for String.cc in libg++. */
10553 if (DECL_FRIEND_P (fndecl))
10555 CLASSTYPE_INLINE_FRIENDS (current_class_type)
10556 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
10557 decl = void_type_node;
10564 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
10565 we can lay it out later, when and if its type becomes complete. */
10568 maybe_register_incomplete_var (tree var)
10570 my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
10572 /* Keep track of variables with incomplete types. */
10573 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
10574 && DECL_EXTERNAL (var))
10576 tree inner_type = TREE_TYPE (var);
10578 while (TREE_CODE (inner_type) == ARRAY_TYPE)
10579 inner_type = TREE_TYPE (inner_type);
10580 inner_type = TYPE_MAIN_VARIANT (inner_type);
10582 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
10583 /* RTTI TD entries are created while defining the type_info. */
10584 || (TYPE_LANG_SPECIFIC (inner_type)
10585 && TYPE_BEING_DEFINED (inner_type)))
10586 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
10590 /* Called when a class type (given by TYPE) is defined. If there are
10591 any existing VAR_DECLs whose type hsa been completed by this
10592 declaration, update them now. */
10595 complete_vars (tree type)
10597 tree *list = &incomplete_vars;
10599 my_friendly_assert (CLASS_TYPE_P (type), 20020406);
10602 if (same_type_p (type, TREE_PURPOSE (*list)))
10604 tree var = TREE_VALUE (*list);
10605 /* Complete the type of the variable. The VAR_DECL itself
10606 will be laid out in expand_expr. */
10607 complete_type (TREE_TYPE (var));
10608 /* Remove this entry from the list. */
10609 *list = TREE_CHAIN (*list);
10612 list = &TREE_CHAIN (*list);
10616 /* If DECL is of a type which needs a cleanup, build that cleanup
10620 cxx_maybe_build_cleanup (tree decl)
10622 tree type = TREE_TYPE (decl);
10624 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
10626 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
10629 if (TREE_CODE (type) == ARRAY_TYPE)
10633 cxx_mark_addressable (decl);
10634 rval = build_unary_op (ADDR_EXPR, decl, 0);
10637 /* Optimize for space over speed here. */
10638 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
10639 || flag_expensive_optimizations)
10640 flags |= LOOKUP_NONVIRTUAL;
10642 rval = build_delete (TREE_TYPE (rval), rval,
10643 sfk_complete_destructor, flags, 0);
10645 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
10646 && ! TYPE_HAS_DESTRUCTOR (type))
10647 rval = build_compound_expr (rval, build_vbase_delete (type, decl));
10654 /* When a stmt has been parsed, this function is called. */
10661 /* DECL was originally constructed as a non-static member function,
10662 but turned out to be static. Update it accordingly. */
10665 revert_static_member_fn (tree decl)
10668 tree function = TREE_TYPE (decl);
10669 tree args = TYPE_ARG_TYPES (function);
10671 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
10672 != TYPE_UNQUALIFIED)
10673 error ("static member function `%#D' declared with type qualifiers",
10676 args = TREE_CHAIN (args);
10677 tmp = build_function_type (TREE_TYPE (function), args);
10678 tmp = build_qualified_type (tmp, cp_type_quals (function));
10679 tmp = build_exception_variant (tmp,
10680 TYPE_RAISES_EXCEPTIONS (function));
10681 TREE_TYPE (decl) = tmp;
10682 if (DECL_ARGUMENTS (decl))
10683 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
10684 DECL_STATIC_FUNCTION_P (decl) = 1;
10687 /* Initialize the variables used during compilation of a C++
10691 cxx_push_function_context (struct function * f)
10693 struct language_function *p
10694 = ggc_alloc_cleared (sizeof (struct language_function));
10697 /* Whenever we start a new function, we destroy temporaries in the
10699 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
10705 if (DECL_SAVED_FUNCTION_DATA (fn))
10707 /* If we already parsed this function, and we're just expanding it
10708 now, restore saved state. */
10709 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
10711 /* We don't need the saved data anymore. Unless this is an inline
10712 function; we need the named return value info for
10713 cp_copy_res_decl_for_inlining. */
10714 if (! DECL_INLINE (fn))
10715 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
10720 /* Free the language-specific parts of F, now that we've finished
10721 compiling the function. */
10724 cxx_pop_function_context (struct function * f)
10729 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
10730 one of the language-independent trees. */
10732 enum cp_tree_node_structure_enum
10733 cp_tree_node_structure (union lang_tree_node * t)
10735 switch (TREE_CODE (&t->generic))
10737 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
10738 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
10739 case OVERLOAD: return TS_CP_OVERLOAD;
10740 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
10741 case PTRMEM_CST: return TS_CP_PTRMEM;
10742 case BASELINK: return TS_CP_BASELINK;
10743 default: return TS_CP_GENERIC;
10747 /* Build the void_list_node (void_type_node having been created). */
10749 build_void_list_node (void)
10751 tree t = build_tree_list (NULL_TREE, void_type_node);
10756 cp_missing_noreturn_ok_p (tree decl)
10758 /* A missing noreturn is ok for the `main' function. */
10759 return DECL_MAIN_P (decl);
10762 #include "gt-cp-decl.h"
10763 #include "gtype-cp.h"