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, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
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"
38 #include "tree-iterator.h"
39 #include "tree-inline.h"
47 #include "c-family/c-common.h"
48 #include "c-family/c-pragma.h"
49 #include "diagnostic.h"
53 #include "tree-flow.h"
54 #include "pointer-set.h"
55 #include "splay-tree.h"
58 /* Possible cases of bad specifiers type used by bad_specifiers. */
60 BSP_VAR, /* variable */
61 BSP_PARM, /* parameter */
66 static tree grokparms (tree parmlist, tree *);
67 static const char *redeclaration_error_message (tree, tree);
69 static int decl_jump_unsafe (tree);
70 static void require_complete_types_for_parms (tree);
71 static int ambi_op_p (enum tree_code);
72 static int unary_op_p (enum tree_code);
73 static void push_local_name (tree);
74 static tree grok_reference_init (tree, tree, tree, tree *);
75 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
77 static void record_unknown_type (tree, const char *);
78 static tree builtin_function_1 (tree, tree, bool);
79 static tree build_library_fn_1 (tree, enum tree_code, tree);
80 static int member_function_or_else (tree, tree, enum overload_flags);
81 static void bad_specifiers (tree, enum bad_spec_place, int, int, int, int,
83 static void check_for_uninitialized_const_var (tree);
84 static hashval_t typename_hash (const void *);
85 static int typename_compare (const void *, const void *);
86 static tree local_variable_p_walkfn (tree *, int *, void *);
87 static tree record_builtin_java_type (const char *, int);
88 static const char *tag_name (enum tag_types);
89 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
90 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
91 static void maybe_deduce_size_from_array_init (tree, tree);
92 static void layout_var_decl (tree);
93 static tree check_initializer (tree, tree, int, tree *);
94 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
95 static void save_function_data (tree);
96 static void check_function_type (tree, tree);
97 static void finish_constructor_body (void);
98 static void begin_destructor_body (void);
99 static void finish_destructor_body (void);
100 static void record_key_method_defined (tree);
101 static tree create_array_type_for_decl (tree, tree, tree);
102 static tree get_atexit_node (void);
103 static tree get_dso_handle_node (void);
104 static tree start_cleanup_fn (void);
105 static void end_cleanup_fn (void);
106 static tree cp_make_fname_decl (location_t, tree, int);
107 static void initialize_predefined_identifiers (void);
108 static tree check_special_function_return_type
109 (special_function_kind, tree, tree);
110 static tree push_cp_library_fn (enum tree_code, tree);
111 static tree build_cp_library_fn (tree, enum tree_code, tree);
112 static void store_parm_decls (tree);
113 static void initialize_local_var (tree, tree);
114 static void expand_static_init (tree, tree);
116 /* The following symbols are subsumed in the cp_global_trees array, and
117 listed here individually for documentation purposes.
120 tree wchar_decl_node;
122 tree vtable_entry_type;
123 tree delta_type_node;
124 tree __t_desc_type_node;
126 tree class_type_node;
127 tree unknown_type_node;
129 Array type `vtable_entry_type[]'
132 tree vtbl_ptr_type_node;
139 A FUNCTION_DECL which can call `abort'. Not necessarily the
140 one that the user will declare, but sufficient to be called
141 by routines that want to abort the program.
145 The FUNCTION_DECL for the default `::operator delete'.
147 tree global_delete_fndecl;
150 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
151 tree tinfo_var_id; */
153 tree cp_global_trees[CPTI_MAX];
155 /* Indicates that there is a type value in some namespace, although
156 that is not necessarily in scope at the moment. */
158 tree global_type_node;
160 /* The node that holds the "name" of the global scope. */
161 tree global_scope_name;
163 #define local_names cp_function_chain->x_local_names
165 /* A list of objects which have constructors or destructors
166 which reside in the global scope. The decl is stored in
167 the TREE_VALUE slot and the initializer is stored
168 in the TREE_PURPOSE slot. */
169 tree static_aggregates;
173 /* A node for the integer constants 2, and 3. */
175 tree integer_two_node, integer_three_node;
177 /* Used only for jumps to as-yet undefined labels, since jumps to
178 defined labels can have their validity checked immediately. */
180 struct GTY(()) named_label_use_entry {
181 struct named_label_use_entry *next;
182 /* The binding level to which this entry is *currently* attached.
183 This is initially the binding level in which the goto appeared,
184 but is modified as scopes are closed. */
185 struct cp_binding_level *binding_level;
186 /* The head of the names list that was current when the goto appeared,
187 or the inner scope popped. These are the decls that will *not* be
188 skipped when jumping to the label. */
190 /* The location of the goto, for error reporting. */
191 location_t o_goto_locus;
192 /* True if an OpenMP structured block scope has been closed since
193 the goto appeared. This means that the branch from the label will
194 illegally exit an OpenMP scope. */
198 /* A list of all LABEL_DECLs in the function that have names. Here so
199 we can clear out their names' definitions at the end of the
200 function, and so we can check the validity of jumps to these labels. */
202 struct GTY(()) named_label_entry {
203 /* The decl itself. */
206 /* The binding level to which the label is *currently* attached.
207 This is initially set to the binding level in which the label
208 is defined, but is modified as scopes are closed. */
209 struct cp_binding_level *binding_level;
210 /* The head of the names list that was current when the label was
211 defined, or the inner scope popped. These are the decls that will
212 be skipped when jumping to the label. */
214 /* A tree list of all decls from all binding levels that would be
215 crossed by a backward branch to the label. */
218 /* A list of uses of the label, before the label is defined. */
219 struct named_label_use_entry *uses;
221 /* The following bits are set after the label is defined, and are
222 updated as scopes are popped. They indicate that a backward jump
223 to the label will illegally enter a scope of the given flavor. */
229 #define named_labels cp_function_chain->x_named_labels
231 /* The number of function bodies which we are currently processing.
232 (Zero if we are at namespace scope, one inside the body of a
233 function, two inside the body of a function in a local class, etc.) */
236 /* To avoid unwanted recursion, finish_function defers all mark_used calls
237 encountered during its execution until it finishes. */
238 bool defer_mark_used_calls;
239 VEC(tree, gc) *deferred_mark_used_calls;
241 /* States indicating how grokdeclarator() should handle declspecs marked
242 with __attribute__((deprecated)). An object declared as
243 __attribute__((deprecated)) suppresses warnings of uses of other
245 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
248 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
249 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
250 time the VAR_DECL was declared, the type was incomplete. */
252 static GTY(()) tree incomplete_vars;
254 /* Returns the kind of template specialization we are currently
255 processing, given that it's declaration contained N_CLASS_SCOPES
256 explicit scope qualifications. */
259 current_tmpl_spec_kind (int n_class_scopes)
261 int n_template_parm_scopes = 0;
262 int seen_specialization_p = 0;
263 int innermost_specialization_p = 0;
264 struct cp_binding_level *b;
266 /* Scan through the template parameter scopes. */
267 for (b = current_binding_level;
268 b->kind == sk_template_parms;
271 /* If we see a specialization scope inside a parameter scope,
272 then something is wrong. That corresponds to a declaration
275 template <class T> template <> ...
277 which is always invalid since [temp.expl.spec] forbids the
278 specialization of a class member template if the enclosing
279 class templates are not explicitly specialized as well. */
280 if (b->explicit_spec_p)
282 if (n_template_parm_scopes == 0)
283 innermost_specialization_p = 1;
285 seen_specialization_p = 1;
287 else if (seen_specialization_p == 1)
288 return tsk_invalid_member_spec;
290 ++n_template_parm_scopes;
293 /* Handle explicit instantiations. */
294 if (processing_explicit_instantiation)
296 if (n_template_parm_scopes != 0)
297 /* We've seen a template parameter list during an explicit
298 instantiation. For example:
300 template <class T> template void f(int);
302 This is erroneous. */
303 return tsk_invalid_expl_inst;
305 return tsk_expl_inst;
308 if (n_template_parm_scopes < n_class_scopes)
309 /* We've not seen enough template headers to match all the
310 specialized classes present. For example:
312 template <class T> void R<T>::S<T>::f(int);
314 This is invalid; there needs to be one set of template
315 parameters for each class. */
316 return tsk_insufficient_parms;
317 else if (n_template_parm_scopes == n_class_scopes)
318 /* We're processing a non-template declaration (even though it may
319 be a member of a template class.) For example:
321 template <class T> void S<T>::f(int);
323 The `class T' matches the `S<T>', leaving no template headers
324 corresponding to the `f'. */
326 else if (n_template_parm_scopes > n_class_scopes + 1)
327 /* We've got too many template headers. For example:
329 template <> template <class T> void f (T);
331 There need to be more enclosing classes. */
332 return tsk_excessive_parms;
334 /* This must be a template. It's of the form:
336 template <class T> template <class U> void S<T>::f(U);
338 This is a specialization if the innermost level was a
339 specialization; otherwise it's just a definition of the
341 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
344 /* Exit the current scope. */
352 /* When a label goes out of scope, check to see if that label was used
353 in a valid manner, and issue any appropriate warnings or errors. */
356 pop_label (tree label, tree old_value)
358 if (!processing_template_decl)
360 if (DECL_INITIAL (label) == NULL_TREE)
364 error ("label %q+D used but not defined", label);
365 location = input_location; /* FIXME want (input_filename, (line)0) */
366 /* Avoid crashing later. */
367 define_label (location, DECL_NAME (label));
370 warn_for_unused_label (label);
373 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
376 /* At the end of a function, all labels declared within the function
377 go out of scope. BLOCK is the top-level block for the
381 pop_labels_1 (void **slot, void *data)
383 struct named_label_entry *ent = (struct named_label_entry *) *slot;
384 tree block = (tree) data;
386 pop_label (ent->label_decl, NULL_TREE);
388 /* Put the labels into the "variables" of the top-level block,
389 so debugger can see them. */
390 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
391 BLOCK_VARS (block) = ent->label_decl;
393 htab_clear_slot (named_labels, slot);
399 pop_labels (tree block)
403 htab_traverse (named_labels, pop_labels_1, block);
408 /* At the end of a block with local labels, restore the outer definition. */
411 pop_local_label (tree label, tree old_value)
413 struct named_label_entry dummy;
416 pop_label (label, old_value);
418 dummy.label_decl = label;
419 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
420 htab_clear_slot (named_labels, slot);
423 /* The following two routines are used to interface to Objective-C++.
424 The binding level is purposely treated as an opaque type. */
427 objc_get_current_scope (void)
429 return current_binding_level;
432 /* The following routine is used by the NeXT-style SJLJ exceptions;
433 variables get marked 'volatile' so as to not be clobbered by
434 _setjmp()/_longjmp() calls. All variables in the current scope,
435 as well as parent scopes up to (but not including) ENCLOSING_BLK
436 shall be thusly marked. */
439 objc_mark_locals_volatile (void *enclosing_blk)
441 struct cp_binding_level *scope;
443 for (scope = current_binding_level;
444 scope && scope != enclosing_blk;
445 scope = scope->level_chain)
449 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
450 objc_volatilize_decl (decl);
452 /* Do not climb up past the current function. */
453 if (scope->kind == sk_function_parms)
458 /* Update data for defined and undefined labels when leaving a scope. */
461 poplevel_named_label_1 (void **slot, void *data)
463 struct named_label_entry *ent = (struct named_label_entry *) *slot;
464 struct cp_binding_level *bl = (struct cp_binding_level *) data;
465 struct cp_binding_level *obl = bl->level_chain;
467 if (ent->binding_level == bl)
471 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
472 if (decl_jump_unsafe (decl))
473 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
475 ent->binding_level = obl;
476 ent->names_in_scope = obl->names;
480 ent->in_try_scope = true;
483 ent->in_catch_scope = true;
486 ent->in_omp_scope = true;
494 struct named_label_use_entry *use;
496 for (use = ent->uses; use ; use = use->next)
497 if (use->binding_level == bl)
499 use->binding_level = obl;
500 use->names_in_scope = obl->names;
501 if (bl->kind == sk_omp)
502 use->in_omp_scope = true;
509 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
510 when errors were reported, except for -Werror-unused-but-set-*. */
511 static int unused_but_set_errorcount;
513 /* Exit a binding level.
514 Pop the level off, and restore the state of the identifier-decl mappings
515 that were in effect when this level was entered.
517 If KEEP == 1, this level had explicit declarations, so
518 and create a "block" (a BLOCK node) for the level
519 to record its declarations and subblocks for symbol table output.
521 If FUNCTIONBODY is nonzero, this level is the body of a function,
522 so create a block as if KEEP were set and also clear out all
525 If REVERSE is nonzero, reverse the order of decls before putting
526 them into the BLOCK. */
529 poplevel (int keep, int reverse, int functionbody)
532 /* The chain of decls was accumulated in reverse order.
533 Put it into forward order, just for cleanliness. */
538 int leaving_for_scope;
541 timevar_push (TV_NAME_LOOKUP);
546 gcc_assert (current_binding_level->kind != sk_class);
548 if (current_binding_level->kind == sk_cleanup)
550 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
552 gcc_assert (!VEC_length(cp_class_binding,
553 current_binding_level->class_shadowed));
555 /* We used to use KEEP == 2 to indicate that the new block should go
556 at the beginning of the list of blocks at this binding level,
557 rather than the end. This hack is no longer used. */
558 gcc_assert (keep == 0 || keep == 1);
560 if (current_binding_level->keep)
563 /* Any uses of undefined labels, and any defined labels, now operate
564 under constraints of next binding contour. */
565 if (cfun && !functionbody && named_labels)
566 htab_traverse (named_labels, poplevel_named_label_1,
567 current_binding_level);
569 /* Get the decls in the order they were written.
570 Usually current_binding_level->names is in reverse order.
571 But parameter decls were previously put in forward order. */
574 current_binding_level->names
575 = decls = nreverse (current_binding_level->names);
577 decls = current_binding_level->names;
579 /* If there were any declarations or structure tags in that level,
580 or if this level is a function body,
581 create a BLOCK to record them for the life of this function. */
583 if (keep == 1 || functionbody)
584 block = make_node (BLOCK);
585 if (block != NULL_TREE)
587 BLOCK_VARS (block) = decls;
588 BLOCK_SUBBLOCKS (block) = subblocks;
591 /* In each subblock, record that this is its superior. */
593 for (link = subblocks; link; link = BLOCK_CHAIN (link))
594 BLOCK_SUPERCONTEXT (link) = block;
596 /* We still support the old for-scope rules, whereby the variables
597 in a for-init statement were in scope after the for-statement
598 ended. We only use the new rules if flag_new_for_scope is
601 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
603 /* Before we remove the declarations first check for unused variables. */
604 if ((warn_unused_variable || warn_unused_but_set_variable)
605 && !processing_template_decl)
606 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
607 if (TREE_CODE (decl) == VAR_DECL
608 && (! TREE_USED (decl) || !DECL_READ_P (decl))
609 && ! DECL_IN_SYSTEM_HEADER (decl)
610 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
612 if (! TREE_USED (decl))
613 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
614 else if (DECL_CONTEXT (decl) == current_function_decl
615 && TREE_TYPE (decl) != error_mark_node
616 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
617 && errorcount == unused_but_set_errorcount
618 && (!CLASS_TYPE_P (TREE_TYPE (decl))
619 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
621 warning (OPT_Wunused_but_set_variable,
622 "variable %q+D set but not used", decl);
623 unused_but_set_errorcount = errorcount;
627 /* Remove declarations for all the DECLs in this level. */
628 for (link = decls; link; link = TREE_CHAIN (link))
630 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
633 tree name = DECL_NAME (link);
637 ob = outer_binding (name,
638 IDENTIFIER_BINDING (name),
641 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
643 ns_binding = NULL_TREE;
645 if (ob && ob->scope == current_binding_level->level_chain)
646 /* We have something like:
651 and we are leaving the `for' scope. There's no reason to
652 keep the binding of the inner `i' in this case. */
653 pop_binding (name, link);
654 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
655 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
656 /* Here, we have something like:
664 We must pop the for-scope binding so we know what's a
665 type and what isn't. */
666 pop_binding (name, link);
669 /* Mark this VAR_DECL as dead so that we can tell we left it
670 there only for backward compatibility. */
671 DECL_DEAD_FOR_LOCAL (link) = 1;
673 /* Keep track of what should have happened when we
674 popped the binding. */
677 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
678 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
681 /* Add it to the list of dead variables in the next
682 outermost binding to that we can remove these when we
683 leave that binding. */
684 current_binding_level->level_chain->dead_vars_from_for
685 = tree_cons (NULL_TREE, link,
686 current_binding_level->level_chain->
689 /* Although we don't pop the cxx_binding, we do clear
690 its SCOPE since the scope is going away now. */
691 IDENTIFIER_BINDING (name)->scope
692 = current_binding_level->level_chain;
699 /* Remove the binding. */
702 if (TREE_CODE (decl) == TREE_LIST)
703 decl = TREE_VALUE (decl);
706 if (TREE_CODE (name) == OVERLOAD)
707 name = OVL_FUNCTION (name);
709 gcc_assert (DECL_P (name));
710 pop_binding (DECL_NAME (name), decl);
714 /* Remove declarations for any `for' variables from inner scopes
715 that we kept around. */
716 for (link = current_binding_level->dead_vars_from_for;
717 link; link = TREE_CHAIN (link))
718 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
720 /* Restore the IDENTIFIER_TYPE_VALUEs. */
721 for (link = current_binding_level->type_shadowed;
722 link; link = TREE_CHAIN (link))
723 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
725 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
726 for (link = current_binding_level->shadowed_labels;
728 link = TREE_CHAIN (link))
729 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
731 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
732 list if a `using' declaration put them there. The debugging
733 back ends won't understand OVERLOAD, so we remove them here.
734 Because the BLOCK_VARS are (temporarily) shared with
735 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
736 popped all the bindings. */
741 for (d = &BLOCK_VARS (block); *d; )
743 if (TREE_CODE (*d) == TREE_LIST)
744 *d = TREE_CHAIN (*d);
746 d = &TREE_CHAIN (*d);
750 /* If the level being exited is the top level of a function,
751 check over all the labels. */
754 /* Since this is the top level block of a function, the vars are
755 the function's parameters. Don't leave them in the BLOCK
756 because they are found in the FUNCTION_DECL instead. */
757 BLOCK_VARS (block) = 0;
761 kind = current_binding_level->kind;
762 if (kind == sk_cleanup)
766 /* If this is a temporary binding created for a cleanup, then we'll
767 have pushed a statement list level. Pop that, create a new
768 BIND_EXPR for the block, and insert it into the stream. */
769 stmt = pop_stmt_list (current_binding_level->statement_list);
770 stmt = c_build_bind_expr (input_location, block, stmt);
777 /* The current function is being defined, so its DECL_INITIAL
778 should be error_mark_node. */
779 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
780 DECL_INITIAL (current_function_decl) = block;
783 current_binding_level->blocks
784 = chainon (current_binding_level->blocks, block);
786 /* If we did not make a block for the level just exited,
787 any blocks made for inner levels
788 (since they cannot be recorded as subblocks in that level)
789 must be carried forward so they will later become subblocks
790 of something else. */
792 current_binding_level->blocks
793 = chainon (current_binding_level->blocks, subblocks);
795 /* Each and every BLOCK node created here in `poplevel' is important
796 (e.g. for proper debugging information) so if we created one
797 earlier, mark it as "used". */
799 TREE_USED (block) = 1;
801 /* All temporary bindings created for cleanups are popped silently. */
802 if (kind == sk_cleanup)
805 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
808 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
809 itself, calling F for each. The DATA is passed to F as well. */
812 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
815 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
817 result |= (*f) (name_space, data);
819 for (; current; current = TREE_CHAIN (current))
820 result |= walk_namespaces_r (current, f, data);
825 /* Walk all the namespaces, calling F for each. The DATA is passed to
829 walk_namespaces (walk_namespaces_fn f, void* data)
831 return walk_namespaces_r (global_namespace, f, data);
834 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
835 DATA is non-NULL, this is the last time we will call
836 wrapup_global_declarations for this NAMESPACE. */
839 wrapup_globals_for_namespace (tree name_space, void* data)
841 struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
842 VEC(tree,gc) *statics = level->static_decls;
843 tree *vec = VEC_address (tree, statics);
844 int len = VEC_length (tree, statics);
845 int last_time = (data != 0);
849 check_global_declarations (vec, len);
850 emit_debug_global_declarations (vec, len);
854 /* Write out any globals that need to be output. */
855 return wrapup_global_declarations (vec, len);
859 /* In C++, you don't have to write `struct S' to refer to `S'; you
860 can just use `S'. We accomplish this by creating a TYPE_DECL as
861 if the user had written `typedef struct S S'. Create and return
862 the TYPE_DECL for TYPE. */
865 create_implicit_typedef (tree name, tree type)
869 decl = build_decl (input_location, TYPE_DECL, name, type);
870 DECL_ARTIFICIAL (decl) = 1;
871 /* There are other implicit type declarations, like the one *within*
872 a class that allows you to write `S::S'. We must distinguish
874 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
875 TYPE_NAME (type) = decl;
876 TYPE_STUB_DECL (type) = decl;
881 /* Remember a local name for name-mangling purposes. */
884 push_local_name (tree decl)
889 timevar_push (TV_NAME_LOOKUP);
891 name = DECL_NAME (decl);
893 nelts = VEC_length (tree, local_names);
894 for (i = 0; i < nelts; i++)
896 t = VEC_index (tree, local_names, i);
897 if (DECL_NAME (t) == name)
899 if (!DECL_LANG_SPECIFIC (decl))
900 retrofit_lang_decl (decl);
901 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
902 if (DECL_LANG_SPECIFIC (t))
903 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
905 DECL_DISCRIMINATOR (decl) = 1;
907 VEC_replace (tree, local_names, i, decl);
908 timevar_pop (TV_NAME_LOOKUP);
913 VEC_safe_push (tree, gc, local_names, decl);
914 timevar_pop (TV_NAME_LOOKUP);
917 /* Subroutine of duplicate_decls: return truthvalue of whether
918 or not types of these decls match.
920 For C++, we must compare the parameter list so that `int' can match
921 `int&' in a parameter position, but `int&' is not confused with
925 decls_match (tree newdecl, tree olddecl)
929 if (newdecl == olddecl)
932 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
933 /* If the two DECLs are not even the same kind of thing, we're not
934 interested in their types. */
937 if (TREE_CODE (newdecl) == FUNCTION_DECL)
939 tree f1 = TREE_TYPE (newdecl);
940 tree f2 = TREE_TYPE (olddecl);
941 tree p1 = TYPE_ARG_TYPES (f1);
942 tree p2 = TYPE_ARG_TYPES (f2);
944 /* Specializations of different templates are different functions
945 even if they have the same type. */
946 tree t1 = (DECL_USE_TEMPLATE (newdecl)
947 ? DECL_TI_TEMPLATE (newdecl)
949 tree t2 = (DECL_USE_TEMPLATE (olddecl)
950 ? DECL_TI_TEMPLATE (olddecl)
955 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
956 && ! (DECL_EXTERN_C_P (newdecl)
957 && DECL_EXTERN_C_P (olddecl)))
960 #ifdef NO_IMPLICIT_EXTERN_C
961 /* A new declaration doesn't match a built-in one unless it
962 is also extern "C". */
963 if (DECL_IS_BUILTIN (olddecl)
964 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
968 if (TREE_CODE (f1) != TREE_CODE (f2))
971 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
973 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
974 && (DECL_BUILT_IN (olddecl)
975 #ifndef NO_IMPLICIT_EXTERN_C
976 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
977 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
981 types_match = self_promoting_args_p (p1);
982 if (p1 == void_list_node)
983 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
985 #ifndef NO_IMPLICIT_EXTERN_C
986 else if (p1 == NULL_TREE
987 && (DECL_EXTERN_C_P (olddecl)
988 && DECL_IN_SYSTEM_HEADER (olddecl)
989 && !DECL_CLASS_SCOPE_P (olddecl))
990 && (DECL_EXTERN_C_P (newdecl)
991 && DECL_IN_SYSTEM_HEADER (newdecl)
992 && !DECL_CLASS_SCOPE_P (newdecl)))
994 types_match = self_promoting_args_p (p2);
995 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
999 types_match = compparms (p1, p2);
1004 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1006 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1007 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1010 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1011 DECL_TEMPLATE_PARMS (olddecl)))
1014 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1015 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1016 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1018 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1019 DECL_TEMPLATE_RESULT (newdecl));
1023 /* Need to check scope for variable declaration (VAR_DECL).
1024 For typedef (TYPE_DECL), scope is ignored. */
1025 if (TREE_CODE (newdecl) == VAR_DECL
1026 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1028 Two declarations for an object with C language linkage
1029 with the same name (ignoring the namespace that qualify
1030 it) that appear in different namespace scopes refer to
1032 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1035 if (TREE_TYPE (newdecl) == error_mark_node)
1036 types_match = TREE_TYPE (olddecl) == error_mark_node;
1037 else if (TREE_TYPE (olddecl) == NULL_TREE)
1038 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1039 else if (TREE_TYPE (newdecl) == NULL_TREE)
1042 types_match = comptypes (TREE_TYPE (newdecl),
1043 TREE_TYPE (olddecl),
1044 COMPARE_REDECLARATION);
1050 /* If NEWDECL is `static' and an `extern' was seen previously,
1051 warn about it. OLDDECL is the previous declaration.
1053 Note that this does not apply to the C++ case of declaring
1054 a variable `extern const' and then later `const'.
1056 Don't complain about built-in functions, since they are beyond
1057 the user's control. */
1060 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1062 if (TREE_CODE (newdecl) == TYPE_DECL
1063 || TREE_CODE (newdecl) == TEMPLATE_DECL
1064 || TREE_CODE (newdecl) == CONST_DECL
1065 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1068 /* Don't get confused by static member functions; that's a different
1070 if (TREE_CODE (newdecl) == FUNCTION_DECL
1071 && DECL_STATIC_FUNCTION_P (newdecl))
1074 /* If the old declaration was `static', or the new one isn't, then
1075 then everything is OK. */
1076 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1079 /* It's OK to declare a builtin function as `static'. */
1080 if (TREE_CODE (olddecl) == FUNCTION_DECL
1081 && DECL_ARTIFICIAL (olddecl))
1084 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1085 permerror (input_location, "previous declaration of %q+D", olddecl);
1088 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1089 function templates. If their exception specifications do not
1090 match, issue a diagnostic. */
1093 check_redeclaration_exception_specification (tree new_decl,
1098 tree new_exceptions;
1099 tree old_exceptions;
1101 new_type = TREE_TYPE (new_decl);
1102 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1103 old_type = TREE_TYPE (old_decl);
1104 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1108 If any declaration of a function has an exception-specification,
1109 all declarations, including the definition and an explicit
1110 specialization, of that function shall have an
1111 exception-specification with the same set of type-ids. */
1112 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1113 && ! DECL_IS_BUILTIN (old_decl)
1115 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1117 error ("declaration of %qF has a different exception specifier",
1119 error ("from previous declaration %q+F", old_decl);
1123 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1124 && lookup_attribute ("gnu_inline", \
1125 DECL_ATTRIBUTES (fn)))
1127 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1128 If the redeclaration is invalid, a diagnostic is issued, and the
1129 error_mark_node is returned. Otherwise, OLDDECL is returned.
1131 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1134 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1137 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1139 unsigned olddecl_uid = DECL_UID (olddecl);
1140 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1141 int new_defines_function = 0;
1142 tree new_template_info;
1144 if (newdecl == olddecl)
1147 types_match = decls_match (newdecl, olddecl);
1149 /* If either the type of the new decl or the type of the old decl is an
1150 error_mark_node, then that implies that we have already issued an
1151 error (earlier) for some bogus type specification, and in that case,
1152 it is rather pointless to harass the user with yet more error message
1153 about the same declaration, so just pretend the types match here. */
1154 if (TREE_TYPE (newdecl) == error_mark_node
1155 || TREE_TYPE (olddecl) == error_mark_node)
1156 return error_mark_node;
1158 if (DECL_P (olddecl)
1159 && TREE_CODE (newdecl) == FUNCTION_DECL
1160 && TREE_CODE (olddecl) == FUNCTION_DECL
1161 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1163 if (DECL_DECLARED_INLINE_P (newdecl)
1164 && DECL_UNINLINABLE (newdecl)
1165 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1166 /* Already warned elsewhere. */;
1167 else if (DECL_DECLARED_INLINE_P (olddecl)
1168 && DECL_UNINLINABLE (olddecl)
1169 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1170 /* Already warned. */;
1171 else if (DECL_DECLARED_INLINE_P (newdecl)
1172 && DECL_UNINLINABLE (olddecl)
1173 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1175 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1177 warning (OPT_Wattributes, "previous declaration of %q+D "
1178 "with attribute noinline", olddecl);
1180 else if (DECL_DECLARED_INLINE_P (olddecl)
1181 && DECL_UNINLINABLE (newdecl)
1182 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1184 warning (OPT_Wattributes, "function %q+D redeclared with "
1185 "attribute noinline", newdecl);
1186 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1191 /* Check for redeclaration and other discrepancies. */
1192 if (TREE_CODE (olddecl) == FUNCTION_DECL
1193 && DECL_ARTIFICIAL (olddecl))
1195 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1196 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1198 /* Avoid warnings redeclaring built-ins which have not been
1199 explicitly declared. */
1200 if (DECL_ANTICIPATED (olddecl))
1203 /* If you declare a built-in or predefined function name as static,
1204 the old definition is overridden, but optionally warn this was a
1205 bad choice of name. */
1206 if (! TREE_PUBLIC (newdecl))
1208 warning (OPT_Wshadow,
1209 DECL_BUILT_IN (olddecl)
1210 ? G_("shadowing built-in function %q#D")
1211 : G_("shadowing library function %q#D"), olddecl);
1212 /* Discard the old built-in function. */
1215 /* If the built-in is not ansi, then programs can override
1216 it even globally without an error. */
1217 else if (! DECL_BUILT_IN (olddecl))
1218 warning (0, "library function %q#D redeclared as non-function %q#D",
1222 error ("declaration of %q#D", newdecl);
1223 error ("conflicts with built-in declaration %q#D",
1228 else if (!types_match)
1230 /* Avoid warnings redeclaring built-ins which have not been
1231 explicitly declared. */
1232 if (DECL_ANTICIPATED (olddecl))
1234 /* Deal with fileptr_type_node. FILE type is not known
1235 at the time we create the builtins. */
1238 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1239 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1241 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1244 else if (TREE_VALUE (t2) == fileptr_type_node)
1246 tree t = TREE_VALUE (t1);
1248 if (TREE_CODE (t) == POINTER_TYPE
1249 && TYPE_NAME (TREE_TYPE (t))
1250 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1251 == get_identifier ("FILE")
1252 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1254 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1256 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1257 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1258 types_match = decls_match (newdecl, olddecl);
1260 return duplicate_decls (newdecl, olddecl,
1262 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1265 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1268 else if ((DECL_EXTERN_C_P (newdecl)
1269 && DECL_EXTERN_C_P (olddecl))
1270 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1271 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1273 /* A near match; override the builtin. */
1275 if (TREE_PUBLIC (newdecl))
1277 warning (0, "new declaration %q#D", newdecl);
1278 warning (0, "ambiguates built-in declaration %q#D",
1282 warning (OPT_Wshadow,
1283 DECL_BUILT_IN (olddecl)
1284 ? G_("shadowing built-in function %q#D")
1285 : G_("shadowing library function %q#D"), olddecl);
1288 /* Discard the old built-in function. */
1291 /* Replace the old RTL to avoid problems with inlining. */
1292 COPY_DECL_RTL (newdecl, olddecl);
1294 /* Even if the types match, prefer the new declarations type for
1295 built-ins which have not been explicitly declared, for
1296 exception lists, etc... */
1297 else if (DECL_IS_BUILTIN (olddecl))
1299 tree type = TREE_TYPE (newdecl);
1300 tree attribs = (*targetm.merge_type_attributes)
1301 (TREE_TYPE (olddecl), type);
1303 type = cp_build_type_attribute_variant (type, attribs);
1304 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1307 /* If a function is explicitly declared "throw ()", propagate that to
1308 the corresponding builtin. */
1309 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1310 && DECL_ANTICIPATED (olddecl)
1311 && TREE_NOTHROW (newdecl)
1312 && !TREE_NOTHROW (olddecl)
1313 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1314 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1316 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1318 /* Whether or not the builtin can throw exceptions has no
1319 bearing on this declarator. */
1320 TREE_NOTHROW (olddecl) = 0;
1322 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1324 /* If a builtin function is redeclared as `static', merge
1325 the declarations, but make the original one static. */
1326 DECL_THIS_STATIC (olddecl) = 1;
1327 TREE_PUBLIC (olddecl) = 0;
1329 /* Make the old declaration consistent with the new one so
1330 that all remnants of the builtin-ness of this function
1331 will be banished. */
1332 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1333 COPY_DECL_RTL (newdecl, olddecl);
1336 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1338 /* C++ Standard, 3.3, clause 4:
1339 "[Note: a namespace name or a class template name must be unique
1340 in its declarative region (7.3.2, clause 14). ]" */
1341 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1342 && TREE_CODE (newdecl) != NAMESPACE_DECL
1343 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1344 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1345 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1346 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1348 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1349 && TREE_CODE (newdecl) != TYPE_DECL)
1350 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1351 && TREE_CODE (olddecl) != TYPE_DECL))
1353 /* We do nothing special here, because C++ does such nasty
1354 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1355 get shadowed, and know that if we need to find a TYPE_DECL
1356 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1357 slot of the identifier. */
1361 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1362 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1363 || (TREE_CODE (olddecl) == FUNCTION_DECL
1364 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1368 error ("%q#D redeclared as different kind of symbol", newdecl);
1369 if (TREE_CODE (olddecl) == TREE_LIST)
1370 olddecl = TREE_VALUE (olddecl);
1371 error ("previous declaration of %q+#D", olddecl);
1373 return error_mark_node;
1375 else if (!types_match)
1377 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1378 /* These are certainly not duplicate declarations; they're
1379 from different scopes. */
1382 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1384 /* The name of a class template may not be declared to refer to
1385 any other template, class, function, object, namespace, value,
1386 or type in the same scope. */
1387 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1388 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1390 error ("declaration of template %q#D", newdecl);
1391 error ("conflicts with previous declaration %q+#D", olddecl);
1393 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1394 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1395 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1396 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1397 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1398 DECL_TEMPLATE_PARMS (olddecl))
1399 /* Template functions can be disambiguated by
1401 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1402 TREE_TYPE (TREE_TYPE (olddecl))))
1404 error ("new declaration %q#D", newdecl);
1405 error ("ambiguates old declaration %q+#D", olddecl);
1409 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1411 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1413 error ("declaration of C function %q#D conflicts with",
1415 error ("previous declaration %q+#D here", olddecl);
1417 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1418 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1420 error ("new declaration %q#D", newdecl);
1421 error ("ambiguates old declaration %q+#D", olddecl);
1422 return error_mark_node;
1429 error ("conflicting declaration %q#D", newdecl);
1430 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1431 return error_mark_node;
1434 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1435 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1436 && (!DECL_TEMPLATE_INFO (newdecl)
1437 || (DECL_TI_TEMPLATE (newdecl)
1438 != DECL_TI_TEMPLATE (olddecl))))
1439 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1440 && (!DECL_TEMPLATE_INFO (olddecl)
1441 || (DECL_TI_TEMPLATE (olddecl)
1442 != DECL_TI_TEMPLATE (newdecl))))))
1443 /* It's OK to have a template specialization and a non-template
1444 with the same type, or to have specializations of two
1445 different templates with the same type. Note that if one is a
1446 specialization, and the other is an instantiation of the same
1447 template, that we do not exit at this point. That situation
1448 can occur if we instantiate a template class, and then
1449 specialize one of its methods. This situation is valid, but
1450 the declarations must be merged in the usual way. */
1452 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1453 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1454 && !DECL_USE_TEMPLATE (newdecl))
1455 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1456 && !DECL_USE_TEMPLATE (olddecl))))
1457 /* One of the declarations is a template instantiation, and the
1458 other is not a template at all. That's OK. */
1460 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1462 /* In [namespace.alias] we have:
1464 In a declarative region, a namespace-alias-definition can be
1465 used to redefine a namespace-alias declared in that declarative
1466 region to refer only to the namespace to which it already
1469 Therefore, if we encounter a second alias directive for the same
1470 alias, we can just ignore the second directive. */
1471 if (DECL_NAMESPACE_ALIAS (newdecl)
1472 && (DECL_NAMESPACE_ALIAS (newdecl)
1473 == DECL_NAMESPACE_ALIAS (olddecl)))
1475 /* [namespace.alias]
1477 A namespace-name or namespace-alias shall not be declared as
1478 the name of any other entity in the same declarative region.
1479 A namespace-name defined at global scope shall not be
1480 declared as the name of any other entity in any global scope
1482 error ("declaration of namespace %qD conflicts with", newdecl);
1483 error ("previous declaration of namespace %q+D here", olddecl);
1484 return error_mark_node;
1488 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1491 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1492 if (DECL_NAME (olddecl) != NULL_TREE)
1493 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1494 ? "%q+#D previously defined here"
1495 : "%q+#D previously declared here", olddecl);
1496 return error_mark_node;
1498 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1499 && DECL_INITIAL (olddecl) != NULL_TREE
1500 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1501 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1503 /* Prototype decl follows defn w/o prototype. */
1504 warning_at (input_location, 0, "prototype for %q+#D", newdecl);
1505 warning_at (DECL_SOURCE_LOCATION (olddecl), 0,
1506 "follows non-prototype definition here");
1508 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1509 || TREE_CODE (olddecl) == VAR_DECL)
1510 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1513 If two declarations of the same function or object
1514 specify different linkage-specifications ..., the program
1515 is ill-formed.... Except for functions with C++ linkage,
1516 a function declaration without a linkage specification
1517 shall not precede the first linkage specification for
1518 that function. A function can be declared without a
1519 linkage specification after an explicit linkage
1520 specification has been seen; the linkage explicitly
1521 specified in the earlier declaration is not affected by
1522 such a function declaration.
1524 DR 563 raises the question why the restrictions on
1525 functions should not also apply to objects. Older
1526 versions of G++ silently ignore the linkage-specification
1534 which is clearly wrong. Therefore, we now treat objects
1536 if (current_lang_depth () == 0)
1538 /* There is no explicit linkage-specification, so we use
1539 the linkage from the previous declaration. */
1540 if (!DECL_LANG_SPECIFIC (newdecl))
1541 retrofit_lang_decl (newdecl);
1542 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1546 error ("previous declaration of %q+#D with %qL linkage",
1547 olddecl, DECL_LANGUAGE (olddecl));
1548 error ("conflicts with new declaration with %qL linkage",
1549 DECL_LANGUAGE (newdecl));
1553 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1555 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1557 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1558 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1561 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1562 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1564 for (; t1 && t1 != void_list_node;
1565 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1566 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1568 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1571 permerror (input_location, "default argument given for parameter %d of %q#D",
1573 permerror (input_location, "after previous specification in %q+#D", olddecl);
1577 error ("default argument given for parameter %d of %q#D",
1579 error ("after previous specification in %q+#D",
1586 /* Do not merge an implicit typedef with an explicit one. In:
1590 typedef class A A __attribute__ ((foo));
1592 the attribute should apply only to the typedef. */
1593 if (TREE_CODE (olddecl) == TYPE_DECL
1594 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1595 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1598 /* If new decl is `static' and an `extern' was seen previously,
1600 warn_extern_redeclared_static (newdecl, olddecl);
1602 /* We have committed to returning 1 at this point. */
1603 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1605 /* Now that functions must hold information normally held
1606 by field decls, there is extra work to do so that
1607 declaration information does not get destroyed during
1609 if (DECL_VINDEX (olddecl))
1610 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1611 if (DECL_CONTEXT (olddecl))
1612 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1613 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1614 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1615 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1616 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1617 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1618 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1619 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1620 SET_OVERLOADED_OPERATOR_CODE
1621 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1622 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1624 /* Optionally warn about more than one declaration for the same
1625 name, but don't warn about a function declaration followed by a
1627 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1628 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1629 /* Don't warn about extern decl followed by definition. */
1630 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1631 /* Don't warn about friends, let add_friend take care of it. */
1632 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1634 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1635 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1638 if (DECL_DELETED_FN (newdecl))
1640 error ("deleted definition of %qD", newdecl);
1641 error ("after previous declaration %q+D", olddecl);
1645 /* Deal with C++: must preserve virtual function table size. */
1646 if (TREE_CODE (olddecl) == TYPE_DECL)
1648 tree newtype = TREE_TYPE (newdecl);
1649 tree oldtype = TREE_TYPE (olddecl);
1651 if (newtype != error_mark_node && oldtype != error_mark_node
1652 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1653 CLASSTYPE_FRIEND_CLASSES (newtype)
1654 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1656 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1659 /* Copy all the DECL_... slots specified in the new decl
1660 except for any that we copy here from the old type. */
1661 DECL_ATTRIBUTES (newdecl)
1662 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1664 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1668 old_result = DECL_TEMPLATE_RESULT (olddecl);
1669 new_result = DECL_TEMPLATE_RESULT (newdecl);
1670 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1671 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1672 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1673 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1675 DECL_ATTRIBUTES (old_result)
1676 = (*targetm.merge_decl_attributes) (old_result, new_result);
1678 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1680 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1681 && DECL_INITIAL (new_result))
1683 if (DECL_INITIAL (old_result))
1684 DECL_UNINLINABLE (old_result) = 1;
1686 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1687 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1688 DECL_NOT_REALLY_EXTERN (old_result)
1689 = DECL_NOT_REALLY_EXTERN (new_result);
1690 DECL_INTERFACE_KNOWN (old_result)
1691 = DECL_INTERFACE_KNOWN (new_result);
1692 DECL_DECLARED_INLINE_P (old_result)
1693 = DECL_DECLARED_INLINE_P (new_result);
1694 DECL_DISREGARD_INLINE_LIMITS (old_result)
1695 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1700 DECL_DECLARED_INLINE_P (old_result)
1701 |= DECL_DECLARED_INLINE_P (new_result);
1702 DECL_DISREGARD_INLINE_LIMITS (old_result)
1703 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1704 check_redeclaration_exception_specification (newdecl, olddecl);
1708 /* If the new declaration is a definition, update the file and
1709 line information on the declaration, and also make
1710 the old declaration the same definition. */
1711 if (DECL_INITIAL (new_result) != NULL_TREE)
1713 DECL_SOURCE_LOCATION (olddecl)
1714 = DECL_SOURCE_LOCATION (old_result)
1715 = DECL_SOURCE_LOCATION (newdecl);
1716 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1717 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1720 DECL_ARGUMENTS (old_result)
1721 = DECL_ARGUMENTS (new_result);
1722 for (parm = DECL_ARGUMENTS (old_result); parm;
1723 parm = TREE_CHAIN (parm))
1724 DECL_CONTEXT (parm) = old_result;
1733 /* Automatically handles default parameters. */
1734 tree oldtype = TREE_TYPE (olddecl);
1737 /* Merge the data types specified in the two decls. */
1738 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1740 /* If merge_types produces a non-typedef type, just use the old type. */
1741 if (TREE_CODE (newdecl) == TYPE_DECL
1742 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1745 if (TREE_CODE (newdecl) == VAR_DECL)
1747 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1748 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1749 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1750 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1751 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1752 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1754 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1755 if (DECL_LANG_SPECIFIC (olddecl)
1756 && CP_DECL_THREADPRIVATE_P (olddecl))
1758 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1759 if (!DECL_LANG_SPECIFIC (newdecl))
1760 retrofit_lang_decl (newdecl);
1762 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1763 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1767 /* Do this after calling `merge_types' so that default
1768 parameters don't confuse us. */
1769 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1770 check_redeclaration_exception_specification (newdecl, olddecl);
1771 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1773 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1774 check_default_args (newdecl);
1776 /* Lay the type out, unless already done. */
1777 if (! same_type_p (newtype, oldtype)
1778 && TREE_TYPE (newdecl) != error_mark_node
1779 && !(processing_template_decl && uses_template_parms (newdecl)))
1780 layout_type (TREE_TYPE (newdecl));
1782 if ((TREE_CODE (newdecl) == VAR_DECL
1783 || TREE_CODE (newdecl) == PARM_DECL
1784 || TREE_CODE (newdecl) == RESULT_DECL
1785 || TREE_CODE (newdecl) == FIELD_DECL
1786 || TREE_CODE (newdecl) == TYPE_DECL)
1787 && !(processing_template_decl && uses_template_parms (newdecl)))
1788 layout_decl (newdecl, 0);
1790 /* Merge the type qualifiers. */
1791 if (TREE_READONLY (newdecl))
1792 TREE_READONLY (olddecl) = 1;
1793 if (TREE_THIS_VOLATILE (newdecl))
1794 TREE_THIS_VOLATILE (olddecl) = 1;
1795 if (TREE_NOTHROW (newdecl))
1796 TREE_NOTHROW (olddecl) = 1;
1798 /* Merge deprecatedness. */
1799 if (TREE_DEPRECATED (newdecl))
1800 TREE_DEPRECATED (olddecl) = 1;
1802 /* Preserve function specific target and optimization options */
1803 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1805 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1806 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1807 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1808 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1810 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1811 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1812 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1813 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1816 /* Merge the initialization information. */
1817 if (DECL_INITIAL (newdecl) == NULL_TREE
1818 && DECL_INITIAL (olddecl) != NULL_TREE)
1820 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1821 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1822 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1824 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1825 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1829 /* Merge the section attribute.
1830 We want to issue an error if the sections conflict but that must be
1831 done later in decl_attributes since we are called before attributes
1833 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1834 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1836 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1838 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1839 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1840 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1841 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1842 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1843 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1844 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1845 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1846 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1847 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1848 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1849 /* Keep the old RTL. */
1850 COPY_DECL_RTL (olddecl, newdecl);
1852 else if (TREE_CODE (newdecl) == VAR_DECL
1853 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1855 /* Keep the old RTL. We cannot keep the old RTL if the old
1856 declaration was for an incomplete object and the new
1857 declaration is not since many attributes of the RTL will
1859 COPY_DECL_RTL (olddecl, newdecl);
1862 /* If cannot merge, then use the new type and qualifiers,
1863 and don't preserve the old rtl. */
1866 /* Clean out any memory we had of the old declaration. */
1867 tree oldstatic = value_member (olddecl, static_aggregates);
1869 TREE_VALUE (oldstatic) = error_mark_node;
1871 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1872 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1873 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1874 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1877 /* Merge the storage class information. */
1878 merge_weak (newdecl, olddecl);
1880 if (DECL_ONE_ONLY (olddecl))
1881 DECL_COMDAT_GROUP (newdecl) = DECL_COMDAT_GROUP (olddecl);
1883 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1884 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1885 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1886 if (! DECL_EXTERNAL (olddecl))
1887 DECL_EXTERNAL (newdecl) = 0;
1889 new_template_info = NULL_TREE;
1890 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1892 bool new_redefines_gnu_inline = false;
1894 if (new_defines_function
1895 && ((DECL_INTERFACE_KNOWN (olddecl)
1896 && TREE_CODE (olddecl) == FUNCTION_DECL)
1897 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1898 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1899 == FUNCTION_DECL))))
1903 if (TREE_CODE (fn) == TEMPLATE_DECL)
1904 fn = DECL_TEMPLATE_RESULT (olddecl);
1906 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1909 if (!new_redefines_gnu_inline)
1911 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1912 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1913 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1915 DECL_TEMPLATE_INSTANTIATED (newdecl)
1916 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1917 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
1919 /* If the OLDDECL is an instantiation and/or specialization,
1920 then the NEWDECL must be too. But, it may not yet be marked
1921 as such if the caller has created NEWDECL, but has not yet
1922 figured out that it is a redeclaration. */
1923 if (!DECL_USE_TEMPLATE (newdecl))
1924 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1926 /* Don't really know how much of the language-specific
1927 values we should copy from old to new. */
1928 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1929 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1930 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1931 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1933 if (LANG_DECL_HAS_MIN (newdecl))
1935 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
1936 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
1937 if (DECL_TEMPLATE_INFO (newdecl))
1938 new_template_info = DECL_TEMPLATE_INFO (newdecl);
1939 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1941 /* Only functions have these fields. */
1942 if (TREE_CODE (newdecl) == FUNCTION_DECL
1943 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1945 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1946 olddecl_friend = DECL_FRIEND_P (olddecl);
1947 hidden_friend = (DECL_ANTICIPATED (olddecl)
1948 && DECL_HIDDEN_FRIEND_P (olddecl)
1949 && newdecl_is_friend);
1950 DECL_BEFRIENDING_CLASSES (newdecl)
1951 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1952 DECL_BEFRIENDING_CLASSES (olddecl));
1953 /* DECL_THUNKS is only valid for virtual functions,
1954 otherwise it is a DECL_FRIEND_CONTEXT. */
1955 if (DECL_VIRTUAL_P (newdecl))
1956 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1958 /* Only variables have this field. */
1959 else if (TREE_CODE (newdecl) == VAR_DECL
1960 && VAR_HAD_UNKNOWN_BOUND (olddecl))
1961 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
1964 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1968 /* Merge parameter attributes. */
1969 tree oldarg, newarg;
1970 for (oldarg = DECL_ARGUMENTS(olddecl),
1971 newarg = DECL_ARGUMENTS(newdecl);
1973 oldarg = TREE_CHAIN(oldarg), newarg = TREE_CHAIN(newarg)) {
1974 DECL_ATTRIBUTES (newarg)
1975 = (*targetm.merge_decl_attributes) (oldarg, newarg);
1976 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
1979 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1980 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1982 /* If newdecl is not a specialization, then it is not a
1983 template-related function at all. And that means that we
1984 should have exited above, returning 0. */
1985 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1987 if (DECL_ODR_USED (olddecl))
1988 /* From [temp.expl.spec]:
1990 If a template, a member template or the member of a class
1991 template is explicitly specialized then that
1992 specialization shall be declared before the first use of
1993 that specialization that would cause an implicit
1994 instantiation to take place, in every translation unit in
1995 which such a use occurs. */
1996 error ("explicit specialization of %qD after first use",
1999 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2001 /* Don't propagate visibility from the template to the
2002 specialization here. We'll do that in determine_visibility if
2004 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2006 /* [temp.expl.spec/14] We don't inline explicit specialization
2007 just because the primary template says so. */
2009 else if (new_defines_function && DECL_INITIAL (olddecl))
2011 /* Never inline re-defined extern inline functions.
2012 FIXME: this could be better handled by keeping both
2013 function as separate declarations. */
2014 DECL_UNINLINABLE (newdecl) = 1;
2018 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
2019 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2021 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2023 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2024 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2026 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2027 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2028 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2029 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2032 /* Preserve abstractness on cloned [cd]tors. */
2033 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
2035 /* Update newdecl's parms to point at olddecl. */
2036 for (parm = DECL_ARGUMENTS (newdecl); parm;
2037 parm = TREE_CHAIN (parm))
2038 DECL_CONTEXT (parm) = olddecl;
2042 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2043 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2044 COPY_DECL_RTL (newdecl, olddecl);
2046 if (! types_match || new_defines_function)
2048 /* These need to be copied so that the names are available.
2049 Note that if the types do match, we'll preserve inline
2050 info and other bits, but if not, we won't. */
2051 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2052 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2054 if (new_defines_function)
2055 /* If defining a function declared with other language
2056 linkage, use the previously declared language linkage. */
2057 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2058 else if (types_match)
2060 /* If redeclaring a builtin function, and not a definition,
2061 it stays built in. */
2062 if (DECL_BUILT_IN (olddecl))
2064 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2065 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2066 /* If we're keeping the built-in definition, keep the rtl,
2067 regardless of declaration matches. */
2068 COPY_DECL_RTL (olddecl, newdecl);
2071 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2072 /* Don't clear out the arguments if we're just redeclaring a
2074 if (DECL_ARGUMENTS (olddecl))
2075 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2078 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2079 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2081 /* Now preserve various other info from the definition. */
2082 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2083 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2084 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2085 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2087 /* Warn about conflicting visibility specifications. */
2088 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2089 && DECL_VISIBILITY_SPECIFIED (newdecl)
2090 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2092 warning_at (input_location, OPT_Wattributes,
2093 "%q+D: visibility attribute ignored because it", newdecl);
2094 warning_at (DECL_SOURCE_LOCATION (olddecl), OPT_Wattributes,
2095 "conflicts with previous declaration here");
2097 /* Choose the declaration which specified visibility. */
2098 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2100 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2101 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2103 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2104 so keep this behavior. */
2105 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2107 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2108 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2111 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2112 with that from NEWDECL below. */
2113 if (DECL_LANG_SPECIFIC (olddecl))
2115 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2116 != DECL_LANG_SPECIFIC (newdecl));
2117 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2120 /* Merge the USED information. */
2121 if (TREE_USED (olddecl))
2122 TREE_USED (newdecl) = 1;
2123 else if (TREE_USED (newdecl))
2124 TREE_USED (olddecl) = 1;
2125 if (TREE_CODE (newdecl) == VAR_DECL)
2127 if (DECL_READ_P (olddecl))
2128 DECL_READ_P (newdecl) = 1;
2129 else if (DECL_READ_P (newdecl))
2130 DECL_READ_P (olddecl) = 1;
2132 if (DECL_PRESERVE_P (olddecl))
2133 DECL_PRESERVE_P (newdecl) = 1;
2134 else if (DECL_PRESERVE_P (newdecl))
2135 DECL_PRESERVE_P (olddecl) = 1;
2137 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2141 function_size = sizeof (struct tree_decl_common);
2143 memcpy ((char *) olddecl + sizeof (struct tree_common),
2144 (char *) newdecl + sizeof (struct tree_common),
2145 function_size - sizeof (struct tree_common));
2147 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2148 (char *) newdecl + sizeof (struct tree_decl_common),
2149 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2150 if (new_template_info)
2151 /* If newdecl is a template instantiation, it is possible that
2152 the following sequence of events has occurred:
2154 o A friend function was declared in a class template. The
2155 class template was instantiated.
2157 o The instantiation of the friend declaration was
2158 recorded on the instantiation list, and is newdecl.
2160 o Later, however, instantiate_class_template called pushdecl
2161 on the newdecl to perform name injection. But, pushdecl in
2162 turn called duplicate_decls when it discovered that another
2163 declaration of a global function with the same name already
2166 o Here, in duplicate_decls, we decided to clobber newdecl.
2168 If we're going to do that, we'd better make sure that
2169 olddecl, and not newdecl, is on the list of
2170 instantiations so that if we try to do the instantiation
2171 again we won't get the clobbered declaration. */
2172 reregister_specialization (newdecl,
2178 size_t size = tree_code_size (TREE_CODE (olddecl));
2179 memcpy ((char *) olddecl + sizeof (struct tree_common),
2180 (char *) newdecl + sizeof (struct tree_common),
2181 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2182 switch (TREE_CODE (olddecl))
2192 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2193 (char *) newdecl + sizeof (struct tree_decl_common),
2194 size - sizeof (struct tree_decl_common)
2195 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2199 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2200 (char *) newdecl + sizeof (struct tree_decl_common),
2201 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2202 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2206 DECL_UID (olddecl) = olddecl_uid;
2208 DECL_FRIEND_P (olddecl) = 1;
2211 DECL_ANTICIPATED (olddecl) = 1;
2212 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2215 /* NEWDECL contains the merged attribute lists.
2216 Update OLDDECL to be the same. */
2217 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2219 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2220 so that encode_section_info has a chance to look at the new decl
2221 flags and attributes. */
2222 if (DECL_RTL_SET_P (olddecl)
2223 && (TREE_CODE (olddecl) == FUNCTION_DECL
2224 || (TREE_CODE (olddecl) == VAR_DECL
2225 && TREE_STATIC (olddecl))))
2226 make_decl_rtl (olddecl);
2228 /* The NEWDECL will no longer be needed. Because every out-of-class
2229 declaration of a member results in a call to duplicate_decls,
2230 freeing these nodes represents in a significant savings. */
2236 /* Return zero if the declaration NEWDECL is valid
2237 when the declaration OLDDECL (assumed to be for the same name)
2238 has already been seen.
2239 Otherwise return an error message format string with a %s
2240 where the identifier should go. */
2243 redeclaration_error_message (tree newdecl, tree olddecl)
2245 if (TREE_CODE (newdecl) == TYPE_DECL)
2247 /* Because C++ can put things into name space for free,
2248 constructs like "typedef struct foo { ... } foo"
2249 would look like an erroneous redeclaration. */
2250 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2253 return G_("redefinition of %q#D");
2255 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2257 /* If this is a pure function, its olddecl will actually be
2258 the original initialization to `0' (which we force to call
2259 abort()). Don't complain about redefinition in this case. */
2260 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2261 && DECL_INITIAL (olddecl) == NULL_TREE)
2264 /* If both functions come from different namespaces, this is not
2265 a redeclaration - this is a conflict with a used function. */
2266 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2267 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2268 && ! decls_match (olddecl, newdecl))
2269 return G_("%qD conflicts with used function");
2271 /* We'll complain about linkage mismatches in
2272 warn_extern_redeclared_static. */
2274 /* Defining the same name twice is no good. */
2275 if (DECL_INITIAL (olddecl) != NULL_TREE
2276 && DECL_INITIAL (newdecl) != NULL_TREE)
2278 if (DECL_NAME (olddecl) == NULL_TREE)
2279 return G_("%q#D not declared in class");
2280 else if (!GNU_INLINE_P (olddecl)
2281 || GNU_INLINE_P (newdecl))
2282 return G_("redefinition of %q#D");
2285 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2287 bool olda = GNU_INLINE_P (olddecl);
2288 bool newa = GNU_INLINE_P (newdecl);
2293 return G_("%q+D redeclared inline with "
2294 "%<gnu_inline%> attribute");
2296 return G_("%q+D redeclared inline without "
2297 "%<gnu_inline%> attribute");
2303 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2307 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2309 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2310 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2311 return G_("redefinition of %q#D");
2315 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2316 || (DECL_TEMPLATE_RESULT (newdecl)
2317 == DECL_TEMPLATE_RESULT (olddecl)))
2320 nt = DECL_TEMPLATE_RESULT (newdecl);
2321 if (DECL_TEMPLATE_INFO (nt))
2322 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2323 ot = DECL_TEMPLATE_RESULT (olddecl);
2324 if (DECL_TEMPLATE_INFO (ot))
2325 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2326 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2327 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2328 return G_("redefinition of %q#D");
2330 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2332 bool olda = GNU_INLINE_P (ot);
2333 bool newa = GNU_INLINE_P (nt);
2338 return G_("%q+D redeclared inline with "
2339 "%<gnu_inline%> attribute");
2341 return G_("%q+D redeclared inline without "
2342 "%<gnu_inline%> attribute");
2346 /* Core issue #226 (C++0x):
2348 If a friend function template declaration specifies a
2349 default template-argument, that declaration shall be a
2350 definition and shall be the only declaration of the
2351 function template in the translation unit. */
2352 if ((cxx_dialect != cxx98)
2353 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2354 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2355 /*is_primary=*/1, /*is_partial=*/0,
2356 /*is_friend_decl=*/2))
2357 return G_("redeclaration of friend %q#D "
2358 "may not have default template arguments");
2362 else if (TREE_CODE (newdecl) == VAR_DECL
2363 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2364 && (! DECL_LANG_SPECIFIC (olddecl)
2365 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2366 || DECL_THREAD_LOCAL_P (newdecl)))
2368 /* Only variables can be thread-local, and all declarations must
2369 agree on this property. */
2370 if (DECL_THREAD_LOCAL_P (newdecl))
2371 return G_("thread-local declaration of %q#D follows "
2372 "non-thread-local declaration");
2374 return G_("non-thread-local declaration of %q#D follows "
2375 "thread-local declaration");
2377 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2379 /* The objects have been declared at namespace scope. If either
2380 is a member of an anonymous union, then this is an invalid
2381 redeclaration. For example:
2387 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2388 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2389 return G_("redeclaration of %q#D");
2390 /* If at least one declaration is a reference, there is no
2391 conflict. For example:
2397 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2399 /* Reject two definitions. */
2400 return G_("redefinition of %q#D");
2404 /* Objects declared with block scope: */
2405 /* Reject two definitions, and reject a definition
2406 together with an external reference. */
2407 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2408 return G_("redeclaration of %q#D");
2413 /* Hash and equality functions for the named_label table. */
2416 named_label_entry_hash (const void *data)
2418 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2419 return DECL_UID (ent->label_decl);
2423 named_label_entry_eq (const void *a, const void *b)
2425 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2426 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2427 return ent_a->label_decl == ent_b->label_decl;
2430 /* Create a new label, named ID. */
2433 make_label_decl (tree id, int local_p)
2435 struct named_label_entry *ent;
2439 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2441 DECL_CONTEXT (decl) = current_function_decl;
2442 DECL_MODE (decl) = VOIDmode;
2443 C_DECLARED_LABEL_FLAG (decl) = local_p;
2445 /* Say where one reference is to the label, for the sake of the
2446 error if it is not defined. */
2447 DECL_SOURCE_LOCATION (decl) = input_location;
2449 /* Record the fact that this identifier is bound to this label. */
2450 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2452 /* Create the label htab for the function on demand. */
2454 named_labels = htab_create_ggc (13, named_label_entry_hash,
2455 named_label_entry_eq, NULL);
2457 /* Record this label on the list of labels used in this function.
2458 We do this before calling make_label_decl so that we get the
2459 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2460 ent = ggc_alloc_cleared_named_label_entry ();
2461 ent->label_decl = decl;
2463 slot = htab_find_slot (named_labels, ent, INSERT);
2464 gcc_assert (*slot == NULL);
2470 /* Look for a label named ID in the current function. If one cannot
2471 be found, create one. (We keep track of used, but undefined,
2472 labels, and complain about them at the end of a function.) */
2475 lookup_label (tree id)
2479 timevar_push (TV_NAME_LOOKUP);
2480 /* You can't use labels at global scope. */
2481 if (current_function_decl == NULL_TREE)
2483 error ("label %qE referenced outside of any function", id);
2484 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2487 /* See if we've already got this label. */
2488 decl = IDENTIFIER_LABEL_VALUE (id);
2489 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2490 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2492 decl = make_label_decl (id, /*local_p=*/0);
2493 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2496 /* Declare a local label named ID. */
2499 declare_local_label (tree id)
2503 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2504 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2505 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2506 current_binding_level->shadowed_labels);
2507 current_binding_level->shadowed_labels = shadow;
2509 decl = make_label_decl (id, /*local_p=*/1);
2510 TREE_VALUE (shadow) = decl;
2515 /* Returns nonzero if it is ill-formed to jump past the declaration of
2516 DECL. Returns 2 if it's also a real problem. */
2519 decl_jump_unsafe (tree decl)
2521 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2522 with automatic storage duration is not in scope to a point where it is
2523 in scope is ill-formed unless the variable has scalar type, class type
2524 with a trivial default constructor and a trivial destructor, a
2525 cv-qualified version of one of these types, or an array of one of the
2526 preceding types and is declared without an initializer (8.5). */
2527 tree type = TREE_TYPE (decl);
2529 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2530 || type == error_mark_node)
2533 type = strip_array_types (type);
2535 if (type_has_nontrivial_default_init (TREE_TYPE (decl))
2536 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2539 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2545 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2548 identify_goto (tree decl, const location_t *locus)
2551 permerror (input_location, "jump to label %qD", decl);
2553 permerror (input_location, "jump to case label");
2555 permerror (*locus, " from here");
2558 /* Check that a single previously seen jump to a newly defined label
2559 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2560 the jump context; NAMES are the names in scope in LEVEL at the jump
2561 context; LOCUS is the source position of the jump or 0. Returns
2562 true if all is well. */
2565 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2566 bool exited_omp, const location_t *locus)
2568 struct cp_binding_level *b;
2569 bool identified = false, saw_eh = false, saw_omp = false;
2573 identify_goto (decl, locus);
2574 error (" exits OpenMP structured block");
2575 identified = saw_omp = true;
2578 for (b = current_binding_level; b ; b = b->level_chain)
2580 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2582 for (new_decls = b->names; new_decls != old_decls;
2583 new_decls = TREE_CHAIN (new_decls))
2585 int problem = decl_jump_unsafe (new_decls);
2591 identify_goto (decl, locus);
2595 error (" crosses initialization of %q+#D", new_decls);
2597 permerror (input_location, " enters scope of %q+#D which has "
2598 "non-trivial destructor", new_decls);
2603 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2607 identify_goto (decl, locus);
2610 if (b->kind == sk_try)
2611 error (" enters try block");
2613 error (" enters catch block");
2616 if (b->kind == sk_omp && !saw_omp)
2620 identify_goto (decl, locus);
2623 error (" enters OpenMP structured block");
2632 check_previous_goto (tree decl, struct named_label_use_entry *use)
2634 check_previous_goto_1 (decl, use->binding_level,
2635 use->names_in_scope, use->in_omp_scope,
2636 &use->o_goto_locus);
2640 check_switch_goto (struct cp_binding_level* level)
2642 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2645 /* Check that a new jump to a label DECL is OK. Called by
2646 finish_goto_stmt. */
2649 check_goto (tree decl)
2651 struct named_label_entry *ent, dummy;
2652 bool saw_catch = false, identified = false;
2655 /* We can't know where a computed goto is jumping.
2656 So we assume that it's OK. */
2657 if (TREE_CODE (decl) != LABEL_DECL)
2660 /* We didn't record any information about this label when we created it,
2661 and there's not much point since it's trivial to analyze as a return. */
2662 if (decl == cdtor_label)
2665 dummy.label_decl = decl;
2666 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2667 gcc_assert (ent != NULL);
2669 /* If the label hasn't been defined yet, defer checking. */
2670 if (! DECL_INITIAL (decl))
2672 struct named_label_use_entry *new_use;
2674 /* Don't bother creating another use if the last goto had the
2675 same data, and will therefore create the same set of errors. */
2677 && ent->uses->names_in_scope == current_binding_level->names)
2680 new_use = ggc_alloc_named_label_use_entry ();
2681 new_use->binding_level = current_binding_level;
2682 new_use->names_in_scope = current_binding_level->names;
2683 new_use->o_goto_locus = input_location;
2684 new_use->in_omp_scope = false;
2686 new_use->next = ent->uses;
2687 ent->uses = new_use;
2691 if (ent->in_try_scope || ent->in_catch_scope
2692 || ent->in_omp_scope || ent->bad_decls)
2694 permerror (input_location, "jump to label %q+D", decl);
2695 permerror (input_location, " from here");
2699 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2701 tree b = TREE_VALUE (bad);
2702 int u = decl_jump_unsafe (b);
2704 if (u > 1 && DECL_ARTIFICIAL (b))
2706 /* Can't skip init of __exception_info. */
2707 error_at (DECL_SOURCE_LOCATION (b), " enters catch block");
2711 error (" skips initialization of %q+#D", b);
2713 permerror (input_location, " enters scope of %q+#D which has "
2714 "non-trivial destructor", b);
2717 if (ent->in_try_scope)
2718 error (" enters try block");
2719 else if (ent->in_catch_scope && !saw_catch)
2720 error (" enters catch block");
2722 if (ent->in_omp_scope)
2723 error (" enters OpenMP structured block");
2724 else if (flag_openmp)
2726 struct cp_binding_level *b;
2727 for (b = current_binding_level; b ; b = b->level_chain)
2729 if (b == ent->binding_level)
2731 if (b->kind == sk_omp)
2735 permerror (input_location, "jump to label %q+D", decl);
2736 permerror (input_location, " from here");
2739 error (" exits OpenMP structured block");
2746 /* Check that a return is ok wrt OpenMP structured blocks.
2747 Called by finish_return_stmt. Returns true if all is well. */
2750 check_omp_return (void)
2752 struct cp_binding_level *b;
2753 for (b = current_binding_level; b ; b = b->level_chain)
2754 if (b->kind == sk_omp)
2756 error ("invalid exit from OpenMP structured block");
2762 /* Define a label, specifying the location in the source file.
2763 Return the LABEL_DECL node for the label. */
2766 define_label (location_t location, tree name)
2768 struct named_label_entry *ent, dummy;
2769 struct cp_binding_level *p;
2772 timevar_push (TV_NAME_LOOKUP);
2774 decl = lookup_label (name);
2776 dummy.label_decl = decl;
2777 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2778 gcc_assert (ent != NULL);
2780 /* After labels, make any new cleanups in the function go into their
2781 own new (temporary) binding contour. */
2782 for (p = current_binding_level;
2783 p->kind != sk_function_parms;
2785 p->more_cleanups_ok = 0;
2787 if (name == get_identifier ("wchar_t"))
2788 permerror (input_location, "label named wchar_t");
2790 if (DECL_INITIAL (decl) != NULL_TREE)
2792 error ("duplicate label %qD", decl);
2793 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2797 struct named_label_use_entry *use;
2799 /* Mark label as having been defined. */
2800 DECL_INITIAL (decl) = error_mark_node;
2801 /* Say where in the source. */
2802 DECL_SOURCE_LOCATION (decl) = location;
2804 ent->binding_level = current_binding_level;
2805 ent->names_in_scope = current_binding_level->names;
2807 for (use = ent->uses; use ; use = use->next)
2808 check_previous_goto (decl, use);
2812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2817 struct cp_binding_level *level;
2818 struct cp_switch *next;
2819 /* The SWITCH_STMT being built. */
2821 /* A splay-tree mapping the low element of a case range to the high
2822 element, or NULL_TREE if there is no high element. Used to
2823 determine whether or not a new case label duplicates an old case
2824 label. We need a tree, rather than simply a hash table, because
2825 of the GNU case range extension. */
2829 /* A stack of the currently active switch statements. The innermost
2830 switch statement is on the top of the stack. There is no need to
2831 mark the stack for garbage collection because it is only active
2832 during the processing of the body of a function, and we never
2833 collect at that point. */
2835 static struct cp_switch *switch_stack;
2837 /* Called right after a switch-statement condition is parsed.
2838 SWITCH_STMT is the switch statement being parsed. */
2841 push_switch (tree switch_stmt)
2843 struct cp_switch *p = XNEW (struct cp_switch);
2844 p->level = current_binding_level;
2845 p->next = switch_stack;
2846 p->switch_stmt = switch_stmt;
2847 p->cases = splay_tree_new (case_compare, NULL, NULL);
2854 struct cp_switch *cs = switch_stack;
2855 location_t switch_location;
2857 /* Emit warnings as needed. */
2858 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2859 switch_location = EXPR_LOCATION (cs->switch_stmt);
2861 switch_location = input_location;
2862 if (!processing_template_decl)
2863 c_do_switch_warnings (cs->cases, switch_location,
2864 SWITCH_STMT_TYPE (cs->switch_stmt),
2865 SWITCH_STMT_COND (cs->switch_stmt));
2867 splay_tree_delete (cs->cases);
2868 switch_stack = switch_stack->next;
2872 /* Note that we've seen a definition of a case label, and complain if this
2873 is a bad place for one. */
2876 finish_case_label (location_t loc, tree low_value, tree high_value)
2879 struct cp_binding_level *p;
2881 if (processing_template_decl)
2885 /* For templates, just add the case label; we'll do semantic
2886 analysis at instantiation-time. */
2887 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
2888 return add_stmt (build_case_label (loc, low_value, high_value, label));
2891 /* Find the condition on which this switch statement depends. */
2892 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2893 if (cond && TREE_CODE (cond) == TREE_LIST)
2894 cond = TREE_VALUE (cond);
2896 if (!check_switch_goto (switch_stack->level))
2897 return error_mark_node;
2899 r = c_add_case_label (loc, switch_stack->cases, cond,
2900 SWITCH_STMT_TYPE (switch_stack->switch_stmt),
2901 low_value, high_value);
2903 /* After labels, make any new cleanups in the function go into their
2904 own new (temporary) binding contour. */
2905 for (p = current_binding_level;
2906 p->kind != sk_function_parms;
2908 p->more_cleanups_ok = 0;
2913 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2916 typename_hash (const void* k)
2919 const_tree const t = (const_tree) k;
2921 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2922 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2927 typedef struct typename_info {
2935 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2936 really of type `typename_info*' */
2939 typename_compare (const void * k1, const void * k2)
2941 const_tree const t1 = (const_tree) k1;
2942 const typename_info *const t2 = (const typename_info *) k2;
2944 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2945 && TYPE_CONTEXT (t1) == t2->scope
2946 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2947 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2948 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2951 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2952 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2954 Returns the new TYPENAME_TYPE. */
2956 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2959 build_typename_type (tree context, tree name, tree fullname,
2960 enum tag_types tag_type)
2968 if (typename_htab == NULL)
2969 typename_htab = htab_create_ggc (61, &typename_hash,
2970 &typename_compare, NULL);
2972 ti.scope = FROB_CONTEXT (context);
2974 ti.template_id = fullname;
2975 ti.enum_p = tag_type == enum_type;
2976 ti.class_p = (tag_type == class_type
2977 || tag_type == record_type
2978 || tag_type == union_type);
2979 hash = (htab_hash_pointer (ti.scope)
2980 ^ htab_hash_pointer (ti.name));
2982 /* See if we already have this type. */
2983 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2988 /* Build the TYPENAME_TYPE. */
2989 t = cxx_make_type (TYPENAME_TYPE);
2990 TYPE_CONTEXT (t) = ti.scope;
2991 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2992 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2993 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2995 /* Build the corresponding TYPE_DECL. */
2996 d = build_decl (input_location, TYPE_DECL, name, t);
2997 TYPE_NAME (TREE_TYPE (d)) = d;
2998 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2999 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3000 DECL_ARTIFICIAL (d) = 1;
3002 /* Store it in the hash table. */
3005 /* TYPENAME_TYPEs must always be compared structurally, because
3006 they may or may not resolve down to another type depending on
3007 the currently open classes. */
3008 SET_TYPE_STRUCTURAL_EQUALITY (t);
3014 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3015 provided to name the type. Returns an appropriate type, unless an
3016 error occurs, in which case error_mark_node is returned. If we
3017 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3018 return that, rather than the _TYPE it corresponds to, in other
3019 cases we look through the type decl. If TF_ERROR is set, complain
3020 about errors, otherwise be quiet. */
3023 make_typename_type (tree context, tree name, enum tag_types tag_type,
3024 tsubst_flags_t complain)
3030 if (name == error_mark_node
3031 || context == NULL_TREE
3032 || context == error_mark_node)
3033 return error_mark_node;
3037 if (!(TYPE_LANG_SPECIFIC (name)
3038 && (CLASSTYPE_IS_TEMPLATE (name)
3039 || CLASSTYPE_USE_TEMPLATE (name))))
3040 name = TYPE_IDENTIFIER (name);
3042 /* Create a TEMPLATE_ID_EXPR for the type. */
3043 name = build_nt (TEMPLATE_ID_EXPR,
3044 CLASSTYPE_TI_TEMPLATE (name),
3045 CLASSTYPE_TI_ARGS (name));
3047 else if (TREE_CODE (name) == TYPE_DECL)
3048 name = DECL_NAME (name);
3052 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3054 name = TREE_OPERAND (name, 0);
3055 if (TREE_CODE (name) == TEMPLATE_DECL)
3056 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3057 else if (TREE_CODE (name) == OVERLOAD)
3059 error ("%qD is not a type", name);
3060 return error_mark_node;
3063 if (TREE_CODE (name) == TEMPLATE_DECL)
3065 error ("%qD used without template parameters", name);
3066 return error_mark_node;
3068 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3069 gcc_assert (TYPE_P (context));
3071 if (!MAYBE_CLASS_TYPE_P (context))
3073 if (complain & tf_error)
3074 error ("%q#T is not a class", context);
3075 return error_mark_node;
3078 /* When the CONTEXT is a dependent type, NAME could refer to a
3079 dependent base class of CONTEXT. But look inside it anyway
3080 if CONTEXT is a currently open scope, in case it refers to a
3081 member of the current instantiation or a non-dependent base;
3082 lookup will stop when we hit a dependent base. */
3083 if (!dependent_scope_p (context))
3084 /* We should only set WANT_TYPE when we're a nested typename type.
3085 Then we can give better diagnostics if we find a non-type. */
3086 t = lookup_field (context, name, 2, /*want_type=*/true);
3090 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3091 return build_typename_type (context, name, fullname, tag_type);
3093 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3097 if (complain & tf_error)
3098 error (want_template ? "no class template named %q#T in %q#T"
3099 : "no type named %q#T in %q#T", name, context);
3100 return error_mark_node;
3103 /* Pull out the template from an injected-class-name (or multiple). */
3105 t = maybe_get_template_decl_from_type_decl (t);
3107 if (TREE_CODE (t) == TREE_LIST)
3109 if (complain & tf_error)
3111 error ("lookup of %qT in %qT is ambiguous", name, context);
3112 print_candidates (t);
3114 return error_mark_node;
3117 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3119 if (complain & tf_error)
3120 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3122 return error_mark_node;
3124 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3126 if (complain & tf_error)
3127 error ("%<typename %T::%D%> names %q#T, which is not a type",
3129 return error_mark_node;
3132 if (complain & tf_error)
3133 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3135 /* If we are currently parsing a template and if T is a typedef accessed
3136 through CONTEXT then we need to remember and check access of T at
3137 template instantiation time. */
3138 add_typedef_to_current_template_for_access_check (t, context, input_location);
3141 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3143 /*entering_scope=*/0,
3144 tf_warning_or_error | tf_user);
3146 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3152 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3153 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3154 in which case error_mark_node is returned.
3156 If PARM_LIST is non-NULL, also make sure that the template parameter
3157 list of TEMPLATE_DECL matches.
3159 If COMPLAIN zero, don't complain about any errors that occur. */
3162 make_unbound_class_template (tree context, tree name, tree parm_list,
3163 tsubst_flags_t complain)
3169 name = TYPE_IDENTIFIER (name);
3170 else if (DECL_P (name))
3171 name = DECL_NAME (name);
3172 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3174 if (!dependent_type_p (context)
3175 || currently_open_class (context))
3177 tree tmpl = NULL_TREE;
3179 if (MAYBE_CLASS_TYPE_P (context))
3180 tmpl = lookup_field (context, name, 0, false);
3182 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3184 if (complain & tf_error)
3185 error ("no class template named %q#T in %q#T", name, context);
3186 return error_mark_node;
3190 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3192 if (complain & tf_error)
3194 error ("template parameters do not match template");
3195 error ("%q+D declared here", tmpl);
3197 return error_mark_node;
3200 if (complain & tf_error)
3201 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3206 /* Build the UNBOUND_CLASS_TEMPLATE. */
3207 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3208 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3209 TREE_TYPE (t) = NULL_TREE;
3210 SET_TYPE_STRUCTURAL_EQUALITY (t);
3212 /* Build the corresponding TEMPLATE_DECL. */
3213 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3214 TYPE_NAME (TREE_TYPE (d)) = d;
3215 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3216 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3217 DECL_ARTIFICIAL (d) = 1;
3218 DECL_TEMPLATE_PARMS (d) = parm_list;
3225 /* Push the declarations of builtin types into the namespace.
3226 RID_INDEX is the index of the builtin type in the array
3227 RID_POINTERS. NAME is the name used when looking up the builtin
3228 type. TYPE is the _TYPE node for the builtin type. */
3231 record_builtin_type (enum rid rid_index,
3235 tree rname = NULL_TREE, tname = NULL_TREE;
3236 tree tdecl = NULL_TREE;
3238 if ((int) rid_index < (int) RID_MAX)
3239 rname = ridpointers[(int) rid_index];
3241 tname = get_identifier (name);
3243 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3244 eliminated. Built-in types should not be looked up name; their
3245 names are keywords that the parser can recognize. However, there
3246 is code in c-common.c that uses identifier_global_value to look
3247 up built-in types by name. */
3250 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3251 DECL_ARTIFICIAL (tdecl) = 1;
3252 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3258 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3259 DECL_ARTIFICIAL (tdecl) = 1;
3261 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3264 if (!TYPE_NAME (type))
3265 TYPE_NAME (type) = tdecl;
3268 debug_hooks->type_decl (tdecl, 0);
3271 /* Record one of the standard Java types.
3272 * Declare it as having the given NAME.
3273 * If SIZE > 0, it is the size of one of the integral types;
3274 * otherwise it is the negative of the size of one of the other types. */
3277 record_builtin_java_type (const char* name, int size)
3281 type = build_nonstandard_integer_type (size, 0);
3282 else if (size > -32)
3285 /* "__java_char" or ""__java_boolean". */
3286 type = build_nonstandard_integer_type (-size, 1);
3287 /* Get the signed type cached and attached to the unsigned type,
3288 so it doesn't get garbage-collected at "random" times,
3289 causing potential codegen differences out of different UIDs
3290 and different alias set numbers. */
3291 stype = build_nonstandard_integer_type (-size, 0);
3292 TREE_CHAIN (type) = stype;
3293 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3296 { /* "__java_float" or ""__java_double". */
3297 type = make_node (REAL_TYPE);
3298 TYPE_PRECISION (type) = - size;
3301 record_builtin_type (RID_MAX, name, type);
3302 decl = TYPE_NAME (type);
3304 /* Suppress generate debug symbol entries for these types,
3305 since for normal C++ they are just clutter.
3306 However, push_lang_context undoes this if extern "Java" is seen. */
3307 DECL_IGNORED_P (decl) = 1;
3309 TYPE_FOR_JAVA (type) = 1;
3313 /* Push a type into the namespace so that the back ends ignore it. */
3316 record_unknown_type (tree type, const char* name)
3318 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3319 TYPE_DECL, get_identifier (name), type));
3320 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3321 DECL_IGNORED_P (decl) = 1;
3322 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3323 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3324 TYPE_ALIGN (type) = 1;
3325 TYPE_USER_ALIGN (type) = 0;
3326 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3329 /* A string for which we should create an IDENTIFIER_NODE at
3332 typedef struct predefined_identifier
3334 /* The name of the identifier. */
3335 const char *const name;
3336 /* The place where the IDENTIFIER_NODE should be stored. */
3338 /* Nonzero if this is the name of a constructor or destructor. */
3339 const int ctor_or_dtor_p;
3340 } predefined_identifier;
3342 /* Create all the predefined identifiers. */
3345 initialize_predefined_identifiers (void)
3347 const predefined_identifier *pid;
3349 /* A table of identifiers to create at startup. */
3350 static const predefined_identifier predefined_identifiers[] = {
3351 { "C++", &lang_name_cplusplus, 0 },
3352 { "C", &lang_name_c, 0 },
3353 { "Java", &lang_name_java, 0 },
3354 /* Some of these names have a trailing space so that it is
3355 impossible for them to conflict with names written by users. */
3356 { "__ct ", &ctor_identifier, 1 },
3357 { "__base_ctor ", &base_ctor_identifier, 1 },
3358 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3359 { "__dt ", &dtor_identifier, 1 },
3360 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3361 { "__base_dtor ", &base_dtor_identifier, 1 },
3362 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3363 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3364 { "nelts", &nelts_identifier, 0 },
3365 { THIS_NAME, &this_identifier, 0 },
3366 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3367 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3368 { "_vptr", &vptr_identifier, 0 },
3369 { "__vtt_parm", &vtt_parm_identifier, 0 },
3370 { "::", &global_scope_name, 0 },
3371 { "std", &std_identifier, 0 },
3375 for (pid = predefined_identifiers; pid->name; ++pid)
3377 *pid->node = get_identifier (pid->name);
3378 if (pid->ctor_or_dtor_p)
3379 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3383 /* Create the predefined scalar types of C,
3384 and some nodes representing standard constants (0, 1, (void *)0).
3385 Initialize the global binding level.
3386 Make definitions for built-in primitive functions. */
3389 cxx_init_decl_processing (void)
3392 tree void_ftype_ptr;
3394 build_common_tree_nodes (flag_signed_char);
3396 /* Create all the identifiers we need. */
3397 initialize_predefined_identifiers ();
3399 /* Create the global variables. */
3400 push_to_top_level ();
3402 current_function_decl = NULL_TREE;
3403 current_binding_level = NULL;
3404 /* Enter the global namespace. */
3405 gcc_assert (global_namespace == NULL_TREE);
3406 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3408 TREE_PUBLIC (global_namespace) = 1;
3409 begin_scope (sk_namespace, global_namespace);
3411 current_lang_name = NULL_TREE;
3413 if (flag_visibility_ms_compat)
3414 default_visibility = VISIBILITY_HIDDEN;
3417 current_lang_name = lang_name_c;
3419 /* Create the `std' namespace. */
3420 push_namespace (std_identifier);
3421 std_node = current_namespace;
3424 c_common_nodes_and_builtins ();
3426 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3427 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3428 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3429 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3430 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3431 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3432 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3433 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3435 integer_two_node = build_int_cst (NULL_TREE, 2);
3436 integer_three_node = build_int_cst (NULL_TREE, 3);
3438 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3439 truthvalue_type_node = boolean_type_node;
3440 truthvalue_false_node = boolean_false_node;
3441 truthvalue_true_node = boolean_true_node;
3443 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3444 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
3445 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
3448 record_builtin_type (RID_MAX, NULL, string_type_node);
3451 delta_type_node = ptrdiff_type_node;
3452 vtable_index_type = ptrdiff_type_node;
3454 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3455 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
3456 void_ftype_ptr = build_function_type_list (void_type_node,
3457 ptr_type_node, NULL_TREE);
3459 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3461 /* C++ extensions */
3463 unknown_type_node = make_node (LANG_TYPE);
3464 record_unknown_type (unknown_type_node, "unknown type");
3466 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3467 TREE_TYPE (unknown_type_node) = unknown_type_node;
3469 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3471 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3472 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3474 init_list_type_node = make_node (LANG_TYPE);
3475 record_unknown_type (init_list_type_node, "init list");
3478 /* Make sure we get a unique function type, so we can give
3479 its pointer type a name. (This wins for gdb.) */
3480 tree vfunc_type = make_node (FUNCTION_TYPE);
3481 TREE_TYPE (vfunc_type) = integer_type_node;
3482 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3483 layout_type (vfunc_type);
3485 vtable_entry_type = build_pointer_type (vfunc_type);
3487 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3490 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3491 layout_type (vtbl_type_node);
3492 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3493 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3494 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3495 layout_type (vtbl_ptr_type_node);
3496 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3498 push_namespace (get_identifier ("__cxxabiv1"));
3499 abi_node = current_namespace;
3502 global_type_node = make_node (LANG_TYPE);
3503 record_unknown_type (global_type_node, "global type");
3506 current_lang_name = lang_name_cplusplus;
3509 tree newtype, deltype;
3510 tree ptr_ftype_sizetype;
3514 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
3515 if (cxx_dialect == cxx98)
3518 tree bad_alloc_type_node;
3519 tree bad_alloc_decl;
3521 push_namespace (std_identifier);
3522 bad_alloc_id = get_identifier ("bad_alloc");
3523 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3524 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3526 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3527 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3531 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
3534 new_eh_spec = noexcept_false_spec;
3536 newtype = build_exception_variant (ptr_ftype_sizetype, new_eh_spec);
3537 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3538 push_cp_library_fn (NEW_EXPR, newtype);
3539 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3540 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3541 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3543 nullptr_type_node = make_node (LANG_TYPE);
3544 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
3545 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
3546 TYPE_UNSIGNED (nullptr_type_node) = 1;
3547 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
3548 SET_TYPE_MODE (nullptr_type_node, Pmode);
3549 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
3550 nullptr_node = make_node (INTEGER_CST);
3551 TREE_TYPE (nullptr_node) = nullptr_type_node;
3555 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3557 /* Perform other language dependent initializations. */
3558 init_class_processing ();
3559 init_rtti_processing ();
3560 init_template_processing ();
3562 if (flag_exceptions)
3563 init_exception_processing ();
3565 if (! supports_one_only ())
3568 make_fname_decl = cp_make_fname_decl;
3569 start_fname_decls ();
3571 /* Show we use EH for cleanups. */
3572 if (flag_exceptions)
3573 using_eh_for_cleanups ();
3576 /* Generate an initializer for a function naming variable from
3577 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3578 filled in with the type of the init. */
3581 cp_fname_init (const char* name, tree *type_p)
3583 tree domain = NULL_TREE;
3585 tree init = NULL_TREE;
3590 length = strlen (name);
3591 domain = build_index_type (size_int (length));
3592 init = build_string (length + 1, name);
3595 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3596 type = build_cplus_array_type (type, domain);
3601 TREE_TYPE (init) = type;
3603 init = error_mark_node;
3608 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3609 the decl, LOC is the location to give the decl, NAME is the
3610 initialization string and TYPE_DEP indicates whether NAME depended
3611 on the type of the function. We make use of that to detect
3612 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3613 at the point of first use, so we mustn't push the decl now. */
3616 cp_make_fname_decl (location_t loc, tree id, int type_dep)
3618 const char *const name = (type_dep && processing_template_decl
3619 ? NULL : fname_as_string (type_dep));
3621 tree init = cp_fname_init (name, &type);
3622 tree decl = build_decl (loc, VAR_DECL, id, type);
3625 free (CONST_CAST (char *, name));
3627 /* As we're using pushdecl_with_scope, we must set the context. */
3628 DECL_CONTEXT (decl) = current_function_decl;
3629 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3631 TREE_STATIC (decl) = 1;
3632 TREE_READONLY (decl) = 1;
3633 DECL_ARTIFICIAL (decl) = 1;
3635 TREE_USED (decl) = 1;
3637 if (current_function_decl)
3639 struct cp_binding_level *b = current_binding_level;
3640 while (b->level_chain->kind != sk_function_parms)
3642 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3643 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3644 LOOKUP_ONLYCONVERTING);
3647 pushdecl_top_level_and_finish (decl, init);
3653 builtin_function_1 (tree decl, tree context, bool is_global)
3655 tree id = DECL_NAME (decl);
3656 const char *name = IDENTIFIER_POINTER (id);
3658 retrofit_lang_decl (decl);
3660 DECL_ARTIFICIAL (decl) = 1;
3661 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3662 SET_DECL_LANGUAGE (decl, lang_c);
3663 /* Runtime library routines are, by definition, available in an
3664 external shared object. */
3665 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3666 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3668 DECL_CONTEXT (decl) = context;
3671 pushdecl_top_level (decl);
3675 /* A function in the user's namespace should have an explicit
3676 declaration before it is used. Mark the built-in function as
3677 anticipated but not actually declared. */
3678 if (name[0] != '_' || name[1] != '_')
3679 DECL_ANTICIPATED (decl) = 1;
3680 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3682 size_t len = strlen (name);
3684 /* Treat __*_chk fortification functions as anticipated as well,
3685 unless they are __builtin_*. */
3686 if (len > strlen ("___chk")
3687 && memcmp (name + len - strlen ("_chk"),
3688 "_chk", strlen ("_chk") + 1) == 0)
3689 DECL_ANTICIPATED (decl) = 1;
3696 cxx_builtin_function (tree decl)
3698 tree id = DECL_NAME (decl);
3699 const char *name = IDENTIFIER_POINTER (id);
3700 /* All builtins that don't begin with an '_' should additionally
3701 go in the 'std' namespace. */
3704 tree decl2 = copy_node(decl);
3705 push_namespace (std_identifier);
3706 builtin_function_1 (decl2, std_node, false);
3710 return builtin_function_1 (decl, NULL_TREE, false);
3713 /* Like cxx_builtin_function, but guarantee the function is added to the global
3714 scope. This is to allow function specific options to add new machine
3715 dependent builtins when the target ISA changes via attribute((target(...)))
3716 which saves space on program startup if the program does not use non-generic
3720 cxx_builtin_function_ext_scope (tree decl)
3723 tree id = DECL_NAME (decl);
3724 const char *name = IDENTIFIER_POINTER (id);
3725 /* All builtins that don't begin with an '_' should additionally
3726 go in the 'std' namespace. */
3729 tree decl2 = copy_node(decl);
3730 push_namespace (std_identifier);
3731 builtin_function_1 (decl2, std_node, true);
3735 return builtin_function_1 (decl, NULL_TREE, true);
3738 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3739 function. Not called directly. */
3742 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3744 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3745 DECL_EXTERNAL (fn) = 1;
3746 TREE_PUBLIC (fn) = 1;
3747 DECL_ARTIFICIAL (fn) = 1;
3748 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3749 SET_DECL_LANGUAGE (fn, lang_c);
3750 /* Runtime library routines are, by definition, available in an
3751 external shared object. */
3752 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3753 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3757 /* Returns the _DECL for a library function with C linkage.
3758 We assume that such functions never throw; if this is incorrect,
3759 callers should unset TREE_NOTHROW. */
3762 build_library_fn (tree name, tree type)
3764 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3765 TREE_NOTHROW (fn) = 1;
3769 /* Returns the _DECL for a library function with C++ linkage. */
3772 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3774 tree fn = build_library_fn_1 (name, operator_code, type);
3775 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3776 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3777 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3781 /* Like build_library_fn, but takes a C string instead of an
3785 build_library_fn_ptr (const char* name, tree type)
3787 return build_library_fn (get_identifier (name), type);
3790 /* Like build_cp_library_fn, but takes a C string instead of an
3794 build_cp_library_fn_ptr (const char* name, tree type)
3796 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3799 /* Like build_library_fn, but also pushes the function so that we will
3800 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3801 may throw exceptions listed in RAISES. */
3804 push_library_fn (tree name, tree type, tree raises)
3809 type = build_exception_variant (type, raises);
3811 fn = build_library_fn (name, type);
3812 pushdecl_top_level (fn);
3816 /* Like build_cp_library_fn, but also pushes the function so that it
3817 will be found by normal lookup. */
3820 push_cp_library_fn (enum tree_code operator_code, tree type)
3822 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3829 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3833 push_void_library_fn (tree name, tree parmtypes)
3835 tree type = build_function_type (void_type_node, parmtypes);
3836 return push_library_fn (name, type, NULL_TREE);
3839 /* Like push_library_fn, but also note that this function throws
3840 and does not return. Used for __throw_foo and the like. */
3843 push_throw_library_fn (tree name, tree type)
3845 tree fn = push_library_fn (name, type, NULL_TREE);
3846 TREE_THIS_VOLATILE (fn) = 1;
3847 TREE_NOTHROW (fn) = 0;
3851 /* When we call finish_struct for an anonymous union, we create
3852 default copy constructors and such. But, an anonymous union
3853 shouldn't have such things; this function undoes the damage to the
3854 anonymous union type T.
3856 (The reason that we create the synthesized methods is that we don't
3857 distinguish `union { int i; }' from `typedef union { int i; } U'.
3858 The first is an anonymous union; the second is just an ordinary
3862 fixup_anonymous_aggr (tree t)
3866 /* Wipe out memory of synthesized methods. */
3867 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
3868 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3869 TYPE_HAS_COPY_CTOR (t) = 0;
3870 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
3871 TYPE_HAS_COPY_ASSIGN (t) = 0;
3872 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
3874 /* Splice the implicitly generated functions out of the TYPE_METHODS
3876 q = &TYPE_METHODS (t);
3879 if (DECL_ARTIFICIAL (*q))
3880 *q = TREE_CHAIN (*q);
3882 q = &TREE_CHAIN (*q);
3885 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3886 if (TYPE_METHODS (t))
3888 tree decl = TYPE_MAIN_DECL (t);
3890 if (TREE_CODE (t) != UNION_TYPE)
3891 error_at (DECL_SOURCE_LOCATION (decl),
3892 "an anonymous struct cannot have function members");
3894 error_at (DECL_SOURCE_LOCATION (decl),
3895 "an anonymous union cannot have function members");
3898 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3899 assignment operators (because they cannot have these methods themselves).
3900 For anonymous unions this is already checked because they are not allowed
3901 in any union, otherwise we have to check it. */
3902 if (TREE_CODE (t) != UNION_TYPE)
3906 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3907 if (TREE_CODE (field) == FIELD_DECL)
3909 type = TREE_TYPE (field);
3910 if (CLASS_TYPE_P (type))
3912 if (TYPE_NEEDS_CONSTRUCTING (type))
3913 error ("member %q+#D with constructor not allowed "
3914 "in anonymous aggregate", field);
3915 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3916 error ("member %q+#D with destructor not allowed "
3917 "in anonymous aggregate", field);
3918 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
3919 error ("member %q+#D with copy assignment operator "
3920 "not allowed in anonymous aggregate", field);
3926 /* Make sure that a declaration with no declarator is well-formed, i.e.
3927 just declares a tagged type or anonymous union.
3929 Returns the type declared; or NULL_TREE if none. */
3932 check_tag_decl (cp_decl_specifier_seq *declspecs)
3934 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3935 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3936 /* If a class, struct, or enum type is declared by the DECLSPECS
3937 (i.e, if a class-specifier, enum-specifier, or non-typename
3938 elaborated-type-specifier appears in the DECLSPECS),
3939 DECLARED_TYPE is set to the corresponding type. */
3940 tree declared_type = NULL_TREE;
3941 bool error_p = false;
3943 if (declspecs->multiple_types_p)
3944 error ("multiple types in one declaration");
3945 else if (declspecs->redefined_builtin_type)
3947 if (!in_system_header)
3948 permerror (input_location, "redeclaration of C++ built-in type %qT",
3949 declspecs->redefined_builtin_type);
3954 && TYPE_P (declspecs->type)
3955 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3956 && MAYBE_CLASS_TYPE_P (declspecs->type))
3957 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3958 declared_type = declspecs->type;
3959 else if (declspecs->type == error_mark_node)
3961 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3962 permerror (input_location, "declaration does not declare anything");
3963 /* Check for an anonymous union. */
3964 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
3965 && TYPE_ANONYMOUS_P (declared_type))
3967 /* 7/3 In a simple-declaration, the optional init-declarator-list
3968 can be omitted only when declaring a class (clause 9) or
3969 enumeration (7.2), that is, when the decl-specifier-seq contains
3970 either a class-specifier, an elaborated-type-specifier with
3971 a class-key (9.1), or an enum-specifier. In these cases and
3972 whenever a class-specifier or enum-specifier is present in the
3973 decl-specifier-seq, the identifiers in these specifiers are among
3974 the names being declared by the declaration (as class-name,
3975 enum-names, or enumerators, depending on the syntax). In such
3976 cases, and except for the declaration of an unnamed bit-field (9.6),
3977 the decl-specifier-seq shall introduce one or more names into the
3978 program, or shall redeclare a name introduced by a previous
3979 declaration. [Example:
3980 enum { }; // ill-formed
3981 typedef class { }; // ill-formed
3985 error ("missing type-name in typedef-declaration");
3988 /* Anonymous unions are objects, so they can have specifiers. */;
3989 SET_ANON_AGGR_TYPE_P (declared_type);
3991 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
3992 pedwarn (input_location, OPT_pedantic, "ISO C++ prohibits anonymous structs");
3997 if (declspecs->specs[(int)ds_inline]
3998 || declspecs->specs[(int)ds_virtual])
3999 error ("%qs can only be specified for functions",
4000 declspecs->specs[(int)ds_inline]
4001 ? "inline" : "virtual");
4003 && (!current_class_type
4004 || current_scope () != current_class_type))
4005 error ("%<friend%> can only be specified inside a class");
4006 else if (declspecs->specs[(int)ds_explicit])
4007 error ("%<explicit%> can only be specified for constructors");
4008 else if (declspecs->storage_class)
4009 error ("a storage class can only be specified for objects "
4011 else if (declspecs->specs[(int)ds_const]
4012 || declspecs->specs[(int)ds_volatile]
4013 || declspecs->specs[(int)ds_restrict]
4014 || declspecs->specs[(int)ds_thread])
4015 error ("qualifiers can only be specified for objects "
4017 else if (saw_typedef)
4018 warning (0, "%<typedef%> was ignored in this declaration");
4019 else if (declspecs->specs[(int) ds_constexpr])
4020 error ("%<constexpr> cannot be used for type declarations");
4023 return declared_type;
4026 /* Called when a declaration is seen that contains no names to declare.
4027 If its type is a reference to a structure, union or enum inherited
4028 from a containing scope, shadow that tag name for the current scope
4029 with a forward reference.
4030 If its type defines a new named structure or union
4031 or defines an enum, it is valid but we need not do anything here.
4032 Otherwise, it is an error.
4034 C++: may have to grok the declspecs to learn about static,
4035 complain for anonymous unions.
4037 Returns the TYPE declared -- or NULL_TREE if none. */
4040 shadow_tag (cp_decl_specifier_seq *declspecs)
4042 tree t = check_tag_decl (declspecs);
4047 if (declspecs->attributes)
4049 warning (0, "attribute ignored in declaration of %q+#T", t);
4050 warning (0, "attribute for %q+#T must follow the %qs keyword",
4051 t, class_key_or_enum_as_string (t));
4055 if (maybe_process_partial_specialization (t) == error_mark_node)
4058 /* This is where the variables in an anonymous union are
4059 declared. An anonymous union declaration looks like:
4061 because there is no declarator after the union, the parser
4062 sends that declaration here. */
4063 if (ANON_AGGR_TYPE_P (t))
4065 fixup_anonymous_aggr (t);
4067 if (TYPE_FIELDS (t))
4069 tree decl = grokdeclarator (/*declarator=*/NULL,
4070 declspecs, NORMAL, 0, NULL);
4071 finish_anon_union (decl);
4078 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4081 groktypename (cp_decl_specifier_seq *type_specifiers,
4082 const cp_declarator *declarator,
4083 bool is_template_arg)
4087 enum decl_context context
4088 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
4089 attrs = type_specifiers->attributes;
4090 type_specifiers->attributes = NULL_TREE;
4091 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
4092 if (attrs && type != error_mark_node)
4094 if (CLASS_TYPE_P (type))
4095 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
4096 "outside of definition", type);
4097 else if (MAYBE_CLASS_TYPE_P (type))
4098 /* A template type parameter or other dependent type. */
4099 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4100 "type %qT without an associated declaration", type);
4102 cplus_decl_attributes (&type, attrs, 0);
4107 /* Process a DECLARATOR for a function-scope variable declaration,
4108 namespace-scope variable declaration, or function declaration.
4109 (Function definitions go through start_function; class member
4110 declarations appearing in the body of the class go through
4111 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4112 If an error occurs, the error_mark_node is returned instead.
4114 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4115 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4116 for an explicitly defaulted function, or SD_DELETED for an explicitly
4117 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4118 implicitly initialized via a default constructor. ATTRIBUTES and
4119 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4120 *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
4121 set, the caller is responsible for calling pop_scope. */
4124 start_decl (const cp_declarator *declarator,
4125 cp_decl_specifier_seq *declspecs,
4128 tree prefix_attributes,
4129 tree *pushed_scope_p)
4137 *pushed_scope_p = NULL_TREE;
4139 /* An object declared as __attribute__((deprecated)) suppresses
4140 warnings of uses of other deprecated items. */
4141 if (lookup_attribute ("deprecated", attributes))
4142 deprecated_state = DEPRECATED_SUPPRESS;
4144 attributes = chainon (attributes, prefix_attributes);
4146 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4149 deprecated_state = DEPRECATED_NORMAL;
4151 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4152 || decl == error_mark_node)
4153 return error_mark_node;
4155 context = DECL_CONTEXT (decl);
4159 *pushed_scope_p = push_scope (context);
4161 /* We are only interested in class contexts, later. */
4162 if (TREE_CODE (context) == NAMESPACE_DECL)
4163 context = NULL_TREE;
4167 /* Is it valid for this decl to have an initializer at all?
4168 If not, set INITIALIZED to zero, which will indirectly
4169 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4170 switch (TREE_CODE (decl))
4173 error ("typedef %qD is initialized (use decltype instead)", decl);
4174 return error_mark_node;
4177 if (initialized == SD_DELETED)
4178 /* We'll handle the rest of the semantics later, but we need to
4179 set this now so it's visible to duplicate_decls. */
4180 DECL_DELETED_FN (decl) = 1;
4189 if (! toplevel_bindings_p ()
4190 && DECL_EXTERNAL (decl))
4191 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4193 DECL_EXTERNAL (decl) = 0;
4194 if (toplevel_bindings_p ())
4195 TREE_STATIC (decl) = 1;
4197 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
4199 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
4200 record_key_method_defined (decl);
4202 /* If this is a typedef that names the class for linkage purposes
4203 (7.1.3p8), apply any attributes directly to the type. */
4204 if (TREE_CODE (decl) == TYPE_DECL
4205 && TAGGED_TYPE_P (TREE_TYPE (decl))
4206 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4207 flags = ATTR_FLAG_TYPE_IN_PLACE;
4211 /* Set attributes here so if duplicate decl, will have proper attributes. */
4212 cplus_decl_attributes (&decl, attributes, flags);
4214 /* Dllimported symbols cannot be defined. Static data members (which
4215 can be initialized in-class and dllimported) go through grokfield,
4216 not here, so we don't need to exclude those decls when checking for
4218 if (initialized && DECL_DLLIMPORT_P (decl))
4220 error ("definition of %q#D is marked %<dllimport%>", decl);
4221 DECL_DLLIMPORT_P (decl) = 0;
4224 /* If #pragma weak was used, mark the decl weak now. */
4225 maybe_apply_pragma_weak (decl);
4227 if (TREE_CODE (decl) == FUNCTION_DECL
4228 && DECL_DECLARED_INLINE_P (decl)
4229 && DECL_UNINLINABLE (decl)
4230 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4231 warning (0, "inline function %q+D given attribute noinline", decl);
4233 if (context && COMPLETE_TYPE_P (complete_type (context)))
4235 if (TREE_CODE (decl) == VAR_DECL)
4237 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4238 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4239 error ("%q#D is not a static member of %q#T", decl, context);
4242 if (DECL_CONTEXT (field) != context)
4244 if (!same_type_p (DECL_CONTEXT (field), context))
4245 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4246 "to be defined as %<%T::%D%>",
4247 DECL_CONTEXT (field), DECL_NAME (decl),
4248 context, DECL_NAME (decl));
4249 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4251 if (processing_specialization
4252 && template_class_depth (context) == 0
4253 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4254 error ("template header not allowed in member definition "
4255 "of explicitly specialized class");
4256 /* Static data member are tricky; an in-class initialization
4257 still doesn't provide a definition, so the in-class
4258 declaration will have DECL_EXTERNAL set, but will have an
4259 initialization. Thus, duplicate_decls won't warn
4260 about this situation, and so we check here. */
4261 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4262 error ("duplicate initialization of %qD", decl);
4263 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4265 if (declspecs->specs[(int) ds_constexpr]
4266 && !DECL_DECLARED_CONSTEXPR_P (field))
4267 error ("%qD declared %<constexpr%> outside its class", field);
4272 tree field = check_classfn (context, decl,
4273 (processing_template_decl
4274 > template_class_depth (context))
4275 ? current_template_parms
4277 if (field && field != error_mark_node
4278 && duplicate_decls (decl, field,
4279 /*newdecl_is_friend=*/false))
4283 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4284 DECL_IN_AGGR_P (decl) = 0;
4285 /* Do not mark DECL as an explicit specialization if it was not
4286 already marked as an instantiation; a declaration should
4287 never be marked as a specialization unless we know what
4288 template is being specialized. */
4289 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4291 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4293 /* [temp.expl.spec] An explicit specialization of a static data
4294 member of a template is a definition if the declaration
4295 includes an initializer; otherwise, it is a declaration.
4297 We check for processing_specialization so this only applies
4298 to the new specialization syntax. */
4299 if (!initialized && processing_specialization)
4300 DECL_EXTERNAL (decl) = 1;
4303 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
4304 /* Aliases are definitions. */
4306 permerror (input_location, "declaration of %q#D outside of class is not definition",
4309 if (!ensure_literal_type_for_constexpr_object (decl))
4310 return error_mark_node;
4313 was_public = TREE_PUBLIC (decl);
4315 /* Enter this declaration into the symbol table. */
4316 decl = maybe_push_decl (decl);
4318 if (processing_template_decl)
4319 decl = push_template_decl (decl);
4320 if (decl == error_mark_node)
4321 return error_mark_node;
4323 /* Tell the back end to use or not use .common as appropriate. If we say
4324 -fconserve-space, we want this to save .data space, at the expense of
4325 wrong semantics. If we say -fno-conserve-space, we want this to
4326 produce errors about redefs; to do this we force variables into the
4328 if (flag_conserve_space
4329 && TREE_CODE (decl) == VAR_DECL
4330 && TREE_PUBLIC (decl)
4331 && !DECL_THREAD_LOCAL_P (decl)
4332 && !have_global_bss_p ())
4333 DECL_COMMON (decl) = 1;
4335 if (TREE_CODE (decl) == VAR_DECL
4336 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4337 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4339 /* This is a const variable with implicit 'static'. Set
4340 DECL_THIS_STATIC so we can tell it from variables that are
4341 !TREE_PUBLIC because of the anonymous namespace. */
4342 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)));
4343 DECL_THIS_STATIC (decl) = 1;
4346 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4347 start_decl_1 (decl, initialized);
4352 /* Process the declaration of a variable DECL. INITIALIZED is true
4353 iff DECL is explicitly initialized. (INITIALIZED is false if the
4354 variable is initialized via an implicitly-called constructor.)
4355 This function must be called for ordinary variables (including, for
4356 example, implicit instantiations of templates), but must not be
4357 called for template declarations. */
4360 start_decl_1 (tree decl, bool initialized)
4364 bool aggregate_definition_p;
4366 gcc_assert (!processing_template_decl);
4368 if (error_operand_p (decl))
4371 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4373 type = TREE_TYPE (decl);
4374 complete_p = COMPLETE_TYPE_P (type);
4375 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4377 /* If an explicit initializer is present, or if this is a definition
4378 of an aggregate, then we need a complete type at this point.
4379 (Scalars are always complete types, so there is nothing to
4380 check.) This code just sets COMPLETE_P; errors (if necessary)
4381 are issued below. */
4382 if ((initialized || aggregate_definition_p)
4384 && COMPLETE_TYPE_P (complete_type (type)))
4387 /* We will not yet have set TREE_READONLY on DECL if the type
4388 was "const", but incomplete, before this point. But, now, we
4389 have a complete type, so we can try again. */
4390 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4394 /* Is it valid for this decl to have an initializer at all? */
4396 /* Don't allow initializations for incomplete types except for
4397 arrays which might be completed by the initialization. */
4399 ; /* A complete type is ok. */
4400 else if (type_uses_auto (type))
4401 ; /* An auto type is ok. */
4402 else if (TREE_CODE (type) != ARRAY_TYPE)
4404 error ("variable %q#D has initializer but incomplete type", decl);
4405 type = TREE_TYPE (decl) = error_mark_node;
4407 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4409 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4410 error ("elements of array %q#D have incomplete type", decl);
4411 /* else we already gave an error in start_decl. */
4414 else if (aggregate_definition_p && !complete_p)
4416 if (type_uses_auto (type))
4417 error ("declaration of %q#D has no initializer", decl);
4419 error ("aggregate %q#D has incomplete type and cannot be defined",
4421 /* Change the type so that assemble_variable will give
4422 DECL an rtl we can live with: (mem (const_int 0)). */
4423 type = TREE_TYPE (decl) = error_mark_node;
4426 /* Create a new scope to hold this declaration if necessary.
4427 Whether or not a new scope is necessary cannot be determined
4428 until after the type has been completed; if the type is a
4429 specialization of a class template it is not until after
4430 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4431 will be set correctly. */
4432 maybe_push_cleanup_level (type);
4435 /* Handle initialization of references. DECL, TYPE, and INIT have the
4436 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4437 but will be set to a new CLEANUP_STMT if a temporary is created
4438 that must be destroyed subsequently.
4440 Returns an initializer expression to use to initialize DECL, or
4441 NULL if the initialization can be performed statically.
4443 Quotes on semantics can be found in ARM 8.4.3. */
4446 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4450 if (init == NULL_TREE)
4452 if ((DECL_LANG_SPECIFIC (decl) == 0
4453 || DECL_IN_AGGR_P (decl) == 0)
4454 && ! DECL_THIS_EXTERN (decl))
4455 error ("%qD declared as reference but not initialized", decl);
4459 if (TREE_CODE (init) == TREE_LIST)
4460 init = build_x_compound_expr_from_list (init, ELK_INIT);
4462 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4463 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4464 /* Note: default conversion is only called in very special cases. */
4465 init = decay_conversion (init);
4467 /* Convert INIT to the reference type TYPE. This may involve the
4468 creation of a temporary, whose lifetime must be the same as that
4469 of the reference. If so, a DECL_EXPR for the temporary will be
4470 added just after the DECL_EXPR for DECL. That's why we don't set
4471 DECL_INITIAL for local references (instead assigning to them
4472 explicitly); we need to allow the temporary to be initialized
4474 tmp = initialize_reference (type, init, decl, cleanup, tf_warning_or_error);
4476 if (tmp == error_mark_node)
4478 else if (tmp == NULL_TREE)
4480 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4484 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4487 DECL_INITIAL (decl) = tmp;
4492 /* Subroutine of check_initializer. We're initializing a DECL of
4493 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4494 extend the lifetime of the underlying array to match that of the decl,
4495 just like for reference initialization. CLEANUP is as for
4496 grok_reference_init. */
4499 build_init_list_var_init (tree decl, tree type, tree init, tree *cleanup)
4501 tree aggr_init, array, arrtype;
4502 init = perform_implicit_conversion (type, init, tf_warning_or_error);
4503 if (error_operand_p (init))
4504 return error_mark_node;
4506 aggr_init = TARGET_EXPR_INITIAL (init);
4507 init = build2 (INIT_EXPR, type, decl, init);
4509 array = AGGR_INIT_EXPR_ARG (aggr_init, 1);
4510 arrtype = TREE_TYPE (array);
4512 gcc_assert (TREE_CODE (array) == ADDR_EXPR);
4513 array = TREE_OPERAND (array, 0);
4514 /* If the array is constant, finish_compound_literal already made it a
4515 static variable and we don't need to do anything here. */
4516 if (decl && TREE_CODE (array) == TARGET_EXPR)
4519 tree var = set_up_extended_ref_temp (decl, array, cleanup, &subinit);
4520 var = build_address (var);
4521 var = convert (arrtype, var);
4522 AGGR_INIT_EXPR_ARG (aggr_init, 1) = var;
4523 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init);
4528 /* Designated initializers in arrays are not supported in GNU C++.
4529 The parser cannot detect this error since it does not know whether
4530 a given brace-enclosed initializer is for a class type or for an
4531 array. This function checks that CE does not use a designated
4532 initializer. If it does, an error is issued. Returns true if CE
4533 is valid, i.e., does not have a designated initializer. */
4536 check_array_designated_initializer (const constructor_elt *ce)
4538 /* Designated initializers for array elements are not supported. */
4541 /* The parser only allows identifiers as designated
4543 if (ce->index == error_mark_node)
4544 error ("name used in a GNU-style designated "
4545 "initializer for an array");
4548 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4549 error ("name %qD used in a GNU-style designated "
4550 "initializer for an array", ce->index);
4558 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4559 array until we finish parsing the initializer. If that's the
4560 situation we're in, update DECL accordingly. */
4563 maybe_deduce_size_from_array_init (tree decl, tree init)
4565 tree type = TREE_TYPE (decl);
4567 if (TREE_CODE (type) == ARRAY_TYPE
4568 && TYPE_DOMAIN (type) == NULL_TREE
4569 && TREE_CODE (decl) != TYPE_DECL)
4571 /* do_default is really a C-ism to deal with tentative definitions.
4572 But let's leave it here to ease the eventual merge. */
4573 int do_default = !DECL_EXTERNAL (decl);
4574 tree initializer = init ? init : DECL_INITIAL (decl);
4577 /* Check that there are no designated initializers in INIT, as
4578 those are not supported in GNU C++, and as the middle-end
4579 will crash if presented with a non-numeric designated
4581 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4583 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4584 constructor_elt *ce;
4587 VEC_iterate (constructor_elt, v, i, ce);
4589 if (!check_array_designated_initializer (ce))
4595 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4599 error ("initializer fails to determine size of %qD", decl);
4600 TREE_TYPE (decl) = error_mark_node;
4602 else if (failure == 2)
4606 error ("array size missing in %qD", decl);
4607 TREE_TYPE (decl) = error_mark_node;
4609 /* If a `static' var's size isn't known, make it extern as
4610 well as static, so it does not get allocated. If it's not
4611 `static', then don't mark it extern; finish_incomplete_decl
4612 will give it a default size and it will get allocated. */
4613 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4614 DECL_EXTERNAL (decl) = 1;
4616 else if (failure == 3)
4618 error ("zero-size array %qD", decl);
4619 TREE_TYPE (decl) = error_mark_node;
4623 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4625 relayout_decl (decl);
4629 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4630 any appropriate error messages regarding the layout. */
4633 layout_var_decl (tree decl)
4637 type = TREE_TYPE (decl);
4638 if (type == error_mark_node)
4641 /* If we haven't already layed out this declaration, do so now.
4642 Note that we must not call complete type for an external object
4643 because it's type might involve templates that we are not
4644 supposed to instantiate yet. (And it's perfectly valid to say
4645 `extern X x' for some incomplete type `X'.) */
4646 if (!DECL_EXTERNAL (decl))
4647 complete_type (type);
4648 if (!DECL_SIZE (decl)
4649 && TREE_TYPE (decl) != error_mark_node
4650 && (COMPLETE_TYPE_P (type)
4651 || (TREE_CODE (type) == ARRAY_TYPE
4652 && !TYPE_DOMAIN (type)
4653 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4654 layout_decl (decl, 0);
4656 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4658 /* An automatic variable with an incomplete type: that is an error.
4659 Don't talk about array types here, since we took care of that
4660 message in grokdeclarator. */
4661 error ("storage size of %qD isn't known", decl);
4662 TREE_TYPE (decl) = error_mark_node;
4665 /* Keep this code around in case we later want to control debug info
4666 based on whether a type is "used". (jason 1999-11-11) */
4668 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4669 /* Let debugger know it should output info for this type. */
4670 note_debug_info_needed (ttype);
4672 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4673 note_debug_info_needed (DECL_CONTEXT (decl));
4676 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4677 && DECL_SIZE (decl) != NULL_TREE
4678 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4680 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4681 constant_expression_warning (DECL_SIZE (decl));
4684 error ("storage size of %qD isn't constant", decl);
4685 TREE_TYPE (decl) = error_mark_node;
4690 /* If a local static variable is declared in an inline function, or if
4691 we have a weak definition, we must endeavor to create only one
4692 instance of the variable at link-time. */
4695 maybe_commonize_var (tree decl)
4697 /* Static data in a function with comdat linkage also has comdat
4699 if (TREE_STATIC (decl)
4700 /* Don't mess with __FUNCTION__. */
4701 && ! DECL_ARTIFICIAL (decl)
4702 && DECL_FUNCTION_SCOPE_P (decl)
4703 && vague_linkage_p (DECL_CONTEXT (decl)))
4707 /* With weak symbols, we simply make the variable COMDAT;
4708 that will cause copies in multiple translations units to
4710 comdat_linkage (decl);
4714 if (DECL_INITIAL (decl) == NULL_TREE
4715 || DECL_INITIAL (decl) == error_mark_node)
4717 /* Without weak symbols, we can use COMMON to merge
4718 uninitialized variables. */
4719 TREE_PUBLIC (decl) = 1;
4720 DECL_COMMON (decl) = 1;
4724 /* While for initialized variables, we must use internal
4725 linkage -- which means that multiple copies will not
4727 TREE_PUBLIC (decl) = 0;
4728 DECL_COMMON (decl) = 0;
4729 warning_at (input_location, 0,
4730 "sorry: semantics of inline function static "
4731 "data %q+#D are wrong (you'll wind up "
4732 "with multiple copies)", decl);
4733 warning_at (DECL_SOURCE_LOCATION (decl), 0,
4734 " you can work around this by removing "
4739 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4740 /* Set it up again; we might have set DECL_INITIAL since the last
4742 comdat_linkage (decl);
4745 /* Issue an error message if DECL is an uninitialized const variable. */
4748 check_for_uninitialized_const_var (tree decl)
4750 tree type = strip_array_types (TREE_TYPE (decl));
4752 if (TREE_CODE (decl) == VAR_DECL && DECL_DECLARED_CONSTEXPR_P (decl)
4753 && DECL_INITIAL (decl) == NULL)
4754 error ("missing initializer for constexpr %qD", decl);
4756 /* ``Unless explicitly declared extern, a const object does not have
4757 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4759 else if (TREE_CODE (decl) == VAR_DECL
4760 && TREE_CODE (type) != REFERENCE_TYPE
4761 && CP_TYPE_CONST_P (type)
4762 && (!TYPE_NEEDS_CONSTRUCTING (type)
4763 || !type_has_user_provided_default_constructor (type))
4764 && !DECL_INITIAL (decl))
4766 permerror (DECL_SOURCE_LOCATION (decl),
4767 "uninitialized const %qD", decl);
4769 if (CLASS_TYPE_P (type)
4770 && !type_has_user_provided_default_constructor (type))
4772 tree defaulted_ctor;
4774 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
4775 "%q#T has no user-provided default constructor", type);
4776 defaulted_ctor = in_class_defaulted_default_constructor (type);
4778 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
4779 "constructor is not user-provided because it is "
4780 "explicitly defaulted in the class body");
4785 /* Structure holding the current initializer being processed by reshape_init.
4786 CUR is a pointer to the current element being processed, END is a pointer
4787 after the last element present in the initializer. */
4788 typedef struct reshape_iterator_t
4790 constructor_elt *cur;
4791 constructor_elt *end;
4794 static tree reshape_init_r (tree, reshape_iter *, bool);
4796 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4797 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4798 initialized. If there are no more such fields, the return value
4802 next_initializable_field (tree field)
4805 && (TREE_CODE (field) != FIELD_DECL
4806 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4807 || DECL_ARTIFICIAL (field)))
4808 field = TREE_CHAIN (field);
4813 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4814 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4815 INTEGER_CST representing the size of the array minus one (the maximum index),
4816 or NULL_TREE if the array was declared without specifying the size. D is
4817 the iterator within the constructor. */
4820 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4823 bool sized_array_p = (max_index != NULL_TREE);
4824 unsigned HOST_WIDE_INT max_index_cst = 0;
4825 unsigned HOST_WIDE_INT index;
4827 /* The initializer for an array is always a CONSTRUCTOR. */
4828 new_init = build_constructor (init_list_type_node, NULL);
4832 /* Minus 1 is used for zero sized arrays. */
4833 if (integer_all_onesp (max_index))
4836 if (host_integerp (max_index, 1))
4837 max_index_cst = tree_low_cst (max_index, 1);
4838 /* sizetype is sign extended, not zero extended. */
4840 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4844 /* Loop until there are no more initializers. */
4846 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4851 check_array_designated_initializer (d->cur);
4852 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4853 if (elt_init == error_mark_node)
4854 return error_mark_node;
4855 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4861 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4862 Parameters are the same of reshape_init_r. */
4865 reshape_init_array (tree type, reshape_iter *d)
4867 tree max_index = NULL_TREE;
4869 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4871 if (TYPE_DOMAIN (type))
4872 max_index = array_type_nelts (type);
4874 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4877 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4878 Parameters are the same of reshape_init_r. */
4881 reshape_init_vector (tree type, reshape_iter *d)
4883 tree max_index = NULL_TREE;
4886 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4888 if (COMPOUND_LITERAL_P (d->cur->value))
4890 tree value = d->cur->value;
4891 if (!same_type_p (TREE_TYPE (value), type))
4893 error ("invalid type %qT as initializer for a vector of type %qT",
4894 TREE_TYPE (d->cur->value), type);
4895 value = error_mark_node;
4901 /* For a vector, the representation type is a struct
4902 containing a single member which is an array of the
4903 appropriate size. */
4904 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4905 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4906 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4908 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4911 /* Subroutine of reshape_init_r, processes the initializers for classes
4912 or union. Parameters are the same of reshape_init_r. */
4915 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4920 gcc_assert (CLASS_TYPE_P (type));
4922 /* The initializer for a class is always a CONSTRUCTOR. */
4923 new_init = build_constructor (init_list_type_node, NULL);
4924 field = next_initializable_field (TYPE_FIELDS (type));
4930 An initializer for an aggregate member that is an
4931 empty class shall have the form of an empty
4932 initializer-list {}. */
4933 if (!first_initializer_p)
4935 error ("initializer for %qT must be brace-enclosed", type);
4936 return error_mark_node;
4941 /* Loop through the initializable fields, gathering initializers. */
4942 while (d->cur != d->end)
4946 /* Handle designated initializers, as an extension. */
4949 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4951 if (!field || TREE_CODE (field) != FIELD_DECL)
4953 error ("%qT has no non-static data member named %qD", type,
4955 return error_mark_node;
4959 /* If we processed all the member of the class, we are done. */
4963 field_init = reshape_init_r (TREE_TYPE (field), d,
4964 /*first_initializer_p=*/false);
4965 if (field_init == error_mark_node)
4966 return error_mark_node;
4968 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4972 When a union is initialized with a brace-enclosed
4973 initializer, the braces shall only contain an
4974 initializer for the first member of the union. */
4975 if (TREE_CODE (type) == UNION_TYPE)
4978 field = next_initializable_field (TREE_CHAIN (field));
4984 /* Subroutine of reshape_init, which processes a single initializer (part of
4985 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4986 iterator within the CONSTRUCTOR which points to the initializer to process.
4987 FIRST_INITIALIZER_P is true if this is the first initializer of the
4988 outermost CONSTRUCTOR node. */
4991 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4993 tree init = d->cur->value;
4995 if (error_operand_p (init))
4996 return error_mark_node;
4998 /* A non-aggregate type is always initialized with a single
5000 if (!CP_AGGREGATE_TYPE_P (type))
5002 /* It is invalid to initialize a non-aggregate type with a
5003 brace-enclosed initializer before C++0x.
5004 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5005 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5006 a CONSTRUCTOR (with a record type). */
5007 if (TREE_CODE (init) == CONSTRUCTOR
5008 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
5010 if (SCALAR_TYPE_P (type))
5012 error ("braces around scalar initializer for type %qT", type);
5013 init = error_mark_node;
5016 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5025 All implicit type conversions (clause _conv_) are considered when
5026 initializing the aggregate member with an initializer from an
5027 initializer-list. If the initializer can initialize a member,
5028 the member is initialized. Otherwise, if the member is itself a
5029 non-empty subaggregate, brace elision is assumed and the
5030 initializer is considered for the initialization of the first
5031 member of the subaggregate. */
5032 if (TREE_CODE (init) != CONSTRUCTOR
5033 /* But don't try this for the first initializer, since that would be
5034 looking through the outermost braces; A a2 = { a1 }; is not a
5035 valid aggregate initialization. */
5036 && !first_initializer_p
5037 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
5038 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL)))
5044 /* [dcl.init.string]
5046 A char array (whether plain char, signed char, or unsigned char)
5047 can be initialized by a string-literal (optionally enclosed in
5048 braces); a wchar_t array can be initialized by a wide
5049 string-literal (optionally enclosed in braces). */
5050 if (TREE_CODE (type) == ARRAY_TYPE
5051 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
5053 tree str_init = init;
5055 /* Strip one level of braces if and only if they enclose a single
5056 element (as allowed by [dcl.init.string]). */
5057 if (!first_initializer_p
5058 && TREE_CODE (str_init) == CONSTRUCTOR
5059 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
5061 str_init = VEC_index (constructor_elt,
5062 CONSTRUCTOR_ELTS (str_init), 0)->value;
5065 /* If it's a string literal, then it's the initializer for the array
5066 as a whole. Otherwise, continue with normal initialization for
5067 array types (one value per array element). */
5068 if (TREE_CODE (str_init) == STRING_CST)
5075 /* The following cases are about aggregates. If we are not within a full
5076 initializer already, and there is not a CONSTRUCTOR, it means that there
5077 is a missing set of braces (that is, we are processing the case for
5078 which reshape_init exists). */
5079 if (!first_initializer_p)
5081 if (TREE_CODE (init) == CONSTRUCTOR)
5083 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
5084 /* There is no need to reshape pointer-to-member function
5085 initializers, as they are always constructed correctly
5086 by the front end. */
5088 else if (COMPOUND_LITERAL_P (init))
5089 /* For a nested compound literal, there is no need to reshape since
5090 brace elision is not allowed. Even if we decided to allow it,
5091 we should add a call to reshape_init in finish_compound_literal,
5092 before calling digest_init, so changing this code would still
5093 not be necessary. */
5094 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
5098 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5099 return reshape_init (type, init);
5103 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
5107 /* Dispatch to specialized routines. */
5108 if (CLASS_TYPE_P (type))
5109 return reshape_init_class (type, d, first_initializer_p);
5110 else if (TREE_CODE (type) == ARRAY_TYPE)
5111 return reshape_init_array (type, d);
5112 else if (TREE_CODE (type) == VECTOR_TYPE)
5113 return reshape_init_vector (type, d);
5118 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5119 brace-enclosed aggregate initializer.
5121 INIT is the CONSTRUCTOR containing the list of initializers describing
5122 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5123 It may not presently match the shape of the TYPE; for example:
5125 struct S { int a; int b; };
5126 struct S a[] = { 1, 2, 3, 4 };
5128 Here INIT will hold a VEC of four elements, rather than a
5129 VEC of two elements, each itself a VEC of two elements. This
5130 routine transforms INIT from the former form into the latter. The
5131 revised CONSTRUCTOR node is returned. */
5134 reshape_init (tree type, tree init)
5136 VEC(constructor_elt, gc) *v;
5140 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5142 v = CONSTRUCTOR_ELTS (init);
5144 /* An empty constructor does not need reshaping, and it is always a valid
5146 if (VEC_empty (constructor_elt, v))
5149 /* Recurse on this CONSTRUCTOR. */
5150 d.cur = VEC_index (constructor_elt, v, 0);
5151 d.end = d.cur + VEC_length (constructor_elt, v);
5153 new_init = reshape_init_r (type, &d, true);
5154 if (new_init == error_mark_node)
5155 return error_mark_node;
5157 /* Make sure all the element of the constructor were used. Otherwise,
5158 issue an error about exceeding initializers. */
5160 error ("too many initializers for %qT", type);
5165 /* Verify array initializer. Returns true if errors have been reported. */
5168 check_array_initializer (tree decl, tree type, tree init)
5170 tree element_type = TREE_TYPE (type);
5172 /* The array type itself need not be complete, because the
5173 initializer may tell us how many elements are in the array.
5174 But, the elements of the array must be complete. */
5175 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5178 error ("elements of array %q#D have incomplete type", decl);
5180 error ("elements of array %q#T have incomplete type", type);
5183 /* It is not valid to initialize a VLA. */
5185 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5186 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5189 error ("variable-sized object %qD may not be initialized", decl);
5191 error ("variable-sized compound literal");
5197 /* Subroutine of check_initializer; args are passed down from that function.
5198 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5201 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5204 int saved_stmts_are_full_exprs_p = 0;
5205 if (building_stmt_tree ())
5207 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5208 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5210 init = build_aggr_init (decl, init, flags, tf_warning_or_error);
5211 if (building_stmt_tree ())
5212 current_stmt_tree ()->stmts_are_full_exprs_p =
5213 saved_stmts_are_full_exprs_p;
5217 /* Verify INIT (the initializer for DECL), and record the
5218 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5219 grok_reference_init.
5221 If the return value is non-NULL, it is an expression that must be
5222 evaluated dynamically to initialize DECL. */
5225 check_initializer (tree decl, tree init, int flags, tree *cleanup)
5227 tree type = TREE_TYPE (decl);
5228 tree init_code = NULL;
5231 /* Things that are going to be initialized need to have complete
5233 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5235 if (type == error_mark_node)
5236 /* We will have already complained. */
5239 if (TREE_CODE (type) == ARRAY_TYPE)
5241 if (check_array_initializer (decl, type, init))
5244 else if (!COMPLETE_TYPE_P (type))
5246 error ("%qD has incomplete type", decl);
5247 TREE_TYPE (decl) = error_mark_node;
5251 /* There is no way to make a variable-sized class type in GNU C++. */
5252 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5254 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5256 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5257 if (SCALAR_TYPE_P (type))
5261 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5262 init = build_zero_init (type, NULL_TREE, false);
5264 else if (init_len != 1)
5266 error ("scalar object %qD requires one element in initializer",
5268 TREE_TYPE (decl) = error_mark_node;
5274 if (TREE_CODE (decl) == CONST_DECL)
5276 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5278 DECL_INITIAL (decl) = init;
5280 gcc_assert (init != NULL_TREE);
5283 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
5284 init = grok_reference_init (decl, type, init, cleanup);
5287 /* Do not reshape constructors of vectors (they don't need to be
5289 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5291 if (is_std_init_list (type))
5292 return build_init_list_var_init (decl, type, init, cleanup);
5293 else if (TYPE_NON_AGGREGATE_CLASS (type))
5295 /* Don't reshape if the class has constructors. */
5296 if (cxx_dialect == cxx98)
5297 error ("in C++98 %qD must be initialized by constructor, "
5301 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5303 error ("opaque vector types cannot be initialized");
5304 init = error_mark_node;
5307 init = reshape_init (type, init);
5310 /* If DECL has an array type without a specific bound, deduce the
5311 array size from the initializer. */
5312 maybe_deduce_size_from_array_init (decl, init);
5313 type = TREE_TYPE (decl);
5314 if (type == error_mark_node)
5317 if (TYPE_NEEDS_CONSTRUCTING (type)
5318 || (CLASS_TYPE_P (type)
5319 && !BRACE_ENCLOSED_INITIALIZER_P (init)))
5320 return build_aggr_init_full_exprs (decl, init, flags);
5321 else if (TREE_CODE (init) != TREE_VEC)
5323 init_code = store_init_value (decl, init, flags);
5324 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5325 && DECL_INITIAL (decl)
5326 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5327 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5328 warning (0, "array %qD initialized by parenthesized string literal %qE",
5329 decl, DECL_INITIAL (decl));
5333 else if (DECL_EXTERNAL (decl))
5335 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
5337 check_for_uninitialized_const_var (decl);
5338 return build_aggr_init_full_exprs (decl, init, flags);
5340 else if (MAYBE_CLASS_TYPE_P (core_type = strip_array_types (type)))
5342 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
5343 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
5344 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
5347 check_for_uninitialized_const_var (decl);
5350 check_for_uninitialized_const_var (decl);
5352 if (init && init != error_mark_node)
5353 init_code = build2 (INIT_EXPR, type, decl, init);
5358 /* If DECL is not a local variable, give it RTL. */
5361 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5363 int toplev = toplevel_bindings_p ();
5365 const char *filename;
5367 /* Set the DECL_ASSEMBLER_NAME for the object. */
5370 /* The `register' keyword, when used together with an
5371 asm-specification, indicates that the variable should be
5372 placed in a particular register. */
5373 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5375 set_user_assembler_name (decl, asmspec);
5376 DECL_HARD_REGISTER (decl) = 1;
5380 if (TREE_CODE (decl) == FUNCTION_DECL
5381 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5382 set_builtin_user_assembler_name (decl, asmspec);
5383 set_user_assembler_name (decl, asmspec);
5387 /* Handle non-variables up front. */
5388 if (TREE_CODE (decl) != VAR_DECL)
5390 rest_of_decl_compilation (decl, toplev, at_eof);
5394 /* If we see a class member here, it should be a static data
5396 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5398 gcc_assert (TREE_STATIC (decl));
5399 /* An in-class declaration of a static data member should be
5400 external; it is only a declaration, and not a definition. */
5401 if (init == NULL_TREE)
5402 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5405 /* We don't create any RTL for local variables. */
5406 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5409 /* We defer emission of local statics until the corresponding
5410 DECL_EXPR is expanded. */
5411 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5413 /* We try to defer namespace-scope static constants so that they are
5414 not emitted into the object file unnecessarily. */
5415 filename = input_filename;
5416 if (!DECL_VIRTUAL_P (decl)
5417 && TREE_READONLY (decl)
5418 && DECL_INITIAL (decl) != NULL_TREE
5419 && DECL_INITIAL (decl) != error_mark_node
5421 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5423 && !TREE_PUBLIC (decl))
5425 /* Fool with the linkage of static consts according to #pragma
5427 struct c_fileinfo *finfo = get_fileinfo (filename);
5428 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5430 TREE_PUBLIC (decl) = 1;
5431 DECL_EXTERNAL (decl) = finfo->interface_only;
5436 /* Likewise for template instantiations. */
5437 else if (DECL_LANG_SPECIFIC (decl)
5438 && DECL_IMPLICIT_INSTANTIATION (decl))
5441 /* If we're not deferring, go ahead and assemble the variable. */
5443 rest_of_decl_compilation (decl, toplev, at_eof);
5446 /* walk_tree helper for wrap_temporary_cleanups, below. */
5449 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5451 if (TYPE_P (*stmt_p))
5457 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5459 tree guard = (tree)data;
5460 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5462 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5463 /* Tell honor_protect_cleanup_actions to handle this as a separate
5465 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5467 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5473 /* We're initializing a local variable which has a cleanup GUARD. If there
5474 are any temporaries used in the initializer INIT of this variable, we
5475 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5476 variable will be cleaned up properly if one of them throws.
5478 Unfortunately, there's no way to express this properly in terms of
5479 nesting, as the regions for the temporaries overlap the region for the
5480 variable itself; if there are two temporaries, the variable needs to be
5481 the first thing destroyed if either of them throws. However, we only
5482 want to run the variable's cleanup if it actually got constructed. So
5483 we need to guard the temporary cleanups with the variable's cleanup if
5484 they are run on the normal path, but not if they are run on the
5485 exceptional path. We implement this by telling
5486 honor_protect_cleanup_actions to strip the variable cleanup from the
5487 exceptional path. */
5490 wrap_temporary_cleanups (tree init, tree guard)
5492 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5495 /* Generate code to initialize DECL (a local variable). */
5498 initialize_local_var (tree decl, tree init)
5500 tree type = TREE_TYPE (decl);
5504 gcc_assert (TREE_CODE (decl) == VAR_DECL
5505 || TREE_CODE (decl) == RESULT_DECL);
5506 gcc_assert (!TREE_STATIC (decl));
5508 if (DECL_SIZE (decl) == NULL_TREE)
5510 /* If we used it already as memory, it must stay in memory. */
5511 DECL_INITIAL (decl) = NULL_TREE;
5512 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5516 if (type == error_mark_node)
5519 /* Compute and store the initial value. */
5520 already_used = TREE_USED (decl) || TREE_USED (type);
5521 if (TREE_USED (type))
5522 DECL_READ_P (decl) = 1;
5524 /* Generate a cleanup, if necessary. */
5525 cleanup = cxx_maybe_build_cleanup (decl);
5527 /* Perform the initialization. */
5530 int saved_stmts_are_full_exprs_p;
5532 /* If we're only initializing a single object, guard the destructors
5533 of any temporaries used in its initializer with its destructor.
5534 This isn't right for arrays because each element initialization is
5535 a full-expression. */
5536 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5537 wrap_temporary_cleanups (init, cleanup);
5539 gcc_assert (building_stmt_tree ());
5540 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5541 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5542 finish_expr_stmt (init);
5543 current_stmt_tree ()->stmts_are_full_exprs_p =
5544 saved_stmts_are_full_exprs_p;
5547 /* Set this to 0 so we can tell whether an aggregate which was
5548 initialized was ever used. Don't do this if it has a
5549 destructor, so we don't complain about the 'resource
5550 allocation is initialization' idiom. Now set
5551 attribute((unused)) on types so decls of that type will be
5552 marked used. (see TREE_USED, above.) */
5553 if (TYPE_NEEDS_CONSTRUCTING (type)
5555 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5556 && DECL_NAME (decl))
5557 TREE_USED (decl) = 0;
5558 else if (already_used)
5559 TREE_USED (decl) = 1;
5562 finish_decl_cleanup (decl, cleanup);
5565 /* DECL is a VAR_DECL for a compiler-generated variable with static
5566 storage duration (like a virtual table) whose initializer is a
5567 compile-time constant. Initialize the variable and provide it to the
5571 initialize_artificial_var (tree decl, VEC(constructor_elt,gc) *v)
5574 gcc_assert (DECL_ARTIFICIAL (decl));
5575 init = build_constructor (TREE_TYPE (decl), v);
5576 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5577 DECL_INITIAL (decl) = init;
5578 DECL_INITIALIZED_P (decl) = 1;
5579 determine_visibility (decl);
5580 layout_var_decl (decl);
5581 maybe_commonize_var (decl);
5582 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5585 /* INIT is the initializer for a variable, as represented by the
5586 parser. Returns true iff INIT is value-dependent. */
5589 value_dependent_init_p (tree init)
5591 if (TREE_CODE (init) == TREE_LIST)
5592 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5593 return any_value_dependent_elements_p (init);
5594 else if (TREE_CODE (init) == CONSTRUCTOR)
5595 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5597 VEC(constructor_elt, gc) *elts;
5601 elts = CONSTRUCTOR_ELTS (init);
5602 nelts = VEC_length (constructor_elt, elts);
5603 for (i = 0; i < nelts; ++i)
5604 if (value_dependent_init_p (VEC_index (constructor_elt,
5609 /* It must be a simple expression, e.g., int i = 3; */
5610 return value_dependent_expression_p (init);
5615 /* Finish processing of a declaration;
5616 install its line number and initial value.
5617 If the length of an array type is not known before,
5618 it must be determined now, from the initial value, or it is an error.
5620 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5621 true, then INIT is an integral constant expression.
5623 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5624 if the (init) syntax was used. */
5627 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5628 tree asmspec_tree, int flags)
5632 const char *asmspec = NULL;
5633 int was_readonly = 0;
5634 bool var_definition_p = false;
5635 int saved_processing_template_decl;
5638 if (decl == error_mark_node)
5643 error ("assignment (not initialization) in declaration");
5647 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5648 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5649 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5651 type = TREE_TYPE (decl);
5652 if (type == error_mark_node)
5655 /* Assume no cleanup is required. */
5656 cleanup = NULL_TREE;
5657 saved_processing_template_decl = processing_template_decl;
5659 /* If a name was specified, get the string. */
5660 if (global_scope_p (current_binding_level))
5661 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5662 if (asmspec_tree && asmspec_tree != error_mark_node)
5663 asmspec = TREE_STRING_POINTER (asmspec_tree);
5665 if (current_class_type
5666 && CP_DECL_CONTEXT (decl) == current_class_type
5667 && TYPE_BEING_DEFINED (current_class_type)
5668 && (DECL_INITIAL (decl) || init))
5669 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5671 auto_node = type_uses_auto (type);
5674 if (init == NULL_TREE)
5676 error ("declaration of %q#D has no initializer", decl);
5677 TREE_TYPE (decl) = error_mark_node;
5680 if (TREE_CODE (init) == TREE_LIST)
5681 init = build_x_compound_expr_from_list (init, ELK_INIT);
5682 if (describable_type (init))
5684 type = TREE_TYPE (decl) = do_auto_deduction (type, init, auto_node);
5685 if (type == error_mark_node)
5690 if (init && TREE_CODE (decl) == FUNCTION_DECL)
5693 if (init == ridpointers[(int)RID_DELETE])
5695 /* FIXME check this is 1st decl. */
5696 DECL_DELETED_FN (decl) = 1;
5697 DECL_DECLARED_INLINE_P (decl) = 1;
5698 DECL_INITIAL (decl) = error_mark_node;
5699 FOR_EACH_CLONE (clone, decl)
5701 DECL_DELETED_FN (clone) = 1;
5702 DECL_DECLARED_INLINE_P (clone) = 1;
5703 DECL_INITIAL (clone) = error_mark_node;
5707 else if (init == ridpointers[(int)RID_DEFAULT])
5709 if (defaultable_fn_check (decl))
5710 DECL_DEFAULTED_FN (decl) = 1;
5712 DECL_INITIAL (decl) = NULL_TREE;
5716 if (processing_template_decl)
5718 bool type_dependent_p;
5720 /* Add this declaration to the statement-tree. */
5721 if (at_function_scope_p ())
5722 add_decl_expr (decl);
5724 type_dependent_p = dependent_type_p (type);
5726 if (check_for_bare_parameter_packs (init))
5729 DECL_INITIAL (decl) = NULL_TREE;
5732 if (init && init_const_expr_p && TREE_CODE (decl) == VAR_DECL)
5734 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5735 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5736 TREE_CONSTANT (decl) = 1;
5739 /* Generally, initializers in templates are expanded when the
5740 template is instantiated. But, if DECL is an integral
5741 constant static data member, then it can be used in future
5742 integral constant expressions, and its value must be
5745 && DECL_CLASS_SCOPE_P (decl)
5746 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5747 && !type_dependent_p
5748 && !value_dependent_init_p (init)))
5751 DECL_INITIAL (decl) = init;
5752 if (TREE_CODE (decl) == VAR_DECL
5753 && !DECL_PRETTY_FUNCTION_P (decl)
5754 && !type_dependent_p)
5755 maybe_deduce_size_from_array_init (decl, init);
5759 if (TREE_CODE (init) == TREE_LIST)
5761 /* If the parenthesized-initializer form was used (e.g.,
5762 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5763 arguments. (There is generally only one.) We convert them
5766 for (; list; list = TREE_CHAIN (list))
5768 tree elt = TREE_VALUE (list);
5769 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5773 init = fold_non_dependent_expr (init);
5774 processing_template_decl = 0;
5777 /* Take care of TYPE_DECLs up front. */
5778 if (TREE_CODE (decl) == TYPE_DECL)
5780 if (type != error_mark_node
5781 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
5783 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5784 warning (0, "shadowing previous type declaration of %q#D", decl);
5785 set_identifier_type_value (DECL_NAME (decl), decl);
5788 /* If we have installed this as the canonical typedef for this
5789 type, and that type has not been defined yet, delay emitting
5790 the debug information for it, as we will emit it later. */
5791 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5792 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5793 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5795 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5800 /* A reference will be modified here, as it is initialized. */
5801 if (! DECL_EXTERNAL (decl)
5802 && TREE_READONLY (decl)
5803 && TREE_CODE (type) == REFERENCE_TYPE)
5806 TREE_READONLY (decl) = 0;
5809 if (TREE_CODE (decl) == VAR_DECL)
5811 /* Only variables with trivial initialization and destruction can
5812 have thread-local storage. */
5813 if (DECL_THREAD_LOCAL_P (decl)
5814 && (type_has_nontrivial_default_init (TREE_TYPE (decl))
5815 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
5816 error ("%qD cannot be thread-local because it has non-trivial "
5817 "type %qT", decl, TREE_TYPE (decl));
5818 /* If this is a local variable that will need a mangled name,
5819 register it now. We must do this before processing the
5820 initializer for the variable, since the initialization might
5821 require a guard variable, and since the mangled name of the
5822 guard variable will depend on the mangled name of this
5824 if (DECL_FUNCTION_SCOPE_P (decl)
5825 && TREE_STATIC (decl)
5826 && !DECL_ARTIFICIAL (decl))
5828 push_local_name (decl);
5829 if (DECL_CONSTRUCTOR_P (current_function_decl)
5830 || DECL_DESTRUCTOR_P (current_function_decl))
5831 /* Normally local_decls is populated during GIMPLE lowering,
5832 but [cd]tors are never actually compiled directly. We need
5833 to put statics on the list so we can deal with the label
5834 address extension. */
5835 cfun->local_decls = tree_cons (NULL_TREE, decl,
5839 /* Convert the initializer to the type of DECL, if we have not
5840 already initialized DECL. */
5841 if (!DECL_INITIALIZED_P (decl)
5842 /* If !DECL_EXTERNAL then DECL is being defined. In the
5843 case of a static data member initialized inside the
5844 class-specifier, there can be an initializer even if DECL
5845 is *not* defined. */
5846 && (!DECL_EXTERNAL (decl) || init))
5848 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5851 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5852 /* Allow libjava/prims.cc define primitive classes. */
5853 if (init != NULL_TREE
5854 || jclass == NULL_TREE
5855 || TREE_CODE (jclass) != TYPE_DECL
5856 || !POINTER_TYPE_P (TREE_TYPE (jclass))
5857 || !same_type_ignoring_top_level_qualifiers_p
5858 (type, TREE_TYPE (TREE_TYPE (jclass))))
5859 error ("Java object %qD not allocated with %<new%>", decl);
5864 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5865 if (init_const_expr_p)
5867 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5868 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5869 TREE_CONSTANT (decl) = 1;
5872 init = check_initializer (decl, init, flags, &cleanup);
5873 /* Thread-local storage cannot be dynamically initialized. */
5874 if (DECL_THREAD_LOCAL_P (decl) && init)
5876 error ("%qD is thread-local and so cannot be dynamically "
5877 "initialized", decl);
5881 /* Check that the initializer for a static data member was a
5882 constant. Although we check in the parser that the
5883 initializer is an integral constant expression, we do not
5884 simplify division-by-zero at the point at which it
5885 occurs. Therefore, in:
5887 struct S { static const int i = 7 / 0; };
5889 we issue an error at this point. It would
5890 probably be better to forbid division by zero in
5891 integral constant expressions. */
5892 if (DECL_EXTERNAL (decl) && init)
5894 error ("%qD cannot be initialized by a non-constant expression"
5895 " when being declared", decl);
5896 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5904 The memory occupied by any object of static storage
5905 duration is zero-initialized at program startup before
5906 any other initialization takes place.
5908 We cannot create an appropriate initializer until after
5909 the type of DECL is finalized. If DECL_INITIAL is set,
5910 then the DECL is statically initialized, and any
5911 necessary zero-initialization has already been performed. */
5912 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5913 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5914 /*nelts=*/NULL_TREE,
5915 /*static_storage_p=*/true);
5916 /* Remember that the initialization for this variable has
5918 DECL_INITIALIZED_P (decl) = 1;
5919 /* This declaration is the definition of this variable,
5920 unless we are initializing a static data member within
5921 the class specifier. */
5922 if (!DECL_EXTERNAL (decl))
5923 var_definition_p = true;
5925 /* If the variable has an array type, lay out the type, even if
5926 there is no initializer. It is valid to index through the
5927 array, and we must get TYPE_ALIGN set correctly on the array
5929 else if (TREE_CODE (type) == ARRAY_TYPE)
5932 if (!processing_template_decl
5933 && TREE_STATIC (decl)
5934 && !at_function_scope_p ()
5935 && current_function_decl == NULL)
5936 /* So decl is a global variable or a static member of a
5937 non local class. Record the types it uses
5938 so that we can decide later to emit debug info for them. */
5939 record_types_used_by_current_var_decl (decl);
5941 else if (TREE_CODE (decl) == FIELD_DECL
5942 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5943 error ("non-static data member %qD has Java class type", decl);
5945 /* Add this declaration to the statement-tree. This needs to happen
5946 after the call to check_initializer so that the DECL_EXPR for a
5947 reference temp is added before the DECL_EXPR for the reference itself. */
5948 if (at_function_scope_p ())
5949 add_decl_expr (decl);
5951 /* Let the middle end know about variables and functions -- but not
5952 static data members in uninstantiated class templates. */
5953 if (!saved_processing_template_decl
5954 && (TREE_CODE (decl) == VAR_DECL
5955 || TREE_CODE (decl) == FUNCTION_DECL))
5957 if (TREE_CODE (decl) == VAR_DECL)
5959 layout_var_decl (decl);
5960 maybe_commonize_var (decl);
5963 /* This needs to happen after the linkage is set. */
5964 determine_visibility (decl);
5966 if (var_definition_p && TREE_STATIC (decl))
5968 /* If a TREE_READONLY variable needs initialization
5969 at runtime, it is no longer readonly and we need to
5970 avoid MEM_READONLY_P being set on RTL created for it. */
5973 if (TREE_READONLY (decl))
5974 TREE_READONLY (decl) = 0;
5977 else if (was_readonly)
5978 TREE_READONLY (decl) = 1;
5981 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5983 /* Check for abstractness of the type. Notice that there is no
5984 need to strip array types here since the check for those types
5985 is already done within create_array_type_for_decl. */
5986 if (TREE_CODE (type) == FUNCTION_TYPE
5987 || TREE_CODE (type) == METHOD_TYPE)
5988 abstract_virtuals_error (decl, TREE_TYPE (type));
5990 abstract_virtuals_error (decl, type);
5992 if (TREE_TYPE (decl) == error_mark_node)
5993 /* No initialization required. */
5995 else if (TREE_CODE (decl) == FUNCTION_DECL)
5999 if (init == ridpointers[(int)RID_DEFAULT])
6001 /* An out-of-class default definition is defined at
6002 the point where it is explicitly defaulted. */
6003 if (DECL_INITIAL (decl) == error_mark_node)
6004 synthesize_method (decl);
6007 error ("function %q#D is initialized like a variable", decl);
6009 /* else no initialization required. */
6011 else if (DECL_EXTERNAL (decl)
6012 && ! (DECL_LANG_SPECIFIC (decl)
6013 && DECL_NOT_REALLY_EXTERN (decl)))
6016 DECL_INITIAL (decl) = init;
6018 /* A variable definition. */
6019 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6020 /* Initialize the local variable. */
6021 initialize_local_var (decl, init);
6023 /* If a variable is defined, and then a subsequent
6024 definition with external linkage is encountered, we will
6025 get here twice for the same variable. We want to avoid
6026 calling expand_static_init more than once. For variables
6027 that are not static data members, we can call
6028 expand_static_init only when we actually process the
6029 initializer. It is not legal to redeclare a static data
6030 member, so this issue does not arise in that case. */
6031 else if (var_definition_p && TREE_STATIC (decl))
6032 expand_static_init (decl, init);
6035 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6036 reference, insert it in the statement-tree now. */
6038 push_cleanup (decl, cleanup, false);
6041 processing_template_decl = saved_processing_template_decl;
6044 TREE_READONLY (decl) = 1;
6047 /* Returns a declaration for a VAR_DECL as if:
6049 extern "C" TYPE NAME;
6051 had been seen. Used to create compiler-generated global
6055 declare_global_var (tree name, tree type)
6059 push_to_top_level ();
6060 decl = build_decl (input_location, VAR_DECL, name, type);
6061 TREE_PUBLIC (decl) = 1;
6062 DECL_EXTERNAL (decl) = 1;
6063 DECL_ARTIFICIAL (decl) = 1;
6064 /* If the user has explicitly declared this variable (perhaps
6065 because the code we are compiling is part of a low-level runtime
6066 library), then it is possible that our declaration will be merged
6067 with theirs by pushdecl. */
6068 decl = pushdecl (decl);
6069 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
6070 pop_from_top_level ();
6075 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6076 if "__cxa_atexit" is not being used) corresponding to the function
6077 to be called when the program exits. */
6080 get_atexit_fn_ptr_type (void)
6084 if (!atexit_fn_ptr_type_node)
6087 if (flag_use_cxa_atexit
6088 && !targetm.cxx.use_atexit_for_cxa_atexit ())
6089 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6090 arg_type = ptr_type_node;
6092 /* The parameter to "atexit" is "void (*)(void)". */
6093 arg_type = NULL_TREE;
6095 fn_type = build_function_type_list (void_type_node,
6096 arg_type, NULL_TREE);
6097 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
6100 return atexit_fn_ptr_type_node;
6103 /* Returns a pointer to the `atexit' function. Note that if
6104 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6105 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6108 get_atexit_node (void)
6114 bool use_aeabi_atexit;
6119 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6121 /* The declaration for `__cxa_atexit' is:
6123 int __cxa_atexit (void (*)(void *), void *, void *)
6125 We build up the argument types and then then function type
6127 tree argtype0, argtype1, argtype2;
6129 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
6130 /* First, build the pointer-to-function type for the first
6132 fn_ptr_type = get_atexit_fn_ptr_type ();
6133 /* Then, build the rest of the argument types. */
6134 argtype2 = ptr_type_node;
6135 if (use_aeabi_atexit)
6137 argtype1 = fn_ptr_type;
6138 argtype0 = ptr_type_node;
6142 argtype1 = ptr_type_node;
6143 argtype0 = fn_ptr_type;
6145 /* And the final __cxa_atexit type. */
6146 fn_type = build_function_type_list (integer_type_node,
6147 argtype0, argtype1, argtype2,
6149 fn_ptr_type = build_pointer_type (fn_type);
6150 if (use_aeabi_atexit)
6151 name = "__aeabi_atexit";
6153 name = "__cxa_atexit";
6157 /* The declaration for `atexit' is:
6159 int atexit (void (*)());
6161 We build up the argument types and then then function type
6163 fn_ptr_type = get_atexit_fn_ptr_type ();
6164 /* Build the final atexit type. */
6165 fn_type = build_function_type_list (integer_type_node,
6166 fn_ptr_type, NULL_TREE);
6170 /* Now, build the function declaration. */
6171 push_lang_context (lang_name_c);
6172 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6173 mark_used (atexit_fndecl);
6174 pop_lang_context ();
6175 atexit_node = decay_conversion (atexit_fndecl);
6180 /* Returns the __dso_handle VAR_DECL. */
6183 get_dso_handle_node (void)
6185 if (dso_handle_node)
6186 return dso_handle_node;
6188 /* Declare the variable. */
6189 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6192 return dso_handle_node;
6195 /* Begin a new function with internal linkage whose job will be simply
6196 to destroy some particular variable. */
6198 static GTY(()) int start_cleanup_cnt;
6201 start_cleanup_fn (void)
6206 bool use_cxa_atexit = flag_use_cxa_atexit
6207 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6209 push_to_top_level ();
6211 /* No need to mangle this. */
6212 push_lang_context (lang_name_c);
6214 /* Build the name of the function. */
6215 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6216 /* Build the function declaration. */
6217 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6218 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6219 /* It's a function with internal linkage, generated by the
6221 TREE_PUBLIC (fndecl) = 0;
6222 DECL_ARTIFICIAL (fndecl) = 1;
6223 /* Make the function `inline' so that it is only emitted if it is
6224 actually needed. It is unlikely that it will be inlined, since
6225 it is only called via a function pointer, but we avoid unnecessary
6226 emissions this way. */
6227 DECL_DECLARED_INLINE_P (fndecl) = 1;
6228 DECL_INTERFACE_KNOWN (fndecl) = 1;
6229 /* Build the parameter. */
6234 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6235 DECL_CONTEXT (parmdecl) = fndecl;
6236 TREE_USED (parmdecl) = 1;
6237 DECL_READ_P (parmdecl) = 1;
6238 DECL_ARGUMENTS (fndecl) = parmdecl;
6242 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6244 pop_lang_context ();
6246 return current_function_decl;
6249 /* Finish the cleanup function begun by start_cleanup_fn. */
6252 end_cleanup_fn (void)
6254 expand_or_defer_fn (finish_function (0));
6256 pop_from_top_level ();
6259 /* Generate code to handle the destruction of DECL, an object with
6260 static storage duration. */
6263 register_dtor_fn (tree decl)
6270 tree arg0, arg1 = NULL_TREE, arg2 = NULL_TREE;
6272 type = TREE_TYPE (decl);
6273 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6274 return void_zero_node;
6276 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6277 a class object, we can just pass the destructor to
6278 "__cxa_atexit"; we don't have to build a temporary function to do
6280 use_dtor = (flag_use_cxa_atexit
6281 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6282 && CLASS_TYPE_P (type));
6287 /* Find the destructor. */
6288 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6289 gcc_assert (idx >= 0);
6290 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6291 /* Make sure it is accessible. */
6292 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
6296 /* Call build_cleanup before we enter the anonymous function so
6297 that any access checks will be done relative to the current
6298 scope, rather than the scope of the anonymous function. */
6299 build_cleanup (decl);
6301 /* Now start the function. */
6302 cleanup = start_cleanup_fn ();
6304 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6305 to the original function, rather than the anonymous one. That
6306 will make the back end think that nested functions are in use,
6307 which causes confusion. */
6308 push_deferring_access_checks (dk_no_check);
6309 fcall = build_cleanup (decl);
6310 pop_deferring_access_checks ();
6312 /* Create the body of the anonymous function. */
6313 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6314 finish_expr_stmt (fcall);
6315 finish_compound_stmt (compound_stmt);
6319 /* Call atexit with the cleanup function. */
6320 mark_used (cleanup);
6321 cleanup = build_address (cleanup);
6322 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6328 /* We must convert CLEANUP to the type that "__cxa_atexit"
6330 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6331 /* "__cxa_atexit" will pass the address of DECL to the
6332 cleanup function. */
6334 addr = build_address (decl);
6335 /* The declared type of the parameter to "__cxa_atexit" is
6336 "void *". For plain "T*", we could just let the
6337 machinery in cp_build_function_call convert it -- but if the
6338 type is "cv-qualified T *", then we need to convert it
6339 before passing it in, to avoid spurious errors. */
6340 addr = build_nop (ptr_type_node, addr);
6343 /* Since the cleanup functions we build ignore the address
6344 they're given, there's no reason to pass the actual address
6345 in, and, in general, it's cheaper to pass NULL than any
6347 addr = null_pointer_node;
6348 arg2 = cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0,
6349 tf_warning_or_error);
6350 if (targetm.cxx.use_aeabi_atexit ())
6363 return cp_build_function_call_nary (get_atexit_node (), tf_warning_or_error,
6364 arg0, arg1, arg2, NULL_TREE);
6367 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6368 is its initializer. Generate code to handle the construction
6369 and destruction of DECL. */
6372 expand_static_init (tree decl, tree init)
6374 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6375 gcc_assert (TREE_STATIC (decl));
6377 /* Some variables require no initialization. */
6379 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6380 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6383 if (DECL_FUNCTION_SCOPE_P (decl))
6385 /* Emit code to perform this initialization but once. */
6386 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6387 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6388 tree guard, guard_addr;
6389 tree acquire_fn, release_fn, abort_fn;
6392 /* Emit code to perform this initialization but once. This code
6395 static <type> guard;
6396 if (!guard.first_byte) {
6397 if (__cxa_guard_acquire (&guard)) {
6400 // Do initialization.
6401 flag = true; __cxa_guard_release (&guard);
6402 // Register variable for destruction at end of program.
6404 if (!flag) __cxa_guard_abort (&guard);
6408 Note that the `flag' variable is only set to 1 *after* the
6409 initialization is complete. This ensures that an exception,
6410 thrown during the construction, will cause the variable to
6411 reinitialized when we pass through this code again, as per:
6415 If the initialization exits by throwing an exception, the
6416 initialization is not complete, so it will be tried again
6417 the next time control enters the declaration.
6419 This process should be thread-safe, too; multiple threads
6420 should not be able to initialize the variable more than
6423 /* Create the guard variable. */
6424 guard = get_guard (decl);
6426 /* This optimization isn't safe on targets with relaxed memory
6427 consistency. On such targets we force synchronization in
6428 __cxa_guard_acquire. */
6429 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6431 /* Begin the conditional initialization. */
6432 if_stmt = begin_if_stmt ();
6433 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6434 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6437 if (flag_threadsafe_statics)
6439 guard_addr = build_address (guard);
6441 acquire_fn = get_identifier ("__cxa_guard_acquire");
6442 release_fn = get_identifier ("__cxa_guard_release");
6443 abort_fn = get_identifier ("__cxa_guard_abort");
6444 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6446 tree vfntype = build_function_type_list (void_type_node,
6447 TREE_TYPE (guard_addr),
6449 acquire_fn = push_library_fn
6450 (acquire_fn, build_function_type_list (integer_type_node,
6451 TREE_TYPE (guard_addr),
6454 release_fn = push_library_fn (release_fn, vfntype, NULL_TREE);
6455 abort_fn = push_library_fn (abort_fn, vfntype, NULL_TREE);
6459 release_fn = identifier_global_value (release_fn);
6460 abort_fn = identifier_global_value (abort_fn);
6463 inner_if_stmt = begin_if_stmt ();
6464 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6467 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6468 begin = get_target_expr (boolean_false_node);
6469 flag = TARGET_EXPR_SLOT (begin);
6471 TARGET_EXPR_CLEANUP (begin)
6472 = build3 (COND_EXPR, void_type_node, flag,
6474 build_call_n (abort_fn, 1, guard_addr));
6475 CLEANUP_EH_ONLY (begin) = 1;
6477 /* Do the initialization itself. */
6478 init = add_stmt_to_compound (begin, init);
6479 init = add_stmt_to_compound
6480 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6481 init = add_stmt_to_compound
6482 (init, build_call_n (release_fn, 1, guard_addr));
6485 init = add_stmt_to_compound (init, set_guard (guard));
6487 /* Use atexit to register a function for destroying this static
6489 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6491 finish_expr_stmt (init);
6493 if (flag_threadsafe_statics)
6495 finish_compound_stmt (inner_then_clause);
6496 finish_then_clause (inner_if_stmt);
6497 finish_if_stmt (inner_if_stmt);
6500 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6502 finish_compound_stmt (then_clause);
6503 finish_then_clause (if_stmt);
6504 finish_if_stmt (if_stmt);
6508 static_aggregates = tree_cons (init, decl, static_aggregates);
6512 /* Make TYPE a complete type based on INITIAL_VALUE.
6513 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6514 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6515 3 if the initializer list is empty (in pedantic mode). */
6518 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6521 tree type, elt_type;
6525 unsigned HOST_WIDE_INT i;
6528 /* An array of character type can be initialized from a
6529 brace-enclosed string constant.
6531 FIXME: this code is duplicated from reshape_init. Probably
6532 we should just call reshape_init here? */
6533 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6534 && TREE_CODE (initial_value) == CONSTRUCTOR
6535 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6537 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6538 tree value = VEC_index (constructor_elt, v, 0)->value;
6540 if (TREE_CODE (value) == STRING_CST
6541 && VEC_length (constructor_elt, v) == 1)
6542 initial_value = value;
6545 /* If any of the elements are parameter packs, we can't actually
6546 complete this type now because the array size is dependent. */
6547 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6549 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6552 if (PACK_EXPANSION_P (value))
6558 failure = complete_array_type (ptype, initial_value, do_default);
6560 /* We can create the array before the element type is complete, which
6561 means that we didn't have these two bits set in the original type
6562 either. In completing the type, we are expected to propagate these
6563 bits. See also complete_type which does the same thing for arrays
6566 if (TYPE_DOMAIN (type))
6568 elt_type = TREE_TYPE (type);
6569 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6570 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6571 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6577 /* Return zero if something is declared to be a member of type
6578 CTYPE when in the context of CUR_TYPE. STRING is the error
6579 message to print in that case. Otherwise, quietly return 1. */
6582 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6584 if (ctype && ctype != cur_type)
6586 if (flags == DTOR_FLAG)
6587 error ("destructor for alien class %qT cannot be a member", ctype);
6589 error ("constructor for alien class %qT cannot be a member", ctype);
6595 /* Subroutine of `grokdeclarator'. */
6597 /* Generate errors possibly applicable for a given set of specifiers.
6598 This is for ARM $7.1.2. */
6601 bad_specifiers (tree object,
6602 enum bad_spec_place type,
6613 error ("%qD declared as a %<virtual%> variable", object);
6615 error ("%qD declared as an %<inline%> variable", object);
6617 error ("%<const%> and %<volatile%> function specifiers on "
6618 "%qD invalid in variable declaration", object);
6622 error ("%qD declared as a %<virtual%> parameter", object);
6624 error ("%qD declared as an %<inline%> parameter", object);
6626 error ("%<const%> and %<volatile%> function specifiers on "
6627 "%qD invalid in parameter declaration", object);
6631 error ("%qD declared as a %<virtual%> type", object);
6633 error ("%qD declared as an %<inline%> type", object);
6635 error ("%<const%> and %<volatile%> function specifiers on "
6636 "%qD invalid in type declaration", object);
6640 error ("%qD declared as a %<virtual%> field", object);
6642 error ("%qD declared as an %<inline%> field", object);
6644 error ("%<const%> and %<volatile%> function specifiers on "
6645 "%qD invalid in field declaration", object);
6651 error ("%q+D declared as a friend", object);
6653 && (TREE_CODE (object) == TYPE_DECL
6654 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6655 && !TYPE_REFFN_P (TREE_TYPE (object))
6656 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6657 error ("%q+D declared with an exception specification", object);
6660 /* DECL is a member function or static data member and is presently
6661 being defined. Check that the definition is taking place in a
6665 check_class_member_definition_namespace (tree decl)
6667 /* These checks only apply to member functions and static data
6669 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6670 || TREE_CODE (decl) == VAR_DECL);
6671 /* We check for problems with specializations in pt.c in
6672 check_specialization_namespace, where we can issue better
6674 if (processing_specialization)
6676 /* There are no restrictions on the placement of
6677 explicit instantiations. */
6678 if (processing_explicit_instantiation)
6682 A member function definition that appears outside of the
6683 class definition shall appear in a namespace scope enclosing
6684 the class definition.
6688 The definition for a static data member shall appear in a
6689 namespace scope enclosing the member's class definition. */
6690 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6691 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
6692 decl, DECL_CONTEXT (decl));
6695 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6696 METHOD_TYPE for a non-static member function; QUALS are the
6697 cv-qualifiers that apply to the function. */
6700 build_this_parm (tree type, cp_cv_quals quals)
6705 cp_cv_quals this_quals;
6707 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6708 /* The `this' parameter is implicitly `const'; it cannot be
6710 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6711 qual_type = cp_build_qualified_type (this_type, this_quals);
6712 parm = build_artificial_parm (this_identifier, qual_type);
6713 cp_apply_type_quals_to_decl (this_quals, parm);
6717 /* CTYPE is class type, or null if non-class.
6718 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6720 DECLARATOR is the function's name.
6721 PARMS is a chain of PARM_DECLs for the function.
6722 VIRTUALP is truthvalue of whether the function is virtual or not.
6723 FLAGS are to be passed through to `grokclassfn'.
6724 QUALS are qualifiers indicating whether the function is `const'
6726 RAISES is a list of exceptions that this function can raise.
6727 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6728 not look, and -1 if we should not call `grokclassfn' at all.
6730 SFK is the kind of special function (if any) for the new function.
6732 Returns `NULL_TREE' if something goes wrong, after issuing
6733 applicable error messages. */
6736 grokfndecl (tree ctype,
6740 tree orig_declarator,
6742 enum overload_flags flags,
6749 special_function_kind sfk,
6754 location_t location)
6757 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6761 type = build_exception_variant (type, raises);
6763 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6765 /* If we have an explicit location, use it, otherwise use whatever
6766 build_lang_decl used (probably input_location). */
6767 if (location != UNKNOWN_LOCATION)
6768 DECL_SOURCE_LOCATION (decl) = location;
6770 if (TREE_CODE (type) == METHOD_TYPE)
6773 parm = build_this_parm (type, quals);
6774 TREE_CHAIN (parm) = parms;
6777 DECL_ARGUMENTS (decl) = parms;
6778 for (t = parms; t; t = TREE_CHAIN (t))
6779 DECL_CONTEXT (t) = decl;
6780 /* Propagate volatile out from type to decl. */
6781 if (TYPE_VOLATILE (type))
6782 TREE_THIS_VOLATILE (decl) = 1;
6784 /* Setup decl according to sfk. */
6787 case sfk_constructor:
6788 case sfk_copy_constructor:
6789 case sfk_move_constructor:
6790 DECL_CONSTRUCTOR_P (decl) = 1;
6792 case sfk_destructor:
6793 DECL_DESTRUCTOR_P (decl) = 1;
6799 /* If pointers to member functions use the least significant bit to
6800 indicate whether a function is virtual, ensure a pointer
6801 to this function will have that bit clear. */
6802 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6803 && TREE_CODE (type) == METHOD_TYPE
6804 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6805 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6808 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6812 ("defining explicit specialization %qD in friend declaration",
6816 tree fns = TREE_OPERAND (orig_declarator, 0);
6817 tree args = TREE_OPERAND (orig_declarator, 1);
6819 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6821 /* Something like `template <class T> friend void f<T>()'. */
6822 error ("invalid use of template-id %qD in declaration "
6823 "of primary template",
6829 /* A friend declaration of the form friend void f<>(). Record
6830 the information in the TEMPLATE_ID_EXPR. */
6831 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6833 if (TREE_CODE (fns) == COMPONENT_REF)
6835 /* Due to bison parser ickiness, we will have already looked
6836 up an operator_name or PFUNCNAME within the current class
6837 (see template_id in parse.y). If the current class contains
6838 such a name, we'll get a COMPONENT_REF here. Undo that. */
6840 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6841 == current_class_type);
6842 fns = TREE_OPERAND (fns, 1);
6844 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6845 || TREE_CODE (fns) == OVERLOAD);
6846 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
6848 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6849 if (TREE_PURPOSE (t)
6850 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6852 error ("default arguments are not allowed in declaration "
6853 "of friend template specialization %qD",
6860 error ("%<inline%> is not allowed in declaration of friend "
6861 "template specialization %qD",
6868 /* If this decl has namespace scope, set that up. */
6870 set_decl_namespace (decl, in_namespace, friendp);
6872 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
6874 /* `main' and builtins have implicit 'C' linkage. */
6875 if ((MAIN_NAME_P (declarator)
6876 || (IDENTIFIER_LENGTH (declarator) > 10
6877 && IDENTIFIER_POINTER (declarator)[0] == '_'
6878 && IDENTIFIER_POINTER (declarator)[1] == '_'
6879 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6880 && current_lang_name == lang_name_cplusplus
6881 && ctype == NULL_TREE
6882 /* NULL_TREE means global namespace. */
6883 && DECL_CONTEXT (decl) == NULL_TREE)
6884 SET_DECL_LANGUAGE (decl, lang_c);
6886 /* Should probably propagate const out from type to decl I bet (mrs). */
6889 DECL_STATIC_FUNCTION_P (decl) = 1;
6890 DECL_CONTEXT (decl) = ctype;
6895 DECL_CONTEXT (decl) = ctype;
6897 check_class_member_definition_namespace (decl);
6900 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6902 if (processing_template_decl)
6903 error ("cannot declare %<::main%> to be a template");
6905 error ("cannot declare %<::main%> to be inline");
6907 error ("cannot declare %<::main%> to be static");
6912 /* Members of anonymous types and local classes have no linkage; make
6913 them internal. If a typedef is made later, this will be changed. */
6914 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6915 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6918 if (publicp && cxx_dialect == cxx98)
6920 /* [basic.link]: A name with no linkage (notably, the name of a class
6921 or enumeration declared in a local scope) shall not be used to
6922 declare an entity with linkage.
6924 DR 757 relaxes this restriction for C++0x. */
6925 t = no_linkage_check (TREE_TYPE (decl),
6926 /*relaxed_p=*/false);
6929 if (TYPE_ANONYMOUS_P (t))
6931 if (DECL_EXTERN_C_P (decl))
6932 /* Allow this; it's pretty common in C. */;
6935 permerror (input_location, "anonymous type with no linkage "
6936 "used to declare function %q#D with linkage",
6938 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6939 permerror (input_location, "%q+#D does not refer to the unqualified "
6940 "type, so it is not used for linkage",
6945 permerror (input_location, "type %qT with no linkage used to "
6946 "declare function %q#D with linkage", t, decl);
6950 TREE_PUBLIC (decl) = publicp;
6953 DECL_INTERFACE_KNOWN (decl) = 1;
6954 DECL_NOT_REALLY_EXTERN (decl) = 1;
6957 /* If the declaration was declared inline, mark it as such. */
6959 DECL_DECLARED_INLINE_P (decl) = 1;
6961 DECL_EXTERNAL (decl) = 1;
6962 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6965 ? G_("static member function %qD cannot have cv-qualifier")
6966 : G_("non-member function %qD cannot have cv-qualifier"),
6968 quals = TYPE_UNQUALIFIED;
6971 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6972 && !grok_op_properties (decl, /*complain=*/true))
6976 /* Make the init_value nonzero so pushdecl knows this is not
6977 tentative. error_mark_node is replaced later with the BLOCK. */
6978 DECL_INITIAL (decl) = error_mark_node;
6980 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6981 TREE_NOTHROW (decl) = 1;
6983 /* Caller will do the rest of this. */
6987 if (ctype != NULL_TREE)
6988 grokclassfn (ctype, decl, flags);
6990 decl = check_explicit_specialization (orig_declarator, decl,
6993 4 * (friendp != 0));
6994 if (decl == error_mark_node)
6999 cplus_decl_attributes (&decl, *attrlist, 0);
7000 *attrlist = NULL_TREE;
7003 /* Check main's type after attributes have been applied. */
7004 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7006 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
7009 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
7011 error ("%<::main%> must return %<int%>");
7012 newtype = build_function_type (integer_type_node, oldtypeargs);
7013 TREE_TYPE (decl) = newtype;
7016 check_main_parameter_types (decl);
7019 if (ctype != NULL_TREE
7020 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
7023 tree old_decl = check_classfn (ctype, decl,
7024 (processing_template_decl
7025 > template_class_depth (ctype))
7026 ? current_template_parms
7029 if (old_decl == error_mark_node)
7037 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
7038 /* Because grokfndecl is always supposed to return a
7039 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7040 here. We depend on our callers to figure out that its
7041 really a template that's being returned. */
7042 old_decl = DECL_TEMPLATE_RESULT (old_decl);
7044 if (DECL_STATIC_FUNCTION_P (old_decl)
7045 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7046 /* Remove the `this' parm added by grokclassfn.
7047 XXX Isn't this done in start_function, too? */
7048 revert_static_member_fn (decl);
7049 if (DECL_ARTIFICIAL (old_decl))
7051 error ("definition of implicitly-declared %qD", old_decl);
7055 /* Since we've smashed OLD_DECL to its
7056 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7057 if (TREE_CODE (decl) == TEMPLATE_DECL)
7058 decl = DECL_TEMPLATE_RESULT (decl);
7060 /* Attempt to merge the declarations. This can fail, in
7061 the case of some invalid specialization declarations. */
7062 pushed_scope = push_scope (ctype);
7063 ok = duplicate_decls (decl, old_decl, friendp);
7065 pop_scope (pushed_scope);
7068 error ("no %q#D member function declared in class %qT",
7076 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
7079 if (ctype == NULL_TREE || check)
7083 DECL_VIRTUAL_P (decl) = 1;
7088 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7089 the linkage that DECL will receive in the object file. */
7092 set_linkage_for_static_data_member (tree decl)
7094 /* A static data member always has static storage duration and
7095 external linkage. Note that static data members are forbidden in
7096 local classes -- the only situation in which a class has
7097 non-external linkage. */
7098 TREE_PUBLIC (decl) = 1;
7099 TREE_STATIC (decl) = 1;
7100 /* For non-template classes, static data members are always put
7101 out in exactly those files where they are defined, just as
7102 with ordinary namespace-scope variables. */
7103 if (!processing_template_decl)
7104 DECL_INTERFACE_KNOWN (decl) = 1;
7107 /* Create a VAR_DECL named NAME with the indicated TYPE.
7109 If SCOPE is non-NULL, it is the class type or namespace containing
7110 the variable. If SCOPE is NULL, the variable should is created in
7111 the innermost enclosings scope. */
7114 grokvardecl (tree type,
7116 const cp_decl_specifier_seq *declspecs,
7122 tree explicit_scope;
7124 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
7126 /* Compute the scope in which to place the variable, but remember
7127 whether or not that scope was explicitly specified by the user. */
7128 explicit_scope = scope;
7131 /* An explicit "extern" specifier indicates a namespace-scope
7133 if (declspecs->storage_class == sc_extern)
7134 scope = current_decl_namespace ();
7135 else if (!at_function_scope_p ())
7136 scope = current_scope ();
7140 && (/* If the variable is a namespace-scope variable declared in a
7141 template, we need DECL_LANG_SPECIFIC. */
7142 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
7143 /* Similarly for namespace-scope variables with language linkage
7145 || (TREE_CODE (scope) == NAMESPACE_DECL
7146 && current_lang_name != lang_name_cplusplus)
7147 /* Similarly for static data members. */
7149 decl = build_lang_decl (VAR_DECL, name, type);
7151 decl = build_decl (input_location, VAR_DECL, name, type);
7153 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
7154 set_decl_namespace (decl, explicit_scope, 0);
7156 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
7158 if (declspecs->storage_class == sc_extern)
7160 DECL_THIS_EXTERN (decl) = 1;
7161 DECL_EXTERNAL (decl) = !initialized;
7164 if (DECL_CLASS_SCOPE_P (decl))
7166 set_linkage_for_static_data_member (decl);
7167 /* This function is only called with out-of-class definitions. */
7168 DECL_EXTERNAL (decl) = 0;
7169 check_class_member_definition_namespace (decl);
7171 /* At top level, either `static' or no s.c. makes a definition
7172 (perhaps tentative), and absence of `static' makes it public. */
7173 else if (toplevel_bindings_p ())
7175 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
7176 && (DECL_THIS_EXTERN (decl) || ! constp));
7177 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
7179 /* Not at top level, only `static' makes a static definition. */
7182 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
7183 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7186 if (declspecs->specs[(int)ds_thread])
7187 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
7189 /* If the type of the decl has no linkage, make sure that we'll
7190 notice that in mark_used. */
7191 if (cxx_dialect > cxx98
7192 && decl_linkage (decl) != lk_none
7193 && DECL_LANG_SPECIFIC (decl) == NULL
7194 && !DECL_EXTERN_C_P (decl)
7195 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
7196 retrofit_lang_decl (decl);
7198 if (TREE_PUBLIC (decl))
7200 /* [basic.link]: A name with no linkage (notably, the name of a class
7201 or enumeration declared in a local scope) shall not be used to
7202 declare an entity with linkage.
7204 DR 757 relaxes this restriction for C++0x. */
7205 tree t = (cxx_dialect > cxx98 ? NULL_TREE
7206 : no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false));
7209 if (TYPE_ANONYMOUS_P (t))
7211 if (DECL_EXTERN_C_P (decl))
7212 /* Allow this; it's pretty common in C. */
7216 /* DRs 132, 319 and 389 seem to indicate types with
7217 no linkage can only be used to declare extern "C"
7218 entities. Since it's not always an error in the
7219 ISO C++ 90 Standard, we only issue a warning. */
7220 warning (0, "anonymous type with no linkage used to declare "
7221 "variable %q#D with linkage", decl);
7222 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7223 warning (0, "%q+#D does not refer to the unqualified "
7224 "type, so it is not used for linkage",
7229 warning (0, "type %qT with no linkage used to declare variable "
7230 "%q#D with linkage", t, decl);
7234 DECL_INTERFACE_KNOWN (decl) = 1;
7239 /* Create and return a canonical pointer to member function type, for
7240 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7243 build_ptrmemfunc_type (tree type)
7247 tree unqualified_variant = NULL_TREE;
7249 if (type == error_mark_node)
7252 /* If a canonical type already exists for this type, use it. We use
7253 this method instead of type_hash_canon, because it only does a
7254 simple equality check on the list of field members. */
7256 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7259 /* Make sure that we always have the unqualified pointer-to-member
7261 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7263 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7265 t = make_class_type (RECORD_TYPE);
7266 xref_basetypes (t, NULL_TREE);
7268 /* Let the front end know this is a pointer to member function... */
7269 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7270 /* ... and not really a class type. */
7271 SET_CLASS_TYPE_P (t, 0);
7273 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
7276 field = build_decl (input_location, FIELD_DECL, delta_identifier,
7278 TREE_CHAIN (field) = fields;
7281 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7283 /* Zap out the name so that the back end will give us the debugging
7284 information for this anonymous RECORD_TYPE. */
7285 TYPE_NAME (t) = NULL_TREE;
7287 /* If this is not the unqualified form of this pointer-to-member
7288 type, set the TYPE_MAIN_VARIANT for this type to be the
7289 unqualified type. Since they are actually RECORD_TYPEs that are
7290 not variants of each other, we must do this manually.
7291 As we just built a new type there is no need to do yet another copy. */
7292 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7294 int type_quals = cp_type_quals (type);
7295 TYPE_READONLY (t) = (type_quals & TYPE_QUAL_CONST) != 0;
7296 TYPE_VOLATILE (t) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
7297 TYPE_RESTRICT (t) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
7298 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7299 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7300 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7301 TREE_TYPE (TYPE_BINFO (t)) = t;
7304 /* Cache this pointer-to-member type so that we can find it again
7306 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7308 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7309 SET_TYPE_STRUCTURAL_EQUALITY (t);
7310 else if (TYPE_CANONICAL (type) != type)
7311 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7316 /* Create and return a pointer to data member type. */
7319 build_ptrmem_type (tree class_type, tree member_type)
7321 if (TREE_CODE (member_type) == METHOD_TYPE)
7323 cp_cv_quals quals = type_memfn_quals (member_type);
7324 member_type = build_memfn_type (member_type, class_type, quals);
7325 return build_ptrmemfunc_type (build_pointer_type (member_type));
7329 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7330 return build_offset_type (class_type, member_type);
7334 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7335 Check to see that the definition is valid. Issue appropriate error
7336 messages. Return 1 if the definition is particularly bad, or 0
7340 check_static_variable_definition (tree decl, tree type)
7342 /* Motion 10 at San Diego: If a static const integral data member is
7343 initialized with an integral constant expression, the initializer
7344 may appear either in the declaration (within the class), or in
7345 the definition, but not both. If it appears in the class, the
7346 member is a member constant. The file-scope definition is always
7348 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7350 error ("invalid in-class initialization of static data member "
7351 "of non-integral type %qT",
7353 /* If we just return the declaration, crashes will sometimes
7354 occur. We therefore return void_type_node, as if this were a
7355 friend declaration, to cause callers to completely ignore
7356 this declaration. */
7359 else if (!CP_TYPE_CONST_P (type))
7360 error ("ISO C++ forbids in-class initialization of non-const "
7361 "static member %qD",
7363 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7364 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids initialization of member constant "
7365 "%qD of non-integral type %qT", decl, type);
7370 /* Given the SIZE (i.e., number of elements) in an array, compute an
7371 appropriate index type for the array. If non-NULL, NAME is the
7372 name of the thing being declared. */
7375 compute_array_index_type (tree name, tree size)
7379 tree abi_1_itype = NULL_TREE;
7381 if (error_operand_p (size))
7382 return error_mark_node;
7384 type = TREE_TYPE (size);
7385 /* The array bound must be an integer type. */
7386 if (!dependent_type_p (type) && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
7389 error ("size of array %qD has non-integral type %qT", name, type);
7391 error ("size of array has non-integral type %qT", type);
7392 size = integer_one_node;
7393 type = TREE_TYPE (size);
7396 /* We can only call value_dependent_expression_p on integral constant
7397 expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
7398 set if this isn't one. */
7399 if (processing_template_decl
7400 && (TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
7402 /* We cannot do any checking for a SIZE that isn't known to be
7403 constant. Just build the index type and mark that it requires
7404 structural equality checks. */
7405 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7406 size, integer_one_node));
7407 TYPE_DEPENDENT_P (itype) = 1;
7408 TYPE_DEPENDENT_P_VALID (itype) = 1;
7409 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7413 if (!abi_version_at_least (2) && processing_template_decl)
7414 /* For abi-1, we handled all instances in templates the same way,
7415 even when they were non-dependent. This affects the manglings
7416 produced. So, we do the normal checking for non-dependent
7417 sizes, but at the end we'll return the same type that abi-1
7418 would have, but with TYPE_CANONICAL set to the "right"
7419 value that the current ABI would provide. */
7420 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7421 size, integer_one_node));
7423 /* The size might be the result of a cast. */
7424 STRIP_TYPE_NOPS (size);
7426 size = mark_rvalue_use (size);
7428 /* It might be a const variable or enumeration constant. */
7429 size = integral_constant_value (size);
7430 if (error_operand_p (size))
7431 return error_mark_node;
7433 /* Normally, the array-bound will be a constant. */
7434 if (TREE_CODE (size) == INTEGER_CST)
7436 /* Check to see if the array bound overflowed. Make that an
7437 error, no matter how generous we're being. */
7438 constant_expression_error (size);
7440 /* An array must have a positive number of elements. */
7441 if (INT_CST_LT (size, integer_zero_node))
7444 error ("size of array %qD is negative", name);
7446 error ("size of array is negative");
7447 size = integer_one_node;
7449 /* As an extension we allow zero-sized arrays. We always allow
7450 them in system headers because glibc uses them. */
7451 else if (integer_zerop (size) && !in_system_header)
7454 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array %qD", name);
7456 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array");
7459 else if (TREE_CONSTANT (size))
7461 /* `(int) &fn' is not a valid array bound. */
7463 error ("size of array %qD is not an integral constant-expression",
7466 error ("size of array is not an integral constant-expression");
7467 size = integer_one_node;
7469 else if (pedantic && warn_vla != 0)
7472 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
7474 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
7476 else if (warn_vla > 0)
7480 "variable length array %qD is used", name);
7483 "variable length array is used");
7486 if (processing_template_decl && !TREE_CONSTANT (size))
7487 /* A variable sized array. */
7488 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7491 HOST_WIDE_INT saved_processing_template_decl;
7493 /* Compute the index of the largest element in the array. It is
7494 one less than the number of elements in the array. We save
7495 and restore PROCESSING_TEMPLATE_DECL so that computations in
7496 cp_build_binary_op will be appropriately folded. */
7497 saved_processing_template_decl = processing_template_decl;
7498 processing_template_decl = 0;
7499 itype = cp_build_binary_op (input_location,
7501 cp_convert (ssizetype, size),
7502 cp_convert (ssizetype, integer_one_node),
7503 tf_warning_or_error);
7504 itype = fold (itype);
7505 processing_template_decl = saved_processing_template_decl;
7507 if (!TREE_CONSTANT (itype))
7508 /* A variable sized array. */
7509 itype = variable_size (itype);
7510 /* Make sure that there was no overflow when creating to a signed
7511 index type. (For example, on a 32-bit machine, an array with
7512 size 2^32 - 1 is too big.) */
7513 else if (TREE_CODE (itype) == INTEGER_CST
7514 && TREE_OVERFLOW (itype))
7516 error ("overflow in array dimension");
7517 TREE_OVERFLOW (itype) = 0;
7521 /* Create and return the appropriate index type. */
7524 tree t = build_index_type (itype);
7525 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7529 return build_index_type (itype);
7532 /* Returns the scope (if any) in which the entity declared by
7533 DECLARATOR will be located. If the entity was declared with an
7534 unqualified name, NULL_TREE is returned. */
7537 get_scope_of_declarator (const cp_declarator *declarator)
7539 while (declarator && declarator->kind != cdk_id)
7540 declarator = declarator->declarator;
7542 /* If the declarator-id is a SCOPE_REF, the scope in which the
7543 declaration occurs is the first operand. */
7545 && declarator->u.id.qualifying_scope)
7546 return declarator->u.id.qualifying_scope;
7548 /* Otherwise, the declarator is not a qualified name; the entity will
7549 be declared in the current scope. */
7553 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7554 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7558 create_array_type_for_decl (tree name, tree type, tree size)
7560 tree itype = NULL_TREE;
7562 /* If things have already gone awry, bail now. */
7563 if (type == error_mark_node || size == error_mark_node)
7564 return error_mark_node;
7566 /* If there are some types which cannot be array elements,
7567 issue an error-message and return. */
7568 switch (TREE_CODE (type))
7572 error ("declaration of %qD as array of void", name);
7574 error ("creating array of void");
7575 return error_mark_node;
7579 error ("declaration of %qD as array of functions", name);
7581 error ("creating array of functions");
7582 return error_mark_node;
7584 case REFERENCE_TYPE:
7586 error ("declaration of %qD as array of references", name);
7588 error ("creating array of references");
7589 return error_mark_node;
7593 error ("declaration of %qD as array of function members", name);
7595 error ("creating array of function members");
7596 return error_mark_node;
7604 The constant expressions that specify the bounds of the arrays
7605 can be omitted only for the first member of the sequence. */
7606 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7609 error ("declaration of %qD as multidimensional array must "
7610 "have bounds for all dimensions except the first",
7613 error ("multidimensional array must have bounds for all "
7614 "dimensions except the first");
7616 return error_mark_node;
7619 /* Figure out the index type for the array. */
7621 itype = compute_array_index_type (name, size);
7624 T is called the array element type; this type shall not be [...] an
7625 abstract class type. */
7626 abstract_virtuals_error (name, type);
7628 return build_cplus_array_type (type, itype);
7631 /* Check that it's OK to declare a function with the indicated TYPE.
7632 SFK indicates the kind of special function (if any) that this
7633 function is. OPTYPE is the type given in a conversion operator
7634 declaration, or the class type for a constructor/destructor.
7635 Returns the actual return type of the function; that
7636 may be different than TYPE if an error occurs, or for certain
7637 special functions. */
7640 check_special_function_return_type (special_function_kind sfk,
7646 case sfk_constructor:
7648 error ("return type specification for constructor invalid");
7650 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7651 type = build_pointer_type (optype);
7653 type = void_type_node;
7656 case sfk_destructor:
7658 error ("return type specification for destructor invalid");
7659 /* We can't use the proper return type here because we run into
7660 problems with ambiguous bases and covariant returns.
7661 Java classes are left unchanged because (void *) isn't a valid
7662 Java type, and we don't want to change the Java ABI. */
7663 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7664 type = build_pointer_type (void_type_node);
7666 type = void_type_node;
7669 case sfk_conversion:
7671 error ("return type specified for %<operator %T%>", optype);
7682 /* A variable or data member (whose unqualified name is IDENTIFIER)
7683 has been declared with the indicated TYPE. If the TYPE is not
7684 acceptable, issue an error message and return a type to use for
7685 error-recovery purposes. */
7688 check_var_type (tree identifier, tree type)
7690 if (VOID_TYPE_P (type))
7693 error ("unnamed variable or field declared void");
7694 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7696 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7697 error ("variable or field %qE declared void", identifier);
7700 error ("variable or field declared void");
7701 type = error_mark_node;
7707 /* Given declspecs and a declarator (abstract or otherwise), determine
7708 the name and type of the object declared and construct a DECL node
7711 DECLSPECS points to the representation of declaration-specifier
7712 sequence that precedes declarator.
7714 DECL_CONTEXT says which syntactic context this declaration is in:
7715 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7716 FUNCDEF for a function definition. Like NORMAL but a few different
7717 error messages in each case. Return value may be zero meaning
7718 this definition is too screwy to try to parse.
7719 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7720 handle member functions (which have FIELD context).
7721 Return value may be zero meaning this definition is too screwy to
7723 PARM for a parameter declaration (either within a function prototype
7724 or before a function body). Make a PARM_DECL, or return void_type_node.
7725 TPARM for a template parameter declaration.
7726 CATCHPARM for a parameter declaration before a catch clause.
7727 TYPENAME if for a typename (in a cast or sizeof).
7728 Don't make a DECL node; just return the ..._TYPE node.
7729 FIELD for a struct or union field; make a FIELD_DECL.
7730 BITFIELD for a field with specified width.
7732 INITIALIZED is as for start_decl.
7734 ATTRLIST is a pointer to the list of attributes, which may be NULL
7735 if there are none; *ATTRLIST may be modified if attributes from inside
7736 the declarator should be applied to the declaration.
7738 When this function is called, scoping variables (such as
7739 CURRENT_CLASS_TYPE) should reflect the scope in which the
7740 declaration occurs, not the scope in which the new declaration will
7741 be placed. For example, on:
7745 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7748 Returns a DECL (if a declarator is present), a TYPE (if there is no
7749 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7753 grokdeclarator (const cp_declarator *declarator,
7754 const cp_decl_specifier_seq *declspecs,
7755 enum decl_context decl_context,
7759 tree type = NULL_TREE;
7761 int explicit_int128 = 0;
7762 int virtualp, explicitp, friendp, inlinep, staticp;
7763 int explicit_int = 0;
7764 int explicit_char = 0;
7765 int defaulted_int = 0;
7766 tree dependent_name = NULL_TREE;
7768 tree typedef_decl = NULL_TREE;
7769 const char *name = NULL;
7770 tree typedef_type = NULL_TREE;
7771 /* True if this declarator is a function definition. */
7772 bool funcdef_flag = false;
7773 cp_declarator_kind innermost_code = cdk_error;
7776 /* See the code below that used this. */
7777 tree decl_attr = NULL_TREE;
7780 /* Keep track of what sort of function is being processed
7781 so that we can warn about default return values, or explicit
7782 return values which do not match prescribed defaults. */
7783 special_function_kind sfk = sfk_none;
7785 tree dname = NULL_TREE;
7786 tree ctor_return_type = NULL_TREE;
7787 enum overload_flags flags = NO_SPECIAL;
7788 /* cv-qualifiers that apply to the declarator, for a declaration of
7789 a member function. */
7790 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7791 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7793 tree raises = NULL_TREE;
7794 int template_count = 0;
7795 tree returned_attrs = NULL_TREE;
7796 tree parms = NULL_TREE;
7797 const cp_declarator *id_declarator;
7798 /* The unqualified name of the declarator; either an
7799 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7800 tree unqualified_id;
7801 /* The class type, if any, in which this entity is located,
7802 or NULL_TREE if none. Note that this value may be different from
7803 the current class type; for example if an attempt is made to declare
7804 "A::f" inside "B", this value will be "A". */
7805 tree ctype = current_class_type;
7806 /* The NAMESPACE_DECL for the namespace in which this entity is
7807 located. If an unqualified name is used to declare the entity,
7808 this value will be NULL_TREE, even if the entity is located at
7810 tree in_namespace = NULL_TREE;
7811 cp_storage_class storage_class;
7812 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7813 bool type_was_error_mark_node = false;
7814 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7815 bool template_type_arg = false;
7816 bool template_parm_flag = false;
7817 bool constexpr_p = declspecs->specs[(int) ds_constexpr];
7820 signed_p = declspecs->specs[(int)ds_signed];
7821 unsigned_p = declspecs->specs[(int)ds_unsigned];
7822 short_p = declspecs->specs[(int)ds_short];
7823 long_p = declspecs->specs[(int)ds_long];
7824 longlong = declspecs->specs[(int)ds_long] >= 2;
7825 explicit_int128 = declspecs->explicit_int128_p;
7826 thread_p = declspecs->specs[(int)ds_thread];
7828 if (decl_context == FUNCDEF)
7829 funcdef_flag = true, decl_context = NORMAL;
7830 else if (decl_context == MEMFUNCDEF)
7831 funcdef_flag = true, decl_context = FIELD;
7832 else if (decl_context == BITFIELD)
7833 bitfield = 1, decl_context = FIELD;
7834 else if (decl_context == TEMPLATE_TYPE_ARG)
7835 template_type_arg = true, decl_context = TYPENAME;
7836 else if (decl_context == TPARM)
7837 template_parm_flag = true, decl_context = PARM;
7839 if (initialized > 1)
7840 funcdef_flag = true;
7842 /* Look inside a declarator for the name being declared
7843 and get it as a string, for an error message. */
7844 for (id_declarator = declarator;
7846 id_declarator = id_declarator->declarator)
7848 if (id_declarator->kind != cdk_id)
7849 innermost_code = id_declarator->kind;
7851 switch (id_declarator->kind)
7854 if (id_declarator->declarator
7855 && id_declarator->declarator->kind == cdk_id)
7857 sfk = id_declarator->declarator->u.id.sfk;
7858 if (sfk == sfk_destructor)
7865 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7866 tree decl = id_declarator->u.id.unqualified_name;
7869 if (qualifying_scope)
7871 if (at_function_scope_p ())
7875 A declarator-id shall not be qualified except
7878 None of the cases are permitted in block
7880 if (qualifying_scope == global_namespace)
7881 error ("invalid use of qualified-name %<::%D%>",
7883 else if (TYPE_P (qualifying_scope))
7884 error ("invalid use of qualified-name %<%T::%D%>",
7885 qualifying_scope, decl);
7887 error ("invalid use of qualified-name %<%D::%D%>",
7888 qualifying_scope, decl);
7889 return error_mark_node;
7891 else if (TYPE_P (qualifying_scope))
7893 ctype = qualifying_scope;
7894 if (innermost_code != cdk_function
7895 && current_class_type
7896 && !UNIQUELY_DERIVED_FROM_P (ctype,
7897 current_class_type))
7899 error ("type %qT is not derived from type %qT",
7900 ctype, current_class_type);
7901 return error_mark_node;
7904 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7905 in_namespace = qualifying_scope;
7907 switch (TREE_CODE (decl))
7913 if (innermost_code != cdk_function)
7915 error ("declaration of %qD as non-function", decl);
7916 return error_mark_node;
7918 else if (!qualifying_scope
7919 && !(current_class_type && at_class_scope_p ()))
7921 error ("declaration of %qD as non-member", decl);
7922 return error_mark_node;
7925 type = TREE_OPERAND (decl, 0);
7927 type = constructor_name (type);
7928 name = identifier_to_locale (IDENTIFIER_POINTER (type));
7933 case TEMPLATE_ID_EXPR:
7935 tree fns = TREE_OPERAND (decl, 0);
7938 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7940 gcc_assert (is_overloaded_fn (dname));
7941 dname = DECL_NAME (get_first_fn (dname));
7946 case IDENTIFIER_NODE:
7947 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7950 if (C_IS_RESERVED_WORD (dname))
7952 error ("declarator-id missing; using reserved word %qD",
7954 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
7956 else if (!IDENTIFIER_TYPENAME_P (dname))
7957 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
7960 gcc_assert (flags == NO_SPECIAL);
7961 flags = TYPENAME_FLAG;
7962 ctor_return_type = TREE_TYPE (dname);
7963 sfk = sfk_conversion;
7964 if (is_typename_at_global_scope (dname))
7965 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
7967 name = "<invalid operator>";
7984 return error_mark_node;
7989 if (id_declarator->kind == cdk_id)
7995 The declarator in a function-definition shall have the form
7996 D1 ( parameter-declaration-clause) ... */
7997 if (funcdef_flag && innermost_code != cdk_function)
7999 error ("function definition does not declare parameters");
8000 return error_mark_node;
8003 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8004 && innermost_code != cdk_function
8005 && ! (ctype && !declspecs->any_specifiers_p))
8007 error ("declaration of %qD as non-function", dname);
8008 return error_mark_node;
8011 /* Anything declared one level down from the top level
8012 must be one of the parameters of a function
8013 (because the body is at least two levels down). */
8015 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8016 by not allowing C++ class definitions to specify their parameters
8017 with xdecls (must be spec.d in the parmlist).
8019 Since we now wait to push a class scope until we are sure that
8020 we are in a legitimate method context, we must set oldcname
8021 explicitly (since current_class_name is not yet alive).
8023 We also want to avoid calling this a PARM if it is in a namespace. */
8025 if (decl_context == NORMAL && !toplevel_bindings_p ())
8027 struct cp_binding_level *b = current_binding_level;
8028 current_binding_level = b->level_chain;
8029 if (current_binding_level != 0 && toplevel_bindings_p ())
8030 decl_context = PARM;
8031 current_binding_level = b;
8035 name = decl_context == PARM ? "parameter" : "type name";
8037 /* If there were multiple types specified in the decl-specifier-seq,
8038 issue an error message. */
8039 if (declspecs->multiple_types_p)
8041 error ("two or more data types in declaration of %qs", name);
8042 return error_mark_node;
8045 if (declspecs->conflicting_specifiers_p)
8047 error ("conflicting specifiers in declaration of %qs", name);
8048 return error_mark_node;
8051 /* Extract the basic type from the decl-specifier-seq. */
8052 type = declspecs->type;
8053 if (type == error_mark_node)
8056 type_was_error_mark_node = true;
8058 /* If the entire declaration is itself tagged as deprecated then
8059 suppress reports of deprecated items. */
8060 if (type && TREE_DEPRECATED (type)
8061 && deprecated_state != DEPRECATED_SUPPRESS)
8062 warn_deprecated_use (type, NULL_TREE);
8063 if (type && TREE_CODE (type) == TYPE_DECL)
8065 typedef_decl = type;
8066 type = TREE_TYPE (typedef_decl);
8067 if (TREE_DEPRECATED (type)
8068 && DECL_ARTIFICIAL (typedef_decl)
8069 && deprecated_state != DEPRECATED_SUPPRESS)
8070 warn_deprecated_use (type, NULL_TREE);
8072 /* No type at all: default to `int', and set DEFAULTED_INT
8073 because it was not a user-defined typedef. */
8074 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
8076 /* These imply 'int'. */
8077 type = integer_type_node;
8081 explicit_int = declspecs->explicit_int_p;
8082 explicit_char = declspecs->explicit_char_p;
8085 /* See the code below that used this. */
8087 decl_attr = DECL_ATTRIBUTES (typedef_decl);
8089 typedef_type = type;
8092 if (sfk != sfk_conversion)
8093 ctor_return_type = ctype;
8095 if (sfk != sfk_none)
8096 type = check_special_function_return_type (sfk, type,
8098 else if (type == NULL_TREE)
8104 /* We handle `main' specially here, because 'main () { }' is so
8105 common. With no options, it is allowed. With -Wreturn-type,
8106 it is a warning. It is only an error with -pedantic-errors. */
8107 is_main = (funcdef_flag
8108 && dname && MAIN_NAME_P (dname)
8109 && ctype == NULL_TREE
8110 && in_namespace == NULL_TREE
8111 && current_namespace == global_namespace);
8113 if (type_was_error_mark_node)
8114 /* We've already issued an error, don't complain more. */;
8115 else if (in_system_header || flag_ms_extensions)
8116 /* Allow it, sigh. */;
8118 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
8120 pedwarn (input_location, OPT_pedantic,
8121 "ISO C++ forbids declaration of %qs with no type", name);
8123 warning (OPT_Wreturn_type,
8124 "ISO C++ forbids declaration of %qs with no type", name);
8126 type = integer_type_node;
8131 /* Now process the modifiers that were specified
8132 and check for invalid combinations. */
8134 /* Long double is a special combination. */
8135 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
8138 type = cp_build_qualified_type (long_double_type_node,
8139 cp_type_quals (type));
8142 /* Check all other uses of type modifiers. */
8144 if (unsigned_p || signed_p || long_p || short_p)
8148 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
8149 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
8150 else if (signed_p && unsigned_p)
8151 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
8152 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
8153 error ("%<long long%> invalid for %qs", name);
8154 else if (explicit_int128 && TREE_CODE (type) != INTEGER_TYPE)
8155 error ("%<__int128%> invalid for %qs", name);
8156 else if (long_p && TREE_CODE (type) == REAL_TYPE)
8157 error ("%<long%> invalid for %qs", name);
8158 else if (short_p && TREE_CODE (type) == REAL_TYPE)
8159 error ("%<short%> invalid for %qs", name);
8160 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
8161 error ("%<long%> or %<short%> invalid for %qs", name);
8162 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_int128)
8163 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
8164 else if ((long_p || short_p) && explicit_char)
8165 error ("%<long%> or %<short%> specified with char for %qs", name);
8166 else if (long_p && short_p)
8167 error ("%<long%> and %<short%> specified together for %qs", name);
8168 else if (type == char16_type_node || type == char32_type_node)
8170 if (signed_p || unsigned_p)
8171 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
8172 else if (short_p || long_p)
8173 error ("%<short%> or %<long%> invalid for %qs", name);
8178 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic)
8180 pedwarn (input_location, OPT_pedantic,
8181 "long, short, signed or unsigned used invalidly for %qs",
8183 if (flag_pedantic_errors)
8186 if (explicit_int128)
8188 if (int128_integer_type_node == NULL_TREE)
8190 error ("%<__int128%> is not supported by this target");
8195 pedwarn (input_location, OPT_pedantic,
8196 "ISO C++ does not support %<__int128%> for %qs",
8198 if (flag_pedantic_errors)
8204 /* Discard the type modifiers if they are invalid. */
8212 explicit_int128 = false;
8216 /* Decide whether an integer type is signed or not.
8217 Optionally treat bitfields as signed by default. */
8221 It is implementation-defined whether a plain (neither
8222 explicitly signed or unsigned) char, short, int, or long
8223 bit-field is signed or unsigned.
8225 Naturally, we extend this to long long as well. Note that
8226 this does not include wchar_t. */
8227 || (bitfield && !flag_signed_bitfields
8229 /* A typedef for plain `int' without `signed' can be
8230 controlled just like plain `int', but a typedef for
8231 `signed int' cannot be so controlled. */
8233 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
8234 && TREE_CODE (type) == INTEGER_TYPE
8235 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
8237 if (explicit_int128)
8238 type = int128_unsigned_type_node;
8240 type = long_long_unsigned_type_node;
8242 type = long_unsigned_type_node;
8244 type = short_unsigned_type_node;
8245 else if (type == char_type_node)
8246 type = unsigned_char_type_node;
8247 else if (typedef_decl)
8248 type = unsigned_type_for (type);
8250 type = unsigned_type_node;
8252 else if (signed_p && type == char_type_node)
8253 type = signed_char_type_node;
8254 else if (explicit_int128)
8255 type = int128_integer_type_node;
8257 type = long_long_integer_type_node;
8259 type = long_integer_type_node;
8261 type = short_integer_type_node;
8263 if (declspecs->specs[(int)ds_complex])
8265 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8266 error ("complex invalid for %qs", name);
8267 /* If we just have "complex", it is equivalent to
8268 "complex double", but if any modifiers at all are specified it is
8269 the complex form of TYPE. E.g, "complex short" is
8270 "complex short int". */
8271 else if (defaulted_int && ! longlong && ! explicit_int128
8272 && ! (long_p || short_p || signed_p || unsigned_p))
8273 type = complex_double_type_node;
8274 else if (type == integer_type_node)
8275 type = complex_integer_type_node;
8276 else if (type == float_type_node)
8277 type = complex_float_type_node;
8278 else if (type == double_type_node)
8279 type = complex_double_type_node;
8280 else if (type == long_double_type_node)
8281 type = complex_long_double_type_node;
8283 type = build_complex_type (type);
8286 type_quals = TYPE_UNQUALIFIED;
8287 if (declspecs->specs[(int)ds_const])
8288 type_quals |= TYPE_QUAL_CONST;
8289 /* A `constexpr' specifier used in an object declaration declares
8290 the object as `const'. */
8293 if (innermost_code == cdk_function)
8295 else if (declspecs->specs[(int)ds_const] != 0)
8296 error ("both %<const%> and %<constexpr%> cannot be used here");
8298 type_quals |= TYPE_QUAL_CONST;
8300 if (declspecs->specs[(int)ds_volatile])
8301 type_quals |= TYPE_QUAL_VOLATILE;
8302 if (declspecs->specs[(int)ds_restrict])
8303 type_quals |= TYPE_QUAL_RESTRICT;
8304 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8305 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8308 type_quals |= cp_type_quals (type);
8309 type = cp_build_qualified_type_real
8310 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8311 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8312 /* We might have ignored or rejected some of the qualifiers. */
8313 type_quals = cp_type_quals (type);
8316 inlinep = !! declspecs->specs[(int)ds_inline];
8317 virtualp = !! declspecs->specs[(int)ds_virtual];
8318 explicitp = !! declspecs->specs[(int)ds_explicit];
8320 storage_class = declspecs->storage_class;
8321 if (storage_class == sc_static)
8322 staticp = 1 + (decl_context == FIELD);
8324 if (virtualp && staticp == 2)
8326 error ("member %qD cannot be declared both virtual and static", dname);
8327 storage_class = sc_none;
8330 friendp = !! declspecs->specs[(int)ds_friend];
8332 if (dependent_name && !friendp)
8334 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8335 return error_mark_node;
8338 /* Issue errors about use of storage classes for parameters. */
8339 if (decl_context == PARM)
8341 if (declspecs->specs[(int)ds_typedef])
8343 error ("typedef declaration invalid in parameter declaration");
8344 return error_mark_node;
8346 else if (template_parm_flag && storage_class != sc_none)
8348 error ("storage class specified for template parameter %qs", name);
8349 return error_mark_node;
8351 else if (storage_class == sc_static
8352 || storage_class == sc_extern
8354 error ("storage class specifiers invalid in parameter declarations");
8356 if (type_uses_auto (type))
8358 error ("parameter declared %<auto%>");
8359 type = error_mark_node;
8362 /* Function parameters cannot be constexpr. If we saw one, moan
8363 and pretend it wasn't there. */
8366 error ("a parameter cannot be declared %<constexpr%>");
8371 /* Give error if `virtual' is used outside of class declaration. */
8373 && (current_class_name == NULL_TREE || decl_context != FIELD))
8375 error ("%<virtual%> outside class declaration");
8379 /* Static anonymous unions are dealt with here. */
8380 if (staticp && decl_context == TYPENAME
8382 && ANON_AGGR_TYPE_P (declspecs->type))
8383 decl_context = FIELD;
8385 /* Warn about storage classes that are invalid for certain
8386 kinds of declarations (parameters, typenames, etc.). */
8389 && storage_class != sc_extern
8390 && storage_class != sc_static)
8391 || declspecs->specs[(int)ds_typedef]))
8393 error ("multiple storage classes in declaration of %qs", name);
8396 if (decl_context != NORMAL
8397 && ((storage_class != sc_none
8398 && storage_class != sc_mutable)
8401 if ((decl_context == PARM || decl_context == CATCHPARM)
8402 && (storage_class == sc_register
8403 || storage_class == sc_auto))
8405 else if (declspecs->specs[(int)ds_typedef])
8407 else if (decl_context == FIELD
8408 /* C++ allows static class elements. */
8409 && storage_class == sc_static)
8410 /* C++ also allows inlines and signed and unsigned elements,
8411 but in those cases we don't come in here. */
8415 if (decl_context == FIELD)
8416 error ("storage class specified for %qs", name);
8419 if (decl_context == PARM || decl_context == CATCHPARM)
8420 error ("storage class specified for parameter %qs", name);
8422 error ("storage class specified for typename");
8424 if (storage_class == sc_register
8425 || storage_class == sc_auto
8426 || storage_class == sc_extern
8428 storage_class = sc_none;
8431 else if (storage_class == sc_extern && funcdef_flag
8432 && ! toplevel_bindings_p ())
8433 error ("nested function %qs declared %<extern%>", name);
8434 else if (toplevel_bindings_p ())
8436 if (storage_class == sc_auto)
8437 error ("top-level declaration of %qs specifies %<auto%>", name);
8440 && storage_class != sc_extern
8441 && storage_class != sc_static)
8443 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8448 if (storage_class && friendp)
8450 error ("storage class specifiers invalid in friend function declarations");
8451 storage_class = sc_none;
8456 unqualified_id = NULL_TREE;
8459 unqualified_id = id_declarator->u.id.unqualified_name;
8460 switch (TREE_CODE (unqualified_id))
8463 unqualified_id = TREE_OPERAND (unqualified_id, 0);
8464 if (TYPE_P (unqualified_id))
8465 unqualified_id = constructor_name (unqualified_id);
8468 case IDENTIFIER_NODE:
8469 case TEMPLATE_ID_EXPR:
8477 /* Determine the type of the entity declared by recurring on the
8479 for (; declarator; declarator = declarator->declarator)
8481 const cp_declarator *inner_declarator;
8484 if (type == error_mark_node)
8485 return error_mark_node;
8487 attrs = declarator->attributes;
8493 if (declarator == NULL || declarator->kind == cdk_id)
8494 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8495 if (declarator->kind == cdk_function)
8496 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8497 if (declarator->kind == cdk_array)
8498 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8499 returned_attrs = decl_attributes (&type,
8500 chainon (returned_attrs, attrs),
8504 if (declarator->kind == cdk_id)
8507 inner_declarator = declarator->declarator;
8509 switch (declarator->kind)
8512 type = create_array_type_for_decl (dname, type,
8513 declarator->u.array.bounds);
8521 /* Declaring a function type.
8522 Make sure we have a valid type for the function to return. */
8524 if (type_quals != TYPE_UNQUALIFIED)
8526 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
8527 warning (OPT_Wignored_qualifiers,
8528 "type qualifiers ignored on function return type");
8529 /* We now know that the TYPE_QUALS don't apply to the
8530 decl, but to its return type. */
8531 type_quals = TYPE_UNQUALIFIED;
8533 errmsg = targetm.invalid_return_type (type);
8537 type = integer_type_node;
8540 /* Error about some types functions can't return. */
8542 if (TREE_CODE (type) == FUNCTION_TYPE)
8544 error ("%qs declared as function returning a function", name);
8545 return error_mark_node;
8547 if (TREE_CODE (type) == ARRAY_TYPE)
8549 error ("%qs declared as function returning an array", name);
8550 return error_mark_node;
8553 /* Pick up type qualifiers which should be applied to `this'. */
8554 memfn_quals = declarator->u.function.qualifiers;
8556 /* Pick up the exception specifications. */
8557 raises = declarator->u.function.exception_specification;
8559 /* Say it's a definition only for the CALL_EXPR
8560 closest to the identifier. */
8561 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8563 /* Handle a late-specified return type. */
8566 if (type_uses_auto (type))
8568 if (!declarator->u.function.late_return_type)
8570 error ("%qs function uses %<auto%> type specifier without"
8571 " late return type", name);
8572 return error_mark_node;
8574 else if (!is_auto (type))
8576 error ("%qs function with late return type has"
8577 " %qT as its type rather than plain %<auto%>",
8579 return error_mark_node;
8582 else if (declarator->u.function.late_return_type)
8584 error ("%qs function with late return type not declared"
8585 " with %<auto%> type specifier", name);
8586 return error_mark_node;
8589 type = splice_late_return_type
8590 (type, declarator->u.function.late_return_type);
8591 if (type == error_mark_node)
8592 return error_mark_node;
8594 if (ctype == NULL_TREE
8595 && decl_context == FIELD
8597 && (friendp == 0 || dname == current_class_name))
8598 ctype = current_class_type;
8600 if (ctype && (sfk == sfk_constructor
8601 || sfk == sfk_destructor))
8603 /* We are within a class's scope. If our declarator name
8604 is the same as the class name, and we are defining
8605 a function, then it is a constructor/destructor, and
8606 therefore returns a void type. */
8608 /* ISO C++ 12.4/2. A destructor may not be declared
8609 const or volatile. A destructor may not be
8612 ISO C++ 12.1. A constructor may not be declared
8613 const or volatile. A constructor may not be
8614 virtual. A constructor may not be static. */
8616 error ((flags == DTOR_FLAG)
8617 ? "destructor cannot be static member function"
8618 : "constructor cannot be static member function");
8621 error ((flags == DTOR_FLAG)
8622 ? "destructors may not be cv-qualified"
8623 : "constructors may not be cv-qualified");
8624 memfn_quals = TYPE_UNQUALIFIED;
8627 if (decl_context == FIELD
8628 && !member_function_or_else (ctype,
8631 return error_mark_node;
8633 if (flags != DTOR_FLAG)
8635 /* It's a constructor. */
8640 permerror (input_location, "constructors cannot be declared virtual");
8643 if (decl_context == FIELD
8644 && sfk != sfk_constructor)
8645 return error_mark_node;
8647 if (decl_context == FIELD)
8653 error ("can't initialize friend function %qs", name);
8656 /* Cannot be both friend and virtual. */
8657 error ("virtual functions cannot be friends");
8660 if (decl_context == NORMAL)
8661 error ("friend declaration not in class definition");
8662 if (current_function_decl && funcdef_flag)
8663 error ("can't define friend function %qs in a local "
8667 else if (ctype && sfk == sfk_conversion)
8671 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
8676 /* It is not allowed to use `constexpr' in a function
8677 declaration that is not a definition.
8678 That is too strict, though. */
8679 if (constexpr_p && !funcdef_flag)
8681 error ("the %<constexpr%> specifier cannot be used in "
8682 "a function declaration that is not a definition");
8683 constexpr_p = false;
8686 /* A constexpr non-static member function is implicitly const. */
8687 if (constexpr_p && decl_context == FIELD && staticp == 0
8688 && sfk != sfk_constructor && sfk != sfk_destructor)
8689 memfn_quals |= TYPE_QUAL_CONST;
8691 arg_types = grokparms (declarator->u.function.parameters,
8694 if (inner_declarator
8695 && inner_declarator->kind == cdk_id
8696 && inner_declarator->u.id.sfk == sfk_destructor
8697 && arg_types != void_list_node)
8699 error ("destructors may not have parameters");
8700 arg_types = void_list_node;
8704 type = build_function_type (type, arg_types);
8711 /* Filter out pointers-to-references and references-to-references.
8712 We can get these if a TYPE_DECL is used. */
8714 if (TREE_CODE (type) == REFERENCE_TYPE)
8716 if (declarator->kind != cdk_reference)
8718 error ("cannot declare pointer to %q#T", type);
8719 type = TREE_TYPE (type);
8722 /* In C++0x, we allow reference to reference declarations
8723 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8724 and template type arguments [14.3.1/4 temp.arg.type]. The
8725 check for direct reference to reference declarations, which
8726 are still forbidden, occurs below. Reasoning behind the change
8727 can be found in DR106, DR540, and the rvalue reference
8729 else if (cxx_dialect == cxx98)
8731 error ("cannot declare reference to %q#T", type);
8732 type = TREE_TYPE (type);
8735 else if (VOID_TYPE_P (type))
8737 if (declarator->kind == cdk_reference)
8738 error ("cannot declare reference to %q#T", type);
8739 else if (declarator->kind == cdk_ptrmem)
8740 error ("cannot declare pointer to %q#T member", type);
8743 /* We now know that the TYPE_QUALS don't apply to the decl,
8744 but to the target of the pointer. */
8745 type_quals = TYPE_UNQUALIFIED;
8747 if (declarator->kind == cdk_ptrmem
8748 && (TREE_CODE (type) == FUNCTION_TYPE
8749 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
8751 memfn_quals |= type_memfn_quals (type);
8752 type = build_memfn_type (type,
8753 declarator->u.pointer.class_type,
8755 memfn_quals = TYPE_UNQUALIFIED;
8758 if (TREE_CODE (type) == FUNCTION_TYPE
8759 && type_memfn_quals (type) != TYPE_UNQUALIFIED)
8760 error (declarator->kind == cdk_reference
8761 ? G_("cannot declare reference to qualified function type %qT")
8762 : G_("cannot declare pointer to qualified function type %qT"),
8765 /* When the pointed-to type involves components of variable size,
8766 care must be taken to ensure that the size evaluation code is
8767 emitted early enough to dominate all the possible later uses
8768 and late enough for the variables on which it depends to have
8771 This is expected to happen automatically when the pointed-to
8772 type has a name/declaration of it's own, but special attention
8773 is required if the type is anonymous.
8775 We handle the NORMAL and FIELD contexts here by inserting a
8776 dummy statement that just evaluates the size at a safe point
8777 and ensures it is not deferred until e.g. within a deeper
8778 conditional context (c++/43555).
8780 We expect nothing to be needed here for PARM or TYPENAME.
8781 Evaluating the size at this point for TYPENAME would
8782 actually be incorrect, as we might be in the middle of an
8783 expression with side effects on the pointed-to type size
8784 "arguments" prior to the pointer declaration point and the
8785 size evaluation could end up prior to the side effects. */
8787 if (!TYPE_NAME (type)
8788 && (decl_context == NORMAL || decl_context == FIELD)
8789 && at_function_scope_p ()
8790 && variably_modified_type_p (type, NULL_TREE))
8791 finish_expr_stmt (TYPE_SIZE (type));
8793 if (declarator->kind == cdk_reference)
8795 /* In C++0x, the type we are creating a reference to might be
8796 a typedef which is itself a reference type. In that case,
8797 we follow the reference collapsing rules in
8798 [7.1.3/8 dcl.typedef] to create the final reference type:
8800 "If a typedef TD names a type that is a reference to a type
8801 T, an attempt to create the type 'lvalue reference to cv TD'
8802 creates the type 'lvalue reference to T,' while an attempt
8803 to create the type "rvalue reference to cv TD' creates the
8806 if (!VOID_TYPE_P (type))
8807 type = cp_build_reference_type
8808 ((TREE_CODE (type) == REFERENCE_TYPE
8809 ? TREE_TYPE (type) : type),
8810 (declarator->u.reference.rvalue_ref
8811 && (TREE_CODE(type) != REFERENCE_TYPE
8812 || TYPE_REF_IS_RVALUE (type))));
8814 /* In C++0x, we need this check for direct reference to
8815 reference declarations, which are forbidden by
8816 [8.3.2/5 dcl.ref]. Reference to reference declarations
8817 are only allowed indirectly through typedefs and template
8818 type arguments. Example:
8820 void foo(int & &); // invalid ref-to-ref decl
8822 typedef int & int_ref;
8823 void foo(int_ref &); // valid ref-to-ref decl
8825 if (inner_declarator && inner_declarator->kind == cdk_reference)
8826 error ("cannot declare reference to %q#T, which is not "
8827 "a typedef or a template type argument", type);
8829 else if (TREE_CODE (type) == METHOD_TYPE)
8830 type = build_ptrmemfunc_type (build_pointer_type (type));
8831 else if (declarator->kind == cdk_ptrmem)
8833 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8835 if (declarator->u.pointer.class_type == error_mark_node)
8836 /* We will already have complained. */
8837 type = error_mark_node;
8839 type = build_ptrmem_type (declarator->u.pointer.class_type,
8843 type = build_pointer_type (type);
8845 /* Process a list of type modifier keywords (such as
8846 const or volatile) that were given inside the `*' or `&'. */
8848 if (declarator->u.pointer.qualifiers)
8851 = cp_build_qualified_type (type,
8852 declarator->u.pointer.qualifiers);
8853 type_quals = cp_type_quals (type);
8866 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8867 && TREE_CODE (type) != FUNCTION_TYPE
8868 && TREE_CODE (type) != METHOD_TYPE)
8870 error ("template-id %qD used as a declarator",
8872 unqualified_id = dname;
8875 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8876 qualified with a class-name, turn it into a METHOD_TYPE, unless
8877 we know that the function is static. We take advantage of this
8878 opportunity to do other processing that pertains to entities
8879 explicitly declared to be class members. Note that if DECLARATOR
8880 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8881 would not have exited the loop above. */
8883 && declarator->u.id.qualifying_scope
8884 && TYPE_P (declarator->u.id.qualifying_scope))
8888 ctype = declarator->u.id.qualifying_scope;
8889 ctype = TYPE_MAIN_VARIANT (ctype);
8891 while (t != NULL_TREE && CLASS_TYPE_P (t))
8893 /* You're supposed to have one `template <...>' for every
8894 template class, but you don't need one for a full
8895 specialization. For example:
8897 template <class T> struct S{};
8898 template <> struct S<int> { void f(); };
8899 void S<int>::f () {}
8901 is correct; there shouldn't be a `template <>' for the
8902 definition of `S<int>::f'. */
8903 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8904 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8905 /* T is an explicit (not partial) specialization. All
8906 containing classes must therefore also be explicitly
8909 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8910 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8911 template_count += 1;
8913 t = TYPE_MAIN_DECL (t);
8914 t = DECL_CONTEXT (t);
8917 if (ctype == current_class_type)
8921 permerror (input_location, "member functions are implicitly friends of their class");
8925 permerror (declarator->id_loc,
8926 "extra qualification %<%T::%> on member %qs",
8929 else if (/* If the qualifying type is already complete, then we
8930 can skip the following checks. */
8931 !COMPLETE_TYPE_P (ctype)
8932 && (/* If the function is being defined, then
8933 qualifying type must certainly be complete. */
8935 /* A friend declaration of "T::f" is OK, even if
8936 "T" is a template parameter. But, if this
8937 function is not a friend, the qualifying type
8939 || (!friendp && !CLASS_TYPE_P (ctype))
8940 /* For a declaration, the type need not be
8941 complete, if either it is dependent (since there
8942 is no meaningful definition of complete in that
8943 case) or the qualifying class is currently being
8945 || !(dependent_type_p (ctype)
8946 || currently_open_class (ctype)))
8947 /* Check that the qualifying type is complete. */
8948 && !complete_type_or_else (ctype, NULL_TREE))
8949 return error_mark_node;
8950 else if (TREE_CODE (type) == FUNCTION_TYPE)
8952 tree sname = declarator->u.id.unqualified_name;
8954 if (current_class_type
8955 && (!friendp || funcdef_flag))
8958 ? "cannot define member function %<%T::%s%> within %<%T%>"
8959 : "cannot declare member function %<%T::%s%> within %<%T%>",
8960 ctype, name, current_class_type);
8961 return error_mark_node;
8964 /* It is not permitted to define a member function outside ist
8965 membership class as `constexpr'. */
8967 error ("a constexpr function cannot be defined "
8968 "outside of its class");
8970 if (TREE_CODE (sname) == IDENTIFIER_NODE
8971 && NEW_DELETE_OPNAME_P (sname))
8972 /* Overloaded operator new and operator delete
8973 are always static functions. */
8976 type = build_memfn_type (type, ctype, memfn_quals);
8978 else if (declspecs->specs[(int)ds_typedef]
8979 && current_class_type)
8981 error ("cannot declare member %<%T::%s%> within %qT",
8982 ctype, name, current_class_type);
8983 return error_mark_node;
8987 /* Now TYPE has the actual type. */
8992 *attrlist = chainon (returned_attrs, *attrlist);
8994 attrlist = &returned_attrs;
8997 /* Handle parameter packs. */
8998 if (parameter_pack_p)
9000 if (decl_context == PARM)
9001 /* Turn the type into a pack expansion.*/
9002 type = make_pack_expansion (type);
9004 error ("non-parameter %qs cannot be a parameter pack", name);
9007 /* Did array size calculations overflow? */
9009 if (TREE_CODE (type) == ARRAY_TYPE
9010 && COMPLETE_TYPE_P (type)
9011 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
9012 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
9014 error ("size of array %qs is too large", name);
9015 /* If we proceed with the array type as it is, we'll eventually
9016 crash in tree_low_cst(). */
9017 type = error_mark_node;
9020 if ((decl_context == FIELD || decl_context == PARM)
9021 && !processing_template_decl
9022 && variably_modified_type_p (type, NULL_TREE))
9024 if (decl_context == FIELD)
9025 error ("data member may not have variably modified type %qT", type);
9027 error ("parameter may not have variably modified type %qT", type);
9028 type = error_mark_node;
9031 if (explicitp == 1 || (explicitp && friendp))
9033 /* [dcl.fct.spec] The explicit specifier shall only be used in
9034 declarations of constructors within a class definition. */
9035 error ("only declarations of constructors can be %<explicit%>");
9039 if (storage_class == sc_mutable)
9041 if (decl_context != FIELD || friendp)
9043 error ("non-member %qs cannot be declared %<mutable%>", name);
9044 storage_class = sc_none;
9046 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
9048 error ("non-object member %qs cannot be declared %<mutable%>", name);
9049 storage_class = sc_none;
9051 else if (TREE_CODE (type) == FUNCTION_TYPE
9052 || TREE_CODE (type) == METHOD_TYPE)
9054 error ("function %qs cannot be declared %<mutable%>", name);
9055 storage_class = sc_none;
9059 error ("static %qs cannot be declared %<mutable%>", name);
9060 storage_class = sc_none;
9062 else if (type_quals & TYPE_QUAL_CONST)
9064 error ("const %qs cannot be declared %<mutable%>", name);
9065 storage_class = sc_none;
9069 /* If this is declaring a typedef name, return a TYPE_DECL. */
9070 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
9074 /* Note that the grammar rejects storage classes
9075 in typenames, fields or parameters. */
9076 if (current_lang_name == lang_name_java)
9077 TYPE_FOR_JAVA (type) = 1;
9079 /* This declaration:
9081 typedef void f(int) const;
9083 declares a function type which is not a member of any
9084 particular class, but which is cv-qualified; for
9085 example "f S::*" declares a pointer to a const-qualified
9086 member function of S. We record the cv-qualification in the
9088 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
9090 type = apply_memfn_quals (type, memfn_quals);
9092 /* We have now dealt with these qualifiers. */
9093 memfn_quals = TYPE_UNQUALIFIED;
9096 if (decl_context == FIELD)
9097 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
9099 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
9100 if (id_declarator && declarator->u.id.qualifying_scope) {
9101 error_at (DECL_SOURCE_LOCATION (decl),
9102 "typedef name may not be a nested-name-specifier");
9103 TREE_TYPE (decl) = error_mark_node;
9106 if (decl_context != FIELD)
9108 if (!current_function_decl)
9109 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
9110 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
9111 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
9112 (current_function_decl)))
9113 /* The TYPE_DECL is "abstract" because there will be
9114 clones of this constructor/destructor, and there will
9115 be copies of this TYPE_DECL generated in those
9117 DECL_ABSTRACT (decl) = 1;
9119 else if (constructor_name_p (unqualified_id, current_class_type))
9120 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
9121 "as enclosing class",
9124 /* If the user declares "typedef struct {...} foo" then the
9125 struct will have an anonymous name. Fill that name in now.
9126 Nothing can refer to it, so nothing needs know about the name
9128 if (type != error_mark_node
9131 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9132 && TYPE_ANONYMOUS_P (type)
9133 && cp_type_quals (type) == TYPE_UNQUALIFIED)
9137 /* Replace the anonymous name with the real name everywhere. */
9138 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
9140 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9141 /* We do not rename the debug info representing the
9142 anonymous tagged type because the standard says in
9143 [dcl.typedef] that the naming applies only for
9144 linkage purposes. */
9145 /*debug_hooks->set_name (t, decl);*/
9146 TYPE_NAME (t) = decl;
9149 if (TYPE_LANG_SPECIFIC (type))
9150 TYPE_WAS_ANONYMOUS (type) = 1;
9152 /* If this is a typedef within a template class, the nested
9153 type is a (non-primary) template. The name for the
9154 template needs updating as well. */
9155 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
9156 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
9157 = TYPE_IDENTIFIER (type);
9159 /* Adjust linkage now that we aren't anonymous anymore. */
9160 set_linkage_according_to_type (type, TYPE_MAIN_DECL (type));
9161 determine_visibility (TYPE_MAIN_DECL (type));
9163 /* FIXME remangle member functions; member functions of a
9164 type with external linkage have external linkage. */
9168 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
9169 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
9171 bad_specifiers (decl, BSP_TYPE, virtualp,
9172 memfn_quals != TYPE_UNQUALIFIED,
9173 inlinep, friendp, raises != NULL_TREE);
9178 /* Detect the case of an array type of unspecified size
9179 which came, as such, direct from a typedef name.
9180 We must copy the type, so that the array's domain can be
9181 individually set by the object's initializer. */
9183 if (type && typedef_type
9184 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
9185 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
9186 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
9188 /* Detect where we're using a typedef of function type to declare a
9189 function. PARMS will not be set, so we must create it now. */
9191 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
9193 tree decls = NULL_TREE;
9196 for (args = TYPE_ARG_TYPES (type);
9197 args && args != void_list_node;
9198 args = TREE_CHAIN (args))
9200 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
9202 TREE_CHAIN (decl) = decls;
9206 parms = nreverse (decls);
9208 if (decl_context != TYPENAME)
9210 /* A cv-qualifier-seq shall only be part of the function type
9211 for a non-static member function. [8.3.5/4 dcl.fct] */
9212 if (type_memfn_quals (type) != TYPE_UNQUALIFIED
9213 && (current_class_type == NULL_TREE || staticp) )
9216 ? G_("qualified function types cannot be used to "
9217 "declare static member functions")
9218 : G_("qualified function types cannot be used to "
9219 "declare free functions"));
9220 type = TYPE_MAIN_VARIANT (type);
9223 /* The qualifiers on the function type become the qualifiers on
9224 the non-static member function. */
9225 memfn_quals |= type_memfn_quals (type);
9226 type_quals = TYPE_UNQUALIFIED;
9230 /* If this is a type name (such as, in a cast or sizeof),
9231 compute the type and return it now. */
9233 if (decl_context == TYPENAME)
9235 /* Note that the grammar rejects storage classes
9236 in typenames, fields or parameters. */
9237 if (type_quals != TYPE_UNQUALIFIED)
9238 type_quals = TYPE_UNQUALIFIED;
9240 /* Special case: "friend class foo" looks like a TYPENAME context. */
9243 if (type_quals != TYPE_UNQUALIFIED)
9245 error ("type qualifiers specified for friend class declaration");
9246 type_quals = TYPE_UNQUALIFIED;
9250 error ("%<inline%> specified for friend class declaration");
9256 /* Don't allow friend declaration without a class-key. */
9257 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9258 permerror (input_location, "template parameters cannot be friends");
9259 else if (TREE_CODE (type) == TYPENAME_TYPE)
9260 permerror (input_location, "friend declaration requires class-key, "
9261 "i.e. %<friend class %T::%D%>",
9262 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
9264 permerror (input_location, "friend declaration requires class-key, "
9265 "i.e. %<friend %#T%>",
9269 /* Only try to do this stuff if we didn't already give up. */
9270 if (type != integer_type_node)
9272 /* A friendly class? */
9273 if (current_class_type)
9274 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
9277 error ("trying to make class %qT a friend of global scope",
9280 type = void_type_node;
9283 else if (memfn_quals)
9285 if (ctype == NULL_TREE
9286 && TREE_CODE (type) == METHOD_TYPE)
9287 ctype = TYPE_METHOD_BASETYPE (type);
9290 type = build_memfn_type (type, ctype, memfn_quals);
9291 /* Core issue #547: need to allow this in template type args. */
9292 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
9293 type = apply_memfn_quals (type, memfn_quals);
9295 error ("invalid qualifiers on non-member function type");
9300 else if (unqualified_id == NULL_TREE && decl_context != PARM
9301 && decl_context != CATCHPARM
9302 && TREE_CODE (type) != UNION_TYPE
9305 error ("abstract declarator %qT used as declaration", type);
9306 return error_mark_node;
9309 /* Only functions may be declared using an operator-function-id. */
9311 && IDENTIFIER_OPNAME_P (unqualified_id)
9312 && TREE_CODE (type) != FUNCTION_TYPE
9313 && TREE_CODE (type) != METHOD_TYPE)
9315 error ("declaration of %qD as non-function", unqualified_id);
9316 return error_mark_node;
9319 /* We don't check parameter types here because we can emit a better
9320 error message later. */
9321 if (decl_context != PARM)
9323 type = check_var_type (unqualified_id, type);
9324 if (type == error_mark_node)
9325 return error_mark_node;
9328 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9329 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9331 if (decl_context == PARM || decl_context == CATCHPARM)
9333 if (ctype || in_namespace)
9334 error ("cannot use %<::%> in parameter declaration");
9336 /* A parameter declared as an array of T is really a pointer to T.
9337 One declared as a function is really a pointer to a function.
9338 One declared as a member is really a pointer to member. */
9340 if (TREE_CODE (type) == ARRAY_TYPE)
9342 /* Transfer const-ness of array into that of type pointed to. */
9343 type = build_pointer_type (TREE_TYPE (type));
9344 type_quals = TYPE_UNQUALIFIED;
9346 else if (TREE_CODE (type) == FUNCTION_TYPE)
9347 type = build_pointer_type (type);
9353 if (decl_context == PARM)
9355 decl = cp_build_parm_decl (unqualified_id, type);
9357 bad_specifiers (decl, BSP_PARM, virtualp,
9358 memfn_quals != TYPE_UNQUALIFIED,
9359 inlinep, friendp, raises != NULL_TREE);
9361 else if (decl_context == FIELD)
9363 /* The C99 flexible array extension. */
9364 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
9365 && TYPE_DOMAIN (type) == NULL_TREE)
9367 tree itype = compute_array_index_type (dname, integer_zero_node);
9368 type = build_cplus_array_type (TREE_TYPE (type), itype);
9371 if (type == error_mark_node)
9373 /* Happens when declaring arrays of sizes which
9374 are error_mark_node, for example. */
9377 else if (in_namespace && !friendp)
9379 /* Something like struct S { int N::j; }; */
9380 error ("invalid use of %<::%>");
9381 return error_mark_node;
9383 else if (TREE_CODE (type) == FUNCTION_TYPE)
9386 tree function_context;
9390 if (ctype == NULL_TREE)
9391 ctype = current_class_type;
9393 if (ctype == NULL_TREE)
9395 error ("can't make %qD into a method -- not in a class",
9397 return error_mark_node;
9400 /* ``A union may [ ... ] not [ have ] virtual functions.''
9402 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9404 error ("function %qD declared virtual inside a union",
9406 return error_mark_node;
9409 if (NEW_DELETE_OPNAME_P (unqualified_id))
9413 error ("%qD cannot be declared virtual, since it "
9419 else if (staticp < 2)
9420 type = build_memfn_type (type, ctype, memfn_quals);
9423 /* Check that the name used for a destructor makes sense. */
9424 if (sfk == sfk_destructor)
9426 tree uqname = id_declarator->u.id.unqualified_name;
9430 gcc_assert (friendp);
9431 error ("expected qualified name in friend declaration "
9432 "for destructor %qD", uqname);
9433 return error_mark_node;
9436 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
9438 error ("declaration of %qD as member of %qT",
9440 return error_mark_node;
9443 error ("a destructor cannot be %<constexpr%>");
9445 else if (sfk == sfk_constructor && friendp)
9447 error ("expected qualified name in friend declaration "
9448 "for constructor %qD",
9449 id_declarator->u.id.unqualified_name);
9450 return error_mark_node;
9453 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9454 function_context = (ctype != NULL_TREE) ?
9455 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9456 publicp = (! friendp || ! staticp)
9457 && function_context == NULL_TREE;
9458 decl = grokfndecl (ctype, type,
9459 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9460 ? unqualified_id : dname,
9463 virtualp, flags, memfn_quals, raises,
9464 friendp ? -1 : 0, friendp, publicp,
9465 inlinep || constexpr_p,
9467 funcdef_flag, template_count, in_namespace,
9468 attrlist, declarator->id_loc);
9469 if (decl == NULL_TREE)
9470 return error_mark_node;
9472 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9473 /* The decl and setting of decl_attr is also turned off. */
9474 decl = build_decl_attribute_variant (decl, decl_attr);
9477 /* [class.conv.ctor]
9479 A constructor declared without the function-specifier
9480 explicit that can be called with a single parameter
9481 specifies a conversion from the type of its first
9482 parameter to the type of its class. Such a constructor
9483 is called a converting constructor. */
9485 DECL_NONCONVERTING_P (decl) = 1;
9487 else if (TREE_CODE (type) == METHOD_TYPE)
9489 /* We only get here for friend declarations of
9490 members of other classes. */
9491 /* All method decls are public, so tell grokfndecl to set
9492 TREE_PUBLIC, also. */
9493 decl = grokfndecl (ctype, type,
9494 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9495 ? unqualified_id : dname,
9498 virtualp, flags, memfn_quals, raises,
9499 friendp ? -1 : 0, friendp, 1, 0, sfk,
9500 funcdef_flag, template_count, in_namespace,
9502 declarator->id_loc);
9503 if (decl == NULL_TREE)
9504 return error_mark_node;
9506 else if (!staticp && !dependent_type_p (type)
9507 && !COMPLETE_TYPE_P (complete_type (type))
9508 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9511 error ("field %qD has incomplete type", unqualified_id);
9513 error ("name %qT has incomplete type", type);
9515 /* If we're instantiating a template, tell them which
9516 instantiation made the field's type be incomplete. */
9517 if (current_class_type
9518 && TYPE_NAME (current_class_type)
9519 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9521 && declspecs->type == type)
9522 error (" in instantiation of template %qT",
9523 current_class_type);
9525 return error_mark_node;
9531 error ("%qE is neither function nor member function; "
9532 "cannot be declared friend", unqualified_id);
9540 /* Friends are treated specially. */
9541 if (ctype == current_class_type)
9542 ; /* We already issued a permerror. */
9543 else if (decl && DECL_NAME (decl))
9545 if (template_class_depth (current_class_type) == 0)
9547 decl = check_explicit_specialization
9548 (unqualified_id, decl, template_count,
9549 2 * funcdef_flag + 4);
9550 if (decl == error_mark_node)
9551 return error_mark_node;
9554 DECL_DECLARED_CONSTEXPR_P (decl) = constexpr_p;
9555 decl = do_friend (ctype, unqualified_id, decl,
9561 return error_mark_node;
9564 /* Structure field. It may not be a function, except for C++. */
9566 if (decl == NULL_TREE)
9572 /* An attempt is being made to initialize a non-static
9573 member. But, from [class.mem]:
9575 4 A member-declarator can contain a
9576 constant-initializer only if it declares a static
9577 member (_class.static_) of integral or enumeration
9578 type, see _class.static.data_.
9580 This used to be relatively common practice, but
9581 the rest of the compiler does not correctly
9582 handle the initialization unless the member is
9583 static so we make it static below. */
9584 permerror (input_location, "ISO C++ forbids initialization of member %qD",
9586 permerror (input_location, "making %qD static", unqualified_id);
9590 if (uses_template_parms (type))
9591 /* We'll check at instantiation time. */
9593 else if (check_static_variable_definition (unqualified_id,
9595 /* If we just return the declaration, crashes
9596 will sometimes occur. We therefore return
9597 void_type_node, as if this was a friend
9598 declaration, to cause callers to completely
9599 ignore this declaration. */
9600 return error_mark_node;
9605 /* C++ allows static class members. All other work
9606 for this is done by grokfield. */
9607 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9608 set_linkage_for_static_data_member (decl);
9609 /* Even if there is an in-class initialization, DECL
9610 is considered undefined until an out-of-class
9611 definition is provided. */
9612 DECL_EXTERNAL (decl) = 1;
9615 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9620 error ("non-static data member %qE declared %<constexpr%>",
9622 decl = build_decl (input_location,
9623 FIELD_DECL, unqualified_id, type);
9624 DECL_NONADDRESSABLE_P (decl) = bitfield;
9625 if (bitfield && !unqualified_id)
9626 TREE_NO_WARNING (decl) = 1;
9628 if (storage_class == sc_mutable)
9630 DECL_MUTABLE_P (decl) = 1;
9631 storage_class = sc_none;
9635 bad_specifiers (decl, BSP_FIELD, virtualp,
9636 memfn_quals != TYPE_UNQUALIFIED,
9637 inlinep, friendp, raises != NULL_TREE);
9640 else if (TREE_CODE (type) == FUNCTION_TYPE
9641 || TREE_CODE (type) == METHOD_TYPE)
9646 if (!unqualified_id)
9647 return error_mark_node;
9649 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9650 original_name = dname;
9652 original_name = unqualified_id;
9654 if (storage_class == sc_auto)
9655 error ("storage class %<auto%> invalid for function %qs", name);
9656 else if (storage_class == sc_register)
9657 error ("storage class %<register%> invalid for function %qs", name);
9659 error ("storage class %<__thread%> invalid for function %qs", name);
9661 /* Function declaration not at top level.
9662 Storage classes other than `extern' are not allowed
9663 and `extern' makes no difference. */
9664 if (! toplevel_bindings_p ()
9665 && (storage_class == sc_static
9666 || declspecs->specs[(int)ds_inline])
9669 if (storage_class == sc_static)
9670 pedwarn (input_location, OPT_pedantic,
9671 "%<static%> specified invalid for function %qs "
9672 "declared out of global scope", name);
9674 pedwarn (input_location, OPT_pedantic,
9675 "%<inline%> specifier invalid for function %qs "
9676 "declared out of global scope", name);
9679 if (ctype != NULL_TREE
9680 && TREE_CODE (ctype) != NAMESPACE_DECL && !MAYBE_CLASS_TYPE_P (ctype))
9682 error ("%q#T is not a class or a namespace", ctype);
9686 if (ctype == NULL_TREE)
9690 error ("virtual non-class function %qs", name);
9693 else if (sfk == sfk_constructor
9694 || sfk == sfk_destructor)
9697 ? "%qs defined in a non-class scope"
9698 : "%qs declared in a non-class scope", name);
9702 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9703 && !NEW_DELETE_OPNAME_P (original_name))
9704 type = build_method_type_directly (ctype,
9706 TYPE_ARG_TYPES (type));
9708 /* Record presence of `static'. */
9709 publicp = (ctype != NULL_TREE
9710 || storage_class == sc_extern
9711 || storage_class != sc_static);
9713 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9714 virtualp, flags, memfn_quals, raises,
9716 publicp, inlinep || constexpr_p, sfk, funcdef_flag,
9717 template_count, in_namespace, attrlist,
9718 declarator->id_loc);
9719 if (decl == NULL_TREE)
9720 return error_mark_node;
9724 int invalid_static = 0;
9726 /* Don't allow a static member function in a class, and forbid
9727 declaring main to be static. */
9728 if (TREE_CODE (type) == METHOD_TYPE)
9730 permerror (input_location, "cannot declare member function %qD to have "
9731 "static linkage", decl);
9734 else if (current_function_decl)
9736 /* FIXME need arm citation */
9737 error ("cannot declare static function inside another function");
9744 storage_class = sc_none;
9750 /* It's a variable. */
9752 /* An uninitialized decl with `extern' is a reference. */
9753 decl = grokvardecl (type, unqualified_id,
9756 (type_quals & TYPE_QUAL_CONST) != 0,
9757 ctype ? ctype : in_namespace);
9758 bad_specifiers (decl, BSP_VAR, virtualp,
9759 memfn_quals != TYPE_UNQUALIFIED,
9760 inlinep, friendp, raises != NULL_TREE);
9764 DECL_CONTEXT (decl) = ctype;
9767 permerror (input_location, "%<static%> may not be used when defining "
9768 "(as opposed to declaring) a static data member");
9770 storage_class = sc_none;
9772 if (storage_class == sc_register && TREE_STATIC (decl))
9774 error ("static member %qD declared %<register%>", decl);
9775 storage_class = sc_none;
9777 if (storage_class == sc_extern && pedantic)
9779 pedwarn (input_location, OPT_pedantic,
9780 "cannot explicitly declare member %q#D to have "
9781 "extern linkage", decl);
9782 storage_class = sc_none;
9787 if (storage_class == sc_extern && initialized && !funcdef_flag)
9789 if (toplevel_bindings_p ())
9791 /* It's common practice (and completely valid) to have a const
9792 be initialized and declared extern. */
9793 if (!(type_quals & TYPE_QUAL_CONST))
9794 warning (0, "%qs initialized and declared %<extern%>", name);
9798 error ("%qs has both %<extern%> and initializer", name);
9799 return error_mark_node;
9803 /* Record `register' declaration for warnings on &
9804 and in case doing stupid register allocation. */
9806 if (storage_class == sc_register)
9807 DECL_REGISTER (decl) = 1;
9808 else if (storage_class == sc_extern)
9809 DECL_THIS_EXTERN (decl) = 1;
9810 else if (storage_class == sc_static)
9811 DECL_THIS_STATIC (decl) = 1;
9813 /* Don't forget constexprness. */
9814 if (VAR_OR_FUNCTION_DECL_P (decl))
9815 DECL_DECLARED_CONSTEXPR_P (decl) = constexpr_p;
9817 /* Record constancy and volatility on the DECL itself . There's
9818 no need to do this when processing a template; we'll do this
9819 for the instantiated declaration based on the type of DECL. */
9820 if (!processing_template_decl)
9821 cp_apply_type_quals_to_decl (type_quals, decl);
9827 /* Subroutine of start_function. Ensure that each of the parameter
9828 types (as listed in PARMS) is complete, as is required for a
9829 function definition. */
9832 require_complete_types_for_parms (tree parms)
9834 for (; parms; parms = TREE_CHAIN (parms))
9836 if (dependent_type_p (TREE_TYPE (parms)))
9838 if (!VOID_TYPE_P (TREE_TYPE (parms))
9839 && complete_type_or_else (TREE_TYPE (parms), parms))
9841 relayout_decl (parms);
9842 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9845 /* grokparms or complete_type_or_else will have already issued
9847 TREE_TYPE (parms) = error_mark_node;
9851 /* Returns nonzero if T is a local variable. */
9854 local_variable_p (const_tree t)
9856 if ((TREE_CODE (t) == VAR_DECL
9857 /* A VAR_DECL with a context that is a _TYPE is a static data
9859 && !TYPE_P (CP_DECL_CONTEXT (t))
9860 /* Any other non-local variable must be at namespace scope. */
9861 && !DECL_NAMESPACE_SCOPE_P (t))
9862 || (TREE_CODE (t) == PARM_DECL))
9868 /* Like local_variable_p, but suitable for use as a tree-walking
9872 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9873 void *data ATTRIBUTE_UNUSED)
9875 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9877 else if (TYPE_P (*tp))
9884 /* Check that ARG, which is a default-argument expression for a
9885 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9886 something goes wrong. DECL may also be a _TYPE node, rather than a
9887 DECL, if there is no DECL available. */
9890 check_default_argument (tree decl, tree arg)
9895 if (TREE_CODE (arg) == DEFAULT_ARG)
9896 /* We get a DEFAULT_ARG when looking at an in-class declaration
9897 with a default argument. Ignore the argument for now; we'll
9898 deal with it after the class is complete. */
9907 decl_type = TREE_TYPE (decl);
9909 if (arg == error_mark_node
9910 || decl == error_mark_node
9911 || TREE_TYPE (arg) == error_mark_node
9912 || decl_type == error_mark_node)
9913 /* Something already went wrong. There's no need to check
9915 return error_mark_node;
9917 /* [dcl.fct.default]
9919 A default argument expression is implicitly converted to the
9921 if (!TREE_TYPE (arg)
9922 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9925 error ("default argument for %q#D has type %qT",
9926 decl, TREE_TYPE (arg));
9928 error ("default argument for parameter of type %qT has type %qT",
9929 decl_type, TREE_TYPE (arg));
9931 return error_mark_node;
9934 /* [dcl.fct.default]
9936 Local variables shall not be used in default argument
9939 The keyword `this' shall not be used in a default argument of a
9941 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9944 error ("default argument %qE uses local variable %qD", arg, var);
9945 return error_mark_node;
9952 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9955 type_is_deprecated (tree type)
9957 enum tree_code code;
9958 if (TREE_DEPRECATED (type))
9960 if (TYPE_NAME (type)
9961 && TREE_DEPRECATED (TYPE_NAME (type)))
9964 /* Do warn about using typedefs to a deprecated class. */
9965 if (TAGGED_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
9966 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
9968 code = TREE_CODE (type);
9970 if (code == POINTER_TYPE || code == REFERENCE_TYPE
9971 || code == OFFSET_TYPE || code == FUNCTION_TYPE
9972 || code == METHOD_TYPE || code == ARRAY_TYPE)
9973 return type_is_deprecated (TREE_TYPE (type));
9975 if (TYPE_PTRMEMFUNC_P (type))
9976 return type_is_deprecated
9977 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
9982 /* Decode the list of parameter types for a function type.
9983 Given the list of things declared inside the parens,
9984 return a list of types.
9986 If this parameter does not end with an ellipsis, we append
9989 *PARMS is set to the chain of PARM_DECLs created. */
9992 grokparms (tree parmlist, tree *parms)
9994 tree result = NULL_TREE;
9995 tree decls = NULL_TREE;
9999 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
10001 tree type = NULL_TREE;
10002 tree init = TREE_PURPOSE (parm);
10003 tree decl = TREE_VALUE (parm);
10004 const char *errmsg;
10006 if (parm == void_list_node)
10009 if (! decl || TREE_TYPE (decl) == error_mark_node)
10012 type = TREE_TYPE (decl);
10013 if (VOID_TYPE_P (type))
10015 if (same_type_p (type, void_type_node)
10016 && DECL_SELF_REFERENCE_P (type)
10017 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
10018 /* this is a parmlist of `(void)', which is ok. */
10020 cxx_incomplete_type_error (decl, type);
10021 /* It's not a good idea to actually create parameters of
10022 type `void'; other parts of the compiler assume that a
10023 void type terminates the parameter list. */
10024 type = error_mark_node;
10025 TREE_TYPE (decl) = error_mark_node;
10028 if (type != error_mark_node
10029 && TYPE_FOR_JAVA (type)
10030 && MAYBE_CLASS_TYPE_P (type))
10032 error ("parameter %qD has Java class type", decl);
10033 type = error_mark_node;
10034 TREE_TYPE (decl) = error_mark_node;
10038 if (type != error_mark_node
10039 && (errmsg = targetm.invalid_parameter_type (type)))
10042 type = error_mark_node;
10043 TREE_TYPE (decl) = error_mark_node;
10046 if (type != error_mark_node)
10048 if (deprecated_state != DEPRECATED_SUPPRESS)
10050 tree deptype = type_is_deprecated (type);
10052 warn_deprecated_use (deptype, NULL_TREE);
10055 /* Top-level qualifiers on the parameters are
10056 ignored for function types. */
10057 type = cp_build_qualified_type (type, 0);
10058 if (TREE_CODE (type) == METHOD_TYPE)
10060 error ("parameter %qD invalidly declared method type", decl);
10061 type = build_pointer_type (type);
10062 TREE_TYPE (decl) = type;
10064 else if (abstract_virtuals_error (decl, type))
10065 any_error = 1; /* Seems like a good idea. */
10066 else if (POINTER_TYPE_P (type))
10068 /* [dcl.fct]/6, parameter types cannot contain pointers
10069 (references) to arrays of unknown bound. */
10070 tree t = TREE_TYPE (type);
10071 int ptr = TYPE_PTR_P (type);
10075 if (TYPE_PTR_P (t))
10077 else if (TREE_CODE (t) != ARRAY_TYPE)
10079 else if (!TYPE_DOMAIN (t))
10083 if (TREE_CODE (t) == ARRAY_TYPE)
10085 ? G_("parameter %qD includes pointer to array of "
10086 "unknown bound %qT")
10087 : G_("parameter %qD includes reference to array of "
10088 "unknown bound %qT"),
10094 else if (init && !processing_template_decl)
10095 init = check_default_argument (decl, init);
10098 if (TREE_CODE (decl) == PARM_DECL
10099 && FUNCTION_PARAMETER_PACK_P (decl)
10100 && TREE_CHAIN (parm)
10101 && TREE_CHAIN (parm) != void_list_node)
10102 error ("parameter packs must be at the end of the parameter list");
10104 TREE_CHAIN (decl) = decls;
10106 result = tree_cons (init, type, result);
10108 decls = nreverse (decls);
10109 result = nreverse (result);
10111 result = chainon (result, void_list_node);
10118 /* D is a constructor or overloaded `operator='.
10120 Let T be the class in which D is declared. Then, this function
10123 -1 if D's is an ill-formed constructor or copy assignment operator
10124 whose first parameter is of type `T'.
10125 0 if D is not a copy constructor or copy assignment
10127 1 if D is a copy constructor or copy assignment operator whose
10128 first parameter is a reference to non-const qualified T.
10129 2 if D is a copy constructor or copy assignment operator whose
10130 first parameter is a reference to const qualified T.
10132 This function can be used as a predicate. Positive values indicate
10133 a copy constructor and nonzero values indicate a copy assignment
10137 copy_fn_p (const_tree d)
10143 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
10145 if (TREE_CODE (d) == TEMPLATE_DECL
10146 || (DECL_TEMPLATE_INFO (d)
10147 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
10148 /* Instantiations of template member functions are never copy
10149 functions. Note that member functions of templated classes are
10150 represented as template functions internally, and we must
10151 accept those as copy functions. */
10154 args = FUNCTION_FIRST_USER_PARMTYPE (d);
10158 arg_type = TREE_VALUE (args);
10159 if (arg_type == error_mark_node)
10162 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
10164 /* Pass by value copy assignment operator. */
10167 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
10168 && !TYPE_REF_IS_RVALUE (arg_type)
10169 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
10171 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
10177 args = TREE_CHAIN (args);
10179 if (args && args != void_list_node && !TREE_PURPOSE (args))
10180 /* There are more non-optional args. */
10186 /* D is a constructor or overloaded `operator='.
10188 Let T be the class in which D is declared. Then, this function
10189 returns true when D is a move constructor or move assignment
10190 operator, false otherwise. */
10193 move_fn_p (const_tree d)
10197 bool result = false;
10199 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
10201 if (cxx_dialect == cxx98)
10202 /* There are no move constructors if we are in C++98 mode. */
10205 if (TREE_CODE (d) == TEMPLATE_DECL
10206 || (DECL_TEMPLATE_INFO (d)
10207 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
10208 /* Instantiations of template member functions are never copy
10209 functions. Note that member functions of templated classes are
10210 represented as template functions internally, and we must
10211 accept those as copy functions. */
10214 args = FUNCTION_FIRST_USER_PARMTYPE (d);
10218 arg_type = TREE_VALUE (args);
10219 if (arg_type == error_mark_node)
10222 if (TREE_CODE (arg_type) == REFERENCE_TYPE
10223 && TYPE_REF_IS_RVALUE (arg_type)
10224 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
10228 args = TREE_CHAIN (args);
10230 if (args && args != void_list_node && !TREE_PURPOSE (args))
10231 /* There are more non-optional args. */
10237 /* Remember any special properties of member function DECL. */
10240 grok_special_member_properties (tree decl)
10244 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10247 class_type = DECL_CONTEXT (decl);
10248 if (DECL_CONSTRUCTOR_P (decl))
10250 int ctor = copy_fn_p (decl);
10252 if (!DECL_ARTIFICIAL (decl))
10253 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
10259 A non-template constructor for class X is a copy
10260 constructor if its first parameter is of type X&, const
10261 X&, volatile X& or const volatile X&, and either there
10262 are no other parameters or else all other parameters have
10263 default arguments. */
10264 TYPE_HAS_COPY_CTOR (class_type) = 1;
10265 if (user_provided_p (decl))
10266 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
10268 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
10270 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
10272 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
10273 if (user_provided_p (decl))
10274 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
10276 else if (is_list_ctor (decl))
10277 TYPE_HAS_LIST_CTOR (class_type) = 1;
10279 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
10283 A non-template assignment operator for class X is a copy
10284 assignment operator if its parameter is of type X, X&, const
10285 X&, volatile X& or const volatile X&. */
10287 int assop = copy_fn_p (decl);
10291 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
10292 if (user_provided_p (decl))
10293 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
10295 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
10300 /* Check a constructor DECL has the correct form. Complains
10301 if the class has a constructor of the form X(X). */
10304 grok_ctor_properties (const_tree ctype, const_tree decl)
10306 int ctor_parm = copy_fn_p (decl);
10312 A declaration of a constructor for a class X is ill-formed if
10313 its first parameter is of type (optionally cv-qualified) X
10314 and either there are no other parameters or else all other
10315 parameters have default arguments.
10317 We *don't* complain about member template instantiations that
10318 have this form, though; they can occur as we try to decide
10319 what constructor to use during overload resolution. Since
10320 overload resolution will never prefer such a constructor to
10321 the non-template copy constructor (which is either explicitly
10322 or implicitly defined), there's no need to worry about their
10323 existence. Theoretically, they should never even be
10324 instantiated, but that's hard to forestall. */
10325 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
10333 /* An operator with this code is unary, but can also be binary. */
10336 ambi_op_p (enum tree_code code)
10338 return (code == INDIRECT_REF
10339 || code == ADDR_EXPR
10340 || code == UNARY_PLUS_EXPR
10341 || code == NEGATE_EXPR
10342 || code == PREINCREMENT_EXPR
10343 || code == PREDECREMENT_EXPR);
10346 /* An operator with this name can only be unary. */
10349 unary_op_p (enum tree_code code)
10351 return (code == TRUTH_NOT_EXPR
10352 || code == BIT_NOT_EXPR
10353 || code == COMPONENT_REF
10354 || code == TYPE_EXPR);
10357 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10358 errors are issued for invalid declarations. */
10361 grok_op_properties (tree decl, bool complain)
10363 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10365 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10366 tree name = DECL_NAME (decl);
10367 enum tree_code operator_code;
10372 /* Count the number of arguments and check for ellipsis. */
10373 for (argtype = argtypes, arity = 0;
10374 argtype && argtype != void_list_node;
10375 argtype = TREE_CHAIN (argtype))
10377 ellipsis_p = !argtype;
10379 class_type = DECL_CONTEXT (decl);
10380 if (class_type && !CLASS_TYPE_P (class_type))
10381 class_type = NULL_TREE;
10383 if (DECL_CONV_FN_P (decl))
10384 operator_code = TYPE_EXPR;
10388 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10389 if (ansi_opname (CODE) == name) \
10391 operator_code = (CODE); \
10394 else if (ansi_assopname (CODE) == name) \
10396 operator_code = (CODE); \
10397 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10401 #include "operators.def"
10402 #undef DEF_OPERATOR
10404 gcc_unreachable ();
10407 gcc_assert (operator_code != MAX_TREE_CODES);
10408 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10411 switch (operator_code)
10414 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
10418 TYPE_GETS_DELETE (class_type) |= 1;
10422 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
10425 case VEC_DELETE_EXPR:
10426 TYPE_GETS_DELETE (class_type) |= 2;
10433 /* [basic.std.dynamic.allocation]/1:
10435 A program is ill-formed if an allocation function is declared
10436 in a namespace scope other than global scope or declared static
10439 The same also holds true for deallocation functions. */
10440 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
10441 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10443 if (DECL_NAMESPACE_SCOPE_P (decl))
10445 if (CP_DECL_CONTEXT (decl) != global_namespace)
10447 error ("%qD may not be declared within a namespace", decl);
10450 else if (!TREE_PUBLIC (decl))
10452 error ("%qD may not be declared as static", decl);
10458 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
10460 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10461 DECL_IS_OPERATOR_NEW (decl) = 1;
10463 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10464 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10467 /* An operator function must either be a non-static member function
10468 or have at least one parameter of a class, a reference to a class,
10469 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10470 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10472 if (operator_code == TYPE_EXPR
10473 || operator_code == CALL_EXPR
10474 || operator_code == COMPONENT_REF
10475 || operator_code == ARRAY_REF
10476 || operator_code == NOP_EXPR)
10478 error ("%qD must be a nonstatic member function", decl);
10485 if (DECL_STATIC_FUNCTION_P (decl))
10487 error ("%qD must be either a non-static member "
10488 "function or a non-member function", decl);
10492 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
10494 tree arg = non_reference (TREE_VALUE (p));
10495 if (arg == error_mark_node)
10498 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10499 because these checks are performed even on
10500 template functions. */
10501 if (MAYBE_CLASS_TYPE_P (arg)
10502 || TREE_CODE (arg) == ENUMERAL_TYPE)
10506 if (!p || p == void_list_node)
10509 error ("%qD must have an argument of class or "
10510 "enumerated type", decl);
10516 /* There are no restrictions on the arguments to an overloaded
10518 if (operator_code == CALL_EXPR)
10521 /* Warn about conversion operators that will never be used. */
10522 if (IDENTIFIER_TYPENAME_P (name)
10523 && ! DECL_TEMPLATE_INFO (decl)
10525 /* Warn only declaring the function; there is no need to
10526 warn again about out-of-class definitions. */
10527 && class_type == current_class_type)
10529 tree t = TREE_TYPE (name);
10530 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10533 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10535 if (TREE_CODE (t) == VOID_TYPE)
10536 warning (OPT_Wconversion,
10538 ? G_("conversion to a reference to void "
10539 "will never use a type conversion operator")
10540 : G_("conversion to void "
10541 "will never use a type conversion operator"));
10542 else if (class_type)
10544 if (t == class_type)
10545 warning (OPT_Wconversion,
10547 ? G_("conversion to a reference to the same type "
10548 "will never use a type conversion operator")
10549 : G_("conversion to the same type "
10550 "will never use a type conversion operator"));
10551 /* Don't force t to be complete here. */
10552 else if (MAYBE_CLASS_TYPE_P (t)
10553 && COMPLETE_TYPE_P (t)
10554 && DERIVED_FROM_P (t, class_type))
10555 warning (OPT_Wconversion,
10557 ? G_("conversion to a reference to a base class "
10558 "will never use a type conversion operator")
10559 : G_("conversion to a base class "
10560 "will never use a type conversion operator"));
10565 if (operator_code == COND_EXPR)
10568 error ("ISO C++ prohibits overloading operator ?:");
10571 else if (ellipsis_p)
10573 error ("%qD must not have variable number of arguments", decl);
10576 else if (ambi_op_p (operator_code))
10579 /* We pick the one-argument operator codes by default, so
10580 we don't have to change anything. */
10582 else if (arity == 2)
10584 /* If we thought this was a unary operator, we now know
10585 it to be a binary operator. */
10586 switch (operator_code)
10589 operator_code = MULT_EXPR;
10593 operator_code = BIT_AND_EXPR;
10596 case UNARY_PLUS_EXPR:
10597 operator_code = PLUS_EXPR;
10601 operator_code = MINUS_EXPR;
10604 case PREINCREMENT_EXPR:
10605 operator_code = POSTINCREMENT_EXPR;
10608 case PREDECREMENT_EXPR:
10609 operator_code = POSTDECREMENT_EXPR;
10613 gcc_unreachable ();
10616 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10618 if ((operator_code == POSTINCREMENT_EXPR
10619 || operator_code == POSTDECREMENT_EXPR)
10620 && ! processing_template_decl
10621 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
10624 error ("postfix %qD must take %<int%> as its argument",
10627 error ("postfix %qD must take %<int%> as its second "
10635 error ("%qD must take either zero or one argument", decl);
10637 error ("%qD must take either one or two arguments", decl);
10641 /* More Effective C++ rule 6. */
10643 && (operator_code == POSTINCREMENT_EXPR
10644 || operator_code == POSTDECREMENT_EXPR
10645 || operator_code == PREINCREMENT_EXPR
10646 || operator_code == PREDECREMENT_EXPR))
10648 tree arg = TREE_VALUE (argtypes);
10649 tree ret = TREE_TYPE (TREE_TYPE (decl));
10650 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10651 arg = TREE_TYPE (arg);
10652 arg = TYPE_MAIN_VARIANT (arg);
10653 if (operator_code == PREINCREMENT_EXPR
10654 || operator_code == PREDECREMENT_EXPR)
10656 if (TREE_CODE (ret) != REFERENCE_TYPE
10657 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10659 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10660 build_reference_type (arg));
10664 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10665 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10669 else if (unary_op_p (operator_code))
10674 error ("%qD must take %<void%>", decl);
10676 error ("%qD must take exactly one argument", decl);
10680 else /* if (binary_op_p (operator_code)) */
10685 error ("%qD must take exactly one argument", decl);
10687 error ("%qD must take exactly two arguments", decl);
10691 /* More Effective C++ rule 7. */
10693 && (operator_code == TRUTH_ANDIF_EXPR
10694 || operator_code == TRUTH_ORIF_EXPR
10695 || operator_code == COMPOUND_EXPR))
10696 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10700 /* Effective C++ rule 23. */
10703 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10704 && (operator_code == PLUS_EXPR
10705 || operator_code == MINUS_EXPR
10706 || operator_code == TRUNC_DIV_EXPR
10707 || operator_code == MULT_EXPR
10708 || operator_code == TRUNC_MOD_EXPR)
10709 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10710 warning (OPT_Weffc__, "%qD should return by value", decl);
10712 /* [over.oper]/8 */
10713 for (; argtypes && argtypes != void_list_node;
10714 argtypes = TREE_CHAIN (argtypes))
10715 if (TREE_PURPOSE (argtypes))
10717 TREE_PURPOSE (argtypes) = NULL_TREE;
10718 if (operator_code == POSTINCREMENT_EXPR
10719 || operator_code == POSTDECREMENT_EXPR)
10721 pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments",
10726 error ("%qD cannot have default arguments", decl);
10734 /* Return a string giving the keyword associate with CODE. */
10736 static const char *
10737 tag_name (enum tag_types code)
10749 case typename_type:
10752 gcc_unreachable ();
10756 /* Name lookup in an elaborated-type-specifier (after the keyword
10757 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10758 elaborated-type-specifier is invalid, issue a diagnostic and return
10759 error_mark_node; otherwise, return the *_TYPE to which it referred.
10760 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10763 check_elaborated_type_specifier (enum tag_types tag_code,
10765 bool allow_template_p)
10771 struct S { struct S *p; };
10773 name lookup will find the TYPE_DECL for the implicit "S::S"
10774 typedef. Adjust for that here. */
10775 if (DECL_SELF_REFERENCE_P (decl))
10776 decl = TYPE_NAME (TREE_TYPE (decl));
10778 type = TREE_TYPE (decl);
10780 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10781 is false for this case as well. */
10782 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10784 error ("using template type parameter %qT after %qs",
10785 type, tag_name (tag_code));
10786 return error_mark_node;
10790 If the identifier resolves to a typedef-name or a template
10791 type-parameter, the elaborated-type-specifier is ill-formed.
10793 In other words, the only legitimate declaration to use in the
10794 elaborated type specifier is the implicit typedef created when
10795 the type is declared. */
10796 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10797 && !DECL_SELF_REFERENCE_P (decl)
10798 && tag_code != typename_type)
10800 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10801 error ("%q+D has a previous declaration here", decl);
10802 return error_mark_node;
10804 else if (TREE_CODE (type) != RECORD_TYPE
10805 && TREE_CODE (type) != UNION_TYPE
10806 && tag_code != enum_type
10807 && tag_code != typename_type)
10809 error ("%qT referred to as %qs", type, tag_name (tag_code));
10810 error ("%q+T has a previous declaration here", type);
10811 return error_mark_node;
10813 else if (TREE_CODE (type) != ENUMERAL_TYPE
10814 && tag_code == enum_type)
10816 error ("%qT referred to as enum", type);
10817 error ("%q+T has a previous declaration here", type);
10818 return error_mark_node;
10820 else if (!allow_template_p
10821 && TREE_CODE (type) == RECORD_TYPE
10822 && CLASSTYPE_IS_TEMPLATE (type))
10824 /* If a class template appears as elaborated type specifier
10825 without a template header such as:
10827 template <class T> class C {};
10828 void f(class C); // No template header here
10830 then the required template argument is missing. */
10831 error ("template argument required for %<%s %T%>",
10832 tag_name (tag_code),
10833 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10834 return error_mark_node;
10840 /* Lookup NAME in elaborate type specifier in scope according to
10841 SCOPE and issue diagnostics if necessary.
10842 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10843 found, and ERROR_MARK_NODE for type error. */
10846 lookup_and_check_tag (enum tag_types tag_code, tree name,
10847 tag_scope scope, bool template_header_p)
10851 if (scope == ts_global)
10853 /* First try ordinary name lookup, ignoring hidden class name
10854 injected via friend declaration. */
10855 decl = lookup_name_prefer_type (name, 2);
10856 /* If that fails, the name will be placed in the smallest
10857 non-class, non-function-prototype scope according to 3.3.1/5.
10858 We may already have a hidden name declared as friend in this
10859 scope. So lookup again but not ignoring hidden names.
10860 If we find one, that name will be made visible rather than
10861 creating a new tag. */
10863 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10866 decl = lookup_type_scope (name, scope);
10868 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10869 decl = DECL_TEMPLATE_RESULT (decl);
10871 if (decl && TREE_CODE (decl) == TYPE_DECL)
10873 /* Look for invalid nested type:
10877 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10879 error ("%qD has the same name as the class in which it is "
10882 return error_mark_node;
10885 /* Two cases we need to consider when deciding if a class
10886 template is allowed as an elaborated type specifier:
10887 1. It is a self reference to its own class.
10888 2. It comes with a template header.
10892 template <class T> class C {
10893 class C *c1; // DECL_SELF_REFERENCE_P is true
10896 template <class U> class C; // template_header_p is true
10897 template <class T> class C<T>::D {
10898 class C *c2; // DECL_SELF_REFERENCE_P is true
10901 t = check_elaborated_type_specifier (tag_code,
10904 | DECL_SELF_REFERENCE_P (decl));
10907 else if (decl && TREE_CODE (decl) == TREE_LIST)
10909 error ("reference to %qD is ambiguous", name);
10910 print_candidates (decl);
10911 return error_mark_node;
10917 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10918 Define the tag as a forward-reference if it is not defined.
10920 If a declaration is given, process it here, and report an error if
10921 multiple declarations are not identical.
10923 SCOPE is TS_CURRENT when this is also a definition. Only look in
10924 the current frame for the name (since C++ allows new names in any
10925 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10926 declaration. Only look beginning from the current scope outward up
10927 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10929 TEMPLATE_HEADER_P is true when this declaration is preceded by
10930 a set of template parameters. */
10933 xref_tag (enum tag_types tag_code, tree name,
10934 tag_scope scope, bool template_header_p)
10936 enum tree_code code;
10938 tree context = NULL_TREE;
10940 timevar_push (TV_NAME_LOOKUP);
10942 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10948 code = RECORD_TYPE;
10954 code = ENUMERAL_TYPE;
10957 gcc_unreachable ();
10960 /* In case of anonymous name, xref_tag is only called to
10961 make type node and push name. Name lookup is not required. */
10962 if (ANON_AGGRNAME_P (name))
10965 t = lookup_and_check_tag (tag_code, name,
10966 scope, template_header_p);
10968 if (t == error_mark_node)
10969 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10971 if (scope != ts_current && t && current_class_type
10972 && template_class_depth (current_class_type)
10973 && template_header_p)
10975 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10976 definition of this tag. Since, in addition, we are currently
10977 processing a (member) template declaration of a template
10978 class, we must be very careful; consider:
10985 { template <class V>
10986 friend struct S1; };
10988 Here, the S2::S1 declaration should not be confused with the
10989 outer declaration. In particular, the inner version should
10990 have a template parameter of level 2, not level 1. This
10991 would be particularly important if the member declaration
10994 template <class V = U> friend struct S1;
10996 say, when we should tsubst into `U' when instantiating
10997 S2. On the other hand, when presented with:
11007 we must find the inner binding eventually. We
11008 accomplish this by making sure that the new type we
11009 create to represent this declaration has the right
11011 context = TYPE_CONTEXT (t);
11017 /* If no such tag is yet defined, create a forward-reference node
11018 and record it as the "definition".
11019 When a real declaration of this type is found,
11020 the forward-reference will be altered into a real type. */
11021 if (code == ENUMERAL_TYPE)
11023 error ("use of enum %q#D without previous declaration", name);
11024 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
11028 t = make_class_type (code);
11029 TYPE_CONTEXT (t) = context;
11030 t = pushtag (name, t, scope);
11035 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
11037 if (!redeclare_class_template (t, current_template_parms))
11038 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
11040 else if (!processing_template_decl
11041 && CLASS_TYPE_P (t)
11042 && CLASSTYPE_IS_TEMPLATE (t))
11044 error ("redeclaration of %qT as a non-template", t);
11045 error ("previous declaration %q+D", t);
11046 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
11049 /* Make injected friend class visible. */
11050 if (scope != ts_within_enclosing_non_class
11051 && hidden_name_p (TYPE_NAME (t)))
11053 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
11054 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
11056 if (TYPE_TEMPLATE_INFO (t))
11058 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
11059 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
11064 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
11068 xref_tag_from_type (tree old, tree id, tag_scope scope)
11070 enum tag_types tag_kind;
11072 if (TREE_CODE (old) == RECORD_TYPE)
11073 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
11075 tag_kind = union_type;
11077 if (id == NULL_TREE)
11078 id = TYPE_IDENTIFIER (old);
11080 return xref_tag (tag_kind, id, scope, false);
11083 /* Create the binfo hierarchy for REF with (possibly NULL) base list
11084 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
11085 access_* node, and the TREE_VALUE is the type of the base-class.
11086 Non-NULL TREE_TYPE indicates virtual inheritance.
11088 Returns true if the binfo hierarchy was successfully created,
11089 false if an error was detected. */
11092 xref_basetypes (tree ref, tree base_list)
11095 tree binfo, base_binfo;
11096 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
11097 unsigned max_bases = 0; /* Maximum direct bases. */
11099 tree default_access;
11100 tree igo_prev; /* Track Inheritance Graph Order. */
11102 if (ref == error_mark_node)
11105 /* The base of a derived class is private by default, all others are
11107 default_access = (TREE_CODE (ref) == RECORD_TYPE
11108 && CLASSTYPE_DECLARED_CLASS (ref)
11109 ? access_private_node : access_public_node);
11111 /* First, make sure that any templates in base-classes are
11112 instantiated. This ensures that if we call ourselves recursively
11113 we do not get confused about which classes are marked and which
11115 basep = &base_list;
11118 tree basetype = TREE_VALUE (*basep);
11120 if (!(processing_template_decl && uses_template_parms (basetype))
11121 && !complete_type_or_else (basetype, NULL))
11122 /* An incomplete type. Remove it from the list. */
11123 *basep = TREE_CHAIN (*basep);
11127 if (TREE_TYPE (*basep))
11129 if (CLASS_TYPE_P (basetype))
11130 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
11131 basep = &TREE_CHAIN (*basep);
11135 TYPE_MARKED_P (ref) = 1;
11137 /* The binfo slot should be empty, unless this is an (ill-formed)
11139 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref))
11141 error ("redefinition of %q#T", ref);
11145 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
11147 binfo = make_tree_binfo (max_bases);
11149 TYPE_BINFO (ref) = binfo;
11150 BINFO_OFFSET (binfo) = size_zero_node;
11151 BINFO_TYPE (binfo) = ref;
11153 /* Apply base-class info set up to the variants of this type. */
11154 fixup_type_variants (ref);
11158 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
11159 /* An aggregate cannot have baseclasses. */
11160 CLASSTYPE_NON_AGGREGATE (ref) = 1;
11162 if (TREE_CODE (ref) == UNION_TYPE)
11164 error ("derived union %qT invalid", ref);
11171 if (TYPE_FOR_JAVA (ref))
11173 error ("Java class %qT cannot have multiple bases", ref);
11180 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
11182 if (TYPE_FOR_JAVA (ref))
11184 error ("Java class %qT cannot have virtual bases", ref);
11189 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
11191 tree access = TREE_PURPOSE (base_list);
11192 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
11193 tree basetype = TREE_VALUE (base_list);
11195 if (access == access_default_node)
11196 access = default_access;
11198 if (PACK_EXPANSION_P (basetype))
11199 basetype = PACK_EXPANSION_PATTERN (basetype);
11200 if (TREE_CODE (basetype) == TYPE_DECL)
11201 basetype = TREE_TYPE (basetype);
11202 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
11204 error ("base type %qT fails to be a struct or class type",
11209 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
11210 TYPE_FOR_JAVA (ref) = 1;
11212 base_binfo = NULL_TREE;
11213 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
11215 base_binfo = TYPE_BINFO (basetype);
11216 /* The original basetype could have been a typedef'd type. */
11217 basetype = BINFO_TYPE (base_binfo);
11219 /* Inherit flags from the base. */
11220 TYPE_HAS_NEW_OPERATOR (ref)
11221 |= TYPE_HAS_NEW_OPERATOR (basetype);
11222 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
11223 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
11224 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
11225 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
11226 CLASSTYPE_DIAMOND_SHAPED_P (ref)
11227 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
11228 CLASSTYPE_REPEATED_BASE_P (ref)
11229 |= CLASSTYPE_REPEATED_BASE_P (basetype);
11232 /* We must do this test after we've seen through a typedef
11234 if (TYPE_MARKED_P (basetype))
11236 if (basetype == ref)
11237 error ("recursive type %qT undefined", basetype);
11239 error ("duplicate base type %qT invalid", basetype);
11243 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
11244 /* Regenerate the pack expansion for the bases. */
11245 basetype = make_pack_expansion (basetype);
11247 TYPE_MARKED_P (basetype) = 1;
11249 base_binfo = copy_binfo (base_binfo, basetype, ref,
11250 &igo_prev, via_virtual);
11251 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
11252 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
11254 BINFO_BASE_APPEND (binfo, base_binfo);
11255 BINFO_BASE_ACCESS_APPEND (binfo, access);
11258 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
11259 /* If we have space in the vbase vector, we must have shared at
11260 least one of them, and are therefore diamond shaped. */
11261 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
11263 /* Unmark all the types. */
11264 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
11265 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
11266 TYPE_MARKED_P (ref) = 0;
11268 /* Now see if we have a repeated base type. */
11269 if (!CLASSTYPE_REPEATED_BASE_P (ref))
11271 for (base_binfo = binfo; base_binfo;
11272 base_binfo = TREE_CHAIN (base_binfo))
11274 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
11276 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
11279 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
11281 for (base_binfo = binfo; base_binfo;
11282 base_binfo = TREE_CHAIN (base_binfo))
11283 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
11284 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
11293 /* Begin compiling the definition of an enumeration type.
11296 UNDERLYING_TYPE is the type that will be used as the storage for
11297 the enumeration type. This should be NULL_TREE if no storage type
11300 SCOPED_ENUM_P is true if this is a scoped enumeration type.
11302 Returns the type object, as yet incomplete.
11303 Also records info about it so that build_enumerator
11304 may be used to declare the individual values as they are read. */
11307 start_enum (tree name, tree underlying_type, bool scoped_enum_p)
11311 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
11313 /* If this is the real definition for a previous forward reference,
11314 fill in the contents in the same object that used to be the
11315 forward reference. */
11317 enumtype = lookup_and_check_tag (enum_type, name,
11318 /*tag_scope=*/ts_current,
11319 /*template_header_p=*/false);
11321 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
11323 error_at (input_location, "multiple definition of %q#T", enumtype);
11324 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
11325 "previous definition here");
11326 /* Clear out TYPE_VALUES, and start again. */
11327 TYPE_VALUES (enumtype) = NULL_TREE;
11331 /* In case of error, make a dummy enum to allow parsing to
11333 if (enumtype == error_mark_node)
11334 name = make_anon_name ();
11336 enumtype = cxx_make_type (ENUMERAL_TYPE);
11337 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
11340 if (enumtype == error_mark_node)
11345 SET_SCOPED_ENUM_P (enumtype, 1);
11346 begin_scope (sk_scoped_enum, enumtype);
11348 /* [C++0x dcl.enum]p5:
11350 If not explicitly specified, the underlying type of a scoped
11351 enumeration type is int. */
11352 if (!underlying_type)
11353 underlying_type = integer_type_node;
11356 if (underlying_type)
11358 if (CP_INTEGRAL_TYPE_P (underlying_type))
11360 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
11361 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
11362 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11363 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11364 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11365 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11366 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11367 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11368 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11369 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
11371 else if (!dependent_type_p (underlying_type))
11372 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11373 underlying_type, enumtype);
11379 /* After processing and defining all the values of an enumeration type,
11380 install their decls in the enumeration type and finish it off.
11381 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11384 finish_enum (tree enumtype)
11392 tree underlying_type = NULL_TREE;
11393 bool fixed_underlying_type_p
11394 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
11396 /* We built up the VALUES in reverse order. */
11397 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
11399 /* For an enum defined in a template, just set the type of the values;
11400 all further processing is postponed until the template is
11401 instantiated. We need to set the type so that tsubst of a CONST_DECL
11403 if (processing_template_decl)
11405 for (values = TYPE_VALUES (enumtype);
11407 values = TREE_CHAIN (values))
11408 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11409 if (at_function_scope_p ())
11410 add_stmt (build_min (TAG_DEFN, enumtype));
11411 if (SCOPED_ENUM_P (enumtype))
11416 /* Determine the minimum and maximum values of the enumerators. */
11417 if (TYPE_VALUES (enumtype))
11419 minnode = maxnode = NULL_TREE;
11421 for (values = TYPE_VALUES (enumtype);
11423 values = TREE_CHAIN (values))
11425 decl = TREE_VALUE (values);
11427 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11428 each enumerator has the type of its enumeration. Prior to the
11429 closing brace, the type of each enumerator is the type of its
11430 initializing value. */
11431 TREE_TYPE (decl) = enumtype;
11433 /* Update the minimum and maximum values, if appropriate. */
11434 value = DECL_INITIAL (decl);
11435 if (value == error_mark_node)
11436 value = integer_zero_node;
11437 /* Figure out what the minimum and maximum values of the
11438 enumerators are. */
11440 minnode = maxnode = value;
11441 else if (tree_int_cst_lt (maxnode, value))
11443 else if (tree_int_cst_lt (value, minnode))
11450 If the enumerator-list is empty, the underlying type is as if
11451 the enumeration had a single enumerator with value 0. */
11452 minnode = maxnode = integer_zero_node;
11454 if (!fixed_underlying_type_p)
11456 /* Compute the number of bits require to represent all values of the
11457 enumeration. We must do this before the type of MINNODE and
11458 MAXNODE are transformed, since tree_int_cst_min_precision relies
11459 on the TREE_TYPE of the value it is passed. */
11460 bool unsignedp = tree_int_cst_sgn (minnode) >= 0;
11461 int lowprec = tree_int_cst_min_precision (minnode, unsignedp);
11462 int highprec = tree_int_cst_min_precision (maxnode, unsignedp);
11463 int precision = MAX (lowprec, highprec);
11465 bool use_short_enum;
11467 /* Determine the underlying type of the enumeration.
11471 The underlying type of an enumeration is an integral type that
11472 can represent all the enumerator values defined in the
11473 enumeration. It is implementation-defined which integral type is
11474 used as the underlying type for an enumeration except that the
11475 underlying type shall not be larger than int unless the value of
11476 an enumerator cannot fit in an int or unsigned int.
11478 We use "int" or an "unsigned int" as the underlying type, even if
11479 a smaller integral type would work, unless the user has
11480 explicitly requested that we use the smallest possible type. The
11481 user can request that for all enumerations with a command line
11482 flag, or for just one enumeration with an attribute. */
11484 use_short_enum = flag_short_enums
11485 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
11487 for (itk = (use_short_enum ? itk_char : itk_int);
11491 underlying_type = integer_types[itk];
11492 if (underlying_type != NULL_TREE
11493 && TYPE_PRECISION (underlying_type) >= precision
11494 && TYPE_UNSIGNED (underlying_type) == unsignedp)
11497 if (itk == itk_none)
11501 IF no integral type can represent all the enumerator values, the
11502 enumeration is ill-formed. */
11503 error ("no integral type can represent all of the enumerator values "
11504 "for %qT", enumtype);
11505 precision = TYPE_PRECISION (long_long_integer_type_node);
11506 underlying_type = integer_types[itk_unsigned_long_long];
11511 The value of sizeof() applied to an enumeration type, an object
11512 of an enumeration type, or an enumerator, is the value of sizeof()
11513 applied to the underlying type. */
11514 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
11515 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
11516 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11517 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11518 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11519 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11520 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11521 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11522 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11524 /* Compute the minimum and maximum values for the type.
11528 For an enumeration where emin is the smallest enumerator and emax
11529 is the largest, the values of the enumeration are the values of the
11530 underlying type in the range bmin to bmax, where bmin and bmax are,
11531 respectively, the smallest and largest values of the smallest bit-
11532 field that can store emin and emax. */
11534 /* The middle-end currently assumes that types with TYPE_PRECISION
11535 narrower than their underlying type are suitably zero or sign
11536 extended to fill their mode. Similarly, it assumes that the front
11537 end assures that a value of a particular type must be within
11538 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
11540 We used to set these fields based on bmin and bmax, but that led
11541 to invalid assumptions like optimizing away bounds checking. So
11542 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
11543 TYPE_MAX_VALUE to the values for the mode above and only restrict
11544 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
11545 ENUM_UNDERLYING_TYPE (enumtype)
11546 = build_distinct_type_copy (underlying_type);
11547 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
11548 set_min_and_max_values_for_integral_type
11549 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
11551 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
11552 if (flag_strict_enums)
11553 set_min_and_max_values_for_integral_type (enumtype, precision,
11557 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
11559 /* Convert each of the enumerators to the type of the underlying
11560 type of the enumeration. */
11561 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
11563 location_t saved_location;
11565 decl = TREE_VALUE (values);
11566 saved_location = input_location;
11567 input_location = DECL_SOURCE_LOCATION (decl);
11568 if (fixed_underlying_type_p)
11569 /* If the enumeration type has a fixed underlying type, we
11570 already checked all of the enumerator values. */
11571 value = DECL_INITIAL (decl);
11573 value = perform_implicit_conversion (underlying_type,
11574 DECL_INITIAL (decl),
11575 tf_warning_or_error);
11576 input_location = saved_location;
11578 /* Do not clobber shared ints. */
11579 value = copy_node (value);
11581 TREE_TYPE (value) = enumtype;
11582 DECL_INITIAL (decl) = value;
11585 /* Fix up all variant types of this enum type. */
11586 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
11588 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
11589 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
11590 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
11591 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
11592 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
11593 SET_TYPE_MODE (t, TYPE_MODE (enumtype));
11594 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
11595 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
11596 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
11597 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
11598 ENUM_UNDERLYING_TYPE (t) = ENUM_UNDERLYING_TYPE (enumtype);
11601 /* Finish up the scope of a scoped enumeration. */
11602 if (SCOPED_ENUM_P (enumtype))
11605 /* Finish debugging output for this type. */
11606 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11609 /* Build and install a CONST_DECL for an enumeration constant of the
11610 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11611 Assignment of sequential values by default is handled here. */
11614 build_enumerator (tree name, tree value, tree enumtype)
11620 /* If the VALUE was erroneous, pretend it wasn't there; that will
11621 result in the enum being assigned the next value in sequence. */
11622 if (value == error_mark_node)
11625 /* Remove no-op casts from the value. */
11627 STRIP_TYPE_NOPS (value);
11629 if (! processing_template_decl)
11631 /* Validate and default VALUE. */
11632 if (value != NULL_TREE)
11634 value = integral_constant_value (value);
11636 if (TREE_CODE (value) == INTEGER_CST)
11638 value = perform_integral_promotions (value);
11639 constant_expression_warning (value);
11643 error ("enumerator value for %qD is not an integer constant", name);
11648 /* Default based on previous value. */
11649 if (value == NULL_TREE)
11651 if (TYPE_VALUES (enumtype))
11654 unsigned HOST_WIDE_INT lo;
11658 /* The next value is the previous value plus one.
11659 add_double doesn't know the type of the target expression,
11660 so we must check with int_fits_type_p as well. */
11661 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
11662 if (error_operand_p (prev_value))
11663 value = error_mark_node;
11666 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11667 TREE_INT_CST_HIGH (prev_value),
11669 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11671 |= !int_fits_type_p (value, TREE_TYPE (prev_value));
11675 error ("overflow in enumeration values at %qD", name);
11676 value = error_mark_node;
11681 value = integer_zero_node;
11684 /* Remove no-op casts from the value. */
11685 STRIP_TYPE_NOPS (value);
11687 /* If the underlying type of the enum is fixed, check whether
11688 the enumerator values fits in the underlying type. If it
11689 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11690 if (ENUM_UNDERLYING_TYPE (enumtype)
11692 && TREE_CODE (value) == INTEGER_CST
11693 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
11695 error ("enumerator value %E is too large for underlying type %<%T%>",
11696 value, ENUM_UNDERLYING_TYPE (enumtype));
11698 /* Silently convert the value so that we can continue. */
11699 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
11704 /* C++ associates enums with global, function, or class declarations. */
11705 context = current_scope ();
11707 /* Build the actual enumeration constant. Note that the enumeration
11708 constants have the underlying type of the enum (if it is fixed)
11709 or the type of their initializer (if the underlying type of the
11710 enum is not fixed):
11714 If the underlying type is fixed, the type of each enumerator
11715 prior to the closing brace is the underlying type; if the
11716 initializing value of an enumerator cannot be represented by
11717 the underlying type, the program is ill-formed. If the
11718 underlying type is not fixed, the type of each enumerator is
11719 the type of its initializing value.
11721 If the underlying type is not fixed, it will be computed by
11722 finish_enum and we will reset the type of this enumerator. Of
11723 course, if we're processing a template, there may be no value. */
11724 type = value ? TREE_TYPE (value) : NULL_TREE;
11726 if (context && context == current_class_type)
11727 /* This enum declaration is local to the class. We need the full
11728 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11729 decl = build_lang_decl (CONST_DECL, name, type);
11731 /* It's a global enum, or it's local to a function. (Note local to
11732 a function could mean local to a class method. */
11733 decl = build_decl (input_location, CONST_DECL, name, type);
11735 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
11736 TREE_CONSTANT (decl) = 1;
11737 TREE_READONLY (decl) = 1;
11738 DECL_INITIAL (decl) = value;
11740 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
11741 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11742 on the TYPE_FIELDS list for `S'. (That's so that you can say
11743 things like `S::i' later.) */
11744 finish_member_declaration (decl);
11748 /* Add this enumeration constant to the list for this type. */
11749 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
11752 /* Look for an enumerator with the given NAME within the enumeration
11753 type ENUMTYPE. This routine is used primarily for qualified name
11754 lookup into an enumerator in C++0x, e.g.,
11756 enum class Color { Red, Green, Blue };
11758 Color color = Color::Red;
11760 Returns the value corresponding to the enumerator, or
11761 NULL_TREE if no such enumerator was found. */
11763 lookup_enumerator (tree enumtype, tree name)
11766 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
11768 e = purpose_member (name, TYPE_VALUES (enumtype));
11769 return e? TREE_VALUE (e) : NULL_TREE;
11773 /* We're defining DECL. Make sure that its type is OK. */
11776 check_function_type (tree decl, tree current_function_parms)
11778 tree fntype = TREE_TYPE (decl);
11779 tree return_type = complete_type (TREE_TYPE (fntype));
11781 /* In a function definition, arg types must be complete. */
11782 require_complete_types_for_parms (current_function_parms);
11784 /* constexpr functions must have literal argument types and
11785 literal return type. */
11786 validate_constexpr_fundecl (decl);
11788 if (dependent_type_p (return_type))
11790 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
11791 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
11793 tree args = TYPE_ARG_TYPES (fntype);
11795 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11796 error ("return type %q#T is incomplete", return_type);
11798 error ("return type has Java class type %q#T", return_type);
11800 /* Make it return void instead. */
11801 if (TREE_CODE (fntype) == METHOD_TYPE)
11802 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11804 TREE_CHAIN (args));
11806 fntype = build_function_type (void_type_node, args);
11808 = build_exception_variant (fntype,
11809 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11810 fntype = (cp_build_type_attribute_variant
11811 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
11812 TREE_TYPE (decl) = fntype;
11815 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11818 /* Create the FUNCTION_DECL for a function definition.
11819 DECLSPECS and DECLARATOR are the parts of the declaration;
11820 they describe the function's name and the type it returns,
11821 but twisted together in a fashion that parallels the syntax of C.
11823 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11824 DECLARATOR is really the DECL for the function we are about to
11825 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11826 indicating that the function is an inline defined in-class.
11828 This function creates a binding context for the function body
11829 as well as setting up the FUNCTION_DECL in current_function_decl.
11831 For C++, we must first check whether that datum makes any sense.
11832 For example, "class A local_a(1,2);" means that variable local_a
11833 is an aggregate of type A, which should have a constructor
11834 applied to it with the argument list [1, 2].
11836 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11837 or may be a BLOCK if the function has been defined previously
11838 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11839 error_mark_node if the function has never been defined, or
11840 a BLOCK if the function has been defined somewhere. */
11843 start_preparsed_function (tree decl1, tree attrs, int flags)
11845 tree ctype = NULL_TREE;
11848 int doing_friend = 0;
11849 struct cp_binding_level *bl;
11850 tree current_function_parms;
11851 struct c_fileinfo *finfo
11852 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11853 bool honor_interface;
11855 /* Sanity check. */
11856 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11857 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11859 fntype = TREE_TYPE (decl1);
11860 if (TREE_CODE (fntype) == METHOD_TYPE)
11861 ctype = TYPE_METHOD_BASETYPE (fntype);
11863 /* ISO C++ 11.4/5. A friend function defined in a class is in
11864 the (lexical) scope of the class in which it is defined. */
11865 if (!ctype && DECL_FRIEND_P (decl1))
11867 ctype = DECL_FRIEND_CONTEXT (decl1);
11869 /* CTYPE could be null here if we're dealing with a template;
11870 for example, `inline friend float foo()' inside a template
11871 will have no CTYPE set. */
11872 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11878 if (DECL_DECLARED_INLINE_P (decl1)
11879 && lookup_attribute ("noinline", attrs))
11880 warning (0, "inline function %q+D given attribute noinline", decl1);
11882 /* Handle gnu_inline attribute. */
11883 if (GNU_INLINE_P (decl1))
11885 DECL_EXTERNAL (decl1) = 1;
11886 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11887 DECL_INTERFACE_KNOWN (decl1) = 1;
11888 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11891 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11892 /* This is a constructor, we must ensure that any default args
11893 introduced by this definition are propagated to the clones
11894 now. The clones are used directly in overload resolution. */
11895 adjust_clone_args (decl1);
11897 /* Sometimes we don't notice that a function is a static member, and
11898 build a METHOD_TYPE for it. Fix that up now. */
11899 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11900 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11902 revert_static_member_fn (decl1);
11906 /* Set up current_class_type, and enter the scope of the class, if
11909 push_nested_class (ctype);
11910 else if (DECL_STATIC_FUNCTION_P (decl1))
11911 push_nested_class (DECL_CONTEXT (decl1));
11913 /* Now that we have entered the scope of the class, we must restore
11914 the bindings for any template parameters surrounding DECL1, if it
11915 is an inline member template. (Order is important; consider the
11916 case where a template parameter has the same name as a field of
11917 the class.) It is not until after this point that
11918 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11919 if (flags & SF_INCLASS_INLINE)
11920 maybe_begin_member_template_processing (decl1);
11922 /* Effective C++ rule 15. */
11924 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11925 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11926 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11928 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11929 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11930 if (!DECL_INITIAL (decl1))
11931 DECL_INITIAL (decl1) = error_mark_node;
11933 /* This function exists in static storage.
11934 (This does not mean `static' in the C sense!) */
11935 TREE_STATIC (decl1) = 1;
11937 /* We must call push_template_decl after current_class_type is set
11938 up. (If we are processing inline definitions after exiting a
11939 class scope, current_class_type will be NULL_TREE until set above
11940 by push_nested_class.) */
11941 if (processing_template_decl)
11943 /* FIXME: Handle error_mark_node more gracefully. */
11944 tree newdecl1 = push_template_decl (decl1);
11945 if (newdecl1 != error_mark_node)
11949 /* We are now in the scope of the function being defined. */
11950 current_function_decl = decl1;
11952 /* Save the parm names or decls from this function's declarator
11953 where store_parm_decls will find them. */
11954 current_function_parms = DECL_ARGUMENTS (decl1);
11956 /* Make sure the parameter and return types are reasonable. When
11957 you declare a function, these types can be incomplete, but they
11958 must be complete when you define the function. */
11959 check_function_type (decl1, current_function_parms);
11961 /* Build the return declaration for the function. */
11962 restype = TREE_TYPE (fntype);
11963 if (DECL_RESULT (decl1) == NULL_TREE)
11967 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
11968 DECL_ARTIFICIAL (resdecl) = 1;
11969 DECL_IGNORED_P (resdecl) = 1;
11970 DECL_RESULT (decl1) = resdecl;
11972 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11975 /* Let the user know we're compiling this function. */
11976 announce_function (decl1);
11978 /* Record the decl so that the function name is defined.
11979 If we already have a decl for this name, and it is a FUNCTION_DECL,
11980 use the old decl. */
11981 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11983 /* A specialization is not used to guide overload resolution. */
11984 if (!DECL_FUNCTION_MEMBER_P (decl1)
11985 && !(DECL_USE_TEMPLATE (decl1) &&
11986 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11988 tree olddecl = pushdecl (decl1);
11990 if (olddecl == error_mark_node)
11991 /* If something went wrong when registering the declaration,
11992 use DECL1; we have to have a FUNCTION_DECL to use when
11993 parsing the body of the function. */
11997 /* Otherwise, OLDDECL is either a previous declaration
11998 of the same function or DECL1 itself. */
12000 if (warn_missing_declarations
12001 && olddecl == decl1
12002 && !DECL_MAIN_P (decl1)
12003 && TREE_PUBLIC (decl1)
12004 && !DECL_DECLARED_INLINE_P (decl1))
12008 /* Check whether DECL1 is in an anonymous
12010 for (context = DECL_CONTEXT (decl1);
12012 context = DECL_CONTEXT (context))
12014 if (TREE_CODE (context) == NAMESPACE_DECL
12015 && DECL_NAME (context) == NULL_TREE)
12019 if (context == NULL)
12020 warning (OPT_Wmissing_declarations,
12021 "no previous declaration for %q+D", decl1);
12029 /* We need to set the DECL_CONTEXT. */
12030 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
12031 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
12033 fntype = TREE_TYPE (decl1);
12035 /* If #pragma weak applies, mark the decl appropriately now.
12036 The pragma only applies to global functions. Because
12037 determining whether or not the #pragma applies involves
12038 computing the mangled name for the declaration, we cannot
12039 apply the pragma until after we have merged this declaration
12040 with any previous declarations; if the original declaration
12041 has a linkage specification, that specification applies to
12042 the definition as well, and may affect the mangled name. */
12043 if (!DECL_CONTEXT (decl1))
12044 maybe_apply_pragma_weak (decl1);
12047 /* Reset this in case the call to pushdecl changed it. */
12048 current_function_decl = decl1;
12050 gcc_assert (DECL_INITIAL (decl1));
12052 /* This function may already have been parsed, in which case just
12053 return; our caller will skip over the body without parsing. */
12054 if (DECL_INITIAL (decl1) != error_mark_node)
12057 /* Initialize RTL machinery. We cannot do this until
12058 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
12059 even when processing a template; this is how we get
12060 CFUN set up, and our per-function variables initialized.
12061 FIXME factor out the non-RTL stuff. */
12062 bl = current_binding_level;
12063 allocate_struct_function (decl1, processing_template_decl);
12065 /* Initialize the language data structures. Whenever we start
12066 a new function, we destroy temporaries in the usual way. */
12067 cfun->language = ggc_alloc_cleared_language_function ();
12068 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12069 current_binding_level = bl;
12071 /* Even though we're inside a function body, we still don't want to
12072 call expand_expr to calculate the size of a variable-sized array.
12073 We haven't necessarily assigned RTL to all variables yet, so it's
12074 not safe to try to expand expressions involving them. */
12075 cfun->dont_save_pending_sizes_p = 1;
12077 /* Start the statement-tree, start the tree now. */
12078 DECL_SAVED_TREE (decl1) = push_stmt_list ();
12080 /* If we are (erroneously) defining a function that we have already
12081 defined before, wipe out what we knew before. */
12082 if (!DECL_PENDING_INLINE_P (decl1))
12083 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
12085 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
12087 /* We know that this was set up by `grokclassfn'. We do not
12088 wait until `store_parm_decls', since evil parse errors may
12089 never get us to that point. Here we keep the consistency
12090 between `current_class_type' and `current_class_ptr'. */
12091 tree t = DECL_ARGUMENTS (decl1);
12093 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
12094 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
12096 cp_function_chain->x_current_class_ref
12097 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
12098 cp_function_chain->x_current_class_ptr = t;
12100 /* Constructors and destructors need to know whether they're "in
12101 charge" of initializing virtual base classes. */
12102 t = TREE_CHAIN (t);
12103 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
12105 current_in_charge_parm = t;
12106 t = TREE_CHAIN (t);
12108 if (DECL_HAS_VTT_PARM_P (decl1))
12110 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
12111 current_vtt_parm = t;
12115 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
12116 /* Implicitly-defined methods (like the
12117 destructor for a class in which no destructor
12118 is explicitly declared) must not be defined
12119 until their definition is needed. So, we
12120 ignore interface specifications for
12121 compiler-generated functions. */
12122 && !DECL_ARTIFICIAL (decl1));
12124 if (DECL_INTERFACE_KNOWN (decl1))
12126 tree ctx = decl_function_context (decl1);
12128 if (DECL_NOT_REALLY_EXTERN (decl1))
12129 DECL_EXTERNAL (decl1) = 0;
12131 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
12132 && TREE_PUBLIC (ctx))
12133 /* This is a function in a local class in an extern inline
12135 comdat_linkage (decl1);
12137 /* If this function belongs to an interface, it is public.
12138 If it belongs to someone else's interface, it is also external.
12139 This only affects inlines and template instantiations. */
12140 else if (!finfo->interface_unknown && honor_interface)
12142 if (DECL_DECLARED_INLINE_P (decl1)
12143 || DECL_TEMPLATE_INSTANTIATION (decl1)
12144 || processing_template_decl)
12146 DECL_EXTERNAL (decl1)
12147 = (finfo->interface_only
12148 || (DECL_DECLARED_INLINE_P (decl1)
12149 && ! flag_implement_inlines
12150 && !DECL_VINDEX (decl1)));
12152 /* For WIN32 we also want to put these in linkonce sections. */
12153 maybe_make_one_only (decl1);
12156 DECL_EXTERNAL (decl1) = 0;
12157 DECL_INTERFACE_KNOWN (decl1) = 1;
12158 /* If this function is in an interface implemented in this file,
12159 make sure that the back end knows to emit this function
12161 if (!DECL_EXTERNAL (decl1))
12162 mark_needed (decl1);
12164 else if (finfo->interface_unknown && finfo->interface_only
12165 && honor_interface)
12167 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
12168 interface, we will have both finfo->interface_unknown and
12169 finfo->interface_only set. In that case, we don't want to
12170 use the normal heuristics because someone will supply a
12171 #pragma implementation elsewhere, and deducing it here would
12172 produce a conflict. */
12173 comdat_linkage (decl1);
12174 DECL_EXTERNAL (decl1) = 0;
12175 DECL_INTERFACE_KNOWN (decl1) = 1;
12176 DECL_DEFER_OUTPUT (decl1) = 1;
12180 /* This is a definition, not a reference.
12181 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
12182 if (!GNU_INLINE_P (decl1))
12183 DECL_EXTERNAL (decl1) = 0;
12185 if ((DECL_DECLARED_INLINE_P (decl1)
12186 || DECL_TEMPLATE_INSTANTIATION (decl1))
12187 && ! DECL_INTERFACE_KNOWN (decl1))
12188 DECL_DEFER_OUTPUT (decl1) = 1;
12190 DECL_INTERFACE_KNOWN (decl1) = 1;
12193 /* Determine the ELF visibility attribute for the function. We must not
12194 do this before calling "pushdecl", as we must allow "duplicate_decls"
12195 to merge any attributes appropriately. We also need to wait until
12197 if (!DECL_CLONED_FUNCTION_P (decl1))
12198 determine_visibility (decl1);
12200 begin_scope (sk_function_parms, decl1);
12204 if (DECL_DESTRUCTOR_P (decl1)
12205 || (DECL_CONSTRUCTOR_P (decl1)
12206 && targetm.cxx.cdtor_returns_this ()))
12208 cdtor_label = build_decl (input_location,
12209 LABEL_DECL, NULL_TREE, NULL_TREE);
12210 DECL_CONTEXT (cdtor_label) = current_function_decl;
12213 start_fname_decls ();
12215 store_parm_decls (current_function_parms);
12219 /* Like start_preparsed_function, except that instead of a
12220 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
12222 Returns 1 on success. If the DECLARATOR is not suitable for a function
12223 (it defines a datum instead), we return 0, which tells
12224 yyparse to report a parse error. */
12227 start_function (cp_decl_specifier_seq *declspecs,
12228 const cp_declarator *declarator,
12233 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
12234 if (decl1 == error_mark_node)
12236 /* If the declarator is not suitable for a function definition,
12237 cause a syntax error. */
12238 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
12240 error ("invalid function declaration");
12244 if (DECL_MAIN_P (decl1))
12245 /* main must return int. grokfndecl should have corrected it
12246 (and issued a diagnostic) if the user got it wrong. */
12247 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
12248 integer_type_node));
12250 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
12255 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
12259 use_eh_spec_block (tree fn)
12261 return (flag_exceptions && flag_enforce_eh_specs
12262 && !processing_template_decl
12263 && !type_throw_all_p (TREE_TYPE (fn))
12264 /* We insert the EH_SPEC_BLOCK only in the original
12265 function; then, it is copied automatically to the
12267 && !DECL_CLONED_FUNCTION_P (fn)
12268 /* Implicitly-generated constructors and destructors have
12269 exception specifications. However, those specifications
12270 are the union of the possible exceptions specified by the
12271 constructors/destructors for bases and members, so no
12272 unallowed exception will ever reach this function. By
12273 not creating the EH_SPEC_BLOCK we save a little memory,
12274 and we avoid spurious warnings about unreachable
12276 && !DECL_ARTIFICIAL (fn));
12279 /* Store the parameter declarations into the current function declaration.
12280 This is called after parsing the parameter declarations, before
12281 digesting the body of the function.
12283 Also install to binding contour return value identifier, if any. */
12286 store_parm_decls (tree current_function_parms)
12288 tree fndecl = current_function_decl;
12291 /* This is a chain of any other decls that came in among the parm
12292 declarations. If a parm is declared with enum {foo, bar} x;
12293 then CONST_DECLs for foo and bar are put here. */
12294 tree nonparms = NULL_TREE;
12296 if (current_function_parms)
12298 /* This case is when the function was defined with an ANSI prototype.
12299 The parms already have decls, so we need not do anything here
12300 except record them as in effect
12301 and complain if any redundant old-style parm decls were written. */
12303 tree specparms = current_function_parms;
12306 /* Must clear this because it might contain TYPE_DECLs declared
12308 current_binding_level->names = NULL;
12310 /* If we're doing semantic analysis, then we'll call pushdecl
12311 for each of these. We must do them in reverse order so that
12312 they end in the correct forward order. */
12313 specparms = nreverse (specparms);
12315 for (parm = specparms; parm; parm = next)
12317 next = TREE_CHAIN (parm);
12318 if (TREE_CODE (parm) == PARM_DECL)
12320 if (DECL_NAME (parm) == NULL_TREE
12321 || TREE_CODE (parm) != VOID_TYPE)
12324 error ("parameter %qD declared void", parm);
12328 /* If we find an enum constant or a type tag,
12329 put it aside for the moment. */
12330 TREE_CHAIN (parm) = NULL_TREE;
12331 nonparms = chainon (nonparms, parm);
12335 /* Get the decls in their original chain order and record in the
12336 function. This is all and only the PARM_DECLs that were
12337 pushed into scope by the loop above. */
12338 DECL_ARGUMENTS (fndecl) = getdecls ();
12341 DECL_ARGUMENTS (fndecl) = NULL_TREE;
12343 /* Now store the final chain of decls for the arguments
12344 as the decl-chain of the current lexical scope.
12345 Put the enumerators in as well, at the front so that
12346 DECL_ARGUMENTS is not modified. */
12347 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
12349 if (use_eh_spec_block (current_function_decl))
12350 current_eh_spec_block = begin_eh_spec_block ();
12354 /* We have finished doing semantic analysis on DECL, but have not yet
12355 generated RTL for its body. Save away our current state, so that
12356 when we want to generate RTL later we know what to do. */
12359 save_function_data (tree decl)
12361 struct language_function *f;
12363 /* Save the language-specific per-function data so that we can
12364 get it back when we really expand this function. */
12365 gcc_assert (!DECL_PENDING_INLINE_P (decl));
12368 f = ggc_alloc_language_function ();
12369 memcpy (f, cp_function_chain, sizeof (struct language_function));
12370 DECL_SAVED_FUNCTION_DATA (decl) = f;
12372 /* Clear out the bits we don't need. */
12373 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
12374 f->bindings = NULL;
12375 f->x_local_names = NULL;
12379 /* Set the return value of the constructor (if present). */
12382 finish_constructor_body (void)
12387 if (targetm.cxx.cdtor_returns_this ()
12388 && (! TYPE_FOR_JAVA (current_class_type)))
12390 /* Any return from a constructor will end up here. */
12391 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
12393 val = DECL_ARGUMENTS (current_function_decl);
12394 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12395 DECL_RESULT (current_function_decl), val);
12396 /* Return the address of the object. */
12397 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
12398 add_stmt (exprstmt);
12402 /* Do all the processing for the beginning of a destructor; set up the
12403 vtable pointers and cleanups for bases and members. */
12406 begin_destructor_body (void)
12408 tree compound_stmt;
12410 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12411 issued an error message. We still want to try to process the
12412 body of the function, but initialize_vtbl_ptrs will crash if
12413 TYPE_BINFO is NULL. */
12414 if (COMPLETE_TYPE_P (current_class_type))
12416 compound_stmt = begin_compound_stmt (0);
12417 /* Make all virtual function table pointers in non-virtual base
12418 classes point to CURRENT_CLASS_TYPE's virtual function
12420 initialize_vtbl_ptrs (current_class_ptr);
12421 finish_compound_stmt (compound_stmt);
12423 /* And insert cleanups for our bases and members so that they
12424 will be properly destroyed if we throw. */
12425 push_base_cleanups ();
12429 /* At the end of every destructor we generate code to delete the object if
12430 necessary. Do that now. */
12433 finish_destructor_body (void)
12437 /* Any return from a destructor will end up here; that way all base
12438 and member cleanups will be run when the function returns. */
12439 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
12441 /* In a virtual destructor, we must call delete. */
12442 if (DECL_VIRTUAL_P (current_function_decl))
12445 tree virtual_size = cxx_sizeof (current_class_type);
12449 At the point of definition of a virtual destructor (including
12450 an implicit definition), non-placement operator delete shall
12451 be looked up in the scope of the destructor's class and if
12452 found shall be accessible and unambiguous. */
12453 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
12455 /*global_p=*/false,
12456 /*placement=*/NULL_TREE,
12457 /*alloc_fn=*/NULL_TREE);
12459 if_stmt = begin_if_stmt ();
12460 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
12461 current_in_charge_parm,
12464 finish_expr_stmt (exprstmt);
12465 finish_then_clause (if_stmt);
12466 finish_if_stmt (if_stmt);
12469 if (targetm.cxx.cdtor_returns_this ())
12473 val = DECL_ARGUMENTS (current_function_decl);
12474 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12475 DECL_RESULT (current_function_decl), val);
12476 /* Return the address of the object. */
12477 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
12478 add_stmt (exprstmt);
12482 /* Do the necessary processing for the beginning of a function body, which
12483 in this case includes member-initializers, but not the catch clauses of
12484 a function-try-block. Currently, this means opening a binding level
12485 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12488 begin_function_body (void)
12492 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12495 if (processing_template_decl)
12496 /* Do nothing now. */;
12498 /* Always keep the BLOCK node associated with the outermost pair of
12499 curly braces of a function. These are needed for correct
12500 operation of dwarfout.c. */
12501 keep_next_level (true);
12503 stmt = begin_compound_stmt (BCS_FN_BODY);
12505 if (processing_template_decl)
12506 /* Do nothing now. */;
12507 else if (DECL_DESTRUCTOR_P (current_function_decl))
12508 begin_destructor_body ();
12513 /* Do the processing for the end of a function body. Currently, this means
12514 closing out the cleanups for fully-constructed bases and members, and in
12515 the case of the destructor, deleting the object if desired. Again, this
12516 is only meaningful for [cd]tors, since they are the only functions where
12517 there is a significant distinction between the main body and any
12518 function catch clauses. Handling, say, main() return semantics here
12519 would be wrong, as flowing off the end of a function catch clause for
12520 main() would also need to return 0. */
12523 finish_function_body (tree compstmt)
12525 if (compstmt == NULL_TREE)
12528 /* Close the block. */
12529 finish_compound_stmt (compstmt);
12531 if (processing_template_decl)
12532 /* Do nothing now. */;
12533 else if (DECL_CONSTRUCTOR_P (current_function_decl))
12534 finish_constructor_body ();
12535 else if (DECL_DESTRUCTOR_P (current_function_decl))
12536 finish_destructor_body ();
12539 /* Given a function, returns the BLOCK corresponding to the outermost level
12540 of curly braces, skipping the artificial block created for constructor
12544 outer_curly_brace_block (tree fndecl)
12546 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
12547 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12548 /* Skip the artificial function body block. */
12549 block = BLOCK_SUBBLOCKS (block);
12553 /* If FNDECL is a class's key method, add the class to the list of
12554 keyed classes that should be emitted. */
12557 record_key_method_defined (tree fndecl)
12559 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
12560 && DECL_VIRTUAL_P (fndecl)
12561 && !processing_template_decl)
12563 tree fnclass = DECL_CONTEXT (fndecl);
12564 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
12565 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
12569 /* Finish up a function declaration and compile that function
12570 all the way to assembler language output. The free the storage
12571 for the function definition.
12573 FLAGS is a bitwise or of the following values:
12575 We just finished processing the body of an in-class inline
12576 function definition. (This processing will have taken place
12577 after the class definition is complete.) */
12580 finish_function (int flags)
12582 tree fndecl = current_function_decl;
12583 tree fntype, ctype = NULL_TREE;
12584 int inclass_inline = (flags & 2) != 0;
12587 /* When we get some parse errors, we can end up without a
12588 current_function_decl, so cope. */
12589 if (fndecl == NULL_TREE)
12590 return error_mark_node;
12592 gcc_assert (!defer_mark_used_calls);
12593 defer_mark_used_calls = true;
12595 record_key_method_defined (fndecl);
12597 nested = function_depth > 1;
12598 fntype = TREE_TYPE (fndecl);
12600 /* TREE_READONLY (fndecl) = 1;
12601 This caused &foo to be of type ptr-to-const-function
12602 which then got a warning when stored in a ptr-to-function variable. */
12604 gcc_assert (building_stmt_tree ());
12605 /* The current function is being defined, so its DECL_INITIAL should
12606 be set, and unless there's a multiple definition, it should be
12607 error_mark_node. */
12608 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
12610 /* For a cloned function, we've already got all the code we need;
12611 there's no need to add any extra bits. */
12612 if (!DECL_CLONED_FUNCTION_P (fndecl))
12614 if (DECL_MAIN_P (current_function_decl))
12618 /* Make it so that `main' always returns 0 by default (or
12621 stmt = finish_return_stmt (integer_one_node);
12623 stmt = finish_return_stmt (integer_zero_node);
12625 /* Hack. We don't want the middle-end to warn that this
12626 return is unreachable, so put the statement on the
12629 location_t linezero = linemap_line_start (line_table, 0, 1);
12630 SET_EXPR_LOCATION (stmt, linezero);
12634 if (use_eh_spec_block (current_function_decl))
12635 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12636 (TREE_TYPE (current_function_decl)),
12637 current_eh_spec_block);
12640 /* If we're saving up tree structure, tie off the function now. */
12641 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
12643 finish_fname_decls ();
12645 /* If this function can't throw any exceptions, remember that. */
12646 if (!processing_template_decl
12647 && !cp_function_chain->can_throw
12648 && !flag_non_call_exceptions
12649 && !DECL_REPLACEABLE_P (fndecl))
12650 TREE_NOTHROW (fndecl) = 1;
12652 /* This must come after expand_function_end because cleanups might
12653 have declarations (from inline functions) that need to go into
12654 this function's blocks. */
12656 /* If the current binding level isn't the outermost binding level
12657 for this function, either there is a bug, or we have experienced
12658 syntax errors and the statement tree is malformed. */
12659 if (current_binding_level->kind != sk_function_parms)
12661 /* Make sure we have already experienced errors. */
12662 gcc_assert (errorcount);
12664 /* Throw away the broken statement tree and extra binding
12666 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
12668 while (current_binding_level->kind != sk_function_parms)
12670 if (current_binding_level->kind == sk_class)
12671 pop_nested_class ();
12673 poplevel (0, 0, 0);
12676 poplevel (1, 0, 1);
12678 /* Statements should always be full-expressions at the outermost set
12679 of curly braces for a function. */
12680 gcc_assert (stmts_are_full_exprs_p ());
12682 /* Set up the named return value optimization, if we can. Candidate
12683 variables are selected in check_return_expr. */
12684 if (current_function_return_value)
12686 tree r = current_function_return_value;
12689 if (r != error_mark_node
12690 /* This is only worth doing for fns that return in memory--and
12691 simpler, since we don't have to worry about promoted modes. */
12692 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
12693 /* Only allow this for variables declared in the outer scope of
12694 the function so we know that their lifetime always ends with a
12695 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12696 we were to do this optimization in tree-ssa. */
12697 && (outer = outer_curly_brace_block (fndecl))
12698 && chain_member (r, BLOCK_VARS (outer)))
12699 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
12701 current_function_return_value = NULL_TREE;
12704 /* Remember that we were in class scope. */
12705 if (current_class_name)
12706 ctype = current_class_type;
12708 /* Must mark the RESULT_DECL as being in this function. */
12709 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12711 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12712 to the FUNCTION_DECL node itself. */
12713 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12715 /* Save away current state, if appropriate. */
12716 if (!processing_template_decl)
12717 save_function_data (fndecl);
12719 /* Complain if there's just no return statement. */
12720 if (warn_return_type
12721 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
12722 && !dependent_type_p (TREE_TYPE (fntype))
12723 && !current_function_returns_value && !current_function_returns_null
12724 /* Don't complain if we abort or throw. */
12725 && !current_function_returns_abnormally
12726 /* Don't complain if we are declared noreturn. */
12727 && !TREE_THIS_VOLATILE (fndecl)
12728 && !DECL_NAME (DECL_RESULT (fndecl))
12729 && !TREE_NO_WARNING (fndecl)
12730 /* Structor return values (if any) are set by the compiler. */
12731 && !DECL_CONSTRUCTOR_P (fndecl)
12732 && !DECL_DESTRUCTOR_P (fndecl))
12734 warning (OPT_Wreturn_type,
12735 "no return statement in function returning non-void");
12736 TREE_NO_WARNING (fndecl) = 1;
12739 /* Store the end of the function, so that we get good line number
12740 info for the epilogue. */
12741 cfun->function_end_locus = input_location;
12743 /* Complain about parameters that are only set, but never otherwise used. */
12744 if (warn_unused_but_set_parameter
12745 && !processing_template_decl
12746 && errorcount == unused_but_set_errorcount
12747 && !DECL_CLONED_FUNCTION_P (fndecl))
12751 for (decl = DECL_ARGUMENTS (fndecl);
12753 decl = TREE_CHAIN (decl))
12754 if (TREE_USED (decl)
12755 && TREE_CODE (decl) == PARM_DECL
12756 && !DECL_READ_P (decl)
12757 && DECL_NAME (decl)
12758 && !DECL_ARTIFICIAL (decl)
12759 && !TREE_NO_WARNING (decl)
12760 && !DECL_IN_SYSTEM_HEADER (decl)
12761 && TREE_TYPE (decl) != error_mark_node
12762 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
12763 && (!CLASS_TYPE_P (TREE_TYPE (decl))
12764 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
12765 warning (OPT_Wunused_but_set_parameter,
12766 "parameter %q+D set but not used", decl);
12767 unused_but_set_errorcount = errorcount;
12770 /* Genericize before inlining. */
12771 if (!processing_template_decl)
12773 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
12774 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
12775 cp_genericize (fndecl);
12776 /* Clear out the bits we don't need. */
12777 f->x_current_class_ptr = NULL;
12778 f->x_current_class_ref = NULL;
12779 f->x_eh_spec_block = NULL;
12780 f->x_in_charge_parm = NULL;
12781 f->x_vtt_parm = NULL;
12782 f->x_return_value = NULL;
12783 f->bindings = NULL;
12784 f->extern_decl_map = NULL;
12786 /* Clear out the bits we don't need. */
12787 local_names = NULL;
12789 /* We're leaving the context of this function, so zap cfun. It's still in
12790 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12792 current_function_decl = NULL;
12794 /* If this is an in-class inline definition, we may have to pop the
12795 bindings for the template parameters that we added in
12796 maybe_begin_member_template_processing when start_function was
12798 if (inclass_inline)
12799 maybe_end_member_template_processing ();
12801 /* Leave the scope of the class. */
12803 pop_nested_class ();
12809 /* Let the error reporting routines know that we're outside a
12810 function. For a nested function, this value is used in
12811 cxx_pop_function_context and then reset via pop_function_context. */
12812 current_function_decl = NULL_TREE;
12814 defer_mark_used_calls = false;
12815 if (deferred_mark_used_calls)
12820 for (i = 0; VEC_iterate (tree, deferred_mark_used_calls, i, decl); i++)
12822 VEC_free (tree, gc, deferred_mark_used_calls);
12828 /* Create the FUNCTION_DECL for a function definition.
12829 DECLSPECS and DECLARATOR are the parts of the declaration;
12830 they describe the return type and the name of the function,
12831 but twisted together in a fashion that parallels the syntax of C.
12833 This function creates a binding context for the function body
12834 as well as setting up the FUNCTION_DECL in current_function_decl.
12836 Returns a FUNCTION_DECL on success.
12838 If the DECLARATOR is not suitable for a function (it defines a datum
12839 instead), we return 0, which tells yyparse to report a parse error.
12841 May return void_type_node indicating that this method is actually
12842 a friend. See grokfield for more details.
12844 Came here with a `.pushlevel' .
12846 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12847 CHANGES TO CODE IN `grokfield'. */
12850 grokmethod (cp_decl_specifier_seq *declspecs,
12851 const cp_declarator *declarator, tree attrlist)
12853 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12856 if (fndecl == error_mark_node)
12857 return error_mark_node;
12859 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12861 error ("invalid member function declaration");
12862 return error_mark_node;
12866 cplus_decl_attributes (&fndecl, attrlist, 0);
12868 /* Pass friends other than inline friend functions back. */
12869 if (fndecl == void_type_node)
12872 if (DECL_IN_AGGR_P (fndecl))
12874 if (DECL_CONTEXT (fndecl)
12875 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12876 error ("%qD is already defined in class %qT", fndecl,
12877 DECL_CONTEXT (fndecl));
12878 return error_mark_node;
12881 check_template_shadow (fndecl);
12883 DECL_DECLARED_INLINE_P (fndecl) = 1;
12884 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
12886 /* We process method specializations in finish_struct_1. */
12887 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12889 fndecl = push_template_decl (fndecl);
12890 if (fndecl == error_mark_node)
12894 if (! DECL_FRIEND_P (fndecl))
12896 if (TREE_CHAIN (fndecl))
12898 fndecl = copy_node (fndecl);
12899 TREE_CHAIN (fndecl) = NULL_TREE;
12903 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
12905 DECL_IN_AGGR_P (fndecl) = 1;
12910 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12911 we can lay it out later, when and if its type becomes complete. */
12914 maybe_register_incomplete_var (tree var)
12916 gcc_assert (TREE_CODE (var) == VAR_DECL);
12918 /* Keep track of variables with incomplete types. */
12919 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12920 && DECL_EXTERNAL (var))
12922 tree inner_type = TREE_TYPE (var);
12924 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12925 inner_type = TREE_TYPE (inner_type);
12926 inner_type = TYPE_MAIN_VARIANT (inner_type);
12928 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12929 /* RTTI TD entries are created while defining the type_info. */
12930 || (TYPE_LANG_SPECIFIC (inner_type)
12931 && TYPE_BEING_DEFINED (inner_type)))
12932 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12936 /* Called when a class type (given by TYPE) is defined. If there are
12937 any existing VAR_DECLs whose type has been completed by this
12938 declaration, update them now. */
12941 complete_vars (tree type)
12943 tree *list = &incomplete_vars;
12945 gcc_assert (CLASS_TYPE_P (type));
12948 if (same_type_p (type, TREE_PURPOSE (*list)))
12950 tree var = TREE_VALUE (*list);
12951 tree type = TREE_TYPE (var);
12952 /* Complete the type of the variable. The VAR_DECL itself
12953 will be laid out in expand_expr. */
12954 complete_type (type);
12955 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12956 /* Remove this entry from the list. */
12957 *list = TREE_CHAIN (*list);
12960 list = &TREE_CHAIN (*list);
12963 /* Check for pending declarations which may have abstract type. */
12964 complete_type_check_abstract (type);
12967 /* If DECL is of a type which needs a cleanup, build and return an
12968 expression to perform that cleanup here. Return NULL_TREE if no
12969 cleanup need be done. */
12972 cxx_maybe_build_cleanup (tree decl)
12978 /* Assume no cleanup is required. */
12979 cleanup = NULL_TREE;
12981 if (error_operand_p (decl))
12984 /* Handle "__attribute__((cleanup))". We run the cleanup function
12985 before the destructor since the destructor is what actually
12986 terminates the lifetime of the object. */
12987 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12994 /* Get the name specified by the user for the cleanup function. */
12995 id = TREE_VALUE (TREE_VALUE (attr));
12996 /* Look up the name to find the cleanup function to call. It is
12997 important to use lookup_name here because that is what is
12998 used in c-common.c:handle_cleanup_attribute when performing
12999 initial checks on the attribute. Note that those checks
13000 include ensuring that the function found is not an overloaded
13001 function, or an object with an overloaded call operator,
13002 etc.; we can rely on the fact that the function found is an
13003 ordinary FUNCTION_DECL. */
13004 fn = lookup_name (id);
13005 arg = build_address (decl);
13007 cleanup = cp_build_function_call_nary (fn, tf_warning_or_error,
13010 /* Handle ordinary C++ destructors. */
13011 type = TREE_TYPE (decl);
13012 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13014 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
13015 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
13016 && CLASSTYPE_VBASECLASSES (type));
13020 if (TREE_CODE (type) == ARRAY_TYPE)
13023 addr = build_address (decl);
13025 /* Optimize for space over speed here. */
13026 if (!has_vbases || flag_expensive_optimizations)
13027 flags |= LOOKUP_NONVIRTUAL;
13029 call = build_delete (TREE_TYPE (addr), addr,
13030 sfk_complete_destructor, flags, 0);
13032 cleanup = build_compound_expr (input_location, cleanup, call);
13040 /* When a stmt has been parsed, this function is called. */
13047 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
13048 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
13049 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
13052 static_fn_type (tree memfntype)
13057 if (TYPE_PTRMEMFUNC_P (memfntype))
13058 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
13059 if (POINTER_TYPE_P (memfntype)
13060 || TREE_CODE (memfntype) == FUNCTION_DECL)
13061 memfntype = TREE_TYPE (memfntype);
13062 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
13064 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
13065 args = TYPE_ARG_TYPES (memfntype);
13066 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
13067 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype));
13068 fntype = (cp_build_type_attribute_variant
13069 (fntype, TYPE_ATTRIBUTES (memfntype)));
13070 fntype = (build_exception_variant
13071 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
13075 /* DECL was originally constructed as a non-static member function,
13076 but turned out to be static. Update it accordingly. */
13079 revert_static_member_fn (tree decl)
13081 TREE_TYPE (decl) = static_fn_type (decl);
13083 if (cp_type_quals (TREE_TYPE (decl)) != TYPE_UNQUALIFIED)
13084 error ("static member function %q#D declared with type qualifiers", decl);
13086 if (DECL_ARGUMENTS (decl))
13087 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
13088 DECL_STATIC_FUNCTION_P (decl) = 1;
13091 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
13092 one of the language-independent trees. */
13094 enum cp_tree_node_structure_enum
13095 cp_tree_node_structure (union lang_tree_node * t)
13097 switch (TREE_CODE (&t->generic))
13099 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
13100 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
13101 case OVERLOAD: return TS_CP_OVERLOAD;
13102 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
13103 case PTRMEM_CST: return TS_CP_PTRMEM;
13104 case BASELINK: return TS_CP_BASELINK;
13105 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
13106 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
13107 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
13108 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
13109 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
13110 default: return TS_CP_GENERIC;
13114 /* Build the void_list_node (void_type_node having been created). */
13116 build_void_list_node (void)
13118 tree t = build_tree_list (NULL_TREE, void_type_node);
13123 cp_missing_noreturn_ok_p (tree decl)
13125 /* A missing noreturn is ok for the `main' function. */
13126 return DECL_MAIN_P (decl);
13129 /* Return the COMDAT group into which DECL should be placed. */
13132 cxx_comdat_group (tree decl)
13136 /* Virtual tables, construction virtual tables, and virtual table
13137 tables all go in a single COMDAT group, named after the primary
13139 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
13140 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
13141 /* For all other DECLs, the COMDAT group is the mangled name of the
13142 declaration itself. */
13145 while (DECL_THUNK_P (decl))
13147 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
13148 into the same section as the target function. In that case
13149 we must return target's name. */
13150 tree target = THUNK_TARGET (decl);
13151 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
13152 && DECL_SECTION_NAME (target) != NULL
13153 && DECL_ONE_ONLY (target))
13158 name = DECL_ASSEMBLER_NAME (decl);
13164 #include "gt-cp-decl.h"