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, 2005 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, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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 grokvardecl (tree, tree, const cp_decl_specifier_seq *,
66 static void record_unknown_type (tree, const char *);
67 static tree builtin_function_1 (const char *, tree, tree,
68 enum built_in_function code,
69 enum built_in_class cl, const char *,
71 static tree build_library_fn_1 (tree, enum tree_code, tree);
72 static int member_function_or_else (tree, tree, enum overload_flags);
73 static void bad_specifiers (tree, const char *, int, int, int, int,
75 static void check_for_uninitialized_const_var (tree);
76 static hashval_t typename_hash (const void *);
77 static int typename_compare (const void *, const void *);
78 static tree local_variable_p_walkfn (tree *, int *, void *);
79 static tree record_builtin_java_type (const char *, int);
80 static const char *tag_name (enum tag_types);
81 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
83 static tree make_label_decl (tree, int);
84 static void use_label (tree);
85 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
87 static void check_previous_goto (struct named_label_use_list *);
88 static void check_switch_goto (struct cp_binding_level *);
89 static void check_previous_gotos (tree);
90 static void pop_label (tree, tree);
91 static void pop_labels (tree);
92 static void maybe_deduce_size_from_array_init (tree, tree);
93 static void layout_var_decl (tree);
94 static void maybe_commonize_var (tree);
95 static tree check_initializer (tree, tree, int, tree *);
96 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
97 static void save_function_data (tree);
98 static void check_function_type (tree, tree);
99 static void finish_constructor_body (void);
100 static void begin_destructor_body (void);
101 static void finish_destructor_body (void);
102 static tree create_array_type_for_decl (tree, tree, tree);
103 static tree get_atexit_node (void);
104 static tree get_dso_handle_node (void);
105 static tree start_cleanup_fn (void);
106 static void end_cleanup_fn (void);
107 static tree cp_make_fname_decl (tree, int);
108 static void initialize_predefined_identifiers (void);
109 static tree check_special_function_return_type
110 (special_function_kind, tree, tree);
111 static tree push_cp_library_fn (enum tree_code, tree);
112 static tree build_cp_library_fn (tree, enum tree_code, tree);
113 static void store_parm_decls (tree);
114 static void initialize_local_var (tree, tree);
115 static void expand_static_init (tree, tree);
116 static tree next_initializable_field (tree);
118 /* The following symbols are subsumed in the cp_global_trees array, and
119 listed here individually for documentation purposes.
122 tree wchar_decl_node;
124 tree vtable_entry_type;
125 tree delta_type_node;
126 tree __t_desc_type_node;
128 tree class_type_node;
129 tree unknown_type_node;
131 Array type `vtable_entry_type[]'
134 tree vtbl_ptr_type_node;
141 A FUNCTION_DECL which can call `abort'. Not necessarily the
142 one that the user will declare, but sufficient to be called
143 by routines that want to abort the program.
147 The FUNCTION_DECL for the default `::operator delete'.
149 tree global_delete_fndecl;
152 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
157 tree cp_global_trees[CPTI_MAX];
159 /* Indicates that there is a type value in some namespace, although
160 that is not necessarily in scope at the moment. */
162 tree global_type_node;
164 /* The node that holds the "name" of the global scope. */
165 tree global_scope_name;
167 /* Used only for jumps to as-yet undefined labels, since jumps to
168 defined labels can have their validity checked immediately. */
170 struct named_label_use_list GTY(())
172 struct cp_binding_level *binding_level;
175 location_t o_goto_locus;
176 struct named_label_use_list *next;
179 #define named_label_uses cp_function_chain->x_named_label_uses
181 #define local_names cp_function_chain->x_local_names
183 /* A list of objects which have constructors or destructors
184 which reside in the global scope. The decl is stored in
185 the TREE_VALUE slot and the initializer is stored
186 in the TREE_PURPOSE slot. */
187 tree static_aggregates;
191 /* A node for the integer constants 2, and 3. */
193 tree integer_two_node, integer_three_node;
195 /* A list of all LABEL_DECLs in the function that have names. Here so
196 we can clear out their names' definitions at the end of the
197 function, and so we can check the validity of jumps to these labels. */
199 struct named_label_list GTY(())
201 struct cp_binding_level *binding_level;
206 struct named_label_list *next;
207 unsigned int in_try_scope : 1;
208 unsigned int in_catch_scope : 1;
211 #define named_labels cp_function_chain->x_named_labels
213 /* The number of function bodies which we are currently processing.
214 (Zero if we are at namespace scope, one inside the body of a
215 function, two inside the body of a function in a local class, etc.) */
218 /* States indicating how grokdeclarator() should handle declspecs marked
219 with __attribute__((deprecated)). An object declared as
220 __attribute__((deprecated)) suppresses warnings of uses of other
223 enum deprecated_states {
228 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
230 /* True if a declaration with an `extern' linkage specifier is being
232 bool have_extern_spec;
235 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
236 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
237 time the VAR_DECL was declared, the type was incomplete. */
239 static GTY(()) tree incomplete_vars;
241 /* Returns the kind of template specialization we are currently
242 processing, given that it's declaration contained N_CLASS_SCOPES
243 explicit scope qualifications. */
246 current_tmpl_spec_kind (int n_class_scopes)
248 int n_template_parm_scopes = 0;
249 int seen_specialization_p = 0;
250 int innermost_specialization_p = 0;
251 struct cp_binding_level *b;
253 /* Scan through the template parameter scopes. */
254 for (b = current_binding_level;
255 b->kind == sk_template_parms;
258 /* If we see a specialization scope inside a parameter scope,
259 then something is wrong. That corresponds to a declaration
262 template <class T> template <> ...
264 which is always invalid since [temp.expl.spec] forbids the
265 specialization of a class member template if the enclosing
266 class templates are not explicitly specialized as well. */
267 if (b->explicit_spec_p)
269 if (n_template_parm_scopes == 0)
270 innermost_specialization_p = 1;
272 seen_specialization_p = 1;
274 else if (seen_specialization_p == 1)
275 return tsk_invalid_member_spec;
277 ++n_template_parm_scopes;
280 /* Handle explicit instantiations. */
281 if (processing_explicit_instantiation)
283 if (n_template_parm_scopes != 0)
284 /* We've seen a template parameter list during an explicit
285 instantiation. For example:
287 template <class T> template void f(int);
289 This is erroneous. */
290 return tsk_invalid_expl_inst;
292 return tsk_expl_inst;
295 if (n_template_parm_scopes < n_class_scopes)
296 /* We've not seen enough template headers to match all the
297 specialized classes present. For example:
299 template <class T> void R<T>::S<T>::f(int);
301 This is invalid; there needs to be one set of template
302 parameters for each class. */
303 return tsk_insufficient_parms;
304 else if (n_template_parm_scopes == n_class_scopes)
305 /* We're processing a non-template declaration (even though it may
306 be a member of a template class.) For example:
308 template <class T> void S<T>::f(int);
310 The `class T' maches the `S<T>', leaving no template headers
311 corresponding to the `f'. */
313 else if (n_template_parm_scopes > n_class_scopes + 1)
314 /* We've got too many template headers. For example:
316 template <> template <class T> void f (T);
318 There need to be more enclosing classes. */
319 return tsk_excessive_parms;
321 /* This must be a template. It's of the form:
323 template <class T> template <class U> void S<T>::f(U);
325 This is a specialization if the innermost level was a
326 specialization; otherwise it's just a definition of the
328 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
331 /* Exit the current scope. */
339 /* When a label goes out of scope, check to see if that label was used
340 in a valid manner, and issue any appropriate warnings or errors. */
343 pop_label (tree label, tree old_value)
345 if (!processing_template_decl)
347 if (DECL_INITIAL (label) == NULL_TREE)
351 error ("label %q+D used but not defined", label);
352 #ifdef USE_MAPPED_LOCATION
353 location = input_location; /* FIXME want (input_filename, (line)0) */
355 location.file = input_filename;
358 /* Avoid crashing later. */
359 define_label (location, DECL_NAME (label));
361 else if (warn_unused_label && !TREE_USED (label))
362 warning (0, "label %q+D defined but not used", label);
365 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
368 /* At the end of a function, all labels declared within the function
369 go out of scope. BLOCK is the top-level block for the
373 pop_labels (tree block)
375 struct named_label_list *link;
377 /* Clear out the definitions of all label names, since their scopes
379 for (link = named_labels; link; link = link->next)
381 pop_label (link->label_decl, link->old_value);
382 /* Put the labels into the "variables" of the top-level block,
383 so debugger can see them. */
384 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
385 BLOCK_VARS (block) = link->label_decl;
391 /* The following two routines are used to interface to Objective-C++.
392 The binding level is purposely treated as an opaque type. */
395 objc_get_current_scope (void)
397 return current_binding_level;
400 /* The following routine is used by the NeXT-style SJLJ exceptions;
401 variables get marked 'volatile' so as to not be clobbered by
402 _setjmp()/_longjmp() calls. All variables in the current scope,
403 as well as parent scopes up to (but not including) ENCLOSING_BLK
404 shall be thusly marked. */
407 objc_mark_locals_volatile (void *enclosing_blk)
409 struct cp_binding_level *scope;
411 for (scope = current_binding_level;
412 scope && scope != enclosing_blk;
413 scope = scope->level_chain)
417 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
418 objc_volatilize_decl (decl);
420 /* Do not climb up past the current function. */
421 if (scope->kind == sk_function_parms)
426 /* Exit a binding level.
427 Pop the level off, and restore the state of the identifier-decl mappings
428 that were in effect when this level was entered.
430 If KEEP == 1, this level had explicit declarations, so
431 and create a "block" (a BLOCK node) for the level
432 to record its declarations and subblocks for symbol table output.
434 If FUNCTIONBODY is nonzero, this level is the body of a function,
435 so create a block as if KEEP were set and also clear out all
438 If REVERSE is nonzero, reverse the order of decls before putting
439 them into the BLOCK. */
442 poplevel (int keep, int reverse, int functionbody)
445 /* The chain of decls was accumulated in reverse order.
446 Put it into forward order, just for cleanliness. */
448 int tmp = functionbody;
449 int real_functionbody;
453 int leaving_for_scope;
456 timevar_push (TV_NAME_LOOKUP);
461 gcc_assert (current_binding_level->kind != sk_class);
463 real_functionbody = (current_binding_level->kind == sk_cleanup
464 ? ((functionbody = 0), tmp) : functionbody);
465 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
467 gcc_assert (!VEC_length(cp_class_binding,
468 current_binding_level->class_shadowed));
470 /* We used to use KEEP == 2 to indicate that the new block should go
471 at the beginning of the list of blocks at this binding level,
472 rather than the end. This hack is no longer used. */
473 gcc_assert (keep == 0 || keep == 1);
475 if (current_binding_level->keep)
478 /* Any uses of undefined labels, and any defined labels, now operate
479 under constraints of next binding contour. */
480 if (cfun && !functionbody)
482 struct cp_binding_level *level_chain;
483 level_chain = current_binding_level->level_chain;
486 struct named_label_use_list *uses;
487 struct named_label_list *labels;
488 for (labels = named_labels; labels; labels = labels->next)
489 if (labels->binding_level == current_binding_level)
492 if (current_binding_level->kind == sk_try)
493 labels->in_try_scope = 1;
494 if (current_binding_level->kind == sk_catch)
495 labels->in_catch_scope = 1;
496 for (decl = labels->names_in_scope; decl;
497 decl = TREE_CHAIN (decl))
498 if (decl_jump_unsafe (decl))
499 labels->bad_decls = tree_cons (NULL_TREE, decl,
501 labels->binding_level = level_chain;
502 labels->names_in_scope = level_chain->names;
505 for (uses = named_label_uses; uses; uses = uses->next)
506 if (uses->binding_level == current_binding_level)
508 uses->binding_level = level_chain;
509 uses->names_in_scope = level_chain->names;
514 /* Get the decls in the order they were written.
515 Usually current_binding_level->names is in reverse order.
516 But parameter decls were previously put in forward order. */
519 current_binding_level->names
520 = decls = nreverse (current_binding_level->names);
522 decls = current_binding_level->names;
524 /* If there were any declarations or structure tags in that level,
525 or if this level is a function body,
526 create a BLOCK to record them for the life of this function. */
528 if (keep == 1 || functionbody)
529 block = make_node (BLOCK);
530 if (block != NULL_TREE)
532 BLOCK_VARS (block) = decls;
533 BLOCK_SUBBLOCKS (block) = subblocks;
536 /* In each subblock, record that this is its superior. */
538 for (link = subblocks; link; link = TREE_CHAIN (link))
539 BLOCK_SUPERCONTEXT (link) = block;
541 /* We still support the old for-scope rules, whereby the variables
542 in a for-init statement were in scope after the for-statement
543 ended. We only use the new rules if flag_new_for_scope is
546 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
548 /* Before we remove the declarations first check for unused variables. */
549 if (warn_unused_variable
550 && !processing_template_decl)
551 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
552 if (TREE_CODE (decl) == VAR_DECL
553 && ! TREE_USED (decl)
554 && ! DECL_IN_SYSTEM_HEADER (decl)
555 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
556 warning (0, "unused variable %q+D", decl);
558 /* Remove declarations for all the DECLs in this level. */
559 for (link = decls; link; link = TREE_CHAIN (link))
561 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
564 tree name = DECL_NAME (link);
568 ob = outer_binding (name,
569 IDENTIFIER_BINDING (name),
572 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
574 ns_binding = NULL_TREE;
576 if (ob && ob->scope == current_binding_level->level_chain)
577 /* We have something like:
582 and we are leaving the `for' scope. There's no reason to
583 keep the binding of the inner `i' in this case. */
584 pop_binding (name, link);
585 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
586 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
587 /* Here, we have something like:
595 We must pop the for-scope binding so we know what's a
596 type and what isn't. */
597 pop_binding (name, link);
600 /* Mark this VAR_DECL as dead so that we can tell we left it
601 there only for backward compatibility. */
602 DECL_DEAD_FOR_LOCAL (link) = 1;
604 /* Keep track of what should have happened when we
605 popped the binding. */
608 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
609 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
612 /* Add it to the list of dead variables in the next
613 outermost binding to that we can remove these when we
614 leave that binding. */
615 current_binding_level->level_chain->dead_vars_from_for
616 = tree_cons (NULL_TREE, link,
617 current_binding_level->level_chain->
620 /* Although we don't pop the cxx_binding, we do clear
621 its SCOPE since the scope is going away now. */
622 IDENTIFIER_BINDING (name)->scope
623 = current_binding_level->level_chain;
630 /* Remove the binding. */
633 if (TREE_CODE (decl) == TREE_LIST)
634 decl = TREE_VALUE (decl);
637 if (TREE_CODE (name) == OVERLOAD)
638 name = OVL_FUNCTION (name);
640 gcc_assert (DECL_P (name));
641 pop_binding (DECL_NAME (name), decl);
645 /* Remove declarations for any `for' variables from inner scopes
646 that we kept around. */
647 for (link = current_binding_level->dead_vars_from_for;
648 link; link = TREE_CHAIN (link))
649 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
651 /* Restore the IDENTIFIER_TYPE_VALUEs. */
652 for (link = current_binding_level->type_shadowed;
653 link; link = TREE_CHAIN (link))
654 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
656 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
657 for (link = current_binding_level->shadowed_labels;
659 link = TREE_CHAIN (link))
660 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
662 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
663 list if a `using' declaration put them there. The debugging
664 back-ends won't understand OVERLOAD, so we remove them here.
665 Because the BLOCK_VARS are (temporarily) shared with
666 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
667 popped all the bindings. */
672 for (d = &BLOCK_VARS (block); *d; )
674 if (TREE_CODE (*d) == TREE_LIST)
675 *d = TREE_CHAIN (*d);
677 d = &TREE_CHAIN (*d);
681 /* If the level being exited is the top level of a function,
682 check over all the labels. */
685 /* Since this is the top level block of a function, the vars are
686 the function's parameters. Don't leave them in the BLOCK
687 because they are found in the FUNCTION_DECL instead. */
688 BLOCK_VARS (block) = 0;
692 kind = current_binding_level->kind;
693 if (kind == sk_cleanup)
697 /* If this is a temporary binding created for a cleanup, then we'll
698 have pushed a statement list level. Pop that, create a new
699 BIND_EXPR for the block, and insert it into the stream. */
700 stmt = pop_stmt_list (current_binding_level->statement_list);
701 stmt = c_build_bind_expr (block, stmt);
707 DECL_INITIAL (current_function_decl) = block;
709 current_binding_level->blocks
710 = chainon (current_binding_level->blocks, block);
712 /* If we did not make a block for the level just exited,
713 any blocks made for inner levels
714 (since they cannot be recorded as subblocks in that level)
715 must be carried forward so they will later become subblocks
716 of something else. */
718 current_binding_level->blocks
719 = chainon (current_binding_level->blocks, subblocks);
721 /* Each and every BLOCK node created here in `poplevel' is important
722 (e.g. for proper debugging information) so if we created one
723 earlier, mark it as "used". */
725 TREE_USED (block) = 1;
727 /* All temporary bindings created for cleanups are popped silently. */
728 if (kind == sk_cleanup)
731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
734 /* Insert BLOCK at the end of the list of subblocks of the
735 current binding level. This is used when a BIND_EXPR is expanded,
736 to handle the BLOCK node inside the BIND_EXPR. */
739 insert_block (tree block)
741 TREE_USED (block) = 1;
742 current_binding_level->blocks
743 = chainon (current_binding_level->blocks, block);
746 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
747 itself, calling F for each. The DATA is passed to F as well. */
750 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
753 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
755 result |= (*f) (namespace, data);
757 for (; current; current = TREE_CHAIN (current))
758 result |= walk_namespaces_r (current, f, data);
763 /* Walk all the namespaces, calling F for each. The DATA is passed to
767 walk_namespaces (walk_namespaces_fn f, void* data)
769 return walk_namespaces_r (global_namespace, f, data);
772 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
773 DATA is non-NULL, this is the last time we will call
774 wrapup_global_declarations for this NAMESPACE. */
777 wrapup_globals_for_namespace (tree namespace, void* data)
779 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
780 VEC(tree,gc) *statics = level->static_decls;
781 tree *vec = VEC_address (tree, statics);
782 int len = VEC_length (tree, statics);
783 int last_time = (data != 0);
787 check_global_declarations (vec, len);
788 emit_debug_global_declarations (vec, len);
792 /* Write out any globals that need to be output. */
793 return wrapup_global_declarations (vec, len);
797 /* In C++, you don't have to write `struct S' to refer to `S'; you
798 can just use `S'. We accomplish this by creating a TYPE_DECL as
799 if the user had written `typedef struct S S'. Create and return
800 the TYPE_DECL for TYPE. */
803 create_implicit_typedef (tree name, tree type)
807 decl = build_decl (TYPE_DECL, name, type);
808 DECL_ARTIFICIAL (decl) = 1;
809 /* There are other implicit type declarations, like the one *within*
810 a class that allows you to write `S::S'. We must distinguish
812 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
813 TYPE_NAME (type) = decl;
818 /* Remember a local name for name-mangling purposes. */
821 push_local_name (tree decl)
826 timevar_push (TV_NAME_LOOKUP);
828 name = DECL_NAME (decl);
830 nelts = VEC_length (tree, local_names);
831 for (i = 0; i < nelts; i++)
833 t = VEC_index (tree, local_names, i);
834 if (DECL_NAME (t) == name)
836 if (!DECL_LANG_SPECIFIC (decl))
837 retrofit_lang_decl (decl);
838 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
839 if (DECL_LANG_SPECIFIC (t))
840 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
842 DECL_DISCRIMINATOR (decl) = 1;
844 VEC_replace (tree, local_names, i, decl);
845 timevar_pop (TV_NAME_LOOKUP);
850 VEC_safe_push (tree, gc, local_names, decl);
851 timevar_pop (TV_NAME_LOOKUP);
854 /* Subroutine of duplicate_decls: return truthvalue of whether
855 or not types of these decls match.
857 For C++, we must compare the parameter list so that `int' can match
858 `int&' in a parameter position, but `int&' is not confused with
862 decls_match (tree newdecl, tree olddecl)
866 if (newdecl == olddecl)
869 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
870 /* If the two DECLs are not even the same kind of thing, we're not
871 interested in their types. */
874 if (TREE_CODE (newdecl) == FUNCTION_DECL)
876 tree f1 = TREE_TYPE (newdecl);
877 tree f2 = TREE_TYPE (olddecl);
878 tree p1 = TYPE_ARG_TYPES (f1);
879 tree p2 = TYPE_ARG_TYPES (f2);
881 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
882 && ! (DECL_EXTERN_C_P (newdecl)
883 && DECL_EXTERN_C_P (olddecl)))
886 if (TREE_CODE (f1) != TREE_CODE (f2))
889 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
891 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
892 && (DECL_BUILT_IN (olddecl)
893 #ifndef NO_IMPLICIT_EXTERN_C
894 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
895 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
899 types_match = self_promoting_args_p (p1);
900 if (p1 == void_list_node)
901 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
903 #ifndef NO_IMPLICIT_EXTERN_C
904 else if (p1 == NULL_TREE
905 && (DECL_EXTERN_C_P (olddecl)
906 && DECL_IN_SYSTEM_HEADER (olddecl)
907 && !DECL_CLASS_SCOPE_P (olddecl))
908 && (DECL_EXTERN_C_P (newdecl)
909 && DECL_IN_SYSTEM_HEADER (newdecl)
910 && !DECL_CLASS_SCOPE_P (newdecl)))
912 types_match = self_promoting_args_p (p2);
913 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
917 types_match = compparms (p1, p2);
922 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
924 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
925 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
928 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
929 DECL_TEMPLATE_PARMS (olddecl)))
932 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
933 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
934 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
936 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
937 DECL_TEMPLATE_RESULT (newdecl));
941 /* Need to check scope for variable declaration (VAR_DECL).
942 For typedef (TYPE_DECL), scope is ignored. */
943 if (TREE_CODE (newdecl) == VAR_DECL
944 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
947 if (TREE_TYPE (newdecl) == error_mark_node)
948 types_match = TREE_TYPE (olddecl) == error_mark_node;
949 else if (TREE_TYPE (olddecl) == NULL_TREE)
950 types_match = TREE_TYPE (newdecl) == NULL_TREE;
951 else if (TREE_TYPE (newdecl) == NULL_TREE)
954 types_match = comptypes (TREE_TYPE (newdecl),
956 COMPARE_REDECLARATION);
962 /* If NEWDECL is `static' and an `extern' was seen previously,
963 warn about it. OLDDECL is the previous declaration.
965 Note that this does not apply to the C++ case of declaring
966 a variable `extern const' and then later `const'.
968 Don't complain about built-in functions, since they are beyond
969 the user's control. */
972 warn_extern_redeclared_static (tree newdecl, tree olddecl)
976 if (TREE_CODE (newdecl) == TYPE_DECL
977 || TREE_CODE (newdecl) == TEMPLATE_DECL
978 || TREE_CODE (newdecl) == CONST_DECL
979 || TREE_CODE (newdecl) == NAMESPACE_DECL)
982 /* Don't get confused by static member functions; that's a different
984 if (TREE_CODE (newdecl) == FUNCTION_DECL
985 && DECL_STATIC_FUNCTION_P (newdecl))
988 /* If the old declaration was `static', or the new one isn't, then
989 then everything is OK. */
990 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
993 /* It's OK to declare a builtin function as `static'. */
994 if (TREE_CODE (olddecl) == FUNCTION_DECL
995 && DECL_ARTIFICIAL (olddecl))
998 name = DECL_ASSEMBLER_NAME (newdecl);
999 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1000 pedwarn ("previous declaration of %q+D", olddecl);
1003 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1004 function templates. If their exception specifications do not
1005 match, issue an a diagnostic. */
1008 check_redeclaration_exception_specification (tree new_decl,
1013 tree new_exceptions;
1014 tree old_exceptions;
1016 new_type = TREE_TYPE (new_decl);
1017 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1018 old_type = TREE_TYPE (old_decl);
1019 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1023 If any declaration of a function has an exception-specification,
1024 all declarations, including the definition and an explicit
1025 specialization, of that function shall have an
1026 exception-specification with the same set of type-ids. */
1027 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1028 && ! DECL_IS_BUILTIN (old_decl)
1030 && !comp_except_specs (new_exceptions, old_exceptions,
1033 error ("declaration of %qF throws different exceptions", new_decl);
1034 error ("from previous declaration %q+F", old_decl);
1038 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1039 If the redeclaration is invalid, a diagnostic is issued, and the
1040 error_mark_node is returned. Otherwise, OLDDECL is returned.
1042 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1045 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1048 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1050 unsigned olddecl_uid = DECL_UID (olddecl);
1051 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1052 int new_defines_function = 0;
1055 if (newdecl == olddecl)
1058 types_match = decls_match (newdecl, olddecl);
1060 /* If either the type of the new decl or the type of the old decl is an
1061 error_mark_node, then that implies that we have already issued an
1062 error (earlier) for some bogus type specification, and in that case,
1063 it is rather pointless to harass the user with yet more error message
1064 about the same declaration, so just pretend the types match here. */
1065 if (TREE_TYPE (newdecl) == error_mark_node
1066 || TREE_TYPE (olddecl) == error_mark_node)
1069 if (DECL_P (olddecl)
1070 && TREE_CODE (newdecl) == FUNCTION_DECL
1071 && TREE_CODE (olddecl) == FUNCTION_DECL
1072 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1074 if (DECL_DECLARED_INLINE_P (newdecl)
1075 && DECL_UNINLINABLE (newdecl)
1076 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1077 /* Already warned elsewhere. */;
1078 else if (DECL_DECLARED_INLINE_P (olddecl)
1079 && DECL_UNINLINABLE (olddecl)
1080 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1081 /* Already warned. */;
1082 else if (DECL_DECLARED_INLINE_P (newdecl)
1083 && DECL_UNINLINABLE (olddecl)
1084 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1086 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1088 warning (OPT_Wattributes, "previous declaration of %q+D "
1089 "with attribute noinline", olddecl);
1091 else if (DECL_DECLARED_INLINE_P (olddecl)
1092 && DECL_UNINLINABLE (newdecl)
1093 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1095 warning (OPT_Wattributes, "function %q+D redeclared with "
1096 "attribute noinline", newdecl);
1097 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1102 /* Check for redeclaration and other discrepancies. */
1103 if (TREE_CODE (olddecl) == FUNCTION_DECL
1104 && DECL_ARTIFICIAL (olddecl))
1106 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1107 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1109 /* Avoid warnings redeclaring built-ins which have not been
1110 explicitly declared. */
1111 if (DECL_ANTICIPATED (olddecl))
1114 /* If you declare a built-in or predefined function name as static,
1115 the old definition is overridden, but optionally warn this was a
1116 bad choice of name. */
1117 if (! TREE_PUBLIC (newdecl))
1120 warning (0, "shadowing %s function %q#D",
1121 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1123 /* Discard the old built-in function. */
1126 /* If the built-in is not ansi, then programs can override
1127 it even globally without an error. */
1128 else if (! DECL_BUILT_IN (olddecl))
1129 warning (0, "library function %q#D redeclared as non-function %q#D",
1133 error ("declaration of %q#D", newdecl);
1134 error ("conflicts with built-in declaration %q#D",
1139 else if (!types_match)
1141 /* Avoid warnings redeclaring built-ins which have not been
1142 explicitly declared. */
1143 if (DECL_ANTICIPATED (olddecl))
1145 /* Deal with fileptr_type_node. FILE type is not known
1146 at the time we create the builtins. */
1149 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1150 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1152 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1155 else if (TREE_VALUE (t2) == fileptr_type_node)
1157 tree t = TREE_VALUE (t1);
1159 if (TREE_CODE (t) == POINTER_TYPE
1160 && TYPE_NAME (TREE_TYPE (t))
1161 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1162 == get_identifier ("FILE")
1163 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1165 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1167 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1168 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1169 types_match = decls_match (newdecl, olddecl);
1171 return duplicate_decls (newdecl, olddecl,
1173 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1176 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1179 else if ((DECL_EXTERN_C_P (newdecl)
1180 && DECL_EXTERN_C_P (olddecl))
1181 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1182 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1184 /* A near match; override the builtin. */
1186 if (TREE_PUBLIC (newdecl))
1188 warning (0, "new declaration %q#D", newdecl);
1189 warning (0, "ambiguates built-in declaration %q#D",
1192 else if (warn_shadow)
1193 warning (0, "shadowing %s function %q#D",
1194 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1198 /* Discard the old built-in function. */
1201 /* Replace the old RTL to avoid problems with inlining. */
1202 COPY_DECL_RTL (newdecl, olddecl);
1204 /* Even if the types match, prefer the new declarations type for
1205 built-ins which have not been explicitly declared, for
1206 exception lists, etc... */
1207 else if (DECL_ANTICIPATED (olddecl))
1209 tree type = TREE_TYPE (newdecl);
1210 tree attribs = (*targetm.merge_type_attributes)
1211 (TREE_TYPE (olddecl), type);
1213 type = cp_build_type_attribute_variant (type, attribs);
1214 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1217 /* Whether or not the builtin can throw exceptions has no
1218 bearing on this declarator. */
1219 TREE_NOTHROW (olddecl) = 0;
1221 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1223 /* If a builtin function is redeclared as `static', merge
1224 the declarations, but make the original one static. */
1225 DECL_THIS_STATIC (olddecl) = 1;
1226 TREE_PUBLIC (olddecl) = 0;
1228 /* Make the old declaration consistent with the new one so
1229 that all remnants of the builtin-ness of this function
1230 will be banished. */
1231 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1232 COPY_DECL_RTL (newdecl, olddecl);
1235 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1237 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1238 && TREE_CODE (newdecl) != TYPE_DECL
1239 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1240 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1241 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1242 && TREE_CODE (olddecl) != TYPE_DECL
1243 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1244 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1247 /* We do nothing special here, because C++ does such nasty
1248 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1249 get shadowed, and know that if we need to find a TYPE_DECL
1250 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1251 slot of the identifier. */
1255 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1256 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1257 || (TREE_CODE (olddecl) == FUNCTION_DECL
1258 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1261 error ("%q#D redeclared as different kind of symbol", newdecl);
1262 if (TREE_CODE (olddecl) == TREE_LIST)
1263 olddecl = TREE_VALUE (olddecl);
1264 error ("previous declaration of %q+#D", olddecl);
1266 return error_mark_node;
1268 else if (!types_match)
1270 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1271 /* These are certainly not duplicate declarations; they're
1272 from different scopes. */
1275 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1277 /* The name of a class template may not be declared to refer to
1278 any other template, class, function, object, namespace, value,
1279 or type in the same scope. */
1280 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1281 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1283 error ("declaration of template %q#D", newdecl);
1284 error ("conflicts with previous declaration %q+#D", olddecl);
1286 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1287 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1288 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1289 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1290 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1291 DECL_TEMPLATE_PARMS (olddecl))
1292 /* Template functions can be disambiguated by
1294 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1295 TREE_TYPE (TREE_TYPE (olddecl))))
1297 error ("new declaration %q#D", newdecl);
1298 error ("ambiguates old declaration %q+#D", olddecl);
1302 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1304 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1306 error ("declaration of C function %q#D conflicts with",
1308 error ("previous declaration %q+#D here", olddecl);
1310 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1311 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1313 error ("new declaration %q#D", newdecl);
1314 error ("ambiguates old declaration %q+#D", olddecl);
1321 error ("conflicting declaration %q#D", newdecl);
1322 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1323 return error_mark_node;
1326 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1327 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1328 && (!DECL_TEMPLATE_INFO (newdecl)
1329 || (DECL_TI_TEMPLATE (newdecl)
1330 != DECL_TI_TEMPLATE (olddecl))))
1331 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1332 && (!DECL_TEMPLATE_INFO (olddecl)
1333 || (DECL_TI_TEMPLATE (olddecl)
1334 != DECL_TI_TEMPLATE (newdecl))))))
1335 /* It's OK to have a template specialization and a non-template
1336 with the same type, or to have specializations of two
1337 different templates with the same type. Note that if one is a
1338 specialization, and the other is an instantiation of the same
1339 template, that we do not exit at this point. That situation
1340 can occur if we instantiate a template class, and then
1341 specialize one of its methods. This situation is valid, but
1342 the declarations must be merged in the usual way. */
1344 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1345 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1346 && !DECL_USE_TEMPLATE (newdecl))
1347 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1348 && !DECL_USE_TEMPLATE (olddecl))))
1349 /* One of the declarations is a template instantiation, and the
1350 other is not a template at all. That's OK. */
1352 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1354 /* In [namespace.alias] we have:
1356 In a declarative region, a namespace-alias-definition can be
1357 used to redefine a namespace-alias declared in that declarative
1358 region to refer only to the namespace to which it already
1361 Therefore, if we encounter a second alias directive for the same
1362 alias, we can just ignore the second directive. */
1363 if (DECL_NAMESPACE_ALIAS (newdecl)
1364 && (DECL_NAMESPACE_ALIAS (newdecl)
1365 == DECL_NAMESPACE_ALIAS (olddecl)))
1367 /* [namespace.alias]
1369 A namespace-name or namespace-alias shall not be declared as
1370 the name of any other entity in the same declarative region.
1371 A namespace-name defined at global scope shall not be
1372 declared as the name of any other entity in any global scope
1374 error ("declaration of namespace %qD conflicts with", newdecl);
1375 error ("previous declaration of namespace %q+D here", olddecl);
1376 return error_mark_node;
1380 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1383 error (errmsg, newdecl);
1384 if (DECL_NAME (olddecl) != NULL_TREE)
1385 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1386 ? "%q+#D previously defined here"
1387 : "%q+#D previously declared here", olddecl);
1388 return error_mark_node;
1390 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1391 && DECL_INITIAL (olddecl) != NULL_TREE
1392 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1393 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1395 /* Prototype decl follows defn w/o prototype. */
1396 warning (0, "prototype for %q+#D", newdecl);
1397 warning (0, "%Jfollows non-prototype definition here", olddecl);
1399 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1400 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1402 /* extern "C" int foo ();
1403 int foo () { bar (); }
1405 if (current_lang_depth () == 0)
1406 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1409 error ("previous declaration of %q+#D with %qL linkage",
1410 olddecl, DECL_LANGUAGE (olddecl));
1411 error ("conflicts with new declaration with %qL linkage",
1412 DECL_LANGUAGE (newdecl));
1416 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1418 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1420 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1421 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1424 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1425 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1427 for (; t1 && t1 != void_list_node;
1428 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1429 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1431 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1434 pedwarn ("default argument given for parameter %d of %q#D",
1436 pedwarn ("after previous specification in %q+#D", olddecl);
1440 error ("default argument given for parameter %d of %q#D",
1442 error ("after previous specification in %q+#D",
1447 if (DECL_DECLARED_INLINE_P (newdecl)
1448 && ! DECL_DECLARED_INLINE_P (olddecl)
1449 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1451 warning (0, "%q#D was used before it was declared inline", newdecl);
1452 warning (0, "%Jprevious non-inline declaration here", olddecl);
1457 /* Do not merge an implicit typedef with an explicit one. In:
1461 typedef class A A __attribute__ ((foo));
1463 the attribute should apply only to the typedef. */
1464 if (TREE_CODE (olddecl) == TYPE_DECL
1465 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1466 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1469 /* If new decl is `static' and an `extern' was seen previously,
1471 warn_extern_redeclared_static (newdecl, olddecl);
1473 /* We have committed to returning 1 at this point. */
1474 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1476 /* Now that functions must hold information normally held
1477 by field decls, there is extra work to do so that
1478 declaration information does not get destroyed during
1480 if (DECL_VINDEX (olddecl))
1481 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1482 if (DECL_CONTEXT (olddecl))
1483 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1484 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1485 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1486 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1487 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1488 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1489 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1490 SET_OVERLOADED_OPERATOR_CODE
1491 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1492 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1494 /* Optionally warn about more than one declaration for the same
1495 name, but don't warn about a function declaration followed by a
1497 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1498 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1499 /* Don't warn about extern decl followed by definition. */
1500 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1501 /* Don't warn about friends, let add_friend take care of it. */
1502 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1504 warning (0, "redundant redeclaration of %qD in same scope", newdecl);
1505 warning (0, "previous declaration of %q+D", olddecl);
1509 /* Deal with C++: must preserve virtual function table size. */
1510 if (TREE_CODE (olddecl) == TYPE_DECL)
1512 tree newtype = TREE_TYPE (newdecl);
1513 tree oldtype = TREE_TYPE (olddecl);
1515 if (newtype != error_mark_node && oldtype != error_mark_node
1516 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1517 CLASSTYPE_FRIEND_CLASSES (newtype)
1518 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1520 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1523 /* Copy all the DECL_... slots specified in the new decl
1524 except for any that we copy here from the old type. */
1525 DECL_ATTRIBUTES (newdecl)
1526 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1528 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1532 old_result = DECL_TEMPLATE_RESULT (olddecl);
1533 new_result = DECL_TEMPLATE_RESULT (newdecl);
1534 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1535 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1536 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1537 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1539 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1541 DECL_INLINE (old_result)
1542 |= DECL_INLINE (new_result);
1543 DECL_DECLARED_INLINE_P (old_result)
1544 |= DECL_DECLARED_INLINE_P (new_result);
1545 check_redeclaration_exception_specification (newdecl, olddecl);
1548 /* If the new declaration is a definition, update the file and
1549 line information on the declaration. */
1550 if (DECL_INITIAL (old_result) == NULL_TREE
1551 && DECL_INITIAL (new_result) != NULL_TREE)
1553 DECL_SOURCE_LOCATION (olddecl)
1554 = DECL_SOURCE_LOCATION (old_result)
1555 = DECL_SOURCE_LOCATION (newdecl);
1556 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1557 DECL_ARGUMENTS (old_result)
1558 = DECL_ARGUMENTS (new_result);
1566 /* Automatically handles default parameters. */
1567 tree oldtype = TREE_TYPE (olddecl);
1570 /* Merge the data types specified in the two decls. */
1571 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1573 /* If merge_types produces a non-typedef type, just use the old type. */
1574 if (TREE_CODE (newdecl) == TYPE_DECL
1575 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1578 if (TREE_CODE (newdecl) == VAR_DECL)
1580 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1581 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1582 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1583 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1584 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1585 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1588 /* Do this after calling `merge_types' so that default
1589 parameters don't confuse us. */
1590 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1591 check_redeclaration_exception_specification (newdecl, olddecl);
1592 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1594 /* Lay the type out, unless already done. */
1595 if (! same_type_p (newtype, oldtype)
1596 && TREE_TYPE (newdecl) != error_mark_node
1597 && !(processing_template_decl && uses_template_parms (newdecl)))
1598 layout_type (TREE_TYPE (newdecl));
1600 if ((TREE_CODE (newdecl) == VAR_DECL
1601 || TREE_CODE (newdecl) == PARM_DECL
1602 || TREE_CODE (newdecl) == RESULT_DECL
1603 || TREE_CODE (newdecl) == FIELD_DECL
1604 || TREE_CODE (newdecl) == TYPE_DECL)
1605 && !(processing_template_decl && uses_template_parms (newdecl)))
1606 layout_decl (newdecl, 0);
1608 /* Merge the type qualifiers. */
1609 if (TREE_READONLY (newdecl))
1610 TREE_READONLY (olddecl) = 1;
1611 if (TREE_THIS_VOLATILE (newdecl))
1612 TREE_THIS_VOLATILE (olddecl) = 1;
1613 if (TREE_NOTHROW (newdecl))
1614 TREE_NOTHROW (olddecl) = 1;
1616 /* Merge deprecatedness. */
1617 if (TREE_DEPRECATED (newdecl))
1618 TREE_DEPRECATED (olddecl) = 1;
1620 /* Merge the initialization information. */
1621 if (DECL_INITIAL (newdecl) == NULL_TREE
1622 && DECL_INITIAL (olddecl) != NULL_TREE)
1624 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1625 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1626 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1627 && DECL_LANG_SPECIFIC (newdecl)
1628 && DECL_LANG_SPECIFIC (olddecl))
1630 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1631 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1635 /* Merge the section attribute.
1636 We want to issue an error if the sections conflict but that must be
1637 done later in decl_attributes since we are called before attributes
1639 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1640 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1642 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1644 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1645 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1646 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1647 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1648 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1649 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1650 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1651 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1652 /* Keep the old RTL. */
1653 COPY_DECL_RTL (olddecl, newdecl);
1655 else if (TREE_CODE (newdecl) == VAR_DECL
1656 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1658 /* Keep the old RTL. We cannot keep the old RTL if the old
1659 declaration was for an incomplete object and the new
1660 declaration is not since many attributes of the RTL will
1662 COPY_DECL_RTL (olddecl, newdecl);
1665 /* If cannot merge, then use the new type and qualifiers,
1666 and don't preserve the old rtl. */
1669 /* Clean out any memory we had of the old declaration. */
1670 tree oldstatic = value_member (olddecl, static_aggregates);
1672 TREE_VALUE (oldstatic) = error_mark_node;
1674 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1675 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1676 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1677 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1680 /* Merge the storage class information. */
1681 merge_weak (newdecl, olddecl);
1683 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1684 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1685 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1686 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1687 if (! DECL_EXTERNAL (olddecl))
1688 DECL_EXTERNAL (newdecl) = 0;
1690 new_template = NULL_TREE;
1691 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1693 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1694 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1695 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1696 DECL_TEMPLATE_INSTANTIATED (newdecl)
1697 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1699 /* If the OLDDECL is an instantiation and/or specialization,
1700 then the NEWDECL must be too. But, it may not yet be marked
1701 as such if the caller has created NEWDECL, but has not yet
1702 figured out that it is a redeclaration. */
1703 if (!DECL_USE_TEMPLATE (newdecl))
1704 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1706 /* Don't really know how much of the language-specific
1707 values we should copy from old to new. */
1708 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1709 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1710 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1711 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1712 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1713 if (DECL_TEMPLATE_INFO (newdecl))
1714 new_template = DECL_TI_TEMPLATE (newdecl);
1715 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1716 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1717 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1718 olddecl_friend = DECL_FRIEND_P (olddecl);
1719 hidden_friend = (DECL_ANTICIPATED (olddecl)
1720 && DECL_HIDDEN_FRIEND_P (olddecl)
1721 && newdecl_is_friend);
1723 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1724 if (TREE_CODE (newdecl) == FUNCTION_DECL
1725 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1727 DECL_BEFRIENDING_CLASSES (newdecl)
1728 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1729 DECL_BEFRIENDING_CLASSES (olddecl));
1730 /* DECL_THUNKS is only valid for virtual functions,
1731 otherwise it is a DECL_FRIEND_CONTEXT. */
1732 if (DECL_VIRTUAL_P (newdecl))
1733 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1737 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1739 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1740 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1742 /* If newdecl is not a specialization, then it is not a
1743 template-related function at all. And that means that we
1744 should have exited above, returning 0. */
1745 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1747 if (TREE_USED (olddecl))
1748 /* From [temp.expl.spec]:
1750 If a template, a member template or the member of a class
1751 template is explicitly specialized then that
1752 specialization shall be declared before the first use of
1753 that specialization that would cause an implicit
1754 instantiation to take place, in every translation unit in
1755 which such a use occurs. */
1756 error ("explicit specialization of %qD after first use",
1759 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1761 /* [temp.expl.spec/14] We don't inline explicit specialization
1762 just because the primary template says so. */
1766 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1767 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1769 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1771 /* If either decl says `inline', this fn is inline, unless
1772 its definition was passed already. */
1773 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1774 DECL_INLINE (olddecl) = 1;
1775 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1777 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1778 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1781 /* Preserve abstractness on cloned [cd]tors. */
1782 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1786 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1787 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1788 COPY_DECL_RTL (newdecl, olddecl);
1790 if (! types_match || new_defines_function)
1792 /* These need to be copied so that the names are available.
1793 Note that if the types do match, we'll preserve inline
1794 info and other bits, but if not, we won't. */
1795 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1796 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1798 if (new_defines_function)
1799 /* If defining a function declared with other language
1800 linkage, use the previously declared language linkage. */
1801 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1802 else if (types_match)
1804 /* If redeclaring a builtin function, and not a definition,
1805 it stays built in. */
1806 if (DECL_BUILT_IN (olddecl))
1808 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1809 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1810 /* If we're keeping the built-in definition, keep the rtl,
1811 regardless of declaration matches. */
1812 COPY_DECL_RTL (olddecl, newdecl);
1815 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1816 /* Don't clear out the arguments if we're redefining a function. */
1817 if (DECL_ARGUMENTS (olddecl))
1818 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1821 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1822 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1824 /* Now preserve various other info from the definition. */
1825 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1826 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1827 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1828 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1830 /* Warn about conflicting visibility specifications. */
1831 if (DECL_VISIBILITY_SPECIFIED (olddecl)
1832 && DECL_VISIBILITY_SPECIFIED (newdecl)
1833 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1835 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
1836 "because it", newdecl);
1837 warning (OPT_Wattributes, "%Jconflicts with previous "
1838 "declaration here", olddecl);
1840 /* Choose the declaration which specified visibility. */
1841 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1843 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1844 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1846 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
1847 so keep this behavior. */
1848 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
1850 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
1851 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
1854 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1855 with that from NEWDECL below. */
1856 if (DECL_LANG_SPECIFIC (olddecl))
1858 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1859 != DECL_LANG_SPECIFIC (newdecl));
1860 ggc_free (DECL_LANG_SPECIFIC (olddecl));
1863 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1867 function_size = sizeof (struct tree_decl_common);
1869 memcpy ((char *) olddecl + sizeof (struct tree_common),
1870 (char *) newdecl + sizeof (struct tree_common),
1871 function_size - sizeof (struct tree_common));
1873 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1874 (char *) newdecl + sizeof (struct tree_decl_common),
1875 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
1877 /* If newdecl is a template instantiation, it is possible that
1878 the following sequence of events has occurred:
1880 o A friend function was declared in a class template. The
1881 class template was instantiated.
1883 o The instantiation of the friend declaration was
1884 recorded on the instantiation list, and is newdecl.
1886 o Later, however, instantiate_class_template called pushdecl
1887 on the newdecl to perform name injection. But, pushdecl in
1888 turn called duplicate_decls when it discovered that another
1889 declaration of a global function with the same name already
1892 o Here, in duplicate_decls, we decided to clobber newdecl.
1894 If we're going to do that, we'd better make sure that
1895 olddecl, and not newdecl, is on the list of
1896 instantiations so that if we try to do the instantiation
1897 again we won't get the clobbered declaration. */
1898 reregister_specialization (newdecl,
1904 size_t size = tree_code_size (TREE_CODE (olddecl));
1905 memcpy ((char *) olddecl + sizeof (struct tree_common),
1906 (char *) newdecl + sizeof (struct tree_common),
1907 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
1908 switch (TREE_CODE (olddecl))
1918 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1919 (char *) newdecl + sizeof (struct tree_decl_common),
1920 size - sizeof (struct tree_decl_common)
1921 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1925 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1926 (char *) newdecl + sizeof (struct tree_decl_common),
1927 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
1928 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1932 DECL_UID (olddecl) = olddecl_uid;
1934 DECL_FRIEND_P (olddecl) = 1;
1937 DECL_ANTICIPATED (olddecl) = 1;
1938 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
1941 /* NEWDECL contains the merged attribute lists.
1942 Update OLDDECL to be the same. */
1943 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1945 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1946 so that encode_section_info has a chance to look at the new decl
1947 flags and attributes. */
1948 if (DECL_RTL_SET_P (olddecl)
1949 && (TREE_CODE (olddecl) == FUNCTION_DECL
1950 || (TREE_CODE (olddecl) == VAR_DECL
1951 && TREE_STATIC (olddecl))))
1952 make_decl_rtl (olddecl);
1954 /* The NEWDECL will no longer be needed. Because every out-of-class
1955 declaration of a member results in a call to duplicate_decls,
1956 freeing these nodes represents in a significant savings. */
1962 /* Return zero if the declaration NEWDECL is valid
1963 when the declaration OLDDECL (assumed to be for the same name)
1964 has already been seen.
1965 Otherwise return an error message format string with a %s
1966 where the identifier should go. */
1969 redeclaration_error_message (tree newdecl, tree olddecl)
1971 if (TREE_CODE (newdecl) == TYPE_DECL)
1973 /* Because C++ can put things into name space for free,
1974 constructs like "typedef struct foo { ... } foo"
1975 would look like an erroneous redeclaration. */
1976 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
1979 return "redefinition of %q#D";
1981 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1983 /* If this is a pure function, its olddecl will actually be
1984 the original initialization to `0' (which we force to call
1985 abort()). Don't complain about redefinition in this case. */
1986 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
1987 && DECL_INITIAL (olddecl) == NULL_TREE)
1990 /* If both functions come from different namespaces, this is not
1991 a redeclaration - this is a conflict with a used function. */
1992 if (DECL_NAMESPACE_SCOPE_P (olddecl)
1993 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
1994 && ! decls_match (olddecl, newdecl))
1995 return "%qD conflicts with used function";
1997 /* We'll complain about linkage mismatches in
1998 warn_extern_redeclared_static. */
2000 /* Defining the same name twice is no good. */
2001 if (DECL_INITIAL (olddecl) != NULL_TREE
2002 && DECL_INITIAL (newdecl) != NULL_TREE)
2004 if (DECL_NAME (olddecl) == NULL_TREE)
2005 return "%q#D not declared in class";
2007 return "redefinition of %q#D";
2011 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2015 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2017 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2018 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2019 return "redefinition of %q#D";
2023 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2024 || (DECL_TEMPLATE_RESULT (newdecl)
2025 == DECL_TEMPLATE_RESULT (olddecl)))
2028 nt = DECL_TEMPLATE_RESULT (newdecl);
2029 if (DECL_TEMPLATE_INFO (nt))
2030 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2031 ot = DECL_TEMPLATE_RESULT (olddecl);
2032 if (DECL_TEMPLATE_INFO (ot))
2033 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2034 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2035 return "redefinition of %q#D";
2039 else if (TREE_CODE (newdecl) == VAR_DECL
2040 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
2042 /* Only variables can be thread-local, and all declarations must
2043 agree on this property. */
2044 if (DECL_THREAD_LOCAL_P (newdecl))
2045 return "thread-local declaration of %q#D follows "
2046 "non-thread-local declaration";
2048 return "non-thread-local declaration of %q#D follows "
2049 "thread-local declaration";
2051 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2053 /* Objects declared at top level: */
2054 /* If at least one is a reference, it's ok. */
2055 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2057 /* Reject two definitions. */
2058 return "redefinition of %q#D";
2062 /* Objects declared with block scope: */
2063 /* Reject two definitions, and reject a definition
2064 together with an external reference. */
2065 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2066 return "redeclaration of %q#D";
2071 /* Create a new label, named ID. */
2074 make_label_decl (tree id, int local_p)
2078 decl = build_decl (LABEL_DECL, id, void_type_node);
2080 DECL_CONTEXT (decl) = current_function_decl;
2081 DECL_MODE (decl) = VOIDmode;
2082 C_DECLARED_LABEL_FLAG (decl) = local_p;
2084 /* Say where one reference is to the label, for the sake of the
2085 error if it is not defined. */
2086 DECL_SOURCE_LOCATION (decl) = input_location;
2088 /* Record the fact that this identifier is bound to this label. */
2089 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2094 /* Record this label on the list of used labels so that we can check
2095 at the end of the function to see whether or not the label was
2096 actually defined, and so we can check when the label is defined whether
2097 this use is valid. */
2100 use_label (tree decl)
2102 if (named_label_uses == NULL
2103 || named_label_uses->names_in_scope != current_binding_level->names
2104 || named_label_uses->label_decl != decl)
2106 struct named_label_use_list *new_ent;
2107 new_ent = GGC_NEW (struct named_label_use_list);
2108 new_ent->label_decl = decl;
2109 new_ent->names_in_scope = current_binding_level->names;
2110 new_ent->binding_level = current_binding_level;
2111 new_ent->o_goto_locus = input_location;
2112 new_ent->next = named_label_uses;
2113 named_label_uses = new_ent;
2117 /* Look for a label named ID in the current function. If one cannot
2118 be found, create one. (We keep track of used, but undefined,
2119 labels, and complain about them at the end of a function.) */
2122 lookup_label (tree id)
2125 struct named_label_list *ent;
2127 timevar_push (TV_NAME_LOOKUP);
2128 /* You can't use labels at global scope. */
2129 if (current_function_decl == NULL_TREE)
2131 error ("label %qE referenced outside of any function", id);
2132 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2135 /* See if we've already got this label. */
2136 decl = IDENTIFIER_LABEL_VALUE (id);
2137 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2138 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2140 /* Record this label on the list of labels used in this function.
2141 We do this before calling make_label_decl so that we get the
2142 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2143 ent = GGC_CNEW (struct named_label_list);
2144 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2145 ent->next = named_labels;
2148 /* We need a new label. */
2149 decl = make_label_decl (id, /*local_p=*/0);
2151 /* Now fill in the information we didn't have before. */
2152 ent->label_decl = decl;
2154 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2157 /* Declare a local label named ID. */
2160 declare_local_label (tree id)
2164 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2165 this scope we can restore the old value of
2166 IDENTIFIER_TYPE_VALUE. */
2167 current_binding_level->shadowed_labels
2168 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2169 current_binding_level->shadowed_labels);
2170 /* Look for the label. */
2171 decl = make_label_decl (id, /*local_p=*/1);
2172 /* Now fill in the information we didn't have before. */
2173 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2178 /* Returns nonzero if it is ill-formed to jump past the declaration of
2179 DECL. Returns 2 if it's also a real problem. */
2182 decl_jump_unsafe (tree decl)
2184 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2185 || TREE_TYPE (decl) == error_mark_node)
2188 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2189 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2192 if (pod_type_p (TREE_TYPE (decl)))
2195 /* The POD stuff is just pedantry; why should it matter if the class
2196 contains a field of pointer to member type? */
2200 /* Check that a single previously seen jump to a newly defined label
2201 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2202 the jump context; NAMES are the names in scope in LEVEL at the jump
2203 context; FILE and LINE are the source position of the jump or 0. */
2206 check_previous_goto_1 (tree decl,
2207 struct cp_binding_level* level,
2208 tree names, const location_t *locus)
2212 struct cp_binding_level *b = current_binding_level;
2213 for (; b; b = b->level_chain)
2215 tree new_decls = b->names;
2216 tree old_decls = (b == level ? names : NULL_TREE);
2217 for (; new_decls != old_decls;
2218 new_decls = TREE_CHAIN (new_decls))
2220 int problem = decl_jump_unsafe (new_decls);
2227 pedwarn ("jump to label %qD", decl);
2229 pedwarn ("jump to case label");
2232 pedwarn ("%H from here", locus);
2237 error (" crosses initialization of %q+#D", new_decls);
2239 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2244 if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2249 pedwarn ("jump to label %qD", decl);
2251 pedwarn ("jump to case label");
2254 pedwarn ("%H from here", locus);
2257 if (b->kind == sk_try)
2258 error (" enters try block");
2260 error (" enters catch block");
2267 check_previous_goto (struct named_label_use_list* use)
2269 check_previous_goto_1 (use->label_decl, use->binding_level,
2270 use->names_in_scope, &use->o_goto_locus);
2274 check_switch_goto (struct cp_binding_level* level)
2276 check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2279 /* Check that any previously seen jumps to a newly defined label DECL
2280 are OK. Called by define_label. */
2283 check_previous_gotos (tree decl)
2285 struct named_label_use_list **usep;
2287 if (! TREE_USED (decl))
2290 for (usep = &named_label_uses; *usep; )
2292 struct named_label_use_list *use = *usep;
2293 if (use->label_decl == decl)
2295 check_previous_goto (use);
2299 usep = &(use->next);
2303 /* Check that a new jump to a label DECL is OK. Called by
2304 finish_goto_stmt. */
2307 check_goto (tree decl)
2311 struct named_label_list *lab;
2313 /* We can't know where a computed goto is jumping. So we assume
2315 if (! DECL_P (decl))
2318 /* If the label hasn't been defined yet, defer checking. */
2319 if (! DECL_INITIAL (decl))
2325 for (lab = named_labels; lab; lab = lab->next)
2326 if (decl == lab->label_decl)
2329 /* If the label is not on named_labels it's a gcc local label, so
2330 it must be in an outer scope, so jumping to it is always OK. */
2334 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2337 pedwarn ("jump to label %q+D", decl);
2338 pedwarn (" from here");
2342 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2344 tree b = TREE_VALUE (bad);
2345 int u = decl_jump_unsafe (b);
2347 if (u > 1 && DECL_ARTIFICIAL (b))
2348 /* Can't skip init of __exception_info. */
2349 error ("%J enters catch block", b);
2351 error (" skips initialization of %q+#D", b);
2353 pedwarn (" enters scope of non-POD %q+#D", b);
2356 if (lab->in_try_scope)
2357 error (" enters try block");
2358 else if (lab->in_catch_scope)
2359 error (" enters catch block");
2362 /* Define a label, specifying the location in the source file.
2363 Return the LABEL_DECL node for the label. */
2366 define_label (location_t location, tree name)
2368 tree decl = lookup_label (name);
2369 struct named_label_list *ent;
2370 struct cp_binding_level *p;
2372 timevar_push (TV_NAME_LOOKUP);
2373 for (ent = named_labels; ent; ent = ent->next)
2374 if (ent->label_decl == decl)
2377 /* After labels, make any new cleanups in the function go into their
2378 own new (temporary) binding contour. */
2379 for (p = current_binding_level;
2380 p->kind != sk_function_parms;
2382 p->more_cleanups_ok = 0;
2384 if (name == get_identifier ("wchar_t"))
2385 pedwarn ("label named wchar_t");
2387 if (DECL_INITIAL (decl) != NULL_TREE)
2388 error ("duplicate label %qD", decl);
2391 /* Mark label as having been defined. */
2392 DECL_INITIAL (decl) = error_mark_node;
2393 /* Say where in the source. */
2394 DECL_SOURCE_LOCATION (decl) = location;
2397 ent->names_in_scope = current_binding_level->names;
2398 ent->binding_level = current_binding_level;
2400 check_previous_gotos (decl);
2403 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2408 struct cp_binding_level *level;
2409 struct cp_switch *next;
2410 /* The SWITCH_STMT being built. */
2412 /* A splay-tree mapping the low element of a case range to the high
2413 element, or NULL_TREE if there is no high element. Used to
2414 determine whether or not a new case label duplicates an old case
2415 label. We need a tree, rather than simply a hash table, because
2416 of the GNU case range extension. */
2420 /* A stack of the currently active switch statements. The innermost
2421 switch statement is on the top of the stack. There is no need to
2422 mark the stack for garbage collection because it is only active
2423 during the processing of the body of a function, and we never
2424 collect at that point. */
2426 static struct cp_switch *switch_stack;
2428 /* Called right after a switch-statement condition is parsed.
2429 SWITCH_STMT is the switch statement being parsed. */
2432 push_switch (tree switch_stmt)
2434 struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2435 p->level = current_binding_level;
2436 p->next = switch_stack;
2437 p->switch_stmt = switch_stmt;
2438 p->cases = splay_tree_new (case_compare, NULL, NULL);
2445 struct cp_switch *cs = switch_stack;
2446 location_t switch_location;
2448 /* Emit warnings as needed. */
2449 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2450 switch_location = EXPR_LOCATION (cs->switch_stmt);
2452 switch_location = input_location;
2453 if (!processing_template_decl)
2454 c_do_switch_warnings (cs->cases, switch_location,
2455 SWITCH_STMT_TYPE (cs->switch_stmt),
2456 SWITCH_STMT_COND (cs->switch_stmt));
2458 splay_tree_delete (cs->cases);
2459 switch_stack = switch_stack->next;
2463 /* Note that we've seen a definition of a case label, and complain if this
2464 is a bad place for one. */
2467 finish_case_label (tree low_value, tree high_value)
2470 struct cp_binding_level *p;
2472 if (processing_template_decl)
2476 /* For templates, just add the case label; we'll do semantic
2477 analysis at instantiation-time. */
2478 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2479 return add_stmt (build_case_label (low_value, high_value, label));
2482 /* Find the condition on which this switch statement depends. */
2483 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2484 if (cond && TREE_CODE (cond) == TREE_LIST)
2485 cond = TREE_VALUE (cond);
2487 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2488 low_value, high_value);
2490 check_switch_goto (switch_stack->level);
2492 /* After labels, make any new cleanups in the function go into their
2493 own new (temporary) binding contour. */
2494 for (p = current_binding_level;
2495 p->kind != sk_function_parms;
2497 p->more_cleanups_ok = 0;
2502 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2505 typename_hash (const void* k)
2510 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2511 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2516 typedef struct typename_info {
2524 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2527 typename_compare (const void * k1, const void * k2)
2530 const typename_info *t2;
2533 t2 = (const typename_info *) k2;
2535 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2536 && TYPE_CONTEXT (t1) == t2->scope
2537 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2538 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2539 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2542 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2543 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2545 Returns the new TYPENAME_TYPE. */
2547 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2550 build_typename_type (tree context, tree name, tree fullname,
2551 enum tag_types tag_type)
2559 if (typename_htab == NULL)
2560 typename_htab = htab_create_ggc (61, &typename_hash,
2561 &typename_compare, NULL);
2563 ti.scope = FROB_CONTEXT (context);
2565 ti.template_id = fullname;
2566 ti.enum_p = tag_type == enum_type;
2567 ti.class_p = (tag_type == class_type
2568 || tag_type == record_type
2569 || tag_type == union_type);
2570 hash = (htab_hash_pointer (ti.scope)
2571 ^ htab_hash_pointer (ti.name));
2573 /* See if we already have this type. */
2574 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2579 /* Build the TYPENAME_TYPE. */
2580 t = make_aggr_type (TYPENAME_TYPE);
2581 TYPE_CONTEXT (t) = ti.scope;
2582 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2583 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2584 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2586 /* Build the corresponding TYPE_DECL. */
2587 d = build_decl (TYPE_DECL, name, t);
2588 TYPE_NAME (TREE_TYPE (d)) = d;
2589 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2590 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2591 DECL_ARTIFICIAL (d) = 1;
2593 /* Store it in the hash table. */
2600 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2601 provided to name the type. Returns an appropriate type, unless an
2602 error occurs, in which case error_mark_node is returned. If we
2603 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2604 return that, rather than the _TYPE it corresponds to, in other
2605 cases we look through the type decl. If TF_ERROR is set, complain
2606 about errors, otherwise be quiet. */
2609 make_typename_type (tree context, tree name, enum tag_types tag_type,
2610 tsubst_flags_t complain)
2614 if (name == error_mark_node
2615 || context == NULL_TREE
2616 || context == error_mark_node)
2617 return error_mark_node;
2621 if (!(TYPE_LANG_SPECIFIC (name)
2622 && (CLASSTYPE_IS_TEMPLATE (name)
2623 || CLASSTYPE_USE_TEMPLATE (name))))
2624 name = TYPE_IDENTIFIER (name);
2626 /* Create a TEMPLATE_ID_EXPR for the type. */
2627 name = build_nt (TEMPLATE_ID_EXPR,
2628 CLASSTYPE_TI_TEMPLATE (name),
2629 CLASSTYPE_TI_ARGS (name));
2631 else if (TREE_CODE (name) == TYPE_DECL)
2632 name = DECL_NAME (name);
2636 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2638 name = TREE_OPERAND (name, 0);
2639 if (TREE_CODE (name) == TEMPLATE_DECL)
2640 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2642 if (TREE_CODE (name) == TEMPLATE_DECL)
2644 error ("%qD used without template parameters", name);
2645 return error_mark_node;
2647 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2648 gcc_assert (TYPE_P (context));
2650 if (!dependent_type_p (context)
2651 || currently_open_class (context))
2653 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2655 tree tmpl = NULL_TREE;
2656 if (IS_AGGR_TYPE (context))
2657 tmpl = lookup_field (context, name, 0, false);
2658 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2660 if (complain & tf_error)
2661 error ("no class template named %q#T in %q#T",
2663 return error_mark_node;
2666 if (complain & tf_error)
2667 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2669 return lookup_template_class (tmpl,
2670 TREE_OPERAND (fullname, 1),
2672 /*entering_scope=*/0,
2673 tf_error | tf_warning | tf_user);
2679 if (!IS_AGGR_TYPE (context))
2681 if (complain & tf_error)
2682 error ("no type named %q#T in %q#T", name, context);
2683 return error_mark_node;
2686 t = lookup_field (context, name, 0, true);
2689 if (TREE_CODE (t) != TYPE_DECL)
2691 if (complain & tf_error)
2692 error ("no type named %q#T in %q#T", name, context);
2693 return error_mark_node;
2696 if (complain & tf_error)
2697 perform_or_defer_access_check (TYPE_BINFO (context), t);
2699 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2707 /* If the CONTEXT is not a template type, then either the field is
2708 there now or its never going to be. */
2709 if (!dependent_type_p (context))
2711 if (complain & tf_error)
2712 error ("no type named %q#T in %q#T", name, context);
2713 return error_mark_node;
2716 return build_typename_type (context, name, fullname, tag_type);
2719 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
2720 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2721 in which case error_mark_node is returned.
2723 If PARM_LIST is non-NULL, also make sure that the template parameter
2724 list of TEMPLATE_DECL matches.
2726 If COMPLAIN zero, don't complain about any errors that occur. */
2729 make_unbound_class_template (tree context, tree name, tree parm_list,
2730 tsubst_flags_t complain)
2736 name = TYPE_IDENTIFIER (name);
2737 else if (DECL_P (name))
2738 name = DECL_NAME (name);
2739 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2741 if (!dependent_type_p (context)
2742 || currently_open_class (context))
2744 tree tmpl = NULL_TREE;
2746 if (IS_AGGR_TYPE (context))
2747 tmpl = lookup_field (context, name, 0, false);
2749 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2751 if (complain & tf_error)
2752 error ("no class template named %q#T in %q#T", name, context);
2753 return error_mark_node;
2757 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2759 if (complain & tf_error)
2761 error ("template parameters do not match template");
2762 error ("%q+D declared here", tmpl);
2764 return error_mark_node;
2767 if (complain & tf_error)
2768 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2773 /* Build the UNBOUND_CLASS_TEMPLATE. */
2774 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2775 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2776 TREE_TYPE (t) = NULL_TREE;
2778 /* Build the corresponding TEMPLATE_DECL. */
2779 d = build_decl (TEMPLATE_DECL, name, t);
2780 TYPE_NAME (TREE_TYPE (d)) = d;
2781 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2782 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2783 DECL_ARTIFICIAL (d) = 1;
2784 DECL_TEMPLATE_PARMS (d) = parm_list;
2791 /* Push the declarations of builtin types into the namespace.
2792 RID_INDEX is the index of the builtin type in the array
2793 RID_POINTERS. NAME is the name used when looking up the builtin
2794 type. TYPE is the _TYPE node for the builtin type. */
2797 record_builtin_type (enum rid rid_index,
2801 tree rname = NULL_TREE, tname = NULL_TREE;
2802 tree tdecl = NULL_TREE;
2804 if ((int) rid_index < (int) RID_MAX)
2805 rname = ridpointers[(int) rid_index];
2807 tname = get_identifier (name);
2809 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2810 eliminated. Built-in types should not be looked up name; their
2811 names are keywords that the parser can recognize. However, there
2812 is code in c-common.c that uses identifier_global_value to look
2813 up built-in types by name. */
2816 tdecl = build_decl (TYPE_DECL, tname, type);
2817 DECL_ARTIFICIAL (tdecl) = 1;
2818 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2824 tdecl = build_decl (TYPE_DECL, rname, type);
2825 DECL_ARTIFICIAL (tdecl) = 1;
2827 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2830 if (!TYPE_NAME (type))
2831 TYPE_NAME (type) = tdecl;
2834 debug_hooks->type_decl (tdecl, 0);
2837 /* Record one of the standard Java types.
2838 * Declare it as having the given NAME.
2839 * If SIZE > 0, it is the size of one of the integral types;
2840 * otherwise it is the negative of the size of one of the other types. */
2843 record_builtin_java_type (const char* name, int size)
2847 type = make_signed_type (size);
2848 else if (size > -32)
2849 { /* "__java_char" or ""__java_boolean". */
2850 type = make_unsigned_type (-size);
2851 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2854 { /* "__java_float" or ""__java_double". */
2855 type = make_node (REAL_TYPE);
2856 TYPE_PRECISION (type) = - size;
2859 record_builtin_type (RID_MAX, name, type);
2860 decl = TYPE_NAME (type);
2862 /* Suppress generate debug symbol entries for these types,
2863 since for normal C++ they are just clutter.
2864 However, push_lang_context undoes this if extern "Java" is seen. */
2865 DECL_IGNORED_P (decl) = 1;
2867 TYPE_FOR_JAVA (type) = 1;
2871 /* Push a type into the namespace so that the back-ends ignore it. */
2874 record_unknown_type (tree type, const char* name)
2876 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2877 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
2878 DECL_IGNORED_P (decl) = 1;
2879 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2880 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2881 TYPE_ALIGN (type) = 1;
2882 TYPE_USER_ALIGN (type) = 0;
2883 TYPE_MODE (type) = TYPE_MODE (void_type_node);
2886 /* A string for which we should create an IDENTIFIER_NODE at
2889 typedef struct predefined_identifier
2891 /* The name of the identifier. */
2892 const char *const name;
2893 /* The place where the IDENTIFIER_NODE should be stored. */
2895 /* Nonzero if this is the name of a constructor or destructor. */
2896 const int ctor_or_dtor_p;
2897 } predefined_identifier;
2899 /* Create all the predefined identifiers. */
2902 initialize_predefined_identifiers (void)
2904 const predefined_identifier *pid;
2906 /* A table of identifiers to create at startup. */
2907 static const predefined_identifier predefined_identifiers[] = {
2908 { "C++", &lang_name_cplusplus, 0 },
2909 { "C", &lang_name_c, 0 },
2910 { "Java", &lang_name_java, 0 },
2911 /* Some of these names have a trailing space so that it is
2912 impossible for them to conflict with names written by users. */
2913 { "__ct ", &ctor_identifier, 1 },
2914 { "__base_ctor ", &base_ctor_identifier, 1 },
2915 { "__comp_ctor ", &complete_ctor_identifier, 1 },
2916 { "__dt ", &dtor_identifier, 1 },
2917 { "__comp_dtor ", &complete_dtor_identifier, 1 },
2918 { "__base_dtor ", &base_dtor_identifier, 1 },
2919 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
2920 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2921 { "nelts", &nelts_identifier, 0 },
2922 { THIS_NAME, &this_identifier, 0 },
2923 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2924 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2925 { "_vptr", &vptr_identifier, 0 },
2926 { "__vtt_parm", &vtt_parm_identifier, 0 },
2927 { "::", &global_scope_name, 0 },
2928 { "std", &std_identifier, 0 },
2932 for (pid = predefined_identifiers; pid->name; ++pid)
2934 *pid->node = get_identifier (pid->name);
2935 if (pid->ctor_or_dtor_p)
2936 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2940 /* Create the predefined scalar types of C,
2941 and some nodes representing standard constants (0, 1, (void *)0).
2942 Initialize the global binding level.
2943 Make definitions for built-in primitive functions. */
2946 cxx_init_decl_processing (void)
2949 tree void_ftype_ptr;
2951 build_common_tree_nodes (flag_signed_char, false);
2953 /* Create all the identifiers we need. */
2954 initialize_predefined_identifiers ();
2956 /* Create the global variables. */
2957 push_to_top_level ();
2959 current_function_decl = NULL_TREE;
2960 current_binding_level = NULL;
2961 /* Enter the global namespace. */
2962 gcc_assert (global_namespace == NULL_TREE);
2963 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2965 begin_scope (sk_namespace, global_namespace);
2967 current_lang_name = NULL_TREE;
2969 /* Adjust various flags based on command-line settings. */
2970 if (!flag_permissive)
2971 flag_pedantic_errors = 1;
2972 if (!flag_no_inline)
2974 flag_inline_trees = 1;
2977 if (flag_inline_functions)
2978 flag_inline_trees = 2;
2980 /* Force minimum function alignment if using the least significant
2981 bit of function pointers to store the virtual bit. */
2982 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2983 && force_align_functions_log < 1)
2984 force_align_functions_log = 1;
2987 current_lang_name = lang_name_c;
2989 /* Create the `std' namespace. */
2990 push_namespace (std_identifier);
2991 std_node = current_namespace;
2994 c_common_nodes_and_builtins ();
2996 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2997 java_short_type_node = record_builtin_java_type ("__java_short", 16);
2998 java_int_type_node = record_builtin_java_type ("__java_int", 32);
2999 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3000 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3001 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3002 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3003 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3005 integer_two_node = build_int_cst (NULL_TREE, 2);
3006 integer_three_node = build_int_cst (NULL_TREE, 3);
3008 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3009 truthvalue_type_node = boolean_type_node;
3010 truthvalue_false_node = boolean_false_node;
3011 truthvalue_true_node = boolean_true_node;
3013 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3016 record_builtin_type (RID_MAX, NULL, string_type_node);
3019 delta_type_node = ptrdiff_type_node;
3020 vtable_index_type = ptrdiff_type_node;
3022 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3023 void_ftype = build_function_type (void_type_node, void_list_node);
3024 void_ftype_ptr = build_function_type (void_type_node,
3025 tree_cons (NULL_TREE,
3029 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3031 /* C++ extensions */
3033 unknown_type_node = make_node (UNKNOWN_TYPE);
3034 record_unknown_type (unknown_type_node, "unknown type");
3036 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3037 TREE_TYPE (unknown_type_node) = unknown_type_node;
3039 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3041 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3042 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3045 /* Make sure we get a unique function type, so we can give
3046 its pointer type a name. (This wins for gdb.) */
3047 tree vfunc_type = make_node (FUNCTION_TYPE);
3048 TREE_TYPE (vfunc_type) = integer_type_node;
3049 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3050 layout_type (vfunc_type);
3052 vtable_entry_type = build_pointer_type (vfunc_type);
3054 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3057 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3058 layout_type (vtbl_type_node);
3059 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3060 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3061 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3062 layout_type (vtbl_ptr_type_node);
3063 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3065 push_namespace (get_identifier ("__cxxabiv1"));
3066 abi_node = current_namespace;
3069 global_type_node = make_node (LANG_TYPE);
3070 record_unknown_type (global_type_node, "global type");
3073 current_lang_name = lang_name_cplusplus;
3077 tree bad_alloc_type_node;
3078 tree bad_alloc_decl;
3079 tree newtype, deltype;
3080 tree ptr_ftype_sizetype;
3082 push_namespace (std_identifier);
3083 bad_alloc_id = get_identifier ("bad_alloc");
3084 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3085 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3087 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3088 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3089 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3093 = build_function_type (ptr_type_node,
3094 tree_cons (NULL_TREE,
3097 newtype = build_exception_variant
3098 (ptr_ftype_sizetype, add_exception_specifier
3099 (NULL_TREE, bad_alloc_type_node, -1));
3100 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3101 push_cp_library_fn (NEW_EXPR, newtype);
3102 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3103 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3104 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3108 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3110 /* Perform other language dependent initializations. */
3111 init_class_processing ();
3112 init_rtti_processing ();
3114 if (flag_exceptions)
3115 init_exception_processing ();
3117 if (! supports_one_only ())
3120 make_fname_decl = cp_make_fname_decl;
3121 start_fname_decls ();
3123 /* Show we use EH for cleanups. */
3124 if (flag_exceptions)
3125 using_eh_for_cleanups ();
3128 /* Generate an initializer for a function naming variable from
3129 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3130 filled in with the type of the init. */
3133 cp_fname_init (const char* name, tree *type_p)
3135 tree domain = NULL_TREE;
3137 tree init = NULL_TREE;
3142 length = strlen (name);
3143 domain = build_index_type (size_int (length));
3144 init = build_string (length + 1, name);
3147 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3148 type = build_cplus_array_type (type, domain);
3153 TREE_TYPE (init) = type;
3155 init = error_mark_node;
3160 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3161 decl, NAME is the initialization string and TYPE_DEP indicates whether
3162 NAME depended on the type of the function. We make use of that to detect
3163 __PRETTY_FUNCTION__ inside a template fn. This is being done
3164 lazily at the point of first use, so we mustn't push the decl now. */
3167 cp_make_fname_decl (tree id, int type_dep)
3169 const char *const name = (type_dep && processing_template_decl
3170 ? NULL : fname_as_string (type_dep));
3172 tree init = cp_fname_init (name, &type);
3173 tree decl = build_decl (VAR_DECL, id, type);
3176 free ((char *) name);
3178 /* As we're using pushdecl_with_scope, we must set the context. */
3179 DECL_CONTEXT (decl) = current_function_decl;
3180 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3182 TREE_STATIC (decl) = 1;
3183 TREE_READONLY (decl) = 1;
3184 DECL_ARTIFICIAL (decl) = 1;
3185 DECL_INITIAL (decl) = init;
3187 TREE_USED (decl) = 1;
3189 if (current_function_decl)
3191 struct cp_binding_level *b = current_binding_level;
3192 while (b->level_chain->kind != sk_function_parms)
3194 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3195 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3196 LOOKUP_ONLYCONVERTING);
3199 pushdecl_top_level_and_finish (decl, init);
3204 /* Make a definition for a builtin function named NAME in the current
3205 namespace, whose data type is TYPE and whose context is CONTEXT.
3206 TYPE should be a function type with argument types.
3208 CLASS and CODE tell later passes how to compile calls to this function.
3209 See tree.h for possible values.
3211 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3212 the name to be called if we can't opencode the function.
3213 If ATTRS is nonzero, use that for the function's attribute
3217 builtin_function_1 (const char* name,
3220 enum built_in_function code,
3221 enum built_in_class class,
3222 const char* libname,
3225 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3226 DECL_BUILT_IN_CLASS (decl) = class;
3227 DECL_FUNCTION_CODE (decl) = code;
3228 DECL_CONTEXT (decl) = context;
3232 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3233 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3234 function in the namespace. */
3236 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3238 /* A function in the user's namespace should have an explicit
3239 declaration before it is used. Mark the built-in function as
3240 anticipated but not actually declared. */
3241 if (name[0] != '_' || name[1] != '_')
3242 DECL_ANTICIPATED (decl) = 1;
3244 /* Possibly apply some default attributes to this built-in function. */
3246 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3248 decl_attributes (&decl, NULL_TREE, 0);
3253 /* Entry point for the benefit of c_common_nodes_and_builtins.
3255 Make a definition for a builtin function named NAME and whose data type
3256 is TYPE. TYPE should be a function type with argument types. This
3257 function places the anticipated declaration in the global namespace
3258 and additionally in the std namespace if appropriate.
3260 CLASS and CODE tell later passes how to compile calls to this function.
3261 See tree.h for possible values.
3263 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3264 the name to be called if we can't opencode the function.
3266 If ATTRS is nonzero, use that for the function's attribute
3270 builtin_function (const char* name,
3273 enum built_in_class cl,
3274 const char* libname,
3277 /* All builtins that don't begin with an '_' should additionally
3278 go in the 'std' namespace. */
3281 push_namespace (std_identifier);
3282 builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3286 return builtin_function_1 (name, type, NULL_TREE, code,
3287 cl, libname, attrs);
3290 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3291 function. Not called directly. */
3294 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3296 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3297 DECL_EXTERNAL (fn) = 1;
3298 TREE_PUBLIC (fn) = 1;
3299 DECL_ARTIFICIAL (fn) = 1;
3300 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3301 SET_DECL_LANGUAGE (fn, lang_c);
3302 /* Runtime library routines are, by definition, available in an
3303 external shared object. */
3304 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3305 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3309 /* Returns the _DECL for a library function with C linkage.
3310 We assume that such functions never throw; if this is incorrect,
3311 callers should unset TREE_NOTHROW. */
3314 build_library_fn (tree name, tree type)
3316 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3317 TREE_NOTHROW (fn) = 1;
3321 /* Returns the _DECL for a library function with C++ linkage. */
3324 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3326 tree fn = build_library_fn_1 (name, operator_code, type);
3327 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3328 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3329 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3333 /* Like build_library_fn, but takes a C string instead of an
3337 build_library_fn_ptr (const char* name, tree type)
3339 return build_library_fn (get_identifier (name), type);
3342 /* Like build_cp_library_fn, but takes a C string instead of an
3346 build_cp_library_fn_ptr (const char* name, tree type)
3348 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3351 /* Like build_library_fn, but also pushes the function so that we will
3352 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3355 push_library_fn (tree name, tree type)
3357 tree fn = build_library_fn (name, type);
3358 pushdecl_top_level (fn);
3362 /* Like build_cp_library_fn, but also pushes the function so that it
3363 will be found by normal lookup. */
3366 push_cp_library_fn (enum tree_code operator_code, tree type)
3368 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3375 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3379 push_void_library_fn (tree name, tree parmtypes)
3381 tree type = build_function_type (void_type_node, parmtypes);
3382 return push_library_fn (name, type);
3385 /* Like push_library_fn, but also note that this function throws
3386 and does not return. Used for __throw_foo and the like. */
3389 push_throw_library_fn (tree name, tree type)
3391 tree fn = push_library_fn (name, type);
3392 TREE_THIS_VOLATILE (fn) = 1;
3393 TREE_NOTHROW (fn) = 0;
3397 /* When we call finish_struct for an anonymous union, we create
3398 default copy constructors and such. But, an anonymous union
3399 shouldn't have such things; this function undoes the damage to the
3400 anonymous union type T.
3402 (The reason that we create the synthesized methods is that we don't
3403 distinguish `union { int i; }' from `typedef union { int i; } U'.
3404 The first is an anonymous union; the second is just an ordinary
3408 fixup_anonymous_aggr (tree t)
3412 /* Wipe out memory of synthesized methods. */
3413 TYPE_HAS_CONSTRUCTOR (t) = 0;
3414 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3415 TYPE_HAS_INIT_REF (t) = 0;
3416 TYPE_HAS_CONST_INIT_REF (t) = 0;
3417 TYPE_HAS_ASSIGN_REF (t) = 0;
3418 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3420 /* Splice the implicitly generated functions out of the TYPE_METHODS
3422 q = &TYPE_METHODS (t);
3425 if (DECL_ARTIFICIAL (*q))
3426 *q = TREE_CHAIN (*q);
3428 q = &TREE_CHAIN (*q);
3431 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3432 if (TYPE_METHODS (t))
3433 error ("%Jan anonymous union cannot have function members",
3434 TYPE_MAIN_DECL (t));
3436 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3437 assignment operators (because they cannot have these methods themselves).
3438 For anonymous unions this is already checked because they are not allowed
3439 in any union, otherwise we have to check it. */
3440 if (TREE_CODE (t) != UNION_TYPE)
3444 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3445 if (TREE_CODE (field) == FIELD_DECL)
3447 type = TREE_TYPE (field);
3448 if (CLASS_TYPE_P (type))
3450 if (TYPE_NEEDS_CONSTRUCTING (type))
3451 error ("member %q+#D with constructor not allowed "
3452 "in anonymous aggregate", field);
3453 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3454 error ("member %q+#D with destructor not allowed "
3455 "in anonymous aggregate", field);
3456 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3457 error ("member %q+#D with copy assignment operator "
3458 "not allowed in anonymous aggregate", field);
3464 /* Make sure that a declaration with no declarator is well-formed, i.e.
3465 just declares a tagged type or anonymous union.
3467 Returns the type declared; or NULL_TREE if none. */
3470 check_tag_decl (cp_decl_specifier_seq *declspecs)
3472 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3473 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3474 /* If a class, struct, or enum type is declared by the DECLSPECS
3475 (i.e, if a class-specifier, enum-specifier, or non-typename
3476 elaborated-type-specifier appears in the DECLSPECS),
3477 DECLARED_TYPE is set to the corresponding type. */
3478 tree declared_type = NULL_TREE;
3479 bool error_p = false;
3481 if (declspecs->multiple_types_p)
3482 error ("multiple types in one declaration");
3483 else if (declspecs->redefined_builtin_type)
3485 if (!in_system_header)
3486 pedwarn ("redeclaration of C++ built-in type %qT",
3487 declspecs->redefined_builtin_type);
3492 && TYPE_P (declspecs->type)
3493 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3494 && IS_AGGR_TYPE (declspecs->type))
3495 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3496 declared_type = declspecs->type;
3497 else if (declspecs->type == error_mark_node)
3499 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3500 pedwarn ("declaration does not declare anything");
3501 /* Check for an anonymous union. */
3502 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3503 && TYPE_ANONYMOUS_P (declared_type))
3505 /* 7/3 In a simple-declaration, the optional init-declarator-list
3506 can be omitted only when declaring a class (clause 9) or
3507 enumeration (7.2), that is, when the decl-specifier-seq contains
3508 either a class-specifier, an elaborated-type-specifier with
3509 a class-key (9.1), or an enum-specifier. In these cases and
3510 whenever a class-specifier or enum-specifier is present in the
3511 decl-specifier-seq, the identifiers in these specifiers are among
3512 the names being declared by the declaration (as class-name,
3513 enum-names, or enumerators, depending on the syntax). In such
3514 cases, and except for the declaration of an unnamed bit-field (9.6),
3515 the decl-specifier-seq shall introduce one or more names into the
3516 program, or shall redeclare a name introduced by a previous
3517 declaration. [Example:
3518 enum { }; // ill-formed
3519 typedef class { }; // ill-formed
3523 error ("missing type-name in typedef-declaration");
3526 /* Anonymous unions are objects, so they can have specifiers. */;
3527 SET_ANON_AGGR_TYPE_P (declared_type);
3529 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3530 && !in_system_header)
3531 pedwarn ("ISO C++ prohibits anonymous structs");
3536 if (declspecs->specs[(int)ds_inline]
3537 || declspecs->specs[(int)ds_virtual])
3538 error ("%qs can only be specified for functions",
3539 declspecs->specs[(int)ds_inline]
3540 ? "inline" : "virtual");
3542 && (!current_class_type
3543 || current_scope () != current_class_type))
3544 error ("%<friend%> can only be specified inside a class");
3545 else if (declspecs->specs[(int)ds_explicit])
3546 error ("%<explicit%> can only be specified for constructors");
3547 else if (declspecs->storage_class)
3548 error ("a storage class can only be specified for objects "
3550 else if (declspecs->specs[(int)ds_const]
3551 || declspecs->specs[(int)ds_volatile]
3552 || declspecs->specs[(int)ds_restrict]
3553 || declspecs->specs[(int)ds_thread])
3554 error ("qualifiers can only be specified for objects "
3558 return declared_type;
3561 /* Called when a declaration is seen that contains no names to declare.
3562 If its type is a reference to a structure, union or enum inherited
3563 from a containing scope, shadow that tag name for the current scope
3564 with a forward reference.
3565 If its type defines a new named structure or union
3566 or defines an enum, it is valid but we need not do anything here.
3567 Otherwise, it is an error.
3569 C++: may have to grok the declspecs to learn about static,
3570 complain for anonymous unions.
3572 Returns the TYPE declared -- or NULL_TREE if none. */
3575 shadow_tag (cp_decl_specifier_seq *declspecs)
3577 tree t = check_tag_decl (declspecs);
3582 if (declspecs->attributes)
3584 warning (0, "attribute ignored in declaration of %q+#T", t);
3585 warning (0, "attribute for %q+#T must follow the %qs keyword",
3586 t, class_key_or_enum_as_string (t));
3590 maybe_process_partial_specialization (t);
3592 /* This is where the variables in an anonymous union are
3593 declared. An anonymous union declaration looks like:
3595 because there is no declarator after the union, the parser
3596 sends that declaration here. */
3597 if (ANON_AGGR_TYPE_P (t))
3599 fixup_anonymous_aggr (t);
3601 if (TYPE_FIELDS (t))
3603 tree decl = grokdeclarator (/*declarator=*/NULL,
3604 declspecs, NORMAL, 0, NULL);
3605 finish_anon_union (decl);
3612 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3615 groktypename (cp_decl_specifier_seq *type_specifiers,
3616 const cp_declarator *declarator)
3620 attrs = type_specifiers->attributes;
3621 type_specifiers->attributes = NULL_TREE;
3622 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3624 cplus_decl_attributes (&type, attrs, 0);
3628 /* Decode a declarator in an ordinary declaration or data definition.
3629 This is called as soon as the type information and variable name
3630 have been parsed, before parsing the initializer if any.
3631 Here we create the ..._DECL node, fill in its type,
3632 and put it on the list of decls for the current context.
3633 The ..._DECL node is returned as the value.
3635 Exception: for arrays where the length is not specified,
3636 the type is left null, to be filled in by `cp_finish_decl'.
3638 Function definitions do not come here; they go to start_function
3639 instead. However, external and forward declarations of functions
3640 do go through here. Structure field declarations are done by
3641 grokfield and not through here. */
3644 start_decl (const cp_declarator *declarator,
3645 cp_decl_specifier_seq *declspecs,
3648 tree prefix_attributes,
3649 tree *pushed_scope_p)
3655 *pushed_scope_p = NULL_TREE;
3657 /* This should only be done once on the top most decl. */
3658 if (have_extern_spec)
3660 declspecs->storage_class = sc_extern;
3661 have_extern_spec = false;
3664 /* An object declared as __attribute__((deprecated)) suppresses
3665 warnings of uses of other deprecated items. */
3666 if (lookup_attribute ("deprecated", attributes))
3667 deprecated_state = DEPRECATED_SUPPRESS;
3669 attributes = chainon (attributes, prefix_attributes);
3671 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3674 deprecated_state = DEPRECATED_NORMAL;
3676 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3677 || decl == error_mark_node)
3678 return error_mark_node;
3680 type = TREE_TYPE (decl);
3682 context = DECL_CONTEXT (decl);
3686 *pushed_scope_p = push_scope (context);
3688 /* We are only interested in class contexts, later. */
3689 if (TREE_CODE (context) == NAMESPACE_DECL)
3690 context = NULL_TREE;
3694 /* Is it valid for this decl to have an initializer at all?
3695 If not, set INITIALIZED to zero, which will indirectly
3696 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3697 switch (TREE_CODE (decl))
3700 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3705 error ("function %q#D is initialized like a variable", decl);
3715 if (! toplevel_bindings_p ()
3716 && DECL_EXTERNAL (decl))
3717 warning (0, "declaration of %q#D has %<extern%> and is initialized",
3719 DECL_EXTERNAL (decl) = 0;
3720 if (toplevel_bindings_p ())
3721 TREE_STATIC (decl) = 1;
3723 /* Tell `pushdecl' this is an initialized decl
3724 even though we don't yet have the initializer expression.
3725 Also tell `cp_finish_decl' it may store the real initializer. */
3726 DECL_INITIAL (decl) = error_mark_node;
3729 /* Set attributes here so if duplicate decl, will have proper attributes. */
3730 cplus_decl_attributes (&decl, attributes, 0);
3732 /* If #pragma weak was used, mark the decl weak now. */
3733 maybe_apply_pragma_weak (decl);
3735 if (TREE_CODE (decl) == FUNCTION_DECL
3736 && DECL_DECLARED_INLINE_P (decl)
3737 && DECL_UNINLINABLE (decl)
3738 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3739 warning (0, "inline function %q+D given attribute noinline", decl);
3741 if (context && COMPLETE_TYPE_P (complete_type (context)))
3743 if (TREE_CODE (decl) == VAR_DECL)
3745 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3746 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3747 error ("%q#D is not a static member of %q#T", decl, context);
3750 if (DECL_CONTEXT (field) != context)
3752 if (!same_type_p (DECL_CONTEXT (field), context))
3753 pedwarn ("ISO C++ does not permit %<%T::%D%> "
3754 "to be defined as %<%T::%D%>",
3755 DECL_CONTEXT (field), DECL_NAME (decl),
3756 context, DECL_NAME (decl));
3757 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3759 if (processing_specialization
3760 && template_class_depth (context) == 0
3761 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3762 error ("template header not allowed in member definition "
3763 "of explicitly specialized class");
3764 /* Static data member are tricky; an in-class initialization
3765 still doesn't provide a definition, so the in-class
3766 declaration will have DECL_EXTERNAL set, but will have an
3767 initialization. Thus, duplicate_decls won't warn
3768 about this situation, and so we check here. */
3769 if (DECL_INITIAL (decl)
3770 && DECL_INITIALIZED_IN_CLASS_P (field))
3771 error ("duplicate initialization of %qD", decl);
3772 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
3778 tree field = check_classfn (context, decl,
3779 (processing_template_decl
3780 > template_class_depth (context))
3781 ? current_template_parms
3783 if (field && duplicate_decls (decl, field,
3784 /*newdecl_is_friend=*/false))
3788 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3789 DECL_IN_AGGR_P (decl) = 0;
3790 /* Do not mark DECL as an explicit specialization if it was not
3791 already marked as an instantiation; a declaration should
3792 never be marked as a specialization unless we know what
3793 template is being specialized. */
3794 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3796 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3798 /* [temp.expl.spec] An explicit specialization of a static data
3799 member of a template is a definition if the declaration
3800 includes an initializer; otherwise, it is a declaration.
3802 We check for processing_specialization so this only applies
3803 to the new specialization syntax. */
3804 if (!DECL_INITIAL (decl)
3805 && processing_specialization)
3806 DECL_EXTERNAL (decl) = 1;
3809 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3810 pedwarn ("declaration of %q#D outside of class is not definition",
3814 /* Enter this declaration into the symbol table. */
3815 tem = maybe_push_decl (decl);
3817 if (processing_template_decl)
3818 tem = push_template_decl (tem);
3819 if (tem == error_mark_node)
3820 return error_mark_node;
3822 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3823 /* Tell the back-end to use or not use .common as appropriate. If we say
3824 -fconserve-space, we want this to save .data space, at the expense of
3825 wrong semantics. If we say -fno-conserve-space, we want this to
3826 produce errors about redefs; to do this we force variables into the
3828 DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3829 || !DECL_THREAD_LOCAL_P (tem))
3830 && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3833 if (! processing_template_decl)
3840 start_decl_1 (tree decl)
3842 tree type = TREE_TYPE (decl);
3843 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3845 if (type == error_mark_node)
3849 /* Is it valid for this decl to have an initializer at all?
3850 If not, set INITIALIZED to zero, which will indirectly
3851 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3853 /* Don't allow initializations for incomplete types except for
3854 arrays which might be completed by the initialization. */
3855 if (COMPLETE_TYPE_P (complete_type (type)))
3856 ; /* A complete type is ok. */
3857 else if (TREE_CODE (type) != ARRAY_TYPE)
3859 error ("variable %q#D has initializer but incomplete type", decl);
3861 type = TREE_TYPE (decl) = error_mark_node;
3863 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3865 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3866 error ("elements of array %q#D have incomplete type", decl);
3867 /* else we already gave an error in start_decl. */
3873 && TREE_CODE (decl) != TYPE_DECL
3874 && TREE_CODE (decl) != TEMPLATE_DECL
3875 && type != error_mark_node
3876 && IS_AGGR_TYPE (type)
3877 && ! DECL_EXTERNAL (decl))
3879 if ((! processing_template_decl || ! uses_template_parms (type))
3880 && !COMPLETE_TYPE_P (complete_type (type)))
3882 error ("aggregate %q#D has incomplete type and cannot be defined",
3884 /* Change the type so that assemble_variable will give
3885 DECL an rtl we can live with: (mem (const_int 0)). */
3886 type = TREE_TYPE (decl) = error_mark_node;
3890 /* If any base type in the hierarchy of TYPE needs a constructor,
3891 then we set initialized to 1. This way any nodes which are
3892 created for the purposes of initializing this aggregate
3893 will live as long as it does. This is necessary for global
3894 aggregates which do not have their initializers processed until
3895 the end of the file. */
3896 initialized = TYPE_NEEDS_CONSTRUCTING (type);
3901 DECL_INITIAL (decl) = NULL_TREE;
3903 /* Create a new scope to hold this declaration if necessary.
3904 Whether or not a new scope is necessary cannot be determined
3905 until after the type has been completed; if the type is a
3906 specialization of a class template it is not until after
3907 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3908 will be set correctly. */
3909 maybe_push_cleanup_level (type);
3912 /* Handle initialization of references. DECL, TYPE, and INIT have the
3913 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
3914 but will be set to a new CLEANUP_STMT if a temporary is created
3915 that must be destroyed subsequently.
3917 Returns an initializer expression to use to initialize DECL, or
3918 NULL if the initialization can be performed statically.
3920 Quotes on semantics can be found in ARM 8.4.3. */
3923 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3927 if (init == NULL_TREE)
3929 if ((DECL_LANG_SPECIFIC (decl) == 0
3930 || DECL_IN_AGGR_P (decl) == 0)
3931 && ! DECL_THIS_EXTERN (decl))
3932 error ("%qD declared as reference but not initialized", decl);
3936 if (TREE_CODE (init) == CONSTRUCTOR)
3938 error ("ISO C++ forbids use of initializer list to "
3939 "initialize reference %qD", decl);
3943 if (TREE_CODE (init) == TREE_LIST)
3944 init = build_x_compound_expr_from_list (init, "initializer");
3946 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3947 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3948 /* Note: default conversion is only called in very special cases. */
3949 init = decay_conversion (init);
3951 /* Convert INIT to the reference type TYPE. This may involve the
3952 creation of a temporary, whose lifetime must be the same as that
3953 of the reference. If so, a DECL_EXPR for the temporary will be
3954 added just after the DECL_EXPR for DECL. That's why we don't set
3955 DECL_INITIAL for local references (instead assigning to them
3956 explicitly); we need to allow the temporary to be initialized
3958 tmp = initialize_reference (type, init, decl, cleanup);
3960 if (tmp == error_mark_node)
3962 else if (tmp == NULL_TREE)
3964 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
3968 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3971 DECL_INITIAL (decl) = tmp;
3976 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3977 array until we finish parsing the initializer. If that's the
3978 situation we're in, update DECL accordingly. */
3981 maybe_deduce_size_from_array_init (tree decl, tree init)
3983 tree type = TREE_TYPE (decl);
3985 if (TREE_CODE (type) == ARRAY_TYPE
3986 && TYPE_DOMAIN (type) == NULL_TREE
3987 && TREE_CODE (decl) != TYPE_DECL)
3989 /* do_default is really a C-ism to deal with tentative definitions.
3990 But let's leave it here to ease the eventual merge. */
3991 int do_default = !DECL_EXTERNAL (decl);
3992 tree initializer = init ? init : DECL_INITIAL (decl);
3993 int failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
3997 error ("initializer fails to determine size of %qD", decl);
4002 error ("array size missing in %qD", decl);
4003 /* If a `static' var's size isn't known, make it extern as
4004 well as static, so it does not get allocated. If it's not
4005 `static', then don't mark it extern; finish_incomplete_decl
4006 will give it a default size and it will get allocated. */
4007 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4008 DECL_EXTERNAL (decl) = 1;
4012 error ("zero-size array %qD", decl);
4014 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4016 layout_decl (decl, 0);
4020 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4021 any appropriate error messages regarding the layout. */
4024 layout_var_decl (tree decl)
4026 tree type = TREE_TYPE (decl);
4028 /* If we haven't already layed out this declaration, do so now.
4029 Note that we must not call complete type for an external object
4030 because it's type might involve templates that we are not
4031 supposed to instantiate yet. (And it's perfectly valid to say
4032 `extern X x' for some incomplete type `X'.) */
4033 if (!DECL_EXTERNAL (decl))
4034 complete_type (type);
4035 if (!DECL_SIZE (decl)
4036 && TREE_TYPE (decl) != error_mark_node
4037 && (COMPLETE_TYPE_P (type)
4038 || (TREE_CODE (type) == ARRAY_TYPE
4039 && !TYPE_DOMAIN (type)
4040 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4041 layout_decl (decl, 0);
4043 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4045 /* An automatic variable with an incomplete type: that is an error.
4046 Don't talk about array types here, since we took care of that
4047 message in grokdeclarator. */
4048 error ("storage size of %qD isn't known", decl);
4049 TREE_TYPE (decl) = error_mark_node;
4052 /* Keep this code around in case we later want to control debug info
4053 based on whether a type is "used". (jason 1999-11-11) */
4055 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4056 /* Let debugger know it should output info for this type. */
4057 note_debug_info_needed (ttype);
4059 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4060 note_debug_info_needed (DECL_CONTEXT (decl));
4063 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4064 && DECL_SIZE (decl) != NULL_TREE
4065 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4067 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4068 constant_expression_warning (DECL_SIZE (decl));
4070 error ("storage size of %qD isn't constant", decl);
4073 if (TREE_STATIC (decl)
4074 && !DECL_ARTIFICIAL (decl)
4075 && current_function_decl
4076 && DECL_CONTEXT (decl) == current_function_decl)
4077 push_local_name (decl);
4080 /* If a local static variable is declared in an inline function, or if
4081 we have a weak definition, we must endeavor to create only one
4082 instance of the variable at link-time. */
4085 maybe_commonize_var (tree decl)
4087 /* Static data in a function with comdat linkage also has comdat
4089 if (TREE_STATIC (decl)
4090 /* Don't mess with __FUNCTION__. */
4091 && ! DECL_ARTIFICIAL (decl)
4092 && DECL_FUNCTION_SCOPE_P (decl)
4093 /* Unfortunately, import_export_decl has not always been called
4094 before the function is processed, so we cannot simply check
4096 && (DECL_COMDAT (DECL_CONTEXT (decl))
4097 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4098 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4099 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4103 /* With weak symbols, we simply make the variable COMDAT;
4104 that will cause copies in multiple translations units to
4106 comdat_linkage (decl);
4110 if (DECL_INITIAL (decl) == NULL_TREE
4111 || DECL_INITIAL (decl) == error_mark_node)
4113 /* Without weak symbols, we can use COMMON to merge
4114 uninitialized variables. */
4115 TREE_PUBLIC (decl) = 1;
4116 DECL_COMMON (decl) = 1;
4120 /* While for initialized variables, we must use internal
4121 linkage -- which means that multiple copies will not
4123 TREE_PUBLIC (decl) = 0;
4124 DECL_COMMON (decl) = 0;
4125 warning (0, "sorry: semantics of inline function static "
4126 "data %q+#D are wrong (you'll wind up "
4127 "with multiple copies)", decl);
4128 warning (0, "%J you can work around this by removing "
4134 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4135 /* Set it up again; we might have set DECL_INITIAL since the last
4137 comdat_linkage (decl);
4140 /* Issue an error message if DECL is an uninitialized const variable. */
4143 check_for_uninitialized_const_var (tree decl)
4145 tree type = TREE_TYPE (decl);
4147 /* ``Unless explicitly declared extern, a const object does not have
4148 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4150 if (TREE_CODE (decl) == VAR_DECL
4151 && TREE_CODE (type) != REFERENCE_TYPE
4152 && CP_TYPE_CONST_P (type)
4153 && !TYPE_NEEDS_CONSTRUCTING (type)
4154 && !DECL_INITIAL (decl))
4155 error ("uninitialized const %qD", decl);
4159 /* Structure holding the current initializer being processed by reshape_init.
4160 CUR is a pointer to the current element being processed, END is a pointer
4161 after the last element present in the initializer. */
4162 typedef struct reshape_iterator_t
4164 constructor_elt *cur;
4165 constructor_elt *end;
4168 static tree reshape_init_r (tree, reshape_iter *, bool);
4170 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4171 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4172 initialized. If there are no more such fields, the return value
4176 next_initializable_field (tree field)
4179 && (TREE_CODE (field) != FIELD_DECL
4180 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4181 || DECL_ARTIFICIAL (field)))
4182 field = TREE_CHAIN (field);
4187 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4188 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4189 INTEGER_CST representing the size of the array minus one (the maximum index),
4190 or NULL_TREE if the array was declared without specifying the size. D is
4191 the iterator within the constructor. */
4194 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4197 bool sized_array_p = (max_index != NULL_TREE);
4198 unsigned HOST_WIDE_INT max_index_cst = 0;
4199 unsigned HOST_WIDE_INT index;
4201 /* The initializer for an array is always a CONSTRUCTOR. */
4202 new_init = build_constructor (NULL_TREE, NULL);
4206 /* Minus 1 is used for zero sized arrays. */
4207 if (integer_all_onesp (max_index))
4210 if (host_integerp (max_index, 1))
4211 max_index_cst = tree_low_cst (max_index, 1);
4212 /* sizetype is sign extended, not zero extended. */
4214 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4218 /* Loop until there are no more initializers. */
4220 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4227 /* Handle array designated initializers (GNU extension). */
4228 if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
4230 error ("name %qD used in a GNU-style designated "
4231 "initializer for an array", d->cur->index);
4237 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4238 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4244 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4245 Parameters are the same of reshape_init_r. */
4248 reshape_init_array (tree type, reshape_iter *d)
4250 tree max_index = NULL_TREE;
4252 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4254 if (TYPE_DOMAIN (type))
4255 max_index = array_type_nelts (type);
4257 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4260 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4261 Parameters are the same of reshape_init_r. */
4264 reshape_init_vector (tree type, reshape_iter *d)
4266 tree max_index = NULL_TREE;
4269 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4271 if (COMPOUND_LITERAL_P (d->cur->value))
4273 tree value = d->cur->value;
4274 if (!same_type_p (TREE_TYPE (value), type))
4276 error ("invalid type %qT as initializer for a vector of type %qT",
4277 TREE_TYPE (d->cur->value), type);
4278 value = error_mark_node;
4284 /* For a vector, the representation type is a struct
4285 containing a single member which is an array of the
4286 appropriate size. */
4287 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4288 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4289 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4291 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4294 /* Subroutine of reshape_init_r, processes the initializers for classes
4295 or union. Parameters are the same of reshape_init_r. */
4298 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4303 gcc_assert (CLASS_TYPE_P (type));
4305 /* The initializer for a class is always a CONSTRUCTOR. */
4306 new_init = build_constructor (NULL_TREE, NULL);
4307 field = next_initializable_field (TYPE_FIELDS (type));
4313 An initializer for an aggregate member that is an
4314 empty class shall have the form of an empty
4315 initializer-list {}. */
4316 if (!first_initializer_p)
4318 error ("initializer for %qT must be brace-enclosed", type);
4319 return error_mark_node;
4324 /* Loop through the initializable fields, gathering initializers. */
4325 while (d->cur != d->end)
4329 /* Handle designated initializers, as an extension. */
4333 pedwarn ("ISO C++ does not allow designated initializers");
4335 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4337 if (!field || TREE_CODE (field) != FIELD_DECL)
4338 error ("%qT has no non-static data member named %qD", type,
4342 /* If we processed all the member of the class, we are done. */
4346 field_init = reshape_init_r (TREE_TYPE (field), d,
4347 /*first_initializer_p=*/false);
4348 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4352 When a union is initialized with a brace-enclosed
4353 initializer, the braces shall only contain an
4354 initializer for the first member of the union. */
4355 if (TREE_CODE (type) == UNION_TYPE)
4358 field = next_initializable_field (TREE_CHAIN (field));
4364 /* Subroutine of reshape_init, which processes a single initializer (part of
4365 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4366 iterator within the CONSTRUCTOR which points to the initializer to process.
4367 FIRST_INITIALIZER_P is true if this is the first initializer of the
4368 CONSTRUCTOR node. */
4371 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4373 tree init = d->cur->value;
4375 /* A non-aggregate type is always initialized with a single
4377 if (!CP_AGGREGATE_TYPE_P (type))
4379 /* It is invalid to initialize a non-aggregate type with a
4380 brace-enclosed initializer.
4381 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4382 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4383 a CONSTRUCTOR (with a record type). */
4384 if (TREE_CODE (init) == CONSTRUCTOR
4385 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4387 error ("braces around scalar initializer for type %qT", type);
4388 init = error_mark_node;
4397 All implicit type conversions (clause _conv_) are considered when
4398 initializing the aggregate member with an initializer from an
4399 initializer-list. If the initializer can initialize a member,
4400 the member is initialized. Otherwise, if the member is itself a
4401 non-empty subaggregate, brace elision is assumed and the
4402 initializer is considered for the initialization of the first
4403 member of the subaggregate. */
4404 if (TREE_CODE (init) != CONSTRUCTOR
4405 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4411 /* [dcl.init.string]
4413 A char array (whether plain char, signed char, or unsigned char)
4414 can be initialized by a string-literal (optionally enclosed in
4415 braces); a wchar_t array can be initialized by a wide
4416 string-literal (optionally enclosed in braces). */
4417 if (TREE_CODE (type) == ARRAY_TYPE
4418 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4420 tree str_init = init;
4422 /* Strip one level of braces if and only if they enclose a single
4423 element (as allowed by [dcl.init.string]). */
4424 if (!first_initializer_p
4425 && TREE_CODE (str_init) == CONSTRUCTOR
4426 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4428 str_init = VEC_index (constructor_elt,
4429 CONSTRUCTOR_ELTS (str_init), 0)->value;
4432 /* If it's a string literal, then it's the initializer for the array
4433 as a whole. Otherwise, continue with normal initialization for
4434 array types (one value per array element). */
4435 if (TREE_CODE (str_init) == STRING_CST)
4442 /* The following cases are about aggregates. If we are not within a full
4443 initializer already, and there is not a CONSTRUCTOR, it means that there
4444 is a missing set of braces (that is, we are processing the case for
4445 which reshape_init exists). */
4446 if (!first_initializer_p)
4448 if (TREE_CODE (init) == CONSTRUCTOR)
4450 /* For a nested compound literal, there is no need to reshape since
4451 brace elision is not allowed. Even if we decided to allow it,
4452 we should add a call to reshape_init in finish_compound_literal,
4453 before calling digest_init, so changing this code would still
4454 not be necessary. */
4455 if (!COMPOUND_LITERAL_P (init))
4458 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4459 return reshape_init (type, init);
4462 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4465 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4469 /* Dispatch to specialized routines. */
4470 if (CLASS_TYPE_P (type))
4471 return reshape_init_class (type, d, first_initializer_p);
4472 else if (TREE_CODE (type) == ARRAY_TYPE)
4473 return reshape_init_array (type, d);
4474 else if (TREE_CODE (type) == VECTOR_TYPE)
4475 return reshape_init_vector (type, d);
4480 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4481 brace-enclosed aggregate initializer.
4483 INIT is the CONSTRUCTOR containing the list of initializers describing
4484 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4485 It may not presently match the shape of the TYPE; for example:
4487 struct S { int a; int b; };
4488 struct S a[] = { 1, 2, 3, 4 };
4490 Here INIT will hold a VEC of four elements, rather than a
4491 VEC of two elements, each itself a VEC of two elements. This
4492 routine transforms INIT from the former form into the latter. The
4493 revised CONSTRUCTOR node is returned. */
4496 reshape_init (tree type, tree init)
4498 VEC(constructor_elt, gc) *v;
4502 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4504 v = CONSTRUCTOR_ELTS (init);
4506 /* An empty constructor does not need reshaping, and it is always a valid
4508 if (VEC_empty (constructor_elt, v))
4511 /* Recurse on this CONSTRUCTOR. */
4512 d.cur = VEC_index (constructor_elt, v, 0);
4513 d.end = d.cur + VEC_length (constructor_elt, v);
4515 new_init = reshape_init_r (type, &d, true);
4517 /* Make sure all the element of the constructor were used. Otherwise,
4518 issue an error about exceeding initializers. */
4520 error ("too many initializers for %qT", type);
4525 /* Verify INIT (the initializer for DECL), and record the
4526 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4527 grok_reference_init.
4529 If the return value is non-NULL, it is an expression that must be
4530 evaluated dynamically to initialize DECL. */
4533 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4535 tree type = TREE_TYPE (decl);
4536 tree init_code = NULL;
4538 /* If `start_decl' didn't like having an initialization, ignore it now. */
4539 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4542 /* If an initializer is present, DECL_INITIAL has been
4543 error_mark_node, to indicate that an as-of-yet unevaluated
4544 initialization will occur. From now on, DECL_INITIAL reflects
4545 the static initialization -- if any -- of DECL. */
4546 DECL_INITIAL (decl) = NULL_TREE;
4548 /* Things that are going to be initialized need to have complete
4550 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4552 if (type == error_mark_node)
4553 /* We will have already complained. */
4555 else if (init && COMPLETE_TYPE_P (type)
4556 && !TREE_CONSTANT (TYPE_SIZE (type)))
4558 error ("variable-sized object %qD may not be initialized", decl);
4561 else if (TREE_CODE (type) == ARRAY_TYPE
4562 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4564 error ("elements of array %q#D have incomplete type", decl);
4567 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4569 error ("%qD has incomplete type", decl);
4570 TREE_TYPE (decl) = error_mark_node;
4574 if (TREE_CODE (decl) == CONST_DECL)
4576 gcc_assert (TREE_CODE (decl) != REFERENCE_TYPE);
4578 DECL_INITIAL (decl) = init;
4580 gcc_assert (init != NULL_TREE);
4583 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4584 init = grok_reference_init (decl, type, init, cleanup);
4587 /* Do not reshape constructors of vectors (they don't need to be
4589 if (TREE_CODE (init) == CONSTRUCTOR
4590 && !COMPOUND_LITERAL_P (init)
4591 && !TREE_TYPE (init)) /* ptrmemfunc */
4593 init = reshape_init (type, init);
4595 if ((*targetm.vector_opaque_p) (type))
4597 error ("opaque vector types cannot be initialized");
4598 init = error_mark_node;
4602 /* If DECL has an array type without a specific bound, deduce the
4603 array size from the initializer. */
4604 maybe_deduce_size_from_array_init (decl, init);
4605 type = TREE_TYPE (decl);
4607 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4609 if (TREE_CODE (type) == ARRAY_TYPE)
4610 goto initialize_aggr;
4611 else if (TREE_CODE (init) == CONSTRUCTOR)
4613 if (TYPE_NON_AGGREGATE_CLASS (type))
4615 error ("%qD must be initialized by constructor, "
4618 init = error_mark_node;
4621 goto dont_use_constructor;
4625 int saved_stmts_are_full_exprs_p;
4628 saved_stmts_are_full_exprs_p = 0;
4629 if (building_stmt_tree ())
4631 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4632 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4634 init = build_aggr_init (decl, init, flags);
4635 if (building_stmt_tree ())
4636 current_stmt_tree ()->stmts_are_full_exprs_p =
4637 saved_stmts_are_full_exprs_p;
4643 dont_use_constructor:
4644 if (TREE_CODE (init) != TREE_VEC)
4646 init_code = store_init_value (decl, init);
4647 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4648 && DECL_INITIAL (decl)
4649 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4650 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4651 warning (0, "array %qD initialized by parenthesized string literal %qE",
4652 decl, DECL_INITIAL (decl));
4657 else if (DECL_EXTERNAL (decl))
4659 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4660 goto initialize_aggr;
4661 else if (IS_AGGR_TYPE (type))
4663 tree core_type = strip_array_types (type);
4665 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4666 error ("structure %qD with uninitialized const members", decl);
4667 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4668 error ("structure %qD with uninitialized reference members", decl);
4670 check_for_uninitialized_const_var (decl);
4673 check_for_uninitialized_const_var (decl);
4675 if (init && init != error_mark_node)
4676 init_code = build2 (INIT_EXPR, type, decl, init);
4681 /* If DECL is not a local variable, give it RTL. */
4684 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4686 int toplev = toplevel_bindings_p ();
4688 const char *filename;
4690 /* Set the DECL_ASSEMBLER_NAME for the object. */
4693 /* The `register' keyword, when used together with an
4694 asm-specification, indicates that the variable should be
4695 placed in a particular register. */
4696 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
4698 set_user_assembler_name (decl, asmspec);
4699 DECL_HARD_REGISTER (decl) = 1;
4703 if (TREE_CODE (decl) == FUNCTION_DECL
4704 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4705 set_builtin_user_assembler_name (decl, asmspec);
4706 set_user_assembler_name (decl, asmspec);
4710 /* Handle non-variables up front. */
4711 if (TREE_CODE (decl) != VAR_DECL)
4713 rest_of_decl_compilation (decl, toplev, at_eof);
4717 /* If we see a class member here, it should be a static data
4719 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4721 gcc_assert (TREE_STATIC (decl));
4722 /* An in-class declaration of a static data member should be
4723 external; it is only a declaration, and not a definition. */
4724 if (init == NULL_TREE)
4725 gcc_assert (DECL_EXTERNAL (decl));
4728 /* We don't create any RTL for local variables. */
4729 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4732 /* We defer emission of local statics until the corresponding
4733 DECL_EXPR is expanded. */
4734 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4736 /* We try to defer namespace-scope static constants so that they are
4737 not emitted into the object file unnecessarily. */
4738 filename = input_filename;
4739 if (!DECL_VIRTUAL_P (decl)
4740 && TREE_READONLY (decl)
4741 && DECL_INITIAL (decl) != NULL_TREE
4742 && DECL_INITIAL (decl) != error_mark_node
4744 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4746 && !TREE_PUBLIC (decl))
4748 /* Fool with the linkage of static consts according to #pragma
4750 struct c_fileinfo *finfo = get_fileinfo (lbasename (filename));
4751 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
4753 TREE_PUBLIC (decl) = 1;
4754 DECL_EXTERNAL (decl) = finfo->interface_only;
4759 /* Likewise for template instantiations. */
4760 else if (DECL_LANG_SPECIFIC (decl)
4761 && DECL_IMPLICIT_INSTANTIATION (decl))
4764 /* If we're not deferring, go ahead and assemble the variable. */
4766 rest_of_decl_compilation (decl, toplev, at_eof);
4769 /* Generate code to initialize DECL (a local variable). */
4772 initialize_local_var (tree decl, tree init)
4774 tree type = TREE_TYPE (decl);
4777 gcc_assert (TREE_CODE (decl) == VAR_DECL
4778 || TREE_CODE (decl) == RESULT_DECL);
4779 gcc_assert (!TREE_STATIC (decl));
4781 if (DECL_SIZE (decl) == NULL_TREE)
4783 /* If we used it already as memory, it must stay in memory. */
4784 DECL_INITIAL (decl) = NULL_TREE;
4785 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4788 if (DECL_SIZE (decl) && type != error_mark_node)
4792 /* Compute and store the initial value. */
4793 already_used = TREE_USED (decl) || TREE_USED (type);
4795 /* Perform the initialization. */
4798 int saved_stmts_are_full_exprs_p;
4800 gcc_assert (building_stmt_tree ());
4801 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4802 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4803 finish_expr_stmt (init);
4804 current_stmt_tree ()->stmts_are_full_exprs_p =
4805 saved_stmts_are_full_exprs_p;
4808 /* Set this to 0 so we can tell whether an aggregate which was
4809 initialized was ever used. Don't do this if it has a
4810 destructor, so we don't complain about the 'resource
4811 allocation is initialization' idiom. Now set
4812 attribute((unused)) on types so decls of that type will be
4813 marked used. (see TREE_USED, above.) */
4814 if (TYPE_NEEDS_CONSTRUCTING (type)
4816 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4817 && DECL_NAME (decl))
4818 TREE_USED (decl) = 0;
4819 else if (already_used)
4820 TREE_USED (decl) = 1;
4823 /* Generate a cleanup, if necessary. */
4824 cleanup = cxx_maybe_build_cleanup (decl);
4825 if (DECL_SIZE (decl) && cleanup)
4826 finish_decl_cleanup (decl, cleanup);
4829 /* DECL is a VAR_DECL for a compiler-generated variable with static
4830 storage duration (like a virtual table) whose initializer is a
4831 compile-time constant. INIT must be either a TREE_LIST of values,
4832 or a CONSTRUCTOR. Initialize the variable and provide it to the
4836 initialize_artificial_var (tree decl, tree init)
4838 if (TREE_CODE (init) == TREE_LIST)
4839 init = build_constructor_from_list (NULL_TREE, init);
4840 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
4841 DECL_INITIAL (decl) = init;
4842 DECL_INITIALIZED_P (decl) = 1;
4843 determine_visibility (decl);
4844 layout_var_decl (decl);
4845 maybe_commonize_var (decl);
4846 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
4849 /* Finish processing of a declaration;
4850 install its line number and initial value.
4851 If the length of an array type is not known before,
4852 it must be determined now, from the initial value, or it is an error.
4854 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
4855 true, then INIT is an integral constant expression.
4857 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4858 if the (init) syntax was used. */
4861 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
4862 tree asmspec_tree, int flags)
4866 const char *asmspec = NULL;
4867 int was_readonly = 0;
4868 bool var_definition_p = false;
4870 if (decl == error_mark_node)
4875 error ("assignment (not initialization) in declaration");
4879 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
4881 /* Assume no cleanup is required. */
4882 cleanup = NULL_TREE;
4884 /* If a name was specified, get the string. */
4885 if (global_scope_p (current_binding_level))
4886 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4888 asmspec = TREE_STRING_POINTER (asmspec_tree);
4890 if (init && TREE_CODE (init) == NAMESPACE_DECL)
4892 error ("cannot initialize %qD to namespace %qD", decl, init);
4896 if (current_class_type
4897 && CP_DECL_CONTEXT (decl) == current_class_type
4898 && TYPE_BEING_DEFINED (current_class_type)
4899 && (DECL_INITIAL (decl) || init))
4900 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4902 type = TREE_TYPE (decl);
4904 if (type == error_mark_node)
4907 if (processing_template_decl)
4909 /* Add this declaration to the statement-tree. */
4910 if (at_function_scope_p ())
4911 add_decl_expr (decl);
4913 if (init && DECL_INITIAL (decl))
4915 DECL_INITIAL (decl) = init;
4916 if (init_const_expr_p)
4918 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
4919 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
4920 TREE_CONSTANT (decl) = 1;
4924 if (TREE_CODE (decl) == VAR_DECL
4925 && !DECL_PRETTY_FUNCTION_P (decl)
4926 && !dependent_type_p (TREE_TYPE (decl)))
4927 maybe_deduce_size_from_array_init (decl, init);
4932 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4933 gcc_assert (TREE_CODE (decl) != PARM_DECL);
4935 /* Take care of TYPE_DECLs up front. */
4936 if (TREE_CODE (decl) == TYPE_DECL)
4938 if (type != error_mark_node
4939 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4941 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4942 warning (0, "shadowing previous type declaration of %q#D", decl);
4943 set_identifier_type_value (DECL_NAME (decl), decl);
4946 /* If we have installed this as the canonical typedef for this
4947 type, and that type has not been defined yet, delay emitting
4948 the debug information for it, as we will emit it later. */
4949 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4950 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4951 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4953 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
4958 /* A reference will be modified here, as it is initialized. */
4959 if (! DECL_EXTERNAL (decl)
4960 && TREE_READONLY (decl)
4961 && TREE_CODE (type) == REFERENCE_TYPE)
4964 TREE_READONLY (decl) = 0;
4967 if (TREE_CODE (decl) == VAR_DECL)
4969 /* Only PODs can have thread-local storage. Other types may require
4970 various kinds of non-trivial initialization. */
4971 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
4972 error ("%qD cannot be thread-local because it has non-POD type %qT",
4973 decl, TREE_TYPE (decl));
4974 /* Convert the initializer to the type of DECL, if we have not
4975 already initialized DECL. */
4976 if (!DECL_INITIALIZED_P (decl)
4977 /* If !DECL_EXTERNAL then DECL is being defined. In the
4978 case of a static data member initialized inside the
4979 class-specifier, there can be an initializer even if DECL
4980 is *not* defined. */
4981 && (!DECL_EXTERNAL (decl) || init))
4985 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
4986 if (init_const_expr_p)
4988 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
4989 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
4990 TREE_CONSTANT (decl) = 1;
4993 init = check_initializer (decl, init, flags, &cleanup);
4994 /* Thread-local storage cannot be dynamically initialized. */
4995 if (DECL_THREAD_LOCAL_P (decl) && init)
4997 error ("%qD is thread-local and so cannot be dynamically "
4998 "initialized", decl);
5002 /* Check that the initializer for a static data member was a
5003 constant. Although we check in the parser that the
5004 initializer is an integral constant expression, we do not
5005 simplify division-by-zero at the point at which it
5006 occurs. Therefore, in:
5008 struct S { static const int i = 7 / 0; };
5010 we issue an error at this point. It would
5011 probably be better to forbid division by zero in
5012 integral constant expressions. */
5013 if (DECL_EXTERNAL (decl) && init)
5015 error ("%qD cannot be initialized by a non-constant expression"
5016 " when being declared", decl);
5017 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5025 The memory occupied by any object of static storage
5026 duration is zero-initialized at program startup before
5027 any other initialization takes place.
5029 We cannot create an appropriate initializer until after
5030 the type of DECL is finalized. If DECL_INITIAL is set,
5031 then the DECL is statically initialized, and any
5032 necessary zero-initialization has already been performed. */
5033 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5034 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5035 /*nelts=*/NULL_TREE,
5036 /*static_storage_p=*/true);
5037 /* Remember that the initialization for this variable has
5039 DECL_INITIALIZED_P (decl) = 1;
5040 /* This declaration is the definition of this variable,
5041 unless we are initializing a static data member within
5042 the class specifier. */
5043 if (!DECL_EXTERNAL (decl))
5044 var_definition_p = true;
5045 /* The variable is being defined, so determine its
5047 determine_visibility (decl);
5049 /* If the variable has an array type, lay out the type, even if
5050 there is no initializer. It is valid to index through the
5051 array, and we must get TYPE_ALIGN set correctly on the array
5053 else if (TREE_CODE (type) == ARRAY_TYPE)
5057 /* Add this declaration to the statement-tree. This needs to happen
5058 after the call to check_initializer so that the DECL_EXPR for a
5059 reference temp is added before the DECL_EXPR for the reference itself. */
5060 if (at_function_scope_p ())
5061 add_decl_expr (decl);
5063 if (TREE_CODE (decl) == VAR_DECL)
5064 layout_var_decl (decl);
5066 /* Output the assembler code and/or RTL code for variables and functions,
5067 unless the type is an undefined structure or union.
5068 If not, it will get done when the type is completed. */
5069 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
5071 if (TREE_CODE (decl) == VAR_DECL)
5072 maybe_commonize_var (decl);
5074 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5076 /* Check for abstractness of the type. Notice that there is no
5077 need to strip array types here since the check for those types
5078 is already done within create_array_type_for_decl. */
5079 if (TREE_CODE (type) == FUNCTION_TYPE
5080 || TREE_CODE (type) == METHOD_TYPE)
5081 abstract_virtuals_error (decl, TREE_TYPE (type));
5083 abstract_virtuals_error (decl, type);
5085 if (TREE_CODE (decl) == FUNCTION_DECL
5086 || TREE_TYPE (decl) == error_mark_node)
5087 /* No initialization required. */
5089 else if (DECL_EXTERNAL (decl)
5090 && ! (DECL_LANG_SPECIFIC (decl)
5091 && DECL_NOT_REALLY_EXTERN (decl)))
5094 DECL_INITIAL (decl) = init;
5098 /* A variable definition. */
5099 if (DECL_FUNCTION_SCOPE_P (decl))
5101 /* Initialize the local variable. */
5102 if (processing_template_decl)
5104 if (init || DECL_INITIAL (decl) == error_mark_node)
5105 DECL_INITIAL (decl) = init;
5107 else if (!TREE_STATIC (decl))
5108 initialize_local_var (decl, init);
5111 /* If a variable is defined, and then a subsequent
5112 definition with external linkage is encountered, we will
5113 get here twice for the same variable. We want to avoid
5114 calling expand_static_init more than once. For variables
5115 that are not static data members, we can call
5116 expand_static_init only when we actually process the
5117 initializer. It is not legal to redeclare a static data
5118 member, so this issue does not arise in that case. */
5119 if (var_definition_p && TREE_STATIC (decl))
5120 expand_static_init (decl, init);
5124 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5125 reference, insert it in the statement-tree now. */
5127 push_cleanup (decl, cleanup, false);
5132 TREE_READONLY (decl) = 1;
5134 /* If this was marked 'used', be sure it will be output. */
5135 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5136 mark_decl_referenced (decl);
5139 /* This is here for a midend callback from c-common.c. */
5142 finish_decl (tree decl, tree init, tree asmspec_tree)
5144 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5147 /* Returns a declaration for a VAR_DECL as if:
5149 extern "C" TYPE NAME;
5151 had been seen. Used to create compiler-generated global
5155 declare_global_var (tree name, tree type)
5159 push_to_top_level ();
5160 decl = build_decl (VAR_DECL, name, type);
5161 TREE_PUBLIC (decl) = 1;
5162 DECL_EXTERNAL (decl) = 1;
5163 DECL_ARTIFICIAL (decl) = 1;
5164 /* If the user has explicitly declared this variable (perhaps
5165 because the code we are compiling is part of a low-level runtime
5166 library), then it is possible that our declaration will be merged
5167 with theirs by pushdecl. */
5168 decl = pushdecl (decl);
5169 finish_decl (decl, NULL_TREE, NULL_TREE);
5170 pop_from_top_level ();
5175 /* Returns a pointer to the `atexit' function. Note that if
5176 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5177 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5180 get_atexit_node (void)
5187 bool use_aeabi_atexit;
5192 if (flag_use_cxa_atexit)
5194 /* The declaration for `__cxa_atexit' is:
5196 int __cxa_atexit (void (*)(void *), void *, void *)
5198 We build up the argument types and then then function type
5201 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5202 /* First, build the pointer-to-function type for the first
5204 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5205 fn_type = build_function_type (void_type_node, arg_types);
5206 fn_ptr_type = build_pointer_type (fn_type);
5207 /* Then, build the rest of the argument types. */
5208 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5209 if (use_aeabi_atexit)
5211 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5212 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5216 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5217 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5219 /* And the final __cxa_atexit type. */
5220 fn_type = build_function_type (integer_type_node, arg_types);
5221 fn_ptr_type = build_pointer_type (fn_type);
5222 if (use_aeabi_atexit)
5223 name = "__aeabi_atexit";
5225 name = "__cxa_atexit";
5229 /* The declaration for `atexit' is:
5231 int atexit (void (*)());
5233 We build up the argument types and then then function type
5235 fn_type = build_function_type (void_type_node, void_list_node);
5236 fn_ptr_type = build_pointer_type (fn_type);
5237 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5238 /* Build the final atexit type. */
5239 fn_type = build_function_type (integer_type_node, arg_types);
5243 /* Now, build the function declaration. */
5244 push_lang_context (lang_name_c);
5245 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5246 mark_used (atexit_fndecl);
5247 pop_lang_context ();
5248 atexit_node = decay_conversion (atexit_fndecl);
5253 /* Returns the __dso_handle VAR_DECL. */
5256 get_dso_handle_node (void)
5258 if (dso_handle_node)
5259 return dso_handle_node;
5261 /* Declare the variable. */
5262 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5265 return dso_handle_node;
5268 /* Begin a new function with internal linkage whose job will be simply
5269 to destroy some particular variable. */
5271 static GTY(()) int start_cleanup_cnt;
5274 start_cleanup_fn (void)
5281 push_to_top_level ();
5283 /* No need to mangle this. */
5284 push_lang_context (lang_name_c);
5286 /* Build the parameter-types. */
5287 parmtypes = void_list_node;
5288 /* Functions passed to __cxa_atexit take an additional parameter.
5289 We'll just ignore it. After we implement the new calling
5290 convention for destructors, we can eliminate the use of
5291 additional cleanup functions entirely in the -fnew-abi case. */
5292 if (flag_use_cxa_atexit)
5293 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5294 /* Build the function type itself. */
5295 fntype = build_function_type (void_type_node, parmtypes);
5296 /* Build the name of the function. */
5297 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5298 /* Build the function declaration. */
5299 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5300 /* It's a function with internal linkage, generated by the
5302 TREE_PUBLIC (fndecl) = 0;
5303 DECL_ARTIFICIAL (fndecl) = 1;
5304 /* Make the function `inline' so that it is only emitted if it is
5305 actually needed. It is unlikely that it will be inlined, since
5306 it is only called via a function pointer, but we avoid unnecessary
5307 emissions this way. */
5308 DECL_INLINE (fndecl) = 1;
5309 DECL_DECLARED_INLINE_P (fndecl) = 1;
5310 DECL_INTERFACE_KNOWN (fndecl) = 1;
5311 /* Build the parameter. */
5312 if (flag_use_cxa_atexit)
5316 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5317 DECL_CONTEXT (parmdecl) = fndecl;
5318 TREE_USED (parmdecl) = 1;
5319 DECL_ARGUMENTS (fndecl) = parmdecl;
5323 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5325 pop_lang_context ();
5327 return current_function_decl;
5330 /* Finish the cleanup function begun by start_cleanup_fn. */
5333 end_cleanup_fn (void)
5335 expand_or_defer_fn (finish_function (0));
5337 pop_from_top_level ();
5340 /* Generate code to handle the destruction of DECL, an object with
5341 static storage duration. */
5344 register_dtor_fn (tree decl)
5351 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5352 return void_zero_node;
5354 /* Call build_cleanup before we enter the anonymous function so that
5355 any access checks will be done relative to the current scope,
5356 rather than the scope of the anonymous function. */
5357 build_cleanup (decl);
5359 /* Now start the function. */
5360 cleanup = start_cleanup_fn ();
5362 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5363 to the original function, rather than the anonymous one. That
5364 will make the back-end think that nested functions are in use,
5365 which causes confusion. */
5367 push_deferring_access_checks (dk_no_check);
5368 fcall = build_cleanup (decl);
5369 pop_deferring_access_checks ();
5371 /* Create the body of the anonymous function. */
5372 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5373 finish_expr_stmt (fcall);
5374 finish_compound_stmt (compound_stmt);
5377 /* Call atexit with the cleanup function. */
5378 cxx_mark_addressable (cleanup);
5379 mark_used (cleanup);
5380 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5381 if (flag_use_cxa_atexit)
5383 args = tree_cons (NULL_TREE,
5384 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5386 if (targetm.cxx.use_aeabi_atexit ())
5388 args = tree_cons (NULL_TREE, cleanup, args);
5389 args = tree_cons (NULL_TREE, null_pointer_node, args);
5393 args = tree_cons (NULL_TREE, null_pointer_node, args);
5394 args = tree_cons (NULL_TREE, cleanup, args);
5398 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5399 return build_function_call (get_atexit_node (), args);
5402 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5403 is its initializer. Generate code to handle the construction
5404 and destruction of DECL. */
5407 expand_static_init (tree decl, tree init)
5409 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5410 gcc_assert (TREE_STATIC (decl));
5412 /* Some variables require no initialization. */
5414 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5415 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5418 if (DECL_FUNCTION_SCOPE_P (decl))
5420 /* Emit code to perform this initialization but once. */
5421 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5422 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5423 tree guard, guard_addr, guard_addr_list;
5424 tree acquire_fn, release_fn, abort_fn;
5427 /* Emit code to perform this initialization but once. This code
5430 static <type> guard;
5431 if (!guard.first_byte) {
5432 if (__cxa_guard_acquire (&guard)) {
5435 // Do initialization.
5436 flag = true; __cxa_guard_release (&guard);
5437 // Register variable for destruction at end of program.
5439 if (!flag) __cxa_guard_abort (&guard);
5443 Note that the `flag' variable is only set to 1 *after* the
5444 initialization is complete. This ensures that an exception,
5445 thrown during the construction, will cause the variable to
5446 reinitialized when we pass through this code again, as per:
5450 If the initialization exits by throwing an exception, the
5451 initialization is not complete, so it will be tried again
5452 the next time control enters the declaration.
5454 This process should be thread-safe, too; multiple threads
5455 should not be able to initialize the variable more than
5458 /* Create the guard variable. */
5459 guard = get_guard (decl);
5461 /* This optimization isn't safe on targets with relaxed memory
5462 consistency. On such targets we force synchronization in
5463 __cxa_guard_acquire. */
5464 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5466 /* Begin the conditional initialization. */
5467 if_stmt = begin_if_stmt ();
5468 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5469 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5472 if (flag_threadsafe_statics)
5474 guard_addr = build_address (guard);
5475 guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
5477 acquire_fn = get_identifier ("__cxa_guard_acquire");
5478 release_fn = get_identifier ("__cxa_guard_release");
5479 abort_fn = get_identifier ("__cxa_guard_abort");
5480 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5482 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5484 tree vfntype = build_function_type (void_type_node, argtypes);
5485 acquire_fn = push_library_fn
5486 (acquire_fn, build_function_type (integer_type_node, argtypes));
5487 release_fn = push_library_fn (release_fn, vfntype);
5488 abort_fn = push_library_fn (abort_fn, vfntype);
5492 release_fn = identifier_global_value (release_fn);
5493 abort_fn = identifier_global_value (abort_fn);
5496 inner_if_stmt = begin_if_stmt ();
5497 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
5500 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5501 begin = get_target_expr (boolean_false_node);
5502 flag = TARGET_EXPR_SLOT (begin);
5504 TARGET_EXPR_CLEANUP (begin)
5505 = build3 (COND_EXPR, void_type_node, flag,
5507 build_call (abort_fn, guard_addr_list));
5508 CLEANUP_EH_ONLY (begin) = 1;
5510 /* Do the initialization itself. */
5511 init = add_stmt_to_compound (begin, init);
5512 init = add_stmt_to_compound
5513 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
5514 init = add_stmt_to_compound
5515 (init, build_call (release_fn, guard_addr_list));
5518 init = add_stmt_to_compound (init, set_guard (guard));
5520 /* Use atexit to register a function for destroying this static
5522 init = add_stmt_to_compound (init, register_dtor_fn (decl));
5524 finish_expr_stmt (init);
5526 if (flag_threadsafe_statics)
5528 finish_compound_stmt (inner_then_clause);
5529 finish_then_clause (inner_if_stmt);
5530 finish_if_stmt (inner_if_stmt);
5533 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5535 finish_compound_stmt (then_clause);
5536 finish_then_clause (if_stmt);
5537 finish_if_stmt (if_stmt);
5541 static_aggregates = tree_cons (init, decl, static_aggregates);
5545 /* Make TYPE a complete type based on INITIAL_VALUE.
5546 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5547 2 if there was no information (in which case assume 0 if DO_DEFAULT),
5548 3 if the initializer list is empty (in pedantic mode). */
5551 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
5554 tree type, elt_type;
5558 /* An array of character type can be initialized from a
5559 brace-enclosed string constant.
5561 FIXME: this code is duplicated from reshape_init. Probably
5562 we should just call reshape_init here? */
5563 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
5564 && TREE_CODE (initial_value) == CONSTRUCTOR
5565 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
5567 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
5568 tree value = VEC_index (constructor_elt, v, 0)->value;
5570 if (TREE_CODE (value) == STRING_CST
5571 && VEC_length (constructor_elt, v) == 1)
5572 initial_value = value;
5576 failure = complete_array_type (ptype, initial_value, do_default);
5578 /* We can create the array before the element type is complete, which
5579 means that we didn't have these two bits set in the original type
5580 either. In completing the type, we are expected to propagate these
5581 bits. See also complete_type which does the same thing for arrays
5584 if (TYPE_DOMAIN (type))
5586 elt_type = TREE_TYPE (type);
5587 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
5588 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5589 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
5595 /* Return zero if something is declared to be a member of type
5596 CTYPE when in the context of CUR_TYPE. STRING is the error
5597 message to print in that case. Otherwise, quietly return 1. */
5600 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5602 if (ctype && ctype != cur_type)
5604 if (flags == DTOR_FLAG)
5605 error ("destructor for alien class %qT cannot be a member", ctype);
5607 error ("constructor for alien class %qT cannot be a member", ctype);
5613 /* Subroutine of `grokdeclarator'. */
5615 /* Generate errors possibly applicable for a given set of specifiers.
5616 This is for ARM $7.1.2. */
5619 bad_specifiers (tree object,
5628 error ("%qD declared as a %<virtual%> %s", object, type);
5630 error ("%qD declared as an %<inline%> %s", object, type);
5632 error ("%<const%> and %<volatile%> function specifiers on "
5633 "%qD invalid in %s declaration",
5636 error ("%q+D declared as a friend", object);
5638 && (TREE_CODE (object) == TYPE_DECL
5639 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5640 && !TYPE_REFFN_P (TREE_TYPE (object))
5641 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5642 error ("%q+D declared with an exception specification", object);
5645 /* DECL is a member function or static data member and is presently
5646 being defined. Check that the definition is taking place in a
5650 check_class_member_definition_namespace (tree decl)
5652 /* These checks only apply to member functions and static data
5654 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5655 || TREE_CODE (decl) == VAR_DECL);
5656 /* We check for problems with specializations in pt.c in
5657 check_specialization_namespace, where we can issue better
5659 if (processing_specialization)
5661 /* There are no restrictions on the placement of
5662 explicit instantiations. */
5663 if (processing_explicit_instantiation)
5667 A member function definition that appears outside of the
5668 class definition shall appear in a namespace scope enclosing
5669 the class definition.
5673 The definition for a static data member shall appear in a
5674 namespace scope enclosing the member's class definition. */
5675 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
5676 pedwarn ("definition of %qD is not in namespace enclosing %qT",
5677 decl, DECL_CONTEXT (decl));
5680 /* CTYPE is class type, or null if non-class.
5681 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5683 DECLARATOR is the function's name.
5684 PARMS is a chain of PARM_DECLs for the function.
5685 VIRTUALP is truthvalue of whether the function is virtual or not.
5686 FLAGS are to be passed through to `grokclassfn'.
5687 QUALS are qualifiers indicating whether the function is `const'
5689 RAISES is a list of exceptions that this function can raise.
5690 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5691 not look, and -1 if we should not call `grokclassfn' at all.
5693 SFK is the kind of special function (if any) for the new function.
5695 Returns `NULL_TREE' if something goes wrong, after issuing
5696 applicable error messages. */
5699 grokfndecl (tree ctype,
5703 tree orig_declarator,
5705 enum overload_flags flags,
5712 special_function_kind sfk,
5719 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5723 type = build_exception_variant (type, raises);
5725 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5726 DECL_ARGUMENTS (decl) = parms;
5727 /* Propagate volatile out from type to decl. */
5728 if (TYPE_VOLATILE (type))
5729 TREE_THIS_VOLATILE (decl) = 1;
5732 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5736 ("defining explicit specialization %qD in friend declaration",
5740 tree fns = TREE_OPERAND (orig_declarator, 0);
5741 tree args = TREE_OPERAND (orig_declarator, 1);
5743 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5745 /* Something like `template <class T> friend void f<T>()'. */
5746 error ("invalid use of template-id %qD in declaration "
5747 "of primary template",
5753 /* A friend declaration of the form friend void f<>(). Record
5754 the information in the TEMPLATE_ID_EXPR. */
5755 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5757 if (TREE_CODE (fns) == COMPONENT_REF)
5759 /* Due to bison parser ickiness, we will have already looked
5760 up an operator_name or PFUNCNAME within the current class
5761 (see template_id in parse.y). If the current class contains
5762 such a name, we'll get a COMPONENT_REF here. Undo that. */
5764 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5765 == current_class_type);
5766 fns = TREE_OPERAND (fns, 1);
5768 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5769 || TREE_CODE (fns) == OVERLOAD);
5770 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5772 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5773 if (TREE_PURPOSE (t)
5774 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5776 error ("default arguments are not allowed in declaration "
5777 "of friend template specialization %qD",
5784 error ("%<inline%> is not allowed in declaration of friend "
5785 "template specialization %qD",
5792 /* If this decl has namespace scope, set that up. */
5794 set_decl_namespace (decl, in_namespace, friendp);
5796 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5798 /* `main' and builtins have implicit 'C' linkage. */
5799 if ((MAIN_NAME_P (declarator)
5800 || (IDENTIFIER_LENGTH (declarator) > 10
5801 && IDENTIFIER_POINTER (declarator)[0] == '_'
5802 && IDENTIFIER_POINTER (declarator)[1] == '_'
5803 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5804 && current_lang_name == lang_name_cplusplus
5805 && ctype == NULL_TREE
5806 /* NULL_TREE means global namespace. */
5807 && DECL_CONTEXT (decl) == NULL_TREE)
5808 SET_DECL_LANGUAGE (decl, lang_c);
5810 /* Should probably propagate const out from type to decl I bet (mrs). */
5813 DECL_STATIC_FUNCTION_P (decl) = 1;
5814 DECL_CONTEXT (decl) = ctype;
5819 DECL_CONTEXT (decl) = ctype;
5821 check_class_member_definition_namespace (decl);
5824 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5826 if (processing_template_decl)
5827 error ("cannot declare %<::main%> to be a template");
5829 error ("cannot declare %<::main%> to be inline");
5831 error ("cannot declare %<::main%> to be static");
5832 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5835 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
5837 error ("%<::main%> must return %<int%>");
5838 newtype = build_function_type (integer_type_node,
5840 TREE_TYPE (decl) = newtype;
5846 /* Members of anonymous types and local classes have no linkage; make
5847 them internal. If a typedef is made later, this will be changed. */
5848 if (ctype && (TYPE_ANONYMOUS_P (ctype)
5849 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5854 /* [basic.link]: A name with no linkage (notably, the name of a class
5855 or enumeration declared in a local scope) shall not be used to
5856 declare an entity with linkage.
5858 Only check this for public decls for now. See core 319, 389. */
5859 t = no_linkage_check (TREE_TYPE (decl),
5860 /*relaxed_p=*/false);
5863 if (TYPE_ANONYMOUS_P (t))
5865 if (DECL_EXTERN_C_P (decl))
5866 /* Allow this; it's pretty common in C. */;
5869 pedwarn ("non-local function %q#D uses anonymous type",
5871 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5872 pedwarn ("%q+#D does not refer to the unqualified "
5873 "type, so it is not used for linkage",
5878 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
5882 TREE_PUBLIC (decl) = publicp;
5885 DECL_INTERFACE_KNOWN (decl) = 1;
5886 DECL_NOT_REALLY_EXTERN (decl) = 1;
5889 /* If the declaration was declared inline, mark it as such. */
5891 DECL_DECLARED_INLINE_P (decl) = 1;
5892 /* We inline functions that are explicitly declared inline, or, when
5893 the user explicitly asks us to, all functions. */
5894 if (DECL_DECLARED_INLINE_P (decl)
5895 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5896 DECL_INLINE (decl) = 1;
5898 DECL_EXTERNAL (decl) = 1;
5899 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
5901 error ("%smember function %qD cannot have cv-qualifier",
5902 (ctype ? "static " : "non-"), decl);
5903 quals = TYPE_UNQUALIFIED;
5906 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5907 grok_op_properties (decl, /*complain=*/true);
5909 if (ctype && decl_function_context (decl))
5910 DECL_NO_STATIC_CHAIN (decl) = 1;
5913 /* Make the init_value nonzero so pushdecl knows this is not
5914 tentative. error_mark_node is replaced later with the BLOCK. */
5915 DECL_INITIAL (decl) = error_mark_node;
5917 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5918 TREE_NOTHROW (decl) = 1;
5920 /* Caller will do the rest of this. */
5924 if (ctype != NULL_TREE)
5926 if (sfk == sfk_constructor)
5927 DECL_CONSTRUCTOR_P (decl) = 1;
5929 grokclassfn (ctype, decl, flags, quals);
5932 decl = check_explicit_specialization (orig_declarator, decl,
5934 2 * (funcdef_flag != 0) +
5935 4 * (friendp != 0));
5936 if (decl == error_mark_node)
5941 cplus_decl_attributes (&decl, *attrlist, 0);
5942 *attrlist = NULL_TREE;
5945 if (ctype != NULL_TREE
5946 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5951 old_decl = check_classfn (ctype, decl,
5952 (processing_template_decl
5953 > template_class_depth (ctype))
5954 ? current_template_parms
5957 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5958 /* Because grokfndecl is always supposed to return a
5959 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5960 here. We depend on our callers to figure out that its
5961 really a template that's being returned. */
5962 old_decl = DECL_TEMPLATE_RESULT (old_decl);
5964 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5965 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5966 /* Remove the `this' parm added by grokclassfn.
5967 XXX Isn't this done in start_function, too? */
5968 revert_static_member_fn (decl);
5969 if (old_decl && DECL_ARTIFICIAL (old_decl))
5970 error ("definition of implicitly-declared %qD", old_decl);
5977 /* Since we've smashed OLD_DECL to its
5978 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
5979 if (TREE_CODE (decl) == TEMPLATE_DECL)
5980 decl = DECL_TEMPLATE_RESULT (decl);
5982 /* Attempt to merge the declarations. This can fail, in
5983 the case of some invalid specialization declarations. */
5984 pushed_scope = push_scope (ctype);
5985 ok = duplicate_decls (decl, old_decl, friendp);
5987 pop_scope (pushed_scope);
5990 error ("no %q#D member function declared in class %qT",
5998 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6001 if (ctype == NULL_TREE || check)
6005 DECL_VIRTUAL_P (decl) = 1;
6010 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6011 the linkage that DECL will receive in the object file. */
6014 set_linkage_for_static_data_member (tree decl)
6016 /* A static data member always has static storage duration and
6017 external linkage. Note that static data members are forbidden in
6018 local classes -- the only situation in which a class has
6019 non-external linkage. */
6020 TREE_PUBLIC (decl) = 1;
6021 TREE_STATIC (decl) = 1;
6022 /* For non-template classes, static data members are always put
6023 out in exactly those files where they are defined, just as
6024 with ordinary namespace-scope variables. */
6025 if (!processing_template_decl)
6026 DECL_INTERFACE_KNOWN (decl) = 1;
6029 /* Create a VAR_DECL named NAME with the indicated TYPE.
6031 If SCOPE is non-NULL, it is the class type or namespace containing
6032 the variable. If SCOPE is NULL, the variable should is created in
6033 the innermost enclosings scope. */
6036 grokvardecl (tree type,
6038 const cp_decl_specifier_seq *declspecs,
6044 tree explicit_scope;
6046 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6048 /* Compute the scope in which to place the variable, but remember
6049 whether or not that scope was explicitly specified by the user. */
6050 explicit_scope = scope;
6053 /* An explicit "extern" specifier indicates a namespace-scope
6055 if (declspecs->storage_class == sc_extern)
6056 scope = current_namespace;
6057 else if (!at_function_scope_p ())
6058 scope = current_scope ();
6062 && (/* If the variable is a namespace-scope variable declared in a
6063 template, we need DECL_LANG_SPECIFIC. */
6064 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6065 /* Similarly for namespace-scope variables with language linkage
6067 || (TREE_CODE (scope) == NAMESPACE_DECL
6068 && current_lang_name != lang_name_cplusplus)
6069 /* Similarly for static data members. */
6071 decl = build_lang_decl (VAR_DECL, name, type);
6073 decl = build_decl (VAR_DECL, name, type);
6075 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6076 set_decl_namespace (decl, explicit_scope, 0);
6078 DECL_CONTEXT (decl) = scope;
6080 if (declspecs->storage_class == sc_extern)
6082 DECL_THIS_EXTERN (decl) = 1;
6083 DECL_EXTERNAL (decl) = !initialized;
6086 if (DECL_CLASS_SCOPE_P (decl))
6088 set_linkage_for_static_data_member (decl);
6089 /* This function is only called with out-of-class definitions. */
6090 DECL_EXTERNAL (decl) = 0;
6091 check_class_member_definition_namespace (decl);
6093 /* At top level, either `static' or no s.c. makes a definition
6094 (perhaps tentative), and absence of `static' makes it public. */
6095 else if (toplevel_bindings_p ())
6097 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6098 && (DECL_THIS_EXTERN (decl) || ! constp));
6099 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6101 /* Not at top level, only `static' makes a static definition. */
6104 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6105 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6108 if (declspecs->specs[(int)ds_thread])
6110 if (targetm.have_tls)
6111 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6113 /* A mere warning is sure to result in improper semantics
6114 at runtime. Don't bother to allow this to compile. */
6115 error ("thread-local storage not supported for this target");
6118 if (TREE_PUBLIC (decl))
6120 /* [basic.link]: A name with no linkage (notably, the name of a class
6121 or enumeration declared in a local scope) shall not be used to
6122 declare an entity with linkage.
6124 Only check this for public decls for now. */
6125 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6128 if (TYPE_ANONYMOUS_P (t))
6130 if (DECL_EXTERN_C_P (decl))
6131 /* Allow this; it's pretty common in C. */
6135 /* DRs 132, 319 and 389 seem to indicate types with
6136 no linkage can only be used to declare extern "C"
6137 entities. Since it's not always an error in the
6138 ISO C++ 90 Standard, we only issue a warning. */
6139 warning (0, "non-local variable %q#D uses anonymous type",
6141 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6142 warning (0, "%q+#D does not refer to the unqualified "
6143 "type, so it is not used for linkage",
6148 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6152 DECL_INTERFACE_KNOWN (decl) = 1;
6157 /* Create and return a canonical pointer to member function type, for
6158 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6161 build_ptrmemfunc_type (tree type)
6165 tree unqualified_variant = NULL_TREE;
6167 if (type == error_mark_node)
6170 /* If a canonical type already exists for this type, use it. We use
6171 this method instead of type_hash_canon, because it only does a
6172 simple equality check on the list of field members. */
6174 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6177 /* Make sure that we always have the unqualified pointer-to-member
6179 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6181 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6183 t = make_aggr_type (RECORD_TYPE);
6184 xref_basetypes (t, NULL_TREE);
6186 /* Let the front-end know this is a pointer to member function... */
6187 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6188 /* ... and not really an aggregate. */
6189 SET_IS_AGGR_TYPE (t, 0);
6191 field = build_decl (FIELD_DECL, pfn_identifier, type);
6194 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6195 TREE_CHAIN (field) = fields;
6198 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6200 /* Zap out the name so that the back-end will give us the debugging
6201 information for this anonymous RECORD_TYPE. */
6202 TYPE_NAME (t) = NULL_TREE;
6204 /* If this is not the unqualified form of this pointer-to-member
6205 type, set the TYPE_MAIN_VARIANT for this type to be the
6206 unqualified type. Since they are actually RECORD_TYPEs that are
6207 not variants of each other, we must do this manually. */
6208 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6210 t = build_qualified_type (t, cp_type_quals (type));
6211 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6212 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6213 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6216 /* Cache this pointer-to-member type so that we can find it again
6218 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6223 /* Create and return a pointer to data member type. */
6226 build_ptrmem_type (tree class_type, tree member_type)
6228 if (TREE_CODE (member_type) == METHOD_TYPE)
6232 arg_types = TYPE_ARG_TYPES (member_type);
6233 class_type = (cp_build_qualified_type
6235 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6237 = build_method_type_directly (class_type,
6238 TREE_TYPE (member_type),
6239 TREE_CHAIN (arg_types));
6240 return build_ptrmemfunc_type (build_pointer_type (member_type));
6244 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6245 return build_offset_type (class_type, member_type);
6249 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6250 Check to see that the definition is valid. Issue appropriate error
6251 messages. Return 1 if the definition is particularly bad, or 0
6255 check_static_variable_definition (tree decl, tree type)
6257 /* Motion 10 at San Diego: If a static const integral data member is
6258 initialized with an integral constant expression, the initializer
6259 may appear either in the declaration (within the class), or in
6260 the definition, but not both. If it appears in the class, the
6261 member is a member constant. The file-scope definition is always
6263 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6265 error ("invalid in-class initialization of static data member "
6266 "of non-integral type %qT",
6268 /* If we just return the declaration, crashes will sometimes
6269 occur. We therefore return void_type_node, as if this were a
6270 friend declaration, to cause callers to completely ignore
6271 this declaration. */
6274 else if (!CP_TYPE_CONST_P (type))
6275 error ("ISO C++ forbids in-class initialization of non-const "
6276 "static member %qD",
6278 else if (pedantic && !INTEGRAL_TYPE_P (type))
6279 pedwarn ("ISO C++ forbids initialization of member constant "
6280 "%qD of non-integral type %qT", decl, type);
6285 /* Given the SIZE (i.e., number of elements) in an array, compute an
6286 appropriate index type for the array. If non-NULL, NAME is the
6287 name of the thing being declared. */
6290 compute_array_index_type (tree name, tree size)
6295 if (error_operand_p (size))
6296 return error_mark_node;
6298 type = TREE_TYPE (size);
6299 /* The array bound must be an integer type. */
6300 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6303 error ("size of array %qD has non-integral type %qT", name, type);
6305 error ("size of array has non-integral type %qT", type);
6306 size = integer_one_node;
6307 type = TREE_TYPE (size);
6310 if (abi_version_at_least (2)
6311 /* We should only handle value dependent expressions specially. */
6312 ? value_dependent_expression_p (size)
6313 /* But for abi-1, we handled all instances in templates. This
6314 effects the manglings produced. */
6315 : processing_template_decl)
6316 return build_index_type (build_min (MINUS_EXPR, sizetype,
6317 size, integer_one_node));
6319 /* The size might be the result of a cast. */
6320 STRIP_TYPE_NOPS (size);
6322 /* It might be a const variable or enumeration constant. */
6323 size = integral_constant_value (size);
6325 /* Normally, the array-bound will be a constant. */
6326 if (TREE_CODE (size) == INTEGER_CST)
6328 /* Check to see if the array bound overflowed. Make that an
6329 error, no matter how generous we're being. */
6330 int old_flag_pedantic_errors = flag_pedantic_errors;
6331 int old_pedantic = pedantic;
6332 pedantic = flag_pedantic_errors = 1;
6333 constant_expression_warning (size);
6334 pedantic = old_pedantic;
6335 flag_pedantic_errors = old_flag_pedantic_errors;
6337 /* An array must have a positive number of elements. */
6338 if (INT_CST_LT (size, integer_zero_node))
6341 error ("size of array %qD is negative", name);
6343 error ("size of array is negative");
6344 size = integer_one_node;
6346 /* As an extension we allow zero-sized arrays. We always allow
6347 them in system headers because glibc uses them. */
6348 else if (integer_zerop (size) && pedantic && !in_system_header)
6351 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6353 pedwarn ("ISO C++ forbids zero-size array");
6356 else if (TREE_CONSTANT (size))
6358 /* `(int) &fn' is not a valid array bound. */
6360 error ("size of array %qD is not an integral constant-expression",
6363 error ("size of array is not an integral constant-expression");
6364 size = integer_one_node;
6369 pedwarn ("ISO C++ forbids variable-size array %qD", name);
6371 pedwarn ("ISO C++ forbids variable-size array");
6374 if (processing_template_decl && !TREE_CONSTANT (size))
6375 /* A variable sized array. */
6376 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6379 HOST_WIDE_INT saved_processing_template_decl;
6381 /* Compute the index of the largest element in the array. It is
6382 one less than the number of elements in the array. We save
6383 and restore PROCESSING_TEMPLATE_DECL so that computations in
6384 cp_build_binary_op will be appropriately folded. */
6385 saved_processing_template_decl = processing_template_decl;
6386 processing_template_decl = 0;
6387 itype = cp_build_binary_op (MINUS_EXPR,
6388 cp_convert (ssizetype, size),
6389 cp_convert (ssizetype, integer_one_node));
6390 itype = fold (itype);
6391 processing_template_decl = saved_processing_template_decl;
6393 if (!TREE_CONSTANT (itype))
6394 /* A variable sized array. */
6395 itype = variable_size (itype);
6396 /* Make sure that there was no overflow when creating to a signed
6397 index type. (For example, on a 32-bit machine, an array with
6398 size 2^32 - 1 is too big.) */
6399 else if (TREE_OVERFLOW (itype))
6401 error ("overflow in array dimension");
6402 TREE_OVERFLOW (itype) = 0;
6406 /* Create and return the appropriate index type. */
6407 return build_index_type (itype);
6410 /* Returns the scope (if any) in which the entity declared by
6411 DECLARATOR will be located. If the entity was declared with an
6412 unqualified name, NULL_TREE is returned. */
6415 get_scope_of_declarator (const cp_declarator *declarator)
6417 while (declarator && declarator->kind != cdk_id)
6418 declarator = declarator->declarator;
6420 /* If the declarator-id is a SCOPE_REF, the scope in which the
6421 declaration occurs is the first operand. */
6423 && declarator->u.id.qualifying_scope)
6424 return declarator->u.id.qualifying_scope;
6426 /* Otherwise, the declarator is not a qualified name; the entity will
6427 be declared in the current scope. */
6431 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6432 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6436 create_array_type_for_decl (tree name, tree type, tree size)
6438 tree itype = NULL_TREE;
6439 const char* error_msg;
6441 /* If things have already gone awry, bail now. */
6442 if (type == error_mark_node || size == error_mark_node)
6443 return error_mark_node;
6445 /* Assume that everything will go OK. */
6448 /* There are some types which cannot be array elements. */
6449 switch (TREE_CODE (type))
6452 error_msg = "array of void";
6456 error_msg = "array of functions";
6459 case REFERENCE_TYPE:
6460 error_msg = "array of references";
6464 error_msg = "array of function members";
6471 /* If something went wrong, issue an error-message and return. */
6475 error ("declaration of %qD as %s", name, error_msg);
6477 error ("creating %s", error_msg);
6479 return error_mark_node;
6484 The constant expressions that specify the bounds of the arrays
6485 can be omitted only for the first member of the sequence. */
6486 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6489 error ("declaration of %qD as multidimensional array must "
6490 "have bounds for all dimensions except the first",
6493 error ("multidimensional array must have bounds for all "
6494 "dimensions except the first");
6496 return error_mark_node;
6499 /* Figure out the index type for the array. */
6501 itype = compute_array_index_type (name, size);
6504 T is called the array element type; this type shall not be [...] an
6505 abstract class type. */
6506 abstract_virtuals_error (name, type);
6508 return build_cplus_array_type (type, itype);
6511 /* Check that it's OK to declare a function with the indicated TYPE.
6512 SFK indicates the kind of special function (if any) that this
6513 function is. OPTYPE is the type given in a conversion operator
6514 declaration, or the class type for a constructor/destructor.
6515 Returns the actual return type of the function; that
6516 may be different than TYPE if an error occurs, or for certain
6517 special functions. */
6520 check_special_function_return_type (special_function_kind sfk,
6526 case sfk_constructor:
6528 error ("return type specification for constructor invalid");
6530 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6531 type = build_pointer_type (optype);
6533 type = void_type_node;
6536 case sfk_destructor:
6538 error ("return type specification for destructor invalid");
6539 /* We can't use the proper return type here because we run into
6540 problems with ambiguous bases and covariant returns.
6541 Java classes are left unchanged because (void *) isn't a valid
6542 Java type, and we don't want to change the Java ABI. */
6543 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6544 type = build_pointer_type (void_type_node);
6546 type = void_type_node;
6549 case sfk_conversion:
6550 if (type && !same_type_p (type, optype))
6551 error ("operator %qT declared to return %qT", optype, type);
6553 pedwarn ("return type specified for %<operator %T%>", optype);
6564 /* A variable or data member (whose unqualified name is IDENTIFIER)
6565 has been declared with the indicated TYPE. If the TYPE is not
6566 acceptable, issue an error message and return a type to use for
6567 error-recovery purposes. */
6570 check_var_type (tree identifier, tree type)
6572 if (VOID_TYPE_P (type))
6575 error ("unnamed variable or field declared void");
6576 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
6578 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
6579 error ("variable or field %qE declared void", identifier);
6582 error ("variable or field declared void");
6583 type = integer_type_node;
6589 /* Given declspecs and a declarator (abstract or otherwise), determine
6590 the name and type of the object declared and construct a DECL node
6593 DECLSPECS is a chain of tree_list nodes whose value fields
6594 are the storage classes and type specifiers.
6596 DECL_CONTEXT says which syntactic context this declaration is in:
6597 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6598 FUNCDEF for a function definition. Like NORMAL but a few different
6599 error messages in each case. Return value may be zero meaning
6600 this definition is too screwy to try to parse.
6601 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6602 handle member functions (which have FIELD context).
6603 Return value may be zero meaning this definition is too screwy to
6605 PARM for a parameter declaration (either within a function prototype
6606 or before a function body). Make a PARM_DECL, or return void_type_node.
6607 CATCHPARM for a parameter declaration before a catch clause.
6608 TYPENAME if for a typename (in a cast or sizeof).
6609 Don't make a DECL node; just return the ..._TYPE node.
6610 FIELD for a struct or union field; make a FIELD_DECL.
6611 BITFIELD for a field with specified width.
6612 INITIALIZED is 1 if the decl has an initializer.
6614 ATTRLIST is a pointer to the list of attributes, which may be NULL
6615 if there are none; *ATTRLIST may be modified if attributes from inside
6616 the declarator should be applied to the declaration.
6618 When this function is called, scoping variables (such as
6619 CURRENT_CLASS_TYPE) should reflect the scope in which the
6620 declaration occurs, not the scope in which the new declaration will
6621 be placed. For example, on:
6625 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6626 should not be `S'. */
6629 grokdeclarator (const cp_declarator *declarator,
6630 const cp_decl_specifier_seq *declspecs,
6631 enum decl_context decl_context,
6635 tree type = NULL_TREE;
6638 int virtualp, explicitp, friendp, inlinep, staticp;
6639 int explicit_int = 0;
6640 int explicit_char = 0;
6641 int defaulted_int = 0;
6642 tree dependant_name = NULL_TREE;
6644 tree typedef_decl = NULL_TREE;
6645 const char *name = NULL;
6646 tree typedef_type = NULL_TREE;
6647 int funcdef_flag = 0;
6648 cp_declarator_kind innermost_code = cdk_error;
6651 /* See the code below that used this. */
6652 tree decl_attr = NULL_TREE;
6655 /* Keep track of what sort of function is being processed
6656 so that we can warn about default return values, or explicit
6657 return values which do not match prescribed defaults. */
6658 special_function_kind sfk = sfk_none;
6660 tree dname = NULL_TREE;
6661 tree ctor_return_type = NULL_TREE;
6662 enum overload_flags flags = NO_SPECIAL;
6663 cp_cv_quals quals = TYPE_UNQUALIFIED;
6664 tree raises = NULL_TREE;
6665 int template_count = 0;
6666 tree returned_attrs = NULL_TREE;
6667 tree parms = NULL_TREE;
6668 const cp_declarator *id_declarator;
6669 /* The unqualified name of the declarator; either an
6670 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6671 tree unqualified_id;
6672 /* The class type, if any, in which this entity is located,
6673 or NULL_TREE if none. Note that this value may be different from
6674 the current class type; for example if an attempt is made to declare
6675 "A::f" inside "B", this value will be "A". */
6676 tree ctype = current_class_type;
6677 /* The NAMESPACE_DECL for the namespace in which this entity is
6678 located. If an unqualified name is used to declare the entity,
6679 this value will be NULL_TREE, even if the entity is located at
6681 tree in_namespace = NULL_TREE;
6682 cp_storage_class storage_class;
6683 bool unsigned_p, signed_p, short_p, long_p, thread_p;
6684 bool type_was_error_mark_node = false;
6686 signed_p = declspecs->specs[(int)ds_signed];
6687 unsigned_p = declspecs->specs[(int)ds_unsigned];
6688 short_p = declspecs->specs[(int)ds_short];
6689 long_p = declspecs->specs[(int)ds_long];
6690 longlong = declspecs->specs[(int)ds_long] >= 2;
6691 thread_p = declspecs->specs[(int)ds_thread];
6693 if (decl_context == FUNCDEF)
6694 funcdef_flag = 1, decl_context = NORMAL;
6695 else if (decl_context == MEMFUNCDEF)
6696 funcdef_flag = -1, decl_context = FIELD;
6697 else if (decl_context == BITFIELD)
6698 bitfield = 1, decl_context = FIELD;
6700 /* Look inside a declarator for the name being declared
6701 and get it as a string, for an error message. */
6702 for (id_declarator = declarator;
6704 id_declarator = id_declarator->declarator)
6706 if (id_declarator->kind != cdk_id)
6707 innermost_code = id_declarator->kind;
6709 switch (id_declarator->kind)
6712 if (id_declarator->declarator
6713 && id_declarator->declarator->kind == cdk_id)
6715 sfk = id_declarator->declarator->u.id.sfk;
6716 if (sfk == sfk_destructor)
6723 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
6724 tree decl = id_declarator->u.id.unqualified_name;
6727 if (qualifying_scope)
6729 if (TYPE_P (qualifying_scope))
6731 ctype = qualifying_scope;
6732 if (innermost_code != cdk_function
6733 && current_class_type
6734 && !UNIQUELY_DERIVED_FROM_P (ctype,
6735 current_class_type))
6737 error ("type %qT is not derived from type %qT",
6738 ctype, current_class_type);
6739 return error_mark_node;
6742 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6743 in_namespace = qualifying_scope;
6745 switch (TREE_CODE (decl))
6751 if (innermost_code != cdk_function)
6753 error ("declaration of %qD as non-function", decl);
6754 return error_mark_node;
6756 else if (!qualifying_scope
6757 && !(current_class_type && at_class_scope_p ()))
6759 error ("declaration of %qD as non-member", decl);
6760 return error_mark_node;
6763 type = TREE_OPERAND (decl, 0);
6764 name = IDENTIFIER_POINTER (constructor_name (type));
6769 case TEMPLATE_ID_EXPR:
6771 tree fns = TREE_OPERAND (decl, 0);
6774 if (TREE_CODE (dname) == COMPONENT_REF)
6775 dname = TREE_OPERAND (dname, 1);
6776 if (TREE_CODE (dname) != IDENTIFIER_NODE)
6778 gcc_assert (is_overloaded_fn (dname));
6779 dname = DECL_NAME (get_first_fn (dname));
6784 case IDENTIFIER_NODE:
6785 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6788 if (C_IS_RESERVED_WORD (dname))
6790 error ("declarator-id missing; using reserved word %qD",
6792 name = IDENTIFIER_POINTER (dname);
6794 else if (!IDENTIFIER_TYPENAME_P (dname))
6795 name = IDENTIFIER_POINTER (dname);
6798 gcc_assert (flags == NO_SPECIAL);
6799 flags = TYPENAME_FLAG;
6800 ctor_return_type = TREE_TYPE (dname);
6801 sfk = sfk_conversion;
6802 if (is_typename_at_global_scope (dname))
6803 name = IDENTIFIER_POINTER (dname);
6805 name = "<invalid operator>";
6827 if (id_declarator->kind == cdk_id)
6831 /* A function definition's declarator must have the form of
6832 a function declarator. */
6834 if (funcdef_flag && innermost_code != cdk_function)
6837 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6838 && innermost_code != cdk_function
6839 && ! (ctype && !declspecs->any_specifiers_p))
6841 error ("declaration of %qD as non-function", dname);
6842 return error_mark_node;
6845 /* Anything declared one level down from the top level
6846 must be one of the parameters of a function
6847 (because the body is at least two levels down). */
6849 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6850 by not allowing C++ class definitions to specify their parameters
6851 with xdecls (must be spec.d in the parmlist).
6853 Since we now wait to push a class scope until we are sure that
6854 we are in a legitimate method context, we must set oldcname
6855 explicitly (since current_class_name is not yet alive).
6857 We also want to avoid calling this a PARM if it is in a namespace. */
6859 if (decl_context == NORMAL && !toplevel_bindings_p ())
6861 struct cp_binding_level *b = current_binding_level;
6862 current_binding_level = b->level_chain;
6863 if (current_binding_level != 0 && toplevel_bindings_p ())
6864 decl_context = PARM;
6865 current_binding_level = b;
6869 name = decl_context == PARM ? "parameter" : "type name";
6871 /* If there were multiple types specified in the decl-specifier-seq,
6872 issue an error message. */
6873 if (declspecs->multiple_types_p)
6874 error ("two or more data types in declaration of %qs", name);
6875 /* Extract the basic type from the decl-specifier-seq. */
6876 type = declspecs->type;
6877 if (type == error_mark_node)
6880 type_was_error_mark_node = true;
6882 /* If the entire declaration is itself tagged as deprecated then
6883 suppress reports of deprecated items. */
6884 if (type && TREE_DEPRECATED (type)
6885 && deprecated_state != DEPRECATED_SUPPRESS)
6886 warn_deprecated_use (type);
6887 if (type && TREE_CODE (type) == TYPE_DECL)
6889 typedef_decl = type;
6890 type = TREE_TYPE (typedef_decl);
6892 /* No type at all: default to `int', and set DEFAULTED_INT
6893 because it was not a user-defined typedef. */
6894 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
6896 /* These imply 'int'. */
6897 type = integer_type_node;
6901 explicit_int = declspecs->explicit_int_p;
6902 explicit_char = declspecs->explicit_char_p;
6905 /* See the code below that used this. */
6907 decl_attr = DECL_ATTRIBUTES (typedef_decl);
6909 typedef_type = type;
6912 if (sfk != sfk_conversion)
6913 ctor_return_type = ctype;
6915 if (sfk != sfk_none)
6916 type = check_special_function_return_type (sfk, type,
6918 else if (type == NULL_TREE)
6924 /* We handle `main' specially here, because 'main () { }' is so
6925 common. With no options, it is allowed. With -Wreturn-type,
6926 it is a warning. It is only an error with -pedantic-errors. */
6927 is_main = (funcdef_flag
6928 && dname && MAIN_NAME_P (dname)
6929 && ctype == NULL_TREE
6930 && in_namespace == NULL_TREE
6931 && current_namespace == global_namespace);
6933 if (type_was_error_mark_node)
6934 /* We've already issued an error, don't complain more. */;
6935 else if (in_system_header || flag_ms_extensions)
6936 /* Allow it, sigh. */;
6937 else if (pedantic || ! is_main)
6938 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
6939 else if (warn_return_type)
6940 warning (0, "ISO C++ forbids declaration of %qs with no type", name);
6942 type = integer_type_node;
6947 /* Now process the modifiers that were specified
6948 and check for invalid combinations. */
6950 /* Long double is a special combination. */
6951 if (long_p && TYPE_MAIN_VARIANT (type) == double_type_node)
6954 type = build_qualified_type (long_double_type_node,
6955 cp_type_quals (type));
6958 /* Check all other uses of type modifiers. */
6960 if (unsigned_p || signed_p || long_p || short_p)
6964 if (TREE_CODE (type) == REAL_TYPE)
6965 error ("short, signed or unsigned invalid for %qs", name);
6966 else if (TREE_CODE (type) != INTEGER_TYPE)
6967 error ("long, short, signed or unsigned invalid for %qs", name);
6968 else if (long_p && short_p)
6969 error ("long and short specified together for %qs", name);
6970 else if ((long_p || short_p) && explicit_char)
6971 error ("long or short specified with char for %qs", name);
6972 else if ((long_p|| short_p) && TREE_CODE (type) == REAL_TYPE)
6973 error ("long or short specified with floating type for %qs", name);
6974 else if (signed_p && unsigned_p)
6975 error ("signed and unsigned given together for %qs", name);
6979 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6981 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
6983 if (flag_pedantic_errors)
6988 /* Discard the type modifiers if they are invalid. */
6999 /* Decide whether an integer type is signed or not.
7000 Optionally treat bitfields as signed by default. */
7004 It is implementation-defined whether a plain (neither
7005 explicitly signed or unsigned) char, short, int, or long
7006 bit-field is signed or unsigned.
7008 Naturally, we extend this to long long as well. Note that
7009 this does not include wchar_t. */
7010 || (bitfield && !flag_signed_bitfields
7012 /* A typedef for plain `int' without `signed' can be
7013 controlled just like plain `int', but a typedef for
7014 `signed int' cannot be so controlled. */
7016 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7017 && (TREE_CODE (type) == INTEGER_TYPE
7018 || TREE_CODE (type) == CHAR_TYPE)
7019 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7022 type = long_long_unsigned_type_node;
7024 type = long_unsigned_type_node;
7026 type = short_unsigned_type_node;
7027 else if (type == char_type_node)
7028 type = unsigned_char_type_node;
7029 else if (typedef_decl)
7030 type = c_common_unsigned_type (type);
7032 type = unsigned_type_node;
7034 else if (signed_p && type == char_type_node)
7035 type = signed_char_type_node;
7037 type = long_long_integer_type_node;
7039 type = long_integer_type_node;
7041 type = short_integer_type_node;
7043 if (declspecs->specs[(int)ds_complex])
7045 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7046 error ("complex invalid for %qs", name);
7047 /* If we just have "complex", it is equivalent to
7048 "complex double", but if any modifiers at all are specified it is
7049 the complex form of TYPE. E.g, "complex short" is
7050 "complex short int". */
7052 else if (defaulted_int && ! longlong
7053 && ! (long_p || short_p || signed_p || unsigned_p))
7054 type = complex_double_type_node;
7055 else if (type == integer_type_node)
7056 type = complex_integer_type_node;
7057 else if (type == float_type_node)
7058 type = complex_float_type_node;
7059 else if (type == double_type_node)
7060 type = complex_double_type_node;
7061 else if (type == long_double_type_node)
7062 type = complex_long_double_type_node;
7064 type = build_complex_type (type);
7067 type_quals = TYPE_UNQUALIFIED;
7068 if (declspecs->specs[(int)ds_const])
7069 type_quals |= TYPE_QUAL_CONST;
7070 if (declspecs->specs[(int)ds_volatile])
7071 type_quals |= TYPE_QUAL_VOLATILE;
7072 if (declspecs->specs[(int)ds_restrict])
7073 type_quals |= TYPE_QUAL_RESTRICT;
7074 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7075 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7078 if (TREE_CODE (type) == FUNCTION_TYPE
7079 && type_quals != TYPE_UNQUALIFIED)
7081 /* This was an error in C++98 (cv-qualifiers cannot be added to
7082 a function type), but DR 295 makes the code well-formed by
7083 dropping the extra qualifiers. */
7086 tree bad_type = build_qualified_type (type, type_quals);
7087 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7090 type_quals = TYPE_UNQUALIFIED;
7092 type_quals |= cp_type_quals (type);
7093 type = cp_build_qualified_type_real
7094 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7095 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
7096 /* We might have ignored or rejected some of the qualifiers. */
7097 type_quals = cp_type_quals (type);
7100 inlinep = !! declspecs->specs[(int)ds_inline];
7101 virtualp = !! declspecs->specs[(int)ds_virtual];
7102 explicitp = !! declspecs->specs[(int)ds_explicit];
7104 storage_class = declspecs->storage_class;
7105 if (storage_class == sc_static)
7106 staticp = 1 + (decl_context == FIELD);
7108 if (virtualp && staticp == 2)
7110 error ("member %qD cannot be declared both virtual and static", dname);
7111 storage_class = sc_none;
7114 friendp = !! declspecs->specs[(int)ds_friend];
7116 if (dependant_name && !friendp)
7118 error ("%<%T::%D%> is not a valid declarator", ctype, dependant_name);
7119 return void_type_node;
7122 /* Issue errors about use of storage classes for parameters. */
7123 if (decl_context == PARM)
7125 if (declspecs->specs[(int)ds_typedef])
7126 error ("typedef declaration invalid in parameter declaration");
7127 else if (storage_class == sc_static
7128 || storage_class == sc_extern
7130 error ("storage class specifiers invalid in parameter declarations");
7133 /* Give error if `virtual' is used outside of class declaration. */
7135 && (current_class_name == NULL_TREE || decl_context != FIELD))
7137 error ("virtual outside class declaration");
7141 /* Static anonymous unions are dealt with here. */
7142 if (staticp && decl_context == TYPENAME
7144 && ANON_AGGR_TYPE_P (declspecs->type))
7145 decl_context = FIELD;
7147 /* Warn about storage classes that are invalid for certain
7148 kinds of declarations (parameters, typenames, etc.). */
7149 if (declspecs->multiple_storage_classes_p)
7151 error ("multiple storage classes in declaration of %qs", name);
7152 storage_class = sc_none;
7156 && storage_class != sc_extern
7157 && storage_class != sc_static)
7158 || declspecs->specs[(int)ds_typedef]))
7160 error ("multiple storage classes in declaration of %qs", name);
7163 else if (decl_context != NORMAL
7164 && ((storage_class != sc_none
7165 && storage_class != sc_mutable)
7168 if ((decl_context == PARM || decl_context == CATCHPARM)
7169 && (storage_class == sc_register
7170 || storage_class == sc_auto))
7172 else if (declspecs->specs[(int)ds_typedef])
7174 else if (decl_context == FIELD
7175 /* C++ allows static class elements. */
7176 && storage_class == sc_static)
7177 /* C++ also allows inlines and signed and unsigned elements,
7178 but in those cases we don't come in here. */
7182 if (decl_context == FIELD)
7183 error ("storage class specified for %qs", name);
7186 if (decl_context == PARM || decl_context == CATCHPARM)
7187 error ("storage class specified for parameter %qs", name);
7189 error ("storage class specified for typename");
7191 if (storage_class == sc_register
7192 || storage_class == sc_auto
7193 || storage_class == sc_extern
7195 storage_class = sc_none;
7198 else if (storage_class == sc_extern && initialized
7201 if (toplevel_bindings_p ())
7203 /* It's common practice (and completely valid) to have a const
7204 be initialized and declared extern. */
7205 if (!(type_quals & TYPE_QUAL_CONST))
7206 warning (0, "%qs initialized and declared %<extern%>", name);
7209 error ("%qs has both %<extern%> and initializer", name);
7211 else if (storage_class == sc_extern && funcdef_flag
7212 && ! toplevel_bindings_p ())
7213 error ("nested function %qs declared %<extern%>", name);
7214 else if (toplevel_bindings_p ())
7216 if (storage_class == sc_auto)
7217 error ("top-level declaration of %qs specifies %<auto%>", name);
7220 && storage_class != sc_extern
7221 && storage_class != sc_static)
7223 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7228 if (storage_class && friendp)
7229 error ("storage class specifiers invalid in friend function declarations");
7232 unqualified_id = NULL_TREE;
7235 unqualified_id = id_declarator->u.id.unqualified_name;
7236 switch (TREE_CODE (unqualified_id))
7240 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7243 case IDENTIFIER_NODE:
7244 case TEMPLATE_ID_EXPR:
7252 /* Determine the type of the entity declared by recurring on the
7254 for (; declarator; declarator = declarator->declarator)
7256 const cp_declarator *inner_declarator;
7259 if (type == error_mark_node)
7260 return error_mark_node;
7262 attrs = declarator->attributes;
7268 if (declarator == NULL || declarator->kind == cdk_id)
7269 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7270 if (declarator->kind == cdk_function)
7271 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7272 if (declarator->kind == cdk_array)
7273 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7274 returned_attrs = decl_attributes (&type,
7275 chainon (returned_attrs, attrs),
7279 if (declarator->kind == cdk_id)
7282 inner_declarator = declarator->declarator;
7284 switch (declarator->kind)
7287 type = create_array_type_for_decl (dname, type,
7288 declarator->u.array.bounds);
7296 /* Declaring a function type.
7297 Make sure we have a valid type for the function to return. */
7299 /* We now know that the TYPE_QUALS don't apply to the
7300 decl, but to its return type. */
7301 type_quals = TYPE_UNQUALIFIED;
7303 /* Warn about some types functions can't return. */
7305 if (TREE_CODE (type) == FUNCTION_TYPE)
7307 error ("%qs declared as function returning a function", name);
7308 type = integer_type_node;
7310 if (TREE_CODE (type) == ARRAY_TYPE)
7312 error ("%qs declared as function returning an array", name);
7313 type = integer_type_node;
7316 /* Pick up type qualifiers which should be applied to `this'. */
7317 quals = declarator->u.function.qualifiers;
7319 /* Pick up the exception specifications. */
7320 raises = declarator->u.function.exception_specification;
7322 /* Say it's a definition only for the CALL_EXPR
7323 closest to the identifier. */
7324 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7326 if (ctype == NULL_TREE
7327 && decl_context == FIELD
7329 && (friendp == 0 || dname == current_class_name))
7330 ctype = current_class_type;
7332 if (ctype && (sfk == sfk_constructor
7333 || sfk == sfk_destructor))
7335 /* We are within a class's scope. If our declarator name
7336 is the same as the class name, and we are defining
7337 a function, then it is a constructor/destructor, and
7338 therefore returns a void type. */
7340 if (flags == DTOR_FLAG)
7342 /* ISO C++ 12.4/2. A destructor may not be
7343 declared const or volatile. A destructor may
7346 error ("destructor cannot be static member function");
7349 error ("destructors may not be cv-qualified");
7350 quals = TYPE_UNQUALIFIED;
7352 if (decl_context == FIELD)
7354 if (! member_function_or_else (ctype,
7357 return void_type_node;
7360 else /* It's a constructor. */
7364 /* ISO C++ 12.1. A constructor may not be
7365 declared const or volatile. A constructor may
7366 not be virtual. A constructor may not be
7369 error ("constructor cannot be static member function");
7372 pedwarn ("constructors cannot be declared virtual");
7377 error ("constructors may not be cv-qualified");
7378 quals = TYPE_UNQUALIFIED;
7380 if (decl_context == FIELD)
7382 if (! member_function_or_else (ctype,
7385 return void_type_node;
7386 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7387 if (sfk != sfk_constructor)
7391 if (decl_context == FIELD)
7397 error ("can't initialize friend function %qs", name);
7400 /* Cannot be both friend and virtual. */
7401 error ("virtual functions cannot be friends");
7404 if (decl_context == NORMAL)
7405 error ("friend declaration not in class definition");
7406 if (current_function_decl && funcdef_flag)
7407 error ("can't define friend function %qs in a local "
7412 arg_types = grokparms (declarator->u.function.parameters,
7415 if (inner_declarator
7416 && inner_declarator->kind == cdk_id
7417 && inner_declarator->u.id.sfk == sfk_destructor
7418 && arg_types != void_list_node)
7420 error ("destructors may not have parameters");
7421 arg_types = void_list_node;
7425 type = build_function_type (type, arg_types);
7426 type = cp_build_qualified_type (type, quals);
7433 /* Filter out pointers-to-references and references-to-references.
7434 We can get these if a TYPE_DECL is used. */
7436 if (TREE_CODE (type) == REFERENCE_TYPE)
7438 error (declarator->kind == cdk_reference
7439 ? "cannot declare reference to %q#T"
7440 : "cannot declare pointer to %q#T", type);
7441 type = TREE_TYPE (type);
7443 else if (VOID_TYPE_P (type))
7445 if (declarator->kind == cdk_reference)
7446 error ("cannot declare reference to %q#T", type);
7447 else if (declarator->kind == cdk_ptrmem)
7448 error ("cannot declare pointer to %q#T member", type);
7451 /* We now know that the TYPE_QUALS don't apply to the decl,
7452 but to the target of the pointer. */
7453 type_quals = TYPE_UNQUALIFIED;
7455 if (declarator->kind == cdk_ptrmem
7456 && (TREE_CODE (type) == FUNCTION_TYPE
7457 || (quals && TREE_CODE (type) == METHOD_TYPE)))
7461 /* If the type is a FUNCTION_TYPE, pick up the
7462 qualifiers from that function type. No other
7463 qualifiers may be supplied. */
7464 if (TREE_CODE (type) == FUNCTION_TYPE)
7465 quals = cp_type_quals (type);
7467 dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7468 grok_method_quals (declarator->u.pointer.class_type,
7470 type = TREE_TYPE (dummy);
7471 quals = TYPE_UNQUALIFIED;
7474 if (declarator->kind == cdk_reference)
7476 if (!VOID_TYPE_P (type))
7477 type = build_reference_type (type);
7479 else if (TREE_CODE (type) == METHOD_TYPE)
7480 type = build_ptrmemfunc_type (build_pointer_type (type));
7481 else if (declarator->kind == cdk_ptrmem)
7483 /* We might have parsed a namespace as the class type. */
7484 if (TREE_CODE (declarator->u.pointer.class_type)
7487 error ("%qD is a namespace",
7488 declarator->u.pointer.class_type);
7489 type = build_pointer_type (type);
7491 else if (declarator->u.pointer.class_type == error_mark_node)
7492 /* We will already have complained. */
7493 type = error_mark_node;
7495 type = build_ptrmem_type (declarator->u.pointer.class_type,
7499 type = build_pointer_type (type);
7501 /* Process a list of type modifier keywords (such as
7502 const or volatile) that were given inside the `*' or `&'. */
7504 if (declarator->u.pointer.qualifiers)
7507 = cp_build_qualified_type (type,
7508 declarator->u.pointer.qualifiers);
7509 type_quals = cp_type_quals (type);
7522 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7523 && TREE_CODE (type) != FUNCTION_TYPE
7524 && TREE_CODE (type) != METHOD_TYPE)
7526 error ("template-id %qD used as a declarator",
7528 unqualified_id = dname;
7531 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
7532 qualified with a class-name, turn it into a METHOD_TYPE, unless
7533 we know that the function is static. We take advantage of this
7534 opportunity to do other processing that pertains to entities
7535 explicitly declared to be class members. Note that if DECLARATOR
7536 is non-NULL, we know it is a cdk_id declarator; otherwise, we
7537 would not have exited the loop above. */
7539 && declarator->u.id.qualifying_scope
7540 && TYPE_P (declarator->u.id.qualifying_scope))
7544 ctype = declarator->u.id.qualifying_scope;
7545 ctype = TYPE_MAIN_VARIANT (ctype);
7547 while (t != NULL_TREE && CLASS_TYPE_P (t))
7549 /* You're supposed to have one `template <...>' for every
7550 template class, but you don't need one for a full
7551 specialization. For example:
7553 template <class T> struct S{};
7554 template <> struct S<int> { void f(); };
7555 void S<int>::f () {}
7557 is correct; there shouldn't be a `template <>' for the
7558 definition of `S<int>::f'. */
7559 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
7560 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
7561 /* T is an explicit (not partial) specialization. All
7562 containing classes must therefore also be explicitly
7565 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
7566 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7567 template_count += 1;
7569 t = TYPE_MAIN_DECL (t);
7570 t = DECL_CONTEXT (t);
7573 if (ctype == current_class_type)
7576 pedwarn ("member functions are implicitly friends of their class");
7578 pedwarn ("extra qualification %<%T::%> on member %qs",
7581 else if (TREE_CODE (type) == FUNCTION_TYPE)
7583 tree sname = declarator->u.id.unqualified_name;
7585 if (current_class_type
7586 && (!friendp || funcdef_flag))
7589 ? "cannot define member function %<%T::%s%> within %<%T%>"
7590 : "cannot declare member function %<%T::%s%> within %<%T%>",
7591 ctype, name, current_class_type);
7592 return error_mark_node;
7595 if (TREE_CODE (sname) == IDENTIFIER_NODE
7596 && NEW_DELETE_OPNAME_P (sname))
7597 /* Overloaded operator new and operator delete
7598 are always static functions. */
7601 type = (build_method_type_directly
7602 (cp_build_qualified_type (ctype,
7603 quals & ~TYPE_QUAL_RESTRICT),
7605 TYPE_ARG_TYPES (type)));
7607 else if (declspecs->specs[(int)ds_typedef]
7608 || COMPLETE_TYPE_P (complete_type (ctype)))
7610 /* Have to move this code elsewhere in this function.
7611 this code is used for i.e., typedef int A::M; M *pm;
7613 It is? How? jason 10/2/94 */
7615 if (current_class_type)
7617 error ("cannot declare member %<%T::%s%> within %qT",
7618 ctype, name, current_class_type);
7619 return void_type_node;
7624 cxx_incomplete_type_error (NULL_TREE, ctype);
7625 return error_mark_node;
7629 /* Now TYPE has the actual type. */
7634 *attrlist = chainon (returned_attrs, *attrlist);
7636 attrlist = &returned_attrs;
7639 /* Did array size calculations overflow? */
7641 if (TREE_CODE (type) == ARRAY_TYPE
7642 && COMPLETE_TYPE_P (type)
7643 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7644 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7646 error ("size of array %qs is too large", name);
7647 /* If we proceed with the array type as it is, we'll eventually
7648 crash in tree_low_cst(). */
7649 type = error_mark_node;
7652 if ((decl_context == FIELD || decl_context == PARM)
7653 && !processing_template_decl
7654 && variably_modified_type_p (type, NULL_TREE))
7656 if (decl_context == FIELD)
7657 error ("data member may not have variably modified type %qT", type);
7659 error ("parameter may not have variably modified type %qT", type);
7660 type = error_mark_node;
7663 if (explicitp == 1 || (explicitp && friendp))
7665 /* [dcl.fct.spec] The explicit specifier shall only be used in
7666 declarations of constructors within a class definition. */
7667 error ("only declarations of constructors can be %<explicit%>");
7671 if (storage_class == sc_mutable)
7673 if (decl_context != FIELD || friendp)
7675 error ("non-member %qs cannot be declared %<mutable%>", name);
7676 storage_class = sc_none;
7678 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7680 error ("non-object member %qs cannot be declared %<mutable%>", name);
7681 storage_class = sc_none;
7683 else if (TREE_CODE (type) == FUNCTION_TYPE
7684 || TREE_CODE (type) == METHOD_TYPE)
7686 error ("function %qs cannot be declared %<mutable%>", name);
7687 storage_class = sc_none;
7691 error ("static %qs cannot be declared %<mutable%>", name);
7692 storage_class = sc_none;
7694 else if (type_quals & TYPE_QUAL_CONST)
7696 error ("const %qs cannot be declared %<mutable%>", name);
7697 storage_class = sc_none;
7701 /* If this is declaring a typedef name, return a TYPE_DECL. */
7702 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7706 /* Note that the grammar rejects storage classes
7707 in typenames, fields or parameters. */
7708 if (current_lang_name == lang_name_java)
7709 TYPE_FOR_JAVA (type) = 1;
7711 if (decl_context == FIELD)
7712 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7714 decl = build_decl (TYPE_DECL, unqualified_id, type);
7715 if (id_declarator && declarator->u.id.qualifying_scope)
7716 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7718 if (decl_context != FIELD)
7720 if (!current_function_decl)
7721 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7722 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
7723 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
7724 (current_function_decl)))
7725 /* The TYPE_DECL is "abstract" because there will be
7726 clones of this constructor/destructor, and there will
7727 be copies of this TYPE_DECL generated in those
7729 DECL_ABSTRACT (decl) = 1;
7731 else if (constructor_name_p (unqualified_id, current_class_type))
7732 pedwarn ("ISO C++ forbids nested type %qD with same name "
7733 "as enclosing class",
7736 /* If the user declares "typedef struct {...} foo" then the
7737 struct will have an anonymous name. Fill that name in now.
7738 Nothing can refer to it, so nothing needs know about the name
7740 if (type != error_mark_node
7743 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7744 && TYPE_ANONYMOUS_P (type)
7745 /* Don't do this if there are attributes. */
7746 && (!attrlist || !*attrlist)
7747 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7749 tree oldname = TYPE_NAME (type);
7752 /* Replace the anonymous name with the real name everywhere. */
7753 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7754 if (TYPE_NAME (t) == oldname)
7755 TYPE_NAME (t) = decl;
7757 if (TYPE_LANG_SPECIFIC (type))
7758 TYPE_WAS_ANONYMOUS (type) = 1;
7760 /* If this is a typedef within a template class, the nested
7761 type is a (non-primary) template. The name for the
7762 template needs updating as well. */
7763 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7764 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7765 = TYPE_IDENTIFIER (type);
7767 /* FIXME remangle member functions; member functions of a
7768 type with external linkage have external linkage. */
7773 if (ctype == NULL_TREE)
7775 if (TREE_CODE (type) == METHOD_TYPE)
7776 ctype = TYPE_METHOD_BASETYPE (type);
7777 /* Any qualifiers on a function type typedef have
7778 already been dealt with. */
7779 else if (TREE_CODE (type) == FUNCTION_TYPE)
7780 quals = TYPE_UNQUALIFIED;
7782 if (ctype != NULL_TREE)
7783 grok_method_quals (ctype, decl, quals);
7787 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7788 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7790 bad_specifiers (decl, "type", virtualp, quals != TYPE_UNQUALIFIED,
7791 inlinep, friendp, raises != NULL_TREE);
7796 /* Detect the case of an array type of unspecified size
7797 which came, as such, direct from a typedef name.
7798 We must copy the type, so that the array's domain can be
7799 individually set by the object's initializer. */
7801 if (type && typedef_type
7802 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7803 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7804 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7806 /* Detect where we're using a typedef of function type to declare a
7807 function. PARMS will not be set, so we must create it now. */
7809 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7811 tree decls = NULL_TREE;
7814 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7816 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7818 TREE_CHAIN (decl) = decls;
7822 parms = nreverse (decls);
7824 if (decl_context != TYPENAME)
7826 /* A cv-qualifier-seq shall only be part of the function type
7827 for a non-static member function. [8.3.5/4 dcl.fct] */
7828 if (cp_type_quals (type) != TYPE_UNQUALIFIED
7829 && (current_class_type == NULL_TREE || staticp) )
7831 error ("qualified function types cannot be used to declare %s functions",
7832 (staticp? "static member" : "free"));
7833 type = TYPE_MAIN_VARIANT (type);
7836 /* The qualifiers on the function type become the qualifiers on
7837 the non-static member function. */
7838 quals |= cp_type_quals (type);
7842 /* If this is a type name (such as, in a cast or sizeof),
7843 compute the type and return it now. */
7845 if (decl_context == TYPENAME)
7847 /* Note that the grammar rejects storage classes
7848 in typenames, fields or parameters. */
7849 if (type_quals != TYPE_UNQUALIFIED)
7850 type_quals = TYPE_UNQUALIFIED;
7852 /* Special case: "friend class foo" looks like a TYPENAME context. */
7855 if (type_quals != TYPE_UNQUALIFIED)
7857 error ("type qualifiers specified for friend class declaration");
7858 type_quals = TYPE_UNQUALIFIED;
7862 error ("%<inline%> specified for friend class declaration");
7868 /* Don't allow friend declaration without a class-key. */
7869 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7870 pedwarn ("template parameters cannot be friends");
7871 else if (TREE_CODE (type) == TYPENAME_TYPE)
7872 pedwarn ("friend declaration requires class-key, "
7873 "i.e. %<friend class %T::%D%>",
7874 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7876 pedwarn ("friend declaration requires class-key, "
7877 "i.e. %<friend %#T%>",
7881 /* Only try to do this stuff if we didn't already give up. */
7882 if (type != integer_type_node)
7884 /* A friendly class? */
7885 if (current_class_type)
7886 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7889 error ("trying to make class %qT a friend of global scope",
7892 type = void_type_node;
7897 if (ctype == NULL_TREE)
7899 if (TREE_CODE (type) != METHOD_TYPE)
7900 error ("invalid qualifiers on non-member function type");
7902 ctype = TYPE_METHOD_BASETYPE (type);
7906 tree dummy = build_decl (TYPE_DECL, unqualified_id, type);
7907 grok_method_quals (ctype, dummy, quals);
7908 type = TREE_TYPE (dummy);
7914 else if (unqualified_id == NULL_TREE && decl_context != PARM
7915 && decl_context != CATCHPARM
7916 && TREE_CODE (type) != UNION_TYPE
7919 error ("abstract declarator %qT used as declaration", type);
7920 return error_mark_node;
7923 /* Only functions may be declared using an operator-function-id. */
7925 && IDENTIFIER_OPNAME_P (unqualified_id)
7926 && TREE_CODE (type) != FUNCTION_TYPE
7927 && TREE_CODE (type) != METHOD_TYPE)
7929 error ("declaration of %qD as non-function", unqualified_id);
7930 return error_mark_node;
7933 /* We don't check parameter types here because we can emit a better
7934 error message later. */
7935 if (decl_context != PARM)
7936 type = check_var_type (unqualified_id, type);
7938 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7939 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
7941 if (decl_context == PARM || decl_context == CATCHPARM)
7943 if (ctype || in_namespace)
7944 error ("cannot use %<::%> in parameter declaration");
7946 /* A parameter declared as an array of T is really a pointer to T.
7947 One declared as a function is really a pointer to a function.
7948 One declared as a member is really a pointer to member. */
7950 if (TREE_CODE (type) == ARRAY_TYPE)
7952 /* Transfer const-ness of array into that of type pointed to. */
7953 type = build_pointer_type (TREE_TYPE (type));
7954 type_quals = TYPE_UNQUALIFIED;
7956 else if (TREE_CODE (type) == FUNCTION_TYPE)
7957 type = build_pointer_type (type);
7963 if (decl_context == PARM)
7965 decl = cp_build_parm_decl (unqualified_id, type);
7967 bad_specifiers (decl, "parameter", virtualp, quals != TYPE_UNQUALIFIED,
7968 inlinep, friendp, raises != NULL_TREE);
7970 else if (decl_context == FIELD)
7972 /* The C99 flexible array extension. */
7973 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
7974 && TYPE_DOMAIN (type) == NULL_TREE)
7976 tree itype = compute_array_index_type (dname, integer_zero_node);
7977 type = build_cplus_array_type (TREE_TYPE (type), itype);
7980 if (type == error_mark_node)
7982 /* Happens when declaring arrays of sizes which
7983 are error_mark_node, for example. */
7986 else if (in_namespace && !friendp)
7988 /* Something like struct S { int N::j; }; */
7989 error ("invalid use of %<::%>");
7992 else if (TREE_CODE (type) == FUNCTION_TYPE)
7995 tree function_context;
7999 if (ctype == NULL_TREE)
8000 ctype = current_class_type;
8002 if (ctype == NULL_TREE)
8004 error ("can't make %qD into a method -- not in a class",
8006 return void_type_node;
8009 /* ``A union may [ ... ] not [ have ] virtual functions.''
8011 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8013 error ("function %qD declared virtual inside a union",
8015 return void_type_node;
8018 if (NEW_DELETE_OPNAME_P (unqualified_id))
8022 error ("%qD cannot be declared virtual, since it "
8028 else if (staticp < 2)
8029 type = build_method_type_directly (ctype,
8031 TYPE_ARG_TYPES (type));
8034 /* Check that the name used for a destructor makes sense. */
8035 if (sfk == sfk_destructor)
8039 gcc_assert (friendp);
8040 error ("expected qualified name in friend declaration "
8041 "for destructor %qD",
8042 id_declarator->u.id.unqualified_name);
8043 return error_mark_node;
8046 if (!same_type_p (TREE_OPERAND
8047 (id_declarator->u.id.unqualified_name, 0),
8050 error ("declaration of %qD as member of %qT",
8051 id_declarator->u.id.unqualified_name, ctype);
8052 return error_mark_node;
8056 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8057 function_context = (ctype != NULL_TREE) ?
8058 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8059 publicp = (! friendp || ! staticp)
8060 && function_context == NULL_TREE;
8061 decl = grokfndecl (ctype, type,
8062 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8063 ? unqualified_id : dname,
8066 virtualp, flags, quals, raises,
8067 friendp ? -1 : 0, friendp, publicp, inlinep,
8069 funcdef_flag, template_count, in_namespace, attrlist);
8070 if (decl == NULL_TREE)
8073 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8074 /* The decl and setting of decl_attr is also turned off. */
8075 decl = build_decl_attribute_variant (decl, decl_attr);
8078 /* [class.conv.ctor]
8080 A constructor declared without the function-specifier
8081 explicit that can be called with a single parameter
8082 specifies a conversion from the type of its first
8083 parameter to the type of its class. Such a constructor
8084 is called a converting constructor. */
8086 DECL_NONCONVERTING_P (decl) = 1;
8087 else if (DECL_CONSTRUCTOR_P (decl))
8089 /* The constructor can be called with exactly one
8090 parameter if there is at least one parameter, and
8091 any subsequent parameters have default arguments.
8092 Ignore any compiler-added parms. */
8093 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8095 if (arg_types == void_list_node
8097 && TREE_CHAIN (arg_types)
8098 && TREE_CHAIN (arg_types) != void_list_node
8099 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8100 DECL_NONCONVERTING_P (decl) = 1;
8103 else if (TREE_CODE (type) == METHOD_TYPE)
8105 /* We only get here for friend declarations of
8106 members of other classes. */
8107 /* All method decls are public, so tell grokfndecl to set
8108 TREE_PUBLIC, also. */
8109 decl = grokfndecl (ctype, type,
8110 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8111 ? unqualified_id : dname,
8114 virtualp, flags, quals, raises,
8115 friendp ? -1 : 0, friendp, 1, 0, sfk,
8116 funcdef_flag, template_count, in_namespace,
8118 if (decl == NULL_TREE)
8121 else if (!staticp && !dependent_type_p (type)
8122 && !COMPLETE_TYPE_P (complete_type (type))
8123 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8126 error ("field %qD has incomplete type", unqualified_id);
8128 error ("name %qT has incomplete type", type);
8130 /* If we're instantiating a template, tell them which
8131 instantiation made the field's type be incomplete. */
8132 if (current_class_type
8133 && TYPE_NAME (current_class_type)
8134 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8136 && declspecs->type == type)
8137 error (" in instantiation of template %qT",
8138 current_class_type);
8140 type = error_mark_node;
8147 error ("%qE is neither function nor member function; "
8148 "cannot be declared friend", unqualified_id);
8156 /* Friends are treated specially. */
8157 if (ctype == current_class_type)
8158 ; /* We already issued a pedwarn. */
8159 else if (decl && DECL_NAME (decl))
8161 if (template_class_depth (current_class_type) == 0)
8163 decl = check_explicit_specialization
8164 (unqualified_id, decl, template_count,
8165 2 * (funcdef_flag != 0) + 4);
8166 if (decl == error_mark_node)
8167 return error_mark_node;
8170 decl = do_friend (ctype, unqualified_id, decl,
8171 *attrlist, flags, quals, funcdef_flag);
8175 return void_type_node;
8178 /* Structure field. It may not be a function, except for C++. */
8180 if (decl == NULL_TREE)
8186 /* An attempt is being made to initialize a non-static
8187 member. But, from [class.mem]:
8189 4 A member-declarator can contain a
8190 constant-initializer only if it declares a static
8191 member (_class.static_) of integral or enumeration
8192 type, see _class.static.data_.
8194 This used to be relatively common practice, but
8195 the rest of the compiler does not correctly
8196 handle the initialization unless the member is
8197 static so we make it static below. */
8198 pedwarn ("ISO C++ forbids initialization of member %qD",
8200 pedwarn ("making %qD static", unqualified_id);
8204 if (uses_template_parms (type))
8205 /* We'll check at instantiation time. */
8207 else if (check_static_variable_definition (unqualified_id,
8209 /* If we just return the declaration, crashes
8210 will sometimes occur. We therefore return
8211 void_type_node, as if this was a friend
8212 declaration, to cause callers to completely
8213 ignore this declaration. */
8214 return void_type_node;
8219 /* C++ allows static class members. All other work
8220 for this is done by grokfield. */
8221 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8222 set_linkage_for_static_data_member (decl);
8223 /* Even if there is an in-class initialization, DECL
8224 is considered undefined until an out-of-class
8225 definition is provided. */
8226 DECL_EXTERNAL (decl) = 1;
8230 if (targetm.have_tls)
8231 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8233 /* A mere warning is sure to result in improper
8234 semantics at runtime. Don't bother to allow this to
8236 error ("thread-local storage not supported for this target");
8241 decl = build_decl (FIELD_DECL, unqualified_id, type);
8242 DECL_NONADDRESSABLE_P (decl) = bitfield;
8243 if (storage_class == sc_mutable)
8245 DECL_MUTABLE_P (decl) = 1;
8246 storage_class = sc_none;
8250 bad_specifiers (decl, "field", virtualp, quals != TYPE_UNQUALIFIED,
8251 inlinep, friendp, raises != NULL_TREE);
8254 else if (TREE_CODE (type) == FUNCTION_TYPE
8255 || TREE_CODE (type) == METHOD_TYPE)
8260 if (!unqualified_id)
8263 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8264 original_name = dname;
8266 original_name = unqualified_id;
8268 if (storage_class == sc_auto)
8269 error ("storage class %<auto%> invalid for function %qs", name);
8270 else if (storage_class == sc_register)
8271 error ("storage class %<register%> invalid for function %qs", name);
8273 error ("storage class %<__thread%> invalid for function %qs", name);
8275 /* Function declaration not at top level.
8276 Storage classes other than `extern' are not allowed
8277 and `extern' makes no difference. */
8278 if (! toplevel_bindings_p ()
8279 && (storage_class == sc_static
8280 || declspecs->specs[(int)ds_inline])
8283 if (storage_class == sc_static)
8284 pedwarn ("%<static%> specified invalid for function %qs "
8285 "declared out of global scope", name);
8287 pedwarn ("%<inline%> specifier invalid for function %qs "
8288 "declared out of global scope", name);
8291 if (ctype == NULL_TREE)
8295 error ("virtual non-class function %qs", name);
8299 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8300 && !NEW_DELETE_OPNAME_P (original_name))
8301 type = build_method_type_directly (ctype,
8303 TYPE_ARG_TYPES (type));
8305 /* Record presence of `static'. */
8306 publicp = (ctype != NULL_TREE
8307 || storage_class == sc_extern
8308 || storage_class != sc_static);
8310 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8311 virtualp, flags, quals, raises,
8313 publicp, inlinep, sfk, funcdef_flag,
8314 template_count, in_namespace, attrlist);
8315 if (decl == NULL_TREE)
8320 int invalid_static = 0;
8322 /* Don't allow a static member function in a class, and forbid
8323 declaring main to be static. */
8324 if (TREE_CODE (type) == METHOD_TYPE)
8326 pedwarn ("cannot declare member function %qD to have "
8327 "static linkage", decl);
8330 else if (current_function_decl)
8332 /* FIXME need arm citation */
8333 error ("cannot declare static function inside another function");
8340 storage_class = sc_none;
8346 /* It's a variable. */
8348 /* An uninitialized decl with `extern' is a reference. */
8349 decl = grokvardecl (type, unqualified_id,
8352 (type_quals & TYPE_QUAL_CONST) != 0,
8353 ctype ? ctype : in_namespace);
8354 bad_specifiers (decl, "variable", virtualp, quals != TYPE_UNQUALIFIED,
8355 inlinep, friendp, raises != NULL_TREE);
8359 DECL_CONTEXT (decl) = ctype;
8362 pedwarn ("%<static%> may not be used when defining "
8363 "(as opposed to declaring) a static data member");
8365 storage_class = sc_none;
8367 if (storage_class == sc_register && TREE_STATIC (decl))
8369 error ("static member %qD declared %<register%>", decl);
8370 storage_class = sc_none;
8372 if (storage_class == sc_extern && pedantic)
8374 pedwarn ("cannot explicitly declare member %q#D to have "
8377 storage_class = sc_none;
8382 /* Record `register' declaration for warnings on &
8383 and in case doing stupid register allocation. */
8385 if (storage_class == sc_register)
8386 DECL_REGISTER (decl) = 1;
8387 else if (storage_class == sc_extern)
8388 DECL_THIS_EXTERN (decl) = 1;
8389 else if (storage_class == sc_static)
8390 DECL_THIS_STATIC (decl) = 1;
8392 /* Record constancy and volatility. There's no need to do this
8393 when processing a template; we'll do this for the instantiated
8394 declaration based on the type of DECL. */
8395 if (!processing_template_decl)
8396 cp_apply_type_quals_to_decl (type_quals, decl);
8402 /* Subroutine of start_function. Ensure that each of the parameter
8403 types (as listed in PARMS) is complete, as is required for a
8404 function definition. */
8407 require_complete_types_for_parms (tree parms)
8409 for (; parms; parms = TREE_CHAIN (parms))
8411 if (dependent_type_p (TREE_TYPE (parms)))
8413 if (!VOID_TYPE_P (TREE_TYPE (parms))
8414 && complete_type_or_else (TREE_TYPE (parms), parms))
8416 relayout_decl (parms);
8417 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8420 /* grokparms or complete_type_or_else will have already issued
8422 TREE_TYPE (parms) = error_mark_node;
8426 /* Returns nonzero if T is a local variable. */
8429 local_variable_p (tree t)
8431 if ((TREE_CODE (t) == VAR_DECL
8432 /* A VAR_DECL with a context that is a _TYPE is a static data
8434 && !TYPE_P (CP_DECL_CONTEXT (t))
8435 /* Any other non-local variable must be at namespace scope. */
8436 && !DECL_NAMESPACE_SCOPE_P (t))
8437 || (TREE_CODE (t) == PARM_DECL))
8443 /* Returns nonzero if T is an automatic local variable or a label.
8444 (These are the declarations that need to be remapped when the code
8445 containing them is duplicated.) */
8448 nonstatic_local_decl_p (tree t)
8450 return ((local_variable_p (t) && !TREE_STATIC (t))
8451 || TREE_CODE (t) == LABEL_DECL
8452 || TREE_CODE (t) == RESULT_DECL);
8455 /* Like local_variable_p, but suitable for use as a tree-walking
8459 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8460 void *data ATTRIBUTE_UNUSED)
8462 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8464 else if (TYPE_P (*tp))
8471 /* Check that ARG, which is a default-argument expression for a
8472 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8473 something goes wrong. DECL may also be a _TYPE node, rather than a
8474 DECL, if there is no DECL available. */
8477 check_default_argument (tree decl, tree arg)
8482 if (TREE_CODE (arg) == DEFAULT_ARG)
8483 /* We get a DEFAULT_ARG when looking at an in-class declaration
8484 with a default argument. Ignore the argument for now; we'll
8485 deal with it after the class is complete. */
8494 decl_type = TREE_TYPE (decl);
8496 if (arg == error_mark_node
8497 || decl == error_mark_node
8498 || TREE_TYPE (arg) == error_mark_node
8499 || decl_type == error_mark_node)
8500 /* Something already went wrong. There's no need to check
8502 return error_mark_node;
8504 /* [dcl.fct.default]
8506 A default argument expression is implicitly converted to the
8508 if (!TREE_TYPE (arg)
8509 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
8512 error ("default argument for %q#D has type %qT",
8513 decl, TREE_TYPE (arg));
8515 error ("default argument for parameter of type %qT has type %qT",
8516 decl_type, TREE_TYPE (arg));
8518 return error_mark_node;
8521 /* [dcl.fct.default]
8523 Local variables shall not be used in default argument
8526 The keyword `this' shall not be used in a default argument of a
8528 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8532 error ("default argument %qE uses local variable %qD", arg, var);
8533 return error_mark_node;
8540 /* Decode the list of parameter types for a function type.
8541 Given the list of things declared inside the parens,
8542 return a list of types.
8544 If this parameter does not end with an ellipsis, we append
8547 *PARMS is set to the chain of PARM_DECLs created. */
8550 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8552 tree result = NULL_TREE;
8553 tree decls = NULL_TREE;
8554 int ellipsis = !first_parm || first_parm->ellipsis_p;
8555 cp_parameter_declarator *parm;
8558 for (parm = first_parm; parm != NULL; parm = parm->next)
8560 tree type = NULL_TREE;
8561 tree init = parm->default_argument;
8565 if (parm == no_parameters)
8568 attrs = parm->decl_specifiers.attributes;
8569 parm->decl_specifiers.attributes = NULL_TREE;
8570 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8571 PARM, init != NULL_TREE, &attrs);
8572 if (! decl || TREE_TYPE (decl) == error_mark_node)
8576 cplus_decl_attributes (&decl, attrs, 0);
8578 type = TREE_TYPE (decl);
8579 if (VOID_TYPE_P (type))
8581 if (same_type_p (type, void_type_node)
8582 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8583 /* this is a parmlist of `(void)', which is ok. */
8585 cxx_incomplete_type_error (decl, type);
8586 /* It's not a good idea to actually create parameters of
8587 type `void'; other parts of the compiler assume that a
8588 void type terminates the parameter list. */
8589 type = error_mark_node;
8590 TREE_TYPE (decl) = error_mark_node;
8593 if (type != error_mark_node)
8595 /* Top-level qualifiers on the parameters are
8596 ignored for function types. */
8597 type = cp_build_qualified_type (type, 0);
8598 if (TREE_CODE (type) == METHOD_TYPE)
8600 error ("parameter %qD invalidly declared method type", decl);
8601 type = build_pointer_type (type);
8602 TREE_TYPE (decl) = type;
8604 else if (abstract_virtuals_error (decl, type))
8605 any_error = 1; /* Seems like a good idea. */
8606 else if (POINTER_TYPE_P (type))
8608 /* [dcl.fct]/6, parameter types cannot contain pointers
8609 (references) to arrays of unknown bound. */
8610 tree t = TREE_TYPE (type);
8611 int ptr = TYPE_PTR_P (type);
8617 else if (TREE_CODE (t) != ARRAY_TYPE)
8619 else if (!TYPE_DOMAIN (t))
8623 if (TREE_CODE (t) == ARRAY_TYPE)
8624 error ("parameter %qD includes %s to array of unknown "
8626 decl, ptr ? "pointer" : "reference", t);
8631 else if (init && !processing_template_decl)
8632 init = check_default_argument (decl, init);
8635 TREE_CHAIN (decl) = decls;
8637 result = tree_cons (init, type, result);
8639 decls = nreverse (decls);
8640 result = nreverse (result);
8642 result = chainon (result, void_list_node);
8649 /* D is a constructor or overloaded `operator='.
8651 Let T be the class in which D is declared. Then, this function
8654 -1 if D's is an ill-formed constructor or copy assignment operator
8655 whose first parameter is of type `T'.
8656 0 if D is not a copy constructor or copy assignment
8658 1 if D is a copy constructor or copy assignment operator whose
8659 first parameter is a reference to const qualified T.
8660 2 if D is a copy constructor or copy assignment operator whose
8661 first parameter is a reference to non-const qualified T.
8663 This function can be used as a predicate. Positive values indicate
8664 a copy constructor and nonzero values indicate a copy assignment
8674 if (!DECL_FUNCTION_MEMBER_P (d))
8675 /* Non-members are invalid. We complained, but kept the declaration. */
8678 if (DECL_TEMPLATE_INFO (d)
8679 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d)))
8680 /* Instantiations of template member functions are never copy
8681 functions. Note that member functions of templated classes are
8682 represented as template functions internally, and we must
8683 accept those as copy functions. */
8686 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8690 arg_type = TREE_VALUE (args);
8691 if (arg_type == error_mark_node)
8694 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8696 /* Pass by value copy assignment operator. */
8699 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8700 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8702 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8708 args = TREE_CHAIN (args);
8710 if (args && args != void_list_node && !TREE_PURPOSE (args))
8711 /* There are more non-optional args. */
8717 /* Remember any special properties of member function DECL. */
8719 void grok_special_member_properties (tree decl)
8721 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8722 ; /* Not special. */
8723 else if (DECL_CONSTRUCTOR_P (decl))
8725 int ctor = copy_fn_p (decl);
8731 A non-template constructor for class X is a copy
8732 constructor if its first parameter is of type X&, const
8733 X&, volatile X& or const volatile X&, and either there
8734 are no other parameters or else all other parameters have
8735 default arguments. */
8736 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8738 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8740 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8741 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8743 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8747 A non-template assignment operator for class X is a copy
8748 assignment operator if its parameter is of type X, X&, const
8749 X&, volatile X& or const volatile X&. */
8751 int assop = copy_fn_p (decl);
8755 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8757 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8762 /* Check a constructor DECL has the correct form. Complains
8763 if the class has a constructor of the form X(X). */
8766 grok_ctor_properties (tree ctype, tree decl)
8768 int ctor_parm = copy_fn_p (decl);
8774 A declaration of a constructor for a class X is ill-formed if
8775 its first parameter is of type (optionally cv-qualified) X
8776 and either there are no other parameters or else all other
8777 parameters have default arguments.
8779 We *don't* complain about member template instantiations that
8780 have this form, though; they can occur as we try to decide
8781 what constructor to use during overload resolution. Since
8782 overload resolution will never prefer such a constructor to
8783 the non-template copy constructor (which is either explicitly
8784 or implicitly defined), there's no need to worry about their
8785 existence. Theoretically, they should never even be
8786 instantiated, but that's hard to forestall. */
8787 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
8795 /* An operator with this code is unary, but can also be binary. */
8798 ambi_op_p (enum tree_code code)
8800 return (code == INDIRECT_REF
8801 || code == ADDR_EXPR
8802 || code == UNARY_PLUS_EXPR
8803 || code == NEGATE_EXPR
8804 || code == PREINCREMENT_EXPR
8805 || code == PREDECREMENT_EXPR);
8808 /* An operator with this name can only be unary. */
8811 unary_op_p (enum tree_code code)
8813 return (code == TRUTH_NOT_EXPR
8814 || code == BIT_NOT_EXPR
8815 || code == COMPONENT_REF
8816 || code == TYPE_EXPR);
8819 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
8820 errors are issued for invalid declarations. */
8823 grok_op_properties (tree decl, bool complain)
8825 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8827 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8828 tree name = DECL_NAME (decl);
8829 enum tree_code operator_code;
8834 /* Count the number of arguments and check for ellipsis. */
8835 for (argtype = argtypes, arity = 0;
8836 argtype && argtype != void_list_node;
8837 argtype = TREE_CHAIN (argtype))
8839 ellipsis_p = !argtype;
8841 class_type = DECL_CONTEXT (decl);
8842 if (class_type && !CLASS_TYPE_P (class_type))
8843 class_type = NULL_TREE;
8845 if (DECL_CONV_FN_P (decl))
8846 operator_code = TYPE_EXPR;
8850 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8851 if (ansi_opname (CODE) == name) \
8853 operator_code = (CODE); \
8856 else if (ansi_assopname (CODE) == name) \
8858 operator_code = (CODE); \
8859 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8863 #include "operators.def"
8869 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
8870 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8873 switch (operator_code)
8876 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
8880 TYPE_GETS_DELETE (class_type) |= 1;
8884 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
8887 case VEC_DELETE_EXPR:
8888 TYPE_GETS_DELETE (class_type) |= 2;
8895 /* [basic.std.dynamic.allocation]/1:
8897 A program is ill-formed if an allocation function is declared
8898 in a namespace scope other than global scope or declared static
8901 The same also holds true for deallocation functions. */
8902 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
8903 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8905 if (DECL_NAMESPACE_SCOPE_P (decl))
8907 if (CP_DECL_CONTEXT (decl) != global_namespace)
8908 error ("%qD may not be declared within a namespace", decl);
8909 else if (!TREE_PUBLIC (decl))
8910 error ("%qD may not be declared as static", decl);
8914 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8915 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8916 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8917 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8920 /* An operator function must either be a non-static member function
8921 or have at least one parameter of a class, a reference to a class,
8922 an enumeration, or a reference to an enumeration. 13.4.0.6 */
8923 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8925 if (operator_code == TYPE_EXPR
8926 || operator_code == CALL_EXPR
8927 || operator_code == COMPONENT_REF
8928 || operator_code == ARRAY_REF
8929 || operator_code == NOP_EXPR)
8931 error ("%qD must be a nonstatic member function", decl);
8938 if (DECL_STATIC_FUNCTION_P (decl))
8940 error ("%qD must be either a non-static member "
8941 "function or a non-member function", decl);
8945 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8947 tree arg = non_reference (TREE_VALUE (p));
8948 if (arg == error_mark_node)
8951 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8952 because these checks are performed even on
8953 template functions. */
8954 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8958 if (!p || p == void_list_node)
8963 error ("%qD must have an argument of class or "
8970 /* There are no restrictions on the arguments to an overloaded
8972 if (operator_code == CALL_EXPR)
8975 /* Warn about conversion operators that will never be used. */
8976 if (IDENTIFIER_TYPENAME_P (name)
8977 && ! DECL_TEMPLATE_INFO (decl)
8979 /* Warn only declaring the function; there is no need to
8980 warn again about out-of-class definitions. */
8981 && class_type == current_class_type)
8983 tree t = TREE_TYPE (name);
8984 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8985 const char *what = 0;
8988 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8990 if (TREE_CODE (t) == VOID_TYPE)
8992 else if (class_type)
8994 if (t == class_type)
8995 what = "the same type";
8996 /* Don't force t to be complete here. */
8997 else if (IS_AGGR_TYPE (t)
8998 && COMPLETE_TYPE_P (t)
8999 && DERIVED_FROM_P (t, class_type))
9000 what = "a base class";
9004 warning (0, "conversion to %s%s will never use a type "
9005 "conversion operator",
9006 ref ? "a reference to " : "", what);
9009 if (operator_code == COND_EXPR)
9012 error ("ISO C++ prohibits overloading operator ?:");
9014 else if (ellipsis_p)
9015 error ("%qD must not have variable number of arguments", decl);
9016 else if (ambi_op_p (operator_code))
9019 /* We pick the one-argument operator codes by default, so
9020 we don't have to change anything. */
9022 else if (arity == 2)
9024 /* If we thought this was a unary operator, we now know
9025 it to be a binary operator. */
9026 switch (operator_code)
9029 operator_code = MULT_EXPR;
9033 operator_code = BIT_AND_EXPR;
9036 case UNARY_PLUS_EXPR:
9037 operator_code = PLUS_EXPR;
9041 operator_code = MINUS_EXPR;
9044 case PREINCREMENT_EXPR:
9045 operator_code = POSTINCREMENT_EXPR;
9048 case PREDECREMENT_EXPR:
9049 operator_code = POSTDECREMENT_EXPR;
9056 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9058 if ((operator_code == POSTINCREMENT_EXPR
9059 || operator_code == POSTDECREMENT_EXPR)
9060 && ! processing_template_decl
9061 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9064 error ("postfix %qD must take %<int%> as its argument",
9068 ("postfix %qD must take %<int%> as its second argument",
9075 error ("%qD must take either zero or one argument", decl);
9077 error ("%qD must take either one or two arguments", decl);
9080 /* More Effective C++ rule 6. */
9082 && (operator_code == POSTINCREMENT_EXPR
9083 || operator_code == POSTDECREMENT_EXPR
9084 || operator_code == PREINCREMENT_EXPR
9085 || operator_code == PREDECREMENT_EXPR))
9087 tree arg = TREE_VALUE (argtypes);
9088 tree ret = TREE_TYPE (TREE_TYPE (decl));
9089 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9090 arg = TREE_TYPE (arg);
9091 arg = TYPE_MAIN_VARIANT (arg);
9092 if (operator_code == PREINCREMENT_EXPR
9093 || operator_code == PREDECREMENT_EXPR)
9095 if (TREE_CODE (ret) != REFERENCE_TYPE
9096 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9098 warning (0, "prefix %qD should return %qT", decl,
9099 build_reference_type (arg));
9103 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9104 warning (0, "postfix %qD should return %qT", decl, arg);
9108 else if (unary_op_p (operator_code))
9113 error ("%qD must take %<void%>", decl);
9115 error ("%qD must take exactly one argument", decl);
9118 else /* if (binary_op_p (operator_code)) */
9123 error ("%qD must take exactly one argument", decl);
9125 error ("%qD must take exactly two arguments", decl);
9128 /* More Effective C++ rule 7. */
9130 && (operator_code == TRUTH_ANDIF_EXPR
9131 || operator_code == TRUTH_ORIF_EXPR
9132 || operator_code == COMPOUND_EXPR))
9133 warning (0, "user-defined %qD always evaluates both arguments",
9137 /* Effective C++ rule 23. */
9140 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9141 && (operator_code == PLUS_EXPR
9142 || operator_code == MINUS_EXPR
9143 || operator_code == TRUNC_DIV_EXPR
9144 || operator_code == MULT_EXPR
9145 || operator_code == TRUNC_MOD_EXPR)
9146 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9147 warning (0, "%qD should return by value", decl);
9150 for (; argtypes && argtypes != void_list_node;
9151 argtypes = TREE_CHAIN (argtypes))
9152 if (TREE_PURPOSE (argtypes))
9154 TREE_PURPOSE (argtypes) = NULL_TREE;
9155 if (operator_code == POSTINCREMENT_EXPR
9156 || operator_code == POSTDECREMENT_EXPR)
9159 pedwarn ("%qD cannot have default arguments", decl);
9162 error ("%qD cannot have default arguments", decl);
9169 /* Return a string giving the keyword associate with CODE. */
9172 tag_name (enum tag_types code)
9191 /* Name lookup in an elaborated-type-specifier (after the keyword
9192 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9193 elaborated-type-specifier is invalid, issue a diagnostic and return
9194 error_mark_node; otherwise, return the *_TYPE to which it referred.
9195 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9198 check_elaborated_type_specifier (enum tag_types tag_code,
9200 bool allow_template_p)
9206 struct S { struct S *p; };
9208 name lookup will find the TYPE_DECL for the implicit "S::S"
9209 typedef. Adjust for that here. */
9210 if (DECL_SELF_REFERENCE_P (decl))
9211 decl = TYPE_NAME (TREE_TYPE (decl));
9213 type = TREE_TYPE (decl);
9215 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9216 is false for this case as well. */
9217 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9219 error ("using template type parameter %qT after %qs",
9220 type, tag_name (tag_code));
9221 return error_mark_node;
9225 If the identifier resolves to a typedef-name or a template
9226 type-parameter, the elaborated-type-specifier is ill-formed.
9228 In other words, the only legitimate declaration to use in the
9229 elaborated type specifier is the implicit typedef created when
9230 the type is declared. */
9231 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9232 && tag_code != typename_type)
9234 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9235 error ("%q+D has a previous declaration here", decl);
9236 return error_mark_node;
9238 else if (TREE_CODE (type) != RECORD_TYPE
9239 && TREE_CODE (type) != UNION_TYPE
9240 && tag_code != enum_type
9241 && tag_code != typename_type)
9243 error ("%qT referred to as %qs", type, tag_name (tag_code));
9244 error ("%q+T has a previous declaration here", type);
9245 return error_mark_node;
9247 else if (TREE_CODE (type) != ENUMERAL_TYPE
9248 && tag_code == enum_type)
9250 error ("%qT referred to as enum", type);
9251 error ("%q+T has a previous declaration here", type);
9252 return error_mark_node;
9254 else if (!allow_template_p
9255 && TREE_CODE (type) == RECORD_TYPE
9256 && CLASSTYPE_IS_TEMPLATE (type))
9258 /* If a class template appears as elaborated type specifier
9259 without a template header such as:
9261 template <class T> class C {};
9262 void f(class C); // No template header here
9264 then the required template argument is missing. */
9265 error ("template argument required for %<%s %T%>",
9266 tag_name (tag_code),
9267 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9268 return error_mark_node;
9274 /* Lookup NAME in elaborate type specifier in scope according to
9275 SCOPE and issue diagnostics if necessary.
9276 Return *_TYPE node upon success, NULL_TREE when the NAME is not
9277 found, and ERROR_MARK_NODE for type error. */
9280 lookup_and_check_tag (enum tag_types tag_code, tree name,
9281 tag_scope scope, bool template_header_p)
9285 if (scope == ts_global)
9287 /* First try ordinary name lookup, ignoring hidden class name
9288 injected via friend declaration. */
9289 decl = lookup_name (name, 2);
9290 /* If that fails, the name will be placed in the smallest
9291 non-class, non-function-prototype scope according to 3.3.1/5.
9292 We may already have a hidden name declared as friend in this
9293 scope. So lookup again but not ignoring hidden name.
9294 If we find one, that name will be made visible rather than
9295 creating a new tag. */
9297 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
9300 decl = lookup_type_scope (name, scope);
9302 if (decl && DECL_CLASS_TEMPLATE_P (decl))
9303 decl = DECL_TEMPLATE_RESULT (decl);
9305 if (decl && TREE_CODE (decl) == TYPE_DECL)
9307 /* Look for invalid nested type:
9311 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9313 error ("%qD has the same name as the class in which it is "
9316 return error_mark_node;
9319 /* Two cases we need to consider when deciding if a class
9320 template is allowed as an elaborated type specifier:
9321 1. It is a self reference to its own class.
9322 2. It comes with a template header.
9326 template <class T> class C {
9327 class C *c1; // DECL_SELF_REFERENCE_P is true
9330 template <class U> class C; // template_header_p is true
9331 template <class T> class C<T>::D {
9332 class C *c2; // DECL_SELF_REFERENCE_P is true
9335 t = check_elaborated_type_specifier (tag_code,
9338 | DECL_SELF_REFERENCE_P (decl));
9345 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9346 Define the tag as a forward-reference if it is not defined.
9348 If a declaration is given, process it here, and report an error if
9349 multiple declarations are not identical.
9351 SCOPE is TS_CURRENT when this is also a definition. Only look in
9352 the current frame for the name (since C++ allows new names in any
9353 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9354 declaration. Only look beginning from the current scope outward up
9355 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
9357 TEMPLATE_HEADER_P is true when this declaration is preceded by
9358 a set of template parameters. */
9361 xref_tag (enum tag_types tag_code, tree name,
9362 tag_scope scope, bool template_header_p)
9364 enum tree_code code;
9366 tree context = NULL_TREE;
9368 timevar_push (TV_NAME_LOOKUP);
9370 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9382 code = ENUMERAL_TYPE;
9388 /* In case of anonymous name, xref_tag is only called to
9389 make type node and push name. Name lookup is not required. */
9390 if (ANON_AGGRNAME_P (name))
9393 t = lookup_and_check_tag (tag_code, name,
9394 scope, template_header_p);
9396 if (t == error_mark_node)
9397 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9399 if (scope != ts_current && t && current_class_type
9400 && template_class_depth (current_class_type)
9401 && template_header_p)
9403 /* Since SCOPE is not TS_CURRENT, we are not looking at a
9404 definition of this tag. Since, in addition, we are currently
9405 processing a (member) template declaration of a template
9406 class, we must be very careful; consider:
9413 { template <class V>
9414 friend struct S1; };
9416 Here, the S2::S1 declaration should not be confused with the
9417 outer declaration. In particular, the inner version should
9418 have a template parameter of level 2, not level 1. This
9419 would be particularly important if the member declaration
9422 template <class V = U> friend struct S1;
9424 say, when we should tsubst into `U' when instantiating
9425 S2. On the other hand, when presented with:
9435 we must find the inner binding eventually. We
9436 accomplish this by making sure that the new type we
9437 create to represent this declaration has the right
9439 context = TYPE_CONTEXT (t);
9445 /* If no such tag is yet defined, create a forward-reference node
9446 and record it as the "definition".
9447 When a real declaration of this type is found,
9448 the forward-reference will be altered into a real type. */
9449 if (code == ENUMERAL_TYPE)
9451 error ("use of enum %q#D without previous declaration", name);
9452 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9456 t = make_aggr_type (code);
9457 TYPE_CONTEXT (t) = context;
9458 t = pushtag (name, t, scope);
9463 if (template_header_p && IS_AGGR_TYPE (t))
9464 redeclare_class_template (t, current_template_parms);
9465 else if (!processing_template_decl
9467 && CLASSTYPE_IS_TEMPLATE (t))
9469 error ("redeclaration of %qT as a non-template", t);
9470 t = error_mark_node;
9473 /* Make injected friend class visible. */
9474 if (scope != ts_within_enclosing_non_class
9475 && hidden_name_p (TYPE_NAME (t)))
9477 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
9478 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
9480 if (TYPE_TEMPLATE_INFO (t))
9482 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
9483 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
9488 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9492 xref_tag_from_type (tree old, tree id, tag_scope scope)
9494 enum tag_types tag_kind;
9496 if (TREE_CODE (old) == RECORD_TYPE)
9497 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9499 tag_kind = union_type;
9501 if (id == NULL_TREE)
9502 id = TYPE_IDENTIFIER (old);
9504 return xref_tag (tag_kind, id, scope, false);
9507 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9508 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9509 access_* node, and the TREE_VALUE is the type of the base-class.
9510 Non-NULL TREE_TYPE indicates virtual inheritance. */
9513 xref_basetypes (tree ref, tree base_list)
9516 tree binfo, base_binfo;
9517 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
9518 unsigned max_bases = 0; /* Maximum direct bases. */
9520 tree default_access;
9521 tree igo_prev; /* Track Inheritance Graph Order. */
9523 if (ref == error_mark_node)
9526 /* The base of a derived class is private by default, all others are
9528 default_access = (TREE_CODE (ref) == RECORD_TYPE
9529 && CLASSTYPE_DECLARED_CLASS (ref)
9530 ? access_private_node : access_public_node);
9532 /* First, make sure that any templates in base-classes are
9533 instantiated. This ensures that if we call ourselves recursively
9534 we do not get confused about which classes are marked and which
9539 tree basetype = TREE_VALUE (*basep);
9541 if (!(processing_template_decl && uses_template_parms (basetype))
9542 && !complete_type_or_else (basetype, NULL))
9543 /* An incomplete type. Remove it from the list. */
9544 *basep = TREE_CHAIN (*basep);
9548 if (TREE_TYPE (*basep))
9550 if (CLASS_TYPE_P (basetype))
9551 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9552 basep = &TREE_CHAIN (*basep);
9556 TYPE_MARKED_P (ref) = 1;
9558 /* The binfo slot should be empty, unless this is an (ill-formed)
9560 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
9561 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
9563 binfo = make_tree_binfo (max_bases);
9565 TYPE_BINFO (ref) = binfo;
9566 BINFO_OFFSET (binfo) = size_zero_node;
9567 BINFO_TYPE (binfo) = ref;
9571 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
9572 /* An aggregate cannot have baseclasses. */
9573 CLASSTYPE_NON_AGGREGATE (ref) = 1;
9575 if (TREE_CODE (ref) == UNION_TYPE)
9576 error ("derived union %qT invalid", ref);
9581 if (TYPE_FOR_JAVA (ref))
9582 error ("Java class %qT cannot have multiple bases", ref);
9587 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
9589 if (TYPE_FOR_JAVA (ref))
9590 error ("Java class %qT cannot have virtual bases", ref);
9593 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9595 tree access = TREE_PURPOSE (base_list);
9596 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9597 tree basetype = TREE_VALUE (base_list);
9599 if (access == access_default_node)
9600 access = default_access;
9602 if (TREE_CODE (basetype) == TYPE_DECL)
9603 basetype = TREE_TYPE (basetype);
9604 if (TREE_CODE (basetype) != RECORD_TYPE
9605 && TREE_CODE (basetype) != TYPENAME_TYPE
9606 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9607 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9609 error ("base type %qT fails to be a struct or class type",
9614 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9615 TYPE_FOR_JAVA (ref) = 1;
9617 base_binfo = NULL_TREE;
9618 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9620 base_binfo = TYPE_BINFO (basetype);
9621 /* The original basetype could have been a typedef'd type. */
9622 basetype = BINFO_TYPE (base_binfo);
9624 /* Inherit flags from the base. */
9625 TYPE_HAS_NEW_OPERATOR (ref)
9626 |= TYPE_HAS_NEW_OPERATOR (basetype);
9627 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9628 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9629 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9630 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9631 CLASSTYPE_DIAMOND_SHAPED_P (ref)
9632 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
9633 CLASSTYPE_REPEATED_BASE_P (ref)
9634 |= CLASSTYPE_REPEATED_BASE_P (basetype);
9637 /* We must do this test after we've seen through a typedef
9639 if (TYPE_MARKED_P (basetype))
9641 if (basetype == ref)
9642 error ("recursive type %qT undefined", basetype);
9644 error ("duplicate base type %qT invalid", basetype);
9647 TYPE_MARKED_P (basetype) = 1;
9649 base_binfo = copy_binfo (base_binfo, basetype, ref,
9650 &igo_prev, via_virtual);
9651 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9652 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9654 BINFO_BASE_APPEND (binfo, base_binfo);
9655 BINFO_BASE_ACCESS_APPEND (binfo, access);
9658 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
9659 /* If we have space in the vbase vector, we must have shared at
9660 least one of them, and are therefore diamond shaped. */
9661 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
9663 /* Unmark all the types. */
9664 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
9665 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9666 TYPE_MARKED_P (ref) = 0;
9668 /* Now see if we have a repeated base type. */
9669 if (!CLASSTYPE_REPEATED_BASE_P (ref))
9671 for (base_binfo = binfo; base_binfo;
9672 base_binfo = TREE_CHAIN (base_binfo))
9674 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9676 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
9679 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
9681 for (base_binfo = binfo; base_binfo;
9682 base_binfo = TREE_CHAIN (base_binfo))
9683 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9684 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9691 /* Begin compiling the definition of an enumeration type.
9693 Returns the type object, as yet incomplete.
9694 Also records info about it so that build_enumerator
9695 may be used to declare the individual values as they are read. */
9698 start_enum (tree name)
9702 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9704 /* If this is the real definition for a previous forward reference,
9705 fill in the contents in the same object that used to be the
9706 forward reference. */
9708 enumtype = lookup_and_check_tag (enum_type, name,
9709 /*tag_scope=*/ts_current,
9710 /*template_header_p=*/false);
9712 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9714 error ("multiple definition of %q#T", enumtype);
9715 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9716 /* Clear out TYPE_VALUES, and start again. */
9717 TYPE_VALUES (enumtype) = NULL_TREE;
9721 /* In case of error, make a dummy enum to allow parsing to
9723 if (enumtype == error_mark_node)
9724 name = make_anon_name ();
9726 enumtype = make_node (ENUMERAL_TYPE);
9727 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
9733 /* After processing and defining all the values of an enumeration type,
9734 install their decls in the enumeration type and finish it off.
9735 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9738 finish_enum (tree enumtype)
9747 bool use_short_enum;
9751 integer_type_kind itk;
9752 tree underlying_type = NULL_TREE;
9754 /* We built up the VALUES in reverse order. */
9755 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9757 /* For an enum defined in a template, just set the type of the values;
9758 all further processing is postponed until the template is
9759 instantiated. We need to set the type so that tsubst of a CONST_DECL
9761 if (processing_template_decl)
9763 for (values = TYPE_VALUES (enumtype);
9765 values = TREE_CHAIN (values))
9766 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9767 if (at_function_scope_p ())
9768 add_stmt (build_min (TAG_DEFN, enumtype));
9772 /* Determine the minimum and maximum values of the enumerators. */
9773 if (TYPE_VALUES (enumtype))
9775 minnode = maxnode = NULL_TREE;
9777 for (values = TYPE_VALUES (enumtype);
9779 values = TREE_CHAIN (values))
9781 decl = TREE_VALUE (values);
9783 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9784 each enumerator has the type of its enumeration. Prior to the
9785 closing brace, the type of each enumerator is the type of its
9786 initializing value. */
9787 TREE_TYPE (decl) = enumtype;
9789 /* Update the minimum and maximum values, if appropriate. */
9790 value = DECL_INITIAL (decl);
9791 if (value == error_mark_node)
9792 value = integer_zero_node;
9793 /* Figure out what the minimum and maximum values of the
9796 minnode = maxnode = value;
9797 else if (tree_int_cst_lt (maxnode, value))
9799 else if (tree_int_cst_lt (value, minnode))
9806 If the enumerator-list is empty, the underlying type is as if
9807 the enumeration had a single enumerator with value 0. */
9808 minnode = maxnode = integer_zero_node;
9810 /* Compute the number of bits require to represent all values of the
9811 enumeration. We must do this before the type of MINNODE and
9812 MAXNODE are transformed, since min_precision relies on the
9813 TREE_TYPE of the value it is passed. */
9814 unsignedp = tree_int_cst_sgn (minnode) >= 0;
9815 lowprec = min_precision (minnode, unsignedp);
9816 highprec = min_precision (maxnode, unsignedp);
9817 precision = MAX (lowprec, highprec);
9819 /* Determine the underlying type of the enumeration.
9823 The underlying type of an enumeration is an integral type that
9824 can represent all the enumerator values defined in the
9825 enumeration. It is implementation-defined which integral type is
9826 used as the underlying type for an enumeration except that the
9827 underlying type shall not be larger than int unless the value of
9828 an enumerator cannot fit in an int or unsigned int.
9830 We use "int" or an "unsigned int" as the underlying type, even if
9831 a smaller integral type would work, unless the user has
9832 explicitly requested that we use the smallest possible type. The
9833 user can request that for all enumerations with a command line
9834 flag, or for just one enumeration with an attribute. */
9836 use_short_enum = flag_short_enums
9837 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
9839 for (itk = (use_short_enum ? itk_char : itk_int);
9843 underlying_type = integer_types[itk];
9844 if (TYPE_PRECISION (underlying_type) >= precision
9845 && TYPE_UNSIGNED (underlying_type) == unsignedp)
9848 if (itk == itk_none)
9852 IF no integral type can represent all the enumerator values, the
9853 enumeration is ill-formed. */
9854 error ("no integral type can represent all of the enumerator values "
9855 "for %qT", enumtype);
9856 precision = TYPE_PRECISION (long_long_integer_type_node);
9857 underlying_type = integer_types[itk_unsigned_long_long];
9860 /* Compute the minium and maximum values for the type.
9864 For an enumeration where emin is the smallest enumerator and emax
9865 is the largest, the values of the enumeration are the values of the
9866 underlying type in the range bmin to bmax, where bmin and bmax are,
9867 respectively, the smallest and largest values of the smallest bit-
9868 field that can store emin and emax. */
9870 /* The middle-end currently assumes that types with TYPE_PRECISION
9871 narrower than their underlying type are suitably zero or sign
9872 extended to fill their mode. g++ doesn't make these guarantees.
9873 Until the middle-end can represent such paradoxical types, we
9874 set the TYPE_PRECISION to the width of the underlying type. */
9875 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
9877 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9881 The value of sizeof() applied to an enumeration type, an object
9882 of an enumeration type, or an enumerator, is the value of sizeof()
9883 applied to the underlying type. */
9884 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9885 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9886 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9887 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9888 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9889 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9891 /* Convert each of the enumerators to the type of the underlying
9892 type of the enumeration. */
9893 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9895 location_t saved_location;
9897 decl = TREE_VALUE (values);
9898 saved_location = input_location;
9899 input_location = DECL_SOURCE_LOCATION (decl);
9900 value = perform_implicit_conversion (underlying_type,
9901 DECL_INITIAL (decl));
9902 input_location = saved_location;
9904 /* Do not clobber shared ints. */
9905 value = copy_node (value);
9907 TREE_TYPE (value) = enumtype;
9908 DECL_INITIAL (decl) = value;
9909 TREE_VALUE (values) = value;
9912 /* Fix up all variant types of this enum type. */
9913 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9915 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9916 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9917 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9918 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9919 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9920 TYPE_MODE (t) = TYPE_MODE (enumtype);
9921 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9922 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9923 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9924 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9927 /* Finish debugging output for this type. */
9928 rest_of_type_compilation (enumtype, namespace_bindings_p ());
9931 /* Build and install a CONST_DECL for an enumeration constant of the
9932 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9933 Assignment of sequential values by default is handled here. */
9936 build_enumerator (tree name, tree value, tree enumtype)
9942 /* If the VALUE was erroneous, pretend it wasn't there; that will
9943 result in the enum being assigned the next value in sequence. */
9944 if (value == error_mark_node)
9947 /* Remove no-op casts from the value. */
9949 STRIP_TYPE_NOPS (value);
9951 if (! processing_template_decl)
9953 /* Validate and default VALUE. */
9954 if (value != NULL_TREE)
9956 value = integral_constant_value (value);
9958 if (TREE_CODE (value) == INTEGER_CST)
9960 value = perform_integral_promotions (value);
9961 constant_expression_warning (value);
9965 error ("enumerator value for %qD not integer constant", name);
9970 /* Default based on previous value. */
9971 if (value == NULL_TREE)
9973 if (TYPE_VALUES (enumtype))
9976 unsigned HOST_WIDE_INT lo;
9980 /* The next value is the previous value plus one. We can
9981 safely assume that the previous value is an INTEGER_CST.
9982 add_double doesn't know the type of the target expression,
9983 so we must check with int_fits_type_p as well. */
9984 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9985 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
9986 TREE_INT_CST_HIGH (prev_value),
9988 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
9989 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
9993 error ("overflow in enumeration values at %qD", name);
9994 value = error_mark_node;
9998 value = integer_zero_node;
10001 /* Remove no-op casts from the value. */
10002 STRIP_TYPE_NOPS (value);
10005 /* C++ associates enums with global, function, or class declarations. */
10006 context = current_scope ();
10008 /* Build the actual enumeration constant. Note that the enumeration
10009 constants have the type of their initializers until the
10010 enumeration is complete:
10014 Following the closing brace of an enum-specifier, each enumer-
10015 ator has the type of its enumeration. Prior to the closing
10016 brace, the type of each enumerator is the type of its
10017 initializing value.
10019 In finish_enum we will reset the type. Of course, if we're
10020 processing a template, there may be no value. */
10021 type = value ? TREE_TYPE (value) : NULL_TREE;
10023 if (context && context == current_class_type)
10024 /* This enum declaration is local to the class. We need the full
10025 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10026 decl = build_lang_decl (CONST_DECL, name, type);
10028 /* It's a global enum, or it's local to a function. (Note local to
10029 a function could mean local to a class method. */
10030 decl = build_decl (CONST_DECL, name, type);
10032 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10033 TREE_CONSTANT (decl) = 1;
10034 TREE_INVARIANT (decl) = 1;
10035 TREE_READONLY (decl) = 1;
10036 DECL_INITIAL (decl) = value;
10038 if (context && context == current_class_type)
10039 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10040 on the TYPE_FIELDS list for `S'. (That's so that you can say
10041 things like `S::i' later.) */
10042 finish_member_declaration (decl);
10046 /* Add this enumeration constant to the list for this type. */
10047 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10051 /* We're defining DECL. Make sure that it's type is OK. */
10054 check_function_type (tree decl, tree current_function_parms)
10056 tree fntype = TREE_TYPE (decl);
10057 tree return_type = complete_type (TREE_TYPE (fntype));
10059 /* In a function definition, arg types must be complete. */
10060 require_complete_types_for_parms (current_function_parms);
10062 if (dependent_type_p (return_type))
10064 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10066 tree args = TYPE_ARG_TYPES (fntype);
10068 error ("return type %q#T is incomplete", return_type);
10070 /* Make it return void instead. */
10071 if (TREE_CODE (fntype) == METHOD_TYPE)
10072 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10074 TREE_CHAIN (args));
10076 fntype = build_function_type (void_type_node, args);
10078 = build_exception_variant (fntype,
10079 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10082 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10085 /* Create the FUNCTION_DECL for a function definition.
10086 DECLSPECS and DECLARATOR are the parts of the declaration;
10087 they describe the function's name and the type it returns,
10088 but twisted together in a fashion that parallels the syntax of C.
10090 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10091 DECLARATOR is really the DECL for the function we are about to
10092 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10093 indicating that the function is an inline defined in-class.
10095 This function creates a binding context for the function body
10096 as well as setting up the FUNCTION_DECL in current_function_decl.
10098 For C++, we must first check whether that datum makes any sense.
10099 For example, "class A local_a(1,2);" means that variable local_a
10100 is an aggregate of type A, which should have a constructor
10101 applied to it with the argument list [1, 2]. */
10104 start_preparsed_function (tree decl1, tree attrs, int flags)
10106 tree ctype = NULL_TREE;
10109 int doing_friend = 0;
10110 struct cp_binding_level *bl;
10111 tree current_function_parms;
10112 struct c_fileinfo *finfo
10113 = get_fileinfo (lbasename (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1))));
10114 bool honor_interface;
10116 /* Sanity check. */
10117 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10118 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10120 fntype = TREE_TYPE (decl1);
10121 if (TREE_CODE (fntype) == METHOD_TYPE)
10122 ctype = TYPE_METHOD_BASETYPE (fntype);
10124 /* ISO C++ 11.4/5. A friend function defined in a class is in
10125 the (lexical) scope of the class in which it is defined. */
10126 if (!ctype && DECL_FRIEND_P (decl1))
10128 ctype = DECL_FRIEND_CONTEXT (decl1);
10130 /* CTYPE could be null here if we're dealing with a template;
10131 for example, `inline friend float foo()' inside a template
10132 will have no CTYPE set. */
10133 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10139 if (DECL_DECLARED_INLINE_P (decl1)
10140 && lookup_attribute ("noinline", attrs))
10141 warning (0, "inline function %q+D given attribute noinline", decl1);
10143 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10144 /* This is a constructor, we must ensure that any default args
10145 introduced by this definition are propagated to the clones
10146 now. The clones are used directly in overload resolution. */
10147 adjust_clone_args (decl1);
10149 /* Sometimes we don't notice that a function is a static member, and
10150 build a METHOD_TYPE for it. Fix that up now. */
10151 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10152 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10154 revert_static_member_fn (decl1);
10158 /* Set up current_class_type, and enter the scope of the class, if
10161 push_nested_class (ctype);
10162 else if (DECL_STATIC_FUNCTION_P (decl1))
10163 push_nested_class (DECL_CONTEXT (decl1));
10165 /* Now that we have entered the scope of the class, we must restore
10166 the bindings for any template parameters surrounding DECL1, if it
10167 is an inline member template. (Order is important; consider the
10168 case where a template parameter has the same name as a field of
10169 the class.) It is not until after this point that
10170 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10171 if (flags & SF_INCLASS_INLINE)
10172 maybe_begin_member_template_processing (decl1);
10174 /* Effective C++ rule 15. */
10176 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10177 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10178 warning (0, "%<operator=%> should return a reference to %<*this%>");
10180 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10181 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10182 if (!DECL_INITIAL (decl1))
10183 DECL_INITIAL (decl1) = error_mark_node;
10185 /* This function exists in static storage.
10186 (This does not mean `static' in the C sense!) */
10187 TREE_STATIC (decl1) = 1;
10189 /* We must call push_template_decl after current_class_type is set
10190 up. (If we are processing inline definitions after exiting a
10191 class scope, current_class_type will be NULL_TREE until set above
10192 by push_nested_class.) */
10193 if (processing_template_decl)
10195 /* FIXME: Handle error_mark_node more gracefully. */
10196 tree newdecl1 = push_template_decl (decl1);
10197 if (newdecl1 != error_mark_node)
10201 /* We are now in the scope of the function being defined. */
10202 current_function_decl = decl1;
10204 /* Save the parm names or decls from this function's declarator
10205 where store_parm_decls will find them. */
10206 current_function_parms = DECL_ARGUMENTS (decl1);
10208 /* Make sure the parameter and return types are reasonable. When
10209 you declare a function, these types can be incomplete, but they
10210 must be complete when you define the function. */
10211 check_function_type (decl1, current_function_parms);
10212 /* Make sure no default arg is missing. */
10213 check_default_args (decl1);
10215 /* Build the return declaration for the function. */
10216 restype = TREE_TYPE (fntype);
10217 /* Promote the value to int before returning it. */
10218 if (c_promoting_integer_type_p (restype))
10219 restype = type_promotes_to (restype);
10220 if (DECL_RESULT (decl1) == NULL_TREE)
10224 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10225 DECL_ARTIFICIAL (resdecl) = 1;
10226 DECL_IGNORED_P (resdecl) = 1;
10227 DECL_RESULT (decl1) = resdecl;
10229 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
10232 /* Initialize RTL machinery. We cannot do this until
10233 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10234 even when processing a template; this is how we get
10235 CFUN set up, and our per-function variables initialized.
10236 FIXME factor out the non-RTL stuff. */
10237 bl = current_binding_level;
10238 allocate_struct_function (decl1);
10239 current_binding_level = bl;
10241 /* Even though we're inside a function body, we still don't want to
10242 call expand_expr to calculate the size of a variable-sized array.
10243 We haven't necessarily assigned RTL to all variables yet, so it's
10244 not safe to try to expand expressions involving them. */
10245 cfun->x_dont_save_pending_sizes_p = 1;
10247 /* Start the statement-tree, start the tree now. */
10248 DECL_SAVED_TREE (decl1) = push_stmt_list ();
10250 /* Let the user know we're compiling this function. */
10251 announce_function (decl1);
10253 /* Record the decl so that the function name is defined.
10254 If we already have a decl for this name, and it is a FUNCTION_DECL,
10255 use the old decl. */
10256 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10258 /* A specialization is not used to guide overload resolution. */
10259 if (!DECL_FUNCTION_MEMBER_P (decl1)
10260 && !(DECL_USE_TEMPLATE (decl1) &&
10261 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
10263 tree olddecl = pushdecl (decl1);
10265 if (olddecl == error_mark_node)
10266 /* If something went wrong when registering the declaration,
10267 use DECL1; we have to have a FUNCTION_DECL to use when
10268 parsing the body of the function. */
10271 /* Otherwise, OLDDECL is either a previous declaration of
10272 the same function or DECL1 itself. */
10277 /* We need to set the DECL_CONTEXT. */
10278 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10279 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10281 fntype = TREE_TYPE (decl1);
10283 /* If #pragma weak applies, mark the decl appropriately now.
10284 The pragma only applies to global functions. Because
10285 determining whether or not the #pragma applies involves
10286 computing the mangled name for the declaration, we cannot
10287 apply the pragma until after we have merged this declaration
10288 with any previous declarations; if the original declaration
10289 has a linkage specification, that specification applies to
10290 the definition as well, and may affect the mangled name. */
10291 if (!DECL_CONTEXT (decl1))
10292 maybe_apply_pragma_weak (decl1);
10295 /* Determine the ELF visibility attribute for the function. We must
10296 not do this before calling "pushdecl", as we must allow
10297 "duplicate_decls" to merge any attributes appropriately. */
10298 if (!DECL_CLONED_FUNCTION_P (decl1))
10299 determine_visibility (decl1);
10301 /* Reset these in case the call to pushdecl changed them. */
10302 current_function_decl = decl1;
10303 cfun->decl = decl1;
10305 /* If we are (erroneously) defining a function that we have already
10306 defined before, wipe out what we knew before. */
10307 if (!DECL_PENDING_INLINE_P (decl1))
10308 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10310 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10312 /* We know that this was set up by `grokclassfn'. We do not
10313 wait until `store_parm_decls', since evil parse errors may
10314 never get us to that point. Here we keep the consistency
10315 between `current_class_type' and `current_class_ptr'. */
10316 tree t = DECL_ARGUMENTS (decl1);
10318 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
10319 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
10321 cp_function_chain->x_current_class_ref
10322 = build_indirect_ref (t, NULL);
10323 cp_function_chain->x_current_class_ptr = t;
10325 /* Constructors and destructors need to know whether they're "in
10326 charge" of initializing virtual base classes. */
10327 t = TREE_CHAIN (t);
10328 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10330 current_in_charge_parm = t;
10331 t = TREE_CHAIN (t);
10333 if (DECL_HAS_VTT_PARM_P (decl1))
10335 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
10336 current_vtt_parm = t;
10340 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
10341 /* Implicitly-defined methods (like the
10342 destructor for a class in which no destructor
10343 is explicitly declared) must not be defined
10344 until their definition is needed. So, we
10345 ignore interface specifications for
10346 compiler-generated functions. */
10347 && !DECL_ARTIFICIAL (decl1));
10349 if (DECL_INTERFACE_KNOWN (decl1))
10351 tree ctx = decl_function_context (decl1);
10353 if (DECL_NOT_REALLY_EXTERN (decl1))
10354 DECL_EXTERNAL (decl1) = 0;
10356 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10357 && TREE_PUBLIC (ctx))
10358 /* This is a function in a local class in an extern inline
10360 comdat_linkage (decl1);
10362 /* If this function belongs to an interface, it is public.
10363 If it belongs to someone else's interface, it is also external.
10364 This only affects inlines and template instantiations. */
10365 else if (!finfo->interface_unknown && honor_interface)
10367 if (DECL_DECLARED_INLINE_P (decl1)
10368 || DECL_TEMPLATE_INSTANTIATION (decl1)
10369 || processing_template_decl)
10371 DECL_EXTERNAL (decl1)
10372 = (finfo->interface_only
10373 || (DECL_DECLARED_INLINE_P (decl1)
10374 && ! flag_implement_inlines
10375 && !DECL_VINDEX (decl1)));
10377 /* For WIN32 we also want to put these in linkonce sections. */
10378 maybe_make_one_only (decl1);
10381 DECL_EXTERNAL (decl1) = 0;
10382 DECL_INTERFACE_KNOWN (decl1) = 1;
10383 /* If this function is in an interface implemented in this file,
10384 make sure that the backend knows to emit this function
10386 if (!DECL_EXTERNAL (decl1))
10387 mark_needed (decl1);
10389 else if (finfo->interface_unknown && finfo->interface_only
10390 && honor_interface)
10392 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10393 interface, we will have both finfo->interface_unknown and
10394 finfo->interface_only set. In that case, we don't want to
10395 use the normal heuristics because someone will supply a
10396 #pragma implementation elsewhere, and deducing it here would
10397 produce a conflict. */
10398 comdat_linkage (decl1);
10399 DECL_EXTERNAL (decl1) = 0;
10400 DECL_INTERFACE_KNOWN (decl1) = 1;
10401 DECL_DEFER_OUTPUT (decl1) = 1;
10405 /* This is a definition, not a reference.
10406 So clear DECL_EXTERNAL. */
10407 DECL_EXTERNAL (decl1) = 0;
10409 if ((DECL_DECLARED_INLINE_P (decl1)
10410 || DECL_TEMPLATE_INSTANTIATION (decl1))
10411 && ! DECL_INTERFACE_KNOWN (decl1)
10412 /* Don't try to defer nested functions for now. */
10413 && ! decl_function_context (decl1))
10414 DECL_DEFER_OUTPUT (decl1) = 1;
10416 DECL_INTERFACE_KNOWN (decl1) = 1;
10419 begin_scope (sk_function_parms, decl1);
10423 if (DECL_DESTRUCTOR_P (decl1)
10424 || (DECL_CONSTRUCTOR_P (decl1)
10425 && targetm.cxx.cdtor_returns_this ()))
10427 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10428 DECL_CONTEXT (cdtor_label) = current_function_decl;
10431 start_fname_decls ();
10433 store_parm_decls (current_function_parms);
10437 /* Like start_preparsed_function, except that instead of a
10438 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
10440 Returns 1 on success. If the DECLARATOR is not suitable for a function
10441 (it defines a datum instead), we return 0, which tells
10442 yyparse to report a parse error. */
10445 start_function (cp_decl_specifier_seq *declspecs,
10446 const cp_declarator *declarator,
10451 if (have_extern_spec)
10453 declspecs->storage_class = sc_extern;
10454 /* This should only be done once on the outermost decl. */
10455 have_extern_spec = false;
10458 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10459 /* If the declarator is not suitable for a function definition,
10460 cause a syntax error. */
10461 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10464 if (DECL_MAIN_P (decl1))
10465 /* main must return int. grokfndecl should have corrected it
10466 (and issued a diagnostic) if the user got it wrong. */
10467 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
10468 integer_type_node));
10470 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
10475 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
10479 use_eh_spec_block (tree fn)
10481 return (flag_exceptions && flag_enforce_eh_specs
10482 && !processing_template_decl
10483 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
10484 /* We insert the EH_SPEC_BLOCK only in the original
10485 function; then, it is copied automatically to the
10487 && !DECL_CLONED_FUNCTION_P (fn)
10488 /* Implicitly-generated constructors and destructors have
10489 exception specifications. However, those specifications
10490 are the union of the possible exceptions specified by the
10491 constructors/destructors for bases and members, so no
10492 unallowed exception will ever reach this function. By
10493 not creating the EH_SPEC_BLOCK we save a little memory,
10494 and we avoid spurious warnings about unreachable
10496 && !DECL_ARTIFICIAL (fn));
10499 /* Store the parameter declarations into the current function declaration.
10500 This is called after parsing the parameter declarations, before
10501 digesting the body of the function.
10503 Also install to binding contour return value identifier, if any. */
10506 store_parm_decls (tree current_function_parms)
10508 tree fndecl = current_function_decl;
10511 /* This is a chain of any other decls that came in among the parm
10512 declarations. If a parm is declared with enum {foo, bar} x;
10513 then CONST_DECLs for foo and bar are put here. */
10514 tree nonparms = NULL_TREE;
10516 if (current_function_parms)
10518 /* This case is when the function was defined with an ANSI prototype.
10519 The parms already have decls, so we need not do anything here
10520 except record them as in effect
10521 and complain if any redundant old-style parm decls were written. */
10523 tree specparms = current_function_parms;
10526 /* Must clear this because it might contain TYPE_DECLs declared
10528 current_binding_level->names = NULL;
10530 /* If we're doing semantic analysis, then we'll call pushdecl
10531 for each of these. We must do them in reverse order so that
10532 they end in the correct forward order. */
10533 specparms = nreverse (specparms);
10535 for (parm = specparms; parm; parm = next)
10537 next = TREE_CHAIN (parm);
10538 if (TREE_CODE (parm) == PARM_DECL)
10540 if (DECL_NAME (parm) == NULL_TREE
10541 || TREE_CODE (parm) != VOID_TYPE)
10544 error ("parameter %qD declared void", parm);
10548 /* If we find an enum constant or a type tag,
10549 put it aside for the moment. */
10550 TREE_CHAIN (parm) = NULL_TREE;
10551 nonparms = chainon (nonparms, parm);
10555 /* Get the decls in their original chain order and record in the
10556 function. This is all and only the PARM_DECLs that were
10557 pushed into scope by the loop above. */
10558 DECL_ARGUMENTS (fndecl) = getdecls ();
10561 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10563 /* Now store the final chain of decls for the arguments
10564 as the decl-chain of the current lexical scope.
10565 Put the enumerators in as well, at the front so that
10566 DECL_ARGUMENTS is not modified. */
10567 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10569 if (use_eh_spec_block (current_function_decl))
10570 current_eh_spec_block = begin_eh_spec_block ();
10574 /* We have finished doing semantic analysis on DECL, but have not yet
10575 generated RTL for its body. Save away our current state, so that
10576 when we want to generate RTL later we know what to do. */
10579 save_function_data (tree decl)
10581 struct language_function *f;
10583 /* Save the language-specific per-function data so that we can
10584 get it back when we really expand this function. */
10585 gcc_assert (!DECL_PENDING_INLINE_P (decl));
10588 f = GGC_NEW (struct language_function);
10589 memcpy (f, cp_function_chain, sizeof (struct language_function));
10590 DECL_SAVED_FUNCTION_DATA (decl) = f;
10592 /* Clear out the bits we don't need. */
10593 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10594 f->x_named_label_uses = NULL;
10595 f->bindings = NULL;
10596 f->x_local_names = NULL;
10600 /* Set the return value of the constructor (if present). */
10603 finish_constructor_body (void)
10608 if (targetm.cxx.cdtor_returns_this ())
10610 /* Any return from a constructor will end up here. */
10611 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10613 val = DECL_ARGUMENTS (current_function_decl);
10614 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10615 DECL_RESULT (current_function_decl), val);
10616 /* Return the address of the object. */
10617 exprstmt = build_stmt (RETURN_EXPR, val);
10618 add_stmt (exprstmt);
10622 /* Do all the processing for the beginning of a destructor; set up the
10623 vtable pointers and cleanups for bases and members. */
10626 begin_destructor_body (void)
10629 tree compound_stmt;
10631 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
10632 issued an error message. We still want to try to process the
10633 body of the function, but initialize_vtbl_ptrs will crash if
10634 TYPE_BINFO is NULL. */
10635 if (!COMPLETE_TYPE_P (current_class_type))
10638 /* If the dtor is empty, and we know there is not any possible
10639 way we could use any vtable entries, before they are possibly
10640 set by a base class dtor, we don't have to setup the vtables,
10641 as we know that any base class dtor will set up any vtables
10642 it needs. We avoid MI, because one base class dtor can do a
10643 virtual dispatch to an overridden function that would need to
10644 have a non-related vtable set up, we cannot avoid setting up
10645 vtables in that case. We could change this to see if there
10646 is just one vtable.
10648 ??? In the destructor for a class, the vtables are set
10649 appropriately for that class. There will be no non-related
10650 vtables. jason 2001-12-11. */
10651 if_stmt = begin_if_stmt ();
10653 /* If it is not safe to avoid setting up the vtables, then
10654 someone will change the condition to be boolean_true_node.
10655 (Actually, for now, we do not have code to set the condition
10656 appropriately, so we just assume that we always need to
10657 initialize the vtables.) */
10658 finish_if_stmt_cond (boolean_true_node, if_stmt);
10660 compound_stmt = begin_compound_stmt (0);
10662 /* Make all virtual function table pointers in non-virtual base
10663 classes point to CURRENT_CLASS_TYPE's virtual function
10665 initialize_vtbl_ptrs (current_class_ptr);
10667 finish_compound_stmt (compound_stmt);
10668 finish_then_clause (if_stmt);
10669 finish_if_stmt (if_stmt);
10671 /* And insert cleanups for our bases and members so that they
10672 will be properly destroyed if we throw. */
10673 push_base_cleanups ();
10676 /* At the end of every destructor we generate code to delete the object if
10677 necessary. Do that now. */
10680 finish_destructor_body (void)
10684 /* Any return from a destructor will end up here; that way all base
10685 and member cleanups will be run when the function returns. */
10686 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10688 /* In a virtual destructor, we must call delete. */
10689 if (DECL_VIRTUAL_P (current_function_decl))
10692 tree virtual_size = cxx_sizeof (current_class_type);
10696 At the point of definition of a virtual destructor (including
10697 an implicit definition), non-placement operator delete shall
10698 be looked up in the scope of the destructor's class and if
10699 found shall be accessible and unambiguous. */
10700 exprstmt = build_op_delete_call
10701 (DELETE_EXPR, current_class_ptr, virtual_size,
10702 /*global_p=*/false, NULL_TREE);
10704 if_stmt = begin_if_stmt ();
10705 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
10706 current_in_charge_parm,
10709 finish_expr_stmt (exprstmt);
10710 finish_then_clause (if_stmt);
10711 finish_if_stmt (if_stmt);
10714 if (targetm.cxx.cdtor_returns_this ())
10718 val = DECL_ARGUMENTS (current_function_decl);
10719 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10720 DECL_RESULT (current_function_decl), val);
10721 /* Return the address of the object. */
10722 exprstmt = build_stmt (RETURN_EXPR, val);
10723 add_stmt (exprstmt);
10727 /* Do the necessary processing for the beginning of a function body, which
10728 in this case includes member-initializers, but not the catch clauses of
10729 a function-try-block. Currently, this means opening a binding level
10730 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
10733 begin_function_body (void)
10737 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10740 if (processing_template_decl)
10741 /* Do nothing now. */;
10743 /* Always keep the BLOCK node associated with the outermost pair of
10744 curly braces of a function. These are needed for correct
10745 operation of dwarfout.c. */
10746 keep_next_level (true);
10748 stmt = begin_compound_stmt (BCS_FN_BODY);
10750 if (processing_template_decl)
10751 /* Do nothing now. */;
10752 else if (DECL_DESTRUCTOR_P (current_function_decl))
10753 begin_destructor_body ();
10758 /* Do the processing for the end of a function body. Currently, this means
10759 closing out the cleanups for fully-constructed bases and members, and in
10760 the case of the destructor, deleting the object if desired. Again, this
10761 is only meaningful for [cd]tors, since they are the only functions where
10762 there is a significant distinction between the main body and any
10763 function catch clauses. Handling, say, main() return semantics here
10764 would be wrong, as flowing off the end of a function catch clause for
10765 main() would also need to return 0. */
10768 finish_function_body (tree compstmt)
10770 if (compstmt == NULL_TREE)
10773 /* Close the block. */
10774 finish_compound_stmt (compstmt);
10776 if (processing_template_decl)
10777 /* Do nothing now. */;
10778 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10779 finish_constructor_body ();
10780 else if (DECL_DESTRUCTOR_P (current_function_decl))
10781 finish_destructor_body ();
10784 /* Given a function, returns the BLOCK corresponding to the outermost level
10785 of curly braces, skipping the artificial block created for constructor
10789 outer_curly_brace_block (tree fndecl)
10791 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
10792 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10793 /* Skip the artificial function body block. */
10794 block = BLOCK_SUBBLOCKS (block);
10798 /* Finish up a function declaration and compile that function
10799 all the way to assembler language output. The free the storage
10800 for the function definition.
10802 FLAGS is a bitwise or of the following values:
10804 We just finished processing the body of an in-class inline
10805 function definition. (This processing will have taken place
10806 after the class definition is complete.) */
10809 finish_function (int flags)
10811 tree fndecl = current_function_decl;
10812 tree fntype, ctype = NULL_TREE;
10813 int inclass_inline = (flags & 2) != 0;
10816 /* When we get some parse errors, we can end up without a
10817 current_function_decl, so cope. */
10818 if (fndecl == NULL_TREE)
10819 return error_mark_node;
10821 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10822 && DECL_VIRTUAL_P (fndecl)
10823 && !processing_template_decl)
10825 tree fnclass = DECL_CONTEXT (fndecl);
10826 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10827 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10830 nested = function_depth > 1;
10831 fntype = TREE_TYPE (fndecl);
10833 /* TREE_READONLY (fndecl) = 1;
10834 This caused &foo to be of type ptr-to-const-function
10835 which then got a warning when stored in a ptr-to-function variable. */
10837 gcc_assert (building_stmt_tree ());
10839 /* For a cloned function, we've already got all the code we need;
10840 there's no need to add any extra bits. */
10841 if (!DECL_CLONED_FUNCTION_P (fndecl))
10843 if (DECL_MAIN_P (current_function_decl))
10847 /* Make it so that `main' always returns 0 by default (or
10850 stmt = finish_return_stmt (integer_one_node);
10852 stmt = finish_return_stmt (integer_zero_node);
10854 /* Hack. We don't want the middle-end to warn that this
10855 return is unreachable, so put the statement on the
10857 #ifdef USE_MAPPED_LOCATION
10858 SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
10860 annotate_with_file_line (stmt, input_filename, 0);
10864 if (use_eh_spec_block (current_function_decl))
10865 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10866 (TREE_TYPE (current_function_decl)),
10867 current_eh_spec_block);
10870 /* If we're saving up tree structure, tie off the function now. */
10871 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10873 finish_fname_decls ();
10875 /* If this function can't throw any exceptions, remember that. */
10876 if (!processing_template_decl
10877 && !cp_function_chain->can_throw
10878 && !flag_non_call_exceptions)
10879 TREE_NOTHROW (fndecl) = 1;
10881 /* This must come after expand_function_end because cleanups might
10882 have declarations (from inline functions) that need to go into
10883 this function's blocks. */
10885 /* If the current binding level isn't the outermost binding level
10886 for this function, either there is a bug, or we have experienced
10887 syntax errors and the statement tree is malformed. */
10888 if (current_binding_level->kind != sk_function_parms)
10890 /* Make sure we have already experienced errors. */
10891 gcc_assert (errorcount);
10893 /* Throw away the broken statement tree and extra binding
10895 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10897 while (current_binding_level->kind != sk_function_parms)
10899 if (current_binding_level->kind == sk_class)
10900 pop_nested_class ();
10902 poplevel (0, 0, 0);
10905 poplevel (1, 0, 1);
10907 /* Statements should always be full-expressions at the outermost set
10908 of curly braces for a function. */
10909 gcc_assert (stmts_are_full_exprs_p ());
10911 /* Set up the named return value optimization, if we can. Candidate
10912 variables are selected in check_return_value. */
10913 if (current_function_return_value)
10915 tree r = current_function_return_value;
10918 if (r != error_mark_node
10919 /* This is only worth doing for fns that return in memory--and
10920 simpler, since we don't have to worry about promoted modes. */
10921 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10922 /* Only allow this for variables declared in the outer scope of
10923 the function so we know that their lifetime always ends with a
10924 return; see g++.dg/opt/nrv6.C. We could be more flexible if
10925 we were to do this optimization in tree-ssa. */
10926 && (outer = outer_curly_brace_block (fndecl))
10927 && chain_member (r, BLOCK_VARS (outer)))
10928 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10930 current_function_return_value = NULL_TREE;
10933 /* Remember that we were in class scope. */
10934 if (current_class_name)
10935 ctype = current_class_type;
10937 /* Must mark the RESULT_DECL as being in this function. */
10938 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10940 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10941 to the FUNCTION_DECL node itself. */
10942 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10944 /* Save away current state, if appropriate. */
10945 if (!processing_template_decl)
10946 save_function_data (fndecl);
10948 /* Complain if there's just no return statement. */
10949 if (warn_return_type
10950 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10951 && !dependent_type_p (TREE_TYPE (fntype))
10952 && !current_function_returns_value && !current_function_returns_null
10953 /* Don't complain if we abort or throw. */
10954 && !current_function_returns_abnormally
10955 && !DECL_NAME (DECL_RESULT (fndecl))
10956 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
10957 inline function, as we might never be compiled separately. */
10958 && (DECL_INLINE (fndecl) || processing_template_decl)
10959 /* Structor return values (if any) are set by the compiler. */
10960 && !DECL_CONSTRUCTOR_P (fndecl)
10961 && !DECL_DESTRUCTOR_P (fndecl))
10962 warning (0, "no return statement in function returning non-void");
10964 /* Store the end of the function, so that we get good line number
10965 info for the epilogue. */
10966 cfun->function_end_locus = input_location;
10968 /* Genericize before inlining. */
10969 if (!processing_template_decl)
10971 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
10972 cp_genericize (fndecl);
10973 /* Clear out the bits we don't need. */
10974 f->x_current_class_ptr = NULL;
10975 f->x_current_class_ref = NULL;
10976 f->x_eh_spec_block = NULL;
10977 f->x_in_charge_parm = NULL;
10978 f->x_vtt_parm = NULL;
10979 f->x_return_value = NULL;
10980 f->bindings = NULL;
10982 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
10983 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10985 /* Clear out the bits we don't need. */
10986 local_names = NULL;
10987 named_label_uses = NULL;
10989 /* We're leaving the context of this function, so zap cfun. It's still in
10990 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
10992 current_function_decl = NULL;
10994 /* If this is an in-class inline definition, we may have to pop the
10995 bindings for the template parameters that we added in
10996 maybe_begin_member_template_processing when start_function was
10998 if (inclass_inline)
10999 maybe_end_member_template_processing ();
11001 /* Leave the scope of the class. */
11003 pop_nested_class ();
11009 /* Let the error reporting routines know that we're outside a
11010 function. For a nested function, this value is used in
11011 cxx_pop_function_context and then reset via pop_function_context. */
11012 current_function_decl = NULL_TREE;
11017 /* Create the FUNCTION_DECL for a function definition.
11018 DECLSPECS and DECLARATOR are the parts of the declaration;
11019 they describe the return type and the name of the function,
11020 but twisted together in a fashion that parallels the syntax of C.
11022 This function creates a binding context for the function body
11023 as well as setting up the FUNCTION_DECL in current_function_decl.
11025 Returns a FUNCTION_DECL on success.
11027 If the DECLARATOR is not suitable for a function (it defines a datum
11028 instead), we return 0, which tells yyparse to report a parse error.
11030 May return void_type_node indicating that this method is actually
11031 a friend. See grokfield for more details.
11033 Came here with a `.pushlevel' .
11035 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11036 CHANGES TO CODE IN `grokfield'. */
11039 start_method (cp_decl_specifier_seq *declspecs,
11040 const cp_declarator *declarator, tree attrlist)
11042 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11045 if (fndecl == error_mark_node)
11046 return error_mark_node;
11048 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11050 error ("invalid member function declaration");
11051 return error_mark_node;
11055 cplus_decl_attributes (&fndecl, attrlist, 0);
11057 /* Pass friends other than inline friend functions back. */
11058 if (fndecl == void_type_node)
11061 if (DECL_IN_AGGR_P (fndecl))
11063 if (DECL_CONTEXT (fndecl)
11064 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11065 error ("%qD is already defined in class %qT", fndecl,
11066 DECL_CONTEXT (fndecl));
11067 return error_mark_node;
11070 check_template_shadow (fndecl);
11072 DECL_DECLARED_INLINE_P (fndecl) = 1;
11073 if (flag_default_inline)
11074 DECL_INLINE (fndecl) = 1;
11076 /* We process method specializations in finish_struct_1. */
11077 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11079 fndecl = push_template_decl (fndecl);
11080 if (fndecl == error_mark_node)
11084 if (! DECL_FRIEND_P (fndecl))
11086 if (TREE_CHAIN (fndecl))
11088 fndecl = copy_node (fndecl);
11089 TREE_CHAIN (fndecl) = NULL_TREE;
11091 grok_special_member_properties (fndecl);
11094 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11096 /* Make a place for the parms. */
11097 begin_scope (sk_function_parms, fndecl);
11099 DECL_IN_AGGR_P (fndecl) = 1;
11103 /* Go through the motions of finishing a function definition.
11104 We don't compile this method until after the whole class has
11107 FINISH_METHOD must return something that looks as though it
11108 came from GROKFIELD (since we are defining a method, after all).
11110 This is called after parsing the body of the function definition.
11111 STMTS is the chain of statements that makes up the function body.
11113 DECL is the ..._DECL that `start_method' provided. */
11116 finish_method (tree decl)
11118 tree fndecl = decl;
11123 if (decl == void_type_node)
11126 old_initial = DECL_INITIAL (fndecl);
11128 /* Undo the level for the parms (from start_method).
11129 This is like poplevel, but it causes nothing to be
11130 saved. Saving information here confuses symbol-table
11131 output routines. Besides, this information will
11132 be correctly output when this method is actually
11135 /* Clear out the meanings of the local variables of this level;
11136 also record in each decl which block it belongs to. */
11138 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11140 if (DECL_NAME (link) != NULL_TREE)
11141 pop_binding (DECL_NAME (link), link);
11142 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11143 DECL_CONTEXT (link) = NULL_TREE;
11146 poplevel (0, 0, 0);
11148 DECL_INITIAL (fndecl) = old_initial;
11150 /* We used to check if the context of FNDECL was different from
11151 current_class_type as another way to get inside here. This didn't work
11152 for String.cc in libg++. */
11153 if (DECL_FRIEND_P (fndecl))
11155 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
11157 decl = void_type_node;
11164 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11165 we can lay it out later, when and if its type becomes complete. */
11168 maybe_register_incomplete_var (tree var)
11170 gcc_assert (TREE_CODE (var) == VAR_DECL);
11172 /* Keep track of variables with incomplete types. */
11173 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11174 && DECL_EXTERNAL (var))
11176 tree inner_type = TREE_TYPE (var);
11178 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11179 inner_type = TREE_TYPE (inner_type);
11180 inner_type = TYPE_MAIN_VARIANT (inner_type);
11182 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11183 /* RTTI TD entries are created while defining the type_info. */
11184 || (TYPE_LANG_SPECIFIC (inner_type)
11185 && TYPE_BEING_DEFINED (inner_type)))
11186 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11190 /* Called when a class type (given by TYPE) is defined. If there are
11191 any existing VAR_DECLs whose type hsa been completed by this
11192 declaration, update them now. */
11195 complete_vars (tree type)
11197 tree *list = &incomplete_vars;
11199 gcc_assert (CLASS_TYPE_P (type));
11202 if (same_type_p (type, TREE_PURPOSE (*list)))
11204 tree var = TREE_VALUE (*list);
11205 tree type = TREE_TYPE (var);
11206 /* Complete the type of the variable. The VAR_DECL itself
11207 will be laid out in expand_expr. */
11208 complete_type (type);
11209 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
11210 /* Remove this entry from the list. */
11211 *list = TREE_CHAIN (*list);
11214 list = &TREE_CHAIN (*list);
11217 /* Check for pending declarations which may have abstract type. */
11218 complete_type_check_abstract (type);
11221 /* If DECL is of a type which needs a cleanup, build that cleanup
11225 cxx_maybe_build_cleanup (tree decl)
11227 tree type = TREE_TYPE (decl);
11229 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
11231 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11233 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
11234 && CLASSTYPE_VBASECLASSES (type));
11236 if (TREE_CODE (type) == ARRAY_TYPE)
11240 cxx_mark_addressable (decl);
11241 rval = build_unary_op (ADDR_EXPR, decl, 0);
11244 /* Optimize for space over speed here. */
11245 if (!has_vbases || flag_expensive_optimizations)
11246 flags |= LOOKUP_NONVIRTUAL;
11248 rval = build_delete (TREE_TYPE (rval), rval,
11249 sfk_complete_destructor, flags, 0);
11256 /* When a stmt has been parsed, this function is called. */
11263 /* DECL was originally constructed as a non-static member function,
11264 but turned out to be static. Update it accordingly. */
11267 revert_static_member_fn (tree decl)
11270 tree function = TREE_TYPE (decl);
11271 tree args = TYPE_ARG_TYPES (function);
11273 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
11274 != TYPE_UNQUALIFIED)
11275 error ("static member function %q#D declared with type qualifiers", decl);
11277 args = TREE_CHAIN (args);
11278 tmp = build_function_type (TREE_TYPE (function), args);
11279 tmp = build_qualified_type (tmp, cp_type_quals (function));
11280 tmp = build_exception_variant (tmp,
11281 TYPE_RAISES_EXCEPTIONS (function));
11282 TREE_TYPE (decl) = tmp;
11283 if (DECL_ARGUMENTS (decl))
11284 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
11285 DECL_STATIC_FUNCTION_P (decl) = 1;
11288 /* Initialize the variables used during compilation of a C++
11292 cxx_push_function_context (struct function * f)
11294 struct language_function *p = GGC_CNEW (struct language_function);
11297 /* Whenever we start a new function, we destroy temporaries in the
11299 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11305 if (DECL_SAVED_FUNCTION_DATA (fn))
11307 /* If we already parsed this function, and we're just expanding it
11308 now, restore saved state. */
11309 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11311 /* We don't need the saved data anymore. Unless this is an inline
11312 function; we need the named return value info for
11313 declare_return_variable. */
11314 if (! DECL_INLINE (fn))
11315 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11320 /* Free the language-specific parts of F, now that we've finished
11321 compiling the function. */
11324 cxx_pop_function_context (struct function * f)
11329 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11330 one of the language-independent trees. */
11332 enum cp_tree_node_structure_enum
11333 cp_tree_node_structure (union lang_tree_node * t)
11335 switch (TREE_CODE (&t->generic))
11337 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
11338 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
11339 case OVERLOAD: return TS_CP_OVERLOAD;
11340 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
11341 case TINST_LEVEL: return TS_CP_TINST_LEVEL;
11342 case PTRMEM_CST: return TS_CP_PTRMEM;
11343 case BASELINK: return TS_CP_BASELINK;
11344 default: return TS_CP_GENERIC;
11348 /* Build the void_list_node (void_type_node having been created). */
11350 build_void_list_node (void)
11352 tree t = build_tree_list (NULL_TREE, void_type_node);
11357 cp_missing_noreturn_ok_p (tree decl)
11359 /* A missing noreturn is ok for the `main' function. */
11360 return DECL_MAIN_P (decl);
11363 /* Return the COMDAT group into which DECL should be placed. */
11366 cxx_comdat_group (tree decl)
11370 /* Virtual tables, construction virtual tables, and virtual table
11371 tables all go in a single COMDAT group, named after the primary
11373 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
11374 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
11375 /* For all other DECLs, the COMDAT group is the mangled name of the
11376 declaration itself. */
11379 while (DECL_THUNK_P (decl))
11381 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
11382 into the same section as the target function. In that case
11383 we must return target's name. */
11384 tree target = THUNK_TARGET (decl);
11385 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
11386 && DECL_SECTION_NAME (target) != NULL
11387 && DECL_ONE_ONLY (target))
11392 name = DECL_ASSEMBLER_NAME (decl);
11395 return IDENTIFIER_POINTER (name);
11398 #include "gt-cp-decl.h"