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, 2011, 2012
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"
46 #include "c-family/c-common.h"
47 #include "c-family/c-objc.h"
48 #include "c-family/c-pragma.h"
49 #include "diagnostic.h"
53 #include "pointer-set.h"
54 #include "splay-tree.h"
57 /* Possible cases of bad specifiers type used by bad_specifiers. */
59 BSP_VAR, /* variable */
60 BSP_PARM, /* parameter */
65 static tree grokparms (tree parmlist, tree *);
66 static const char *redeclaration_error_message (tree, tree);
68 static int decl_jump_unsafe (tree);
69 static void require_complete_types_for_parms (tree);
70 static int ambi_op_p (enum tree_code);
71 static int unary_op_p (enum tree_code);
72 static void push_local_name (tree);
73 static tree grok_reference_init (tree, tree, tree, int);
74 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
76 static int check_static_variable_definition (tree, tree);
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, VEC(tree,gc) **);
94 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
95 static void save_function_data (tree);
96 static void copy_type_enum (tree , tree);
97 static void check_function_type (tree, tree);
98 static void finish_constructor_body (void);
99 static void begin_destructor_body (void);
100 static void finish_destructor_body (void);
101 static void record_key_method_defined (tree);
102 static tree create_array_type_for_decl (tree, tree, tree);
103 static tree get_atexit_node (void);
104 static tree get_dso_handle_node (void);
105 static tree start_cleanup_fn (void);
106 static void end_cleanup_fn (void);
107 static tree cp_make_fname_decl (location_t, tree, int);
108 static void initialize_predefined_identifiers (void);
109 static tree check_special_function_return_type
110 (special_function_kind, tree, tree);
111 static tree push_cp_library_fn (enum tree_code, tree);
112 static tree build_cp_library_fn (tree, enum tree_code, tree);
113 static void store_parm_decls (tree);
114 static void initialize_local_var (tree, tree);
115 static void expand_static_init (tree, tree);
117 /* The following symbols are subsumed in the cp_global_trees array, and
118 listed here individually for documentation purposes.
121 tree wchar_decl_node;
123 tree vtable_entry_type;
124 tree delta_type_node;
125 tree __t_desc_type_node;
127 tree class_type_node;
128 tree unknown_type_node;
130 Array type `vtable_entry_type[]'
133 tree vtbl_ptr_type_node;
140 A FUNCTION_DECL which can call `abort'. Not necessarily the
141 one that the user will declare, but sufficient to be called
142 by routines that want to abort the program.
146 The FUNCTION_DECL for the default `::operator delete'.
148 tree global_delete_fndecl;
151 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
152 tree tinfo_var_id; */
154 tree cp_global_trees[CPTI_MAX];
156 /* Indicates that there is a type value in some namespace, although
157 that is not necessarily in scope at the moment. */
159 tree global_type_node;
161 /* The node that holds the "name" of the global scope. */
162 tree global_scope_name;
164 #define local_names cp_function_chain->x_local_names
166 /* A list of objects which have constructors or destructors
167 which reside in the global scope. The decl is stored in
168 the TREE_VALUE slot and the initializer is stored
169 in the TREE_PURPOSE slot. */
170 tree static_aggregates;
174 /* A node for the integer constant 2. */
176 tree integer_two_node;
178 /* Used only for jumps to as-yet undefined labels, since jumps to
179 defined labels can have their validity checked immediately. */
181 struct GTY((chain_next ("%h.next"))) named_label_use_entry {
182 struct named_label_use_entry *next;
183 /* The binding level to which this entry is *currently* attached.
184 This is initially the binding level in which the goto appeared,
185 but is modified as scopes are closed. */
186 cp_binding_level *binding_level;
187 /* The head of the names list that was current when the goto appeared,
188 or the inner scope popped. These are the decls that will *not* be
189 skipped when jumping to the label. */
191 /* The location of the goto, for error reporting. */
192 location_t o_goto_locus;
193 /* True if an OpenMP structured block scope has been closed since
194 the goto appeared. This means that the branch from the label will
195 illegally exit an OpenMP scope. */
199 /* A list of all LABEL_DECLs in the function that have names. Here so
200 we can clear out their names' definitions at the end of the
201 function, and so we can check the validity of jumps to these labels. */
203 struct GTY(()) named_label_entry {
204 /* The decl itself. */
207 /* The binding level to which the label is *currently* attached.
208 This is initially set to the binding level in which the label
209 is defined, but is modified as scopes are closed. */
210 cp_binding_level *binding_level;
211 /* The head of the names list that was current when the label was
212 defined, or the inner scope popped. These are the decls that will
213 be skipped when jumping to the label. */
215 /* A vector of all decls from all binding levels that would be
216 crossed by a backward branch to the label. */
217 VEC(tree,gc) *bad_decls;
219 /* A list of uses of the label, before the label is defined. */
220 struct named_label_use_entry *uses;
222 /* The following bits are set after the label is defined, and are
223 updated as scopes are popped. They indicate that a backward jump
224 to the label will illegally enter a scope of the given flavor. */
230 #define named_labels cp_function_chain->x_named_labels
232 /* The number of function bodies which we are currently processing.
233 (Zero if we are at namespace scope, one inside the body of a
234 function, two inside the body of a function in a local class, etc.) */
237 /* To avoid unwanted recursion, finish_function defers all mark_used calls
238 encountered during its execution until it finishes. */
239 bool defer_mark_used_calls;
240 VEC(tree, gc) *deferred_mark_used_calls;
242 /* States indicating how grokdeclarator() should handle declspecs marked
243 with __attribute__((deprecated)). An object declared as
244 __attribute__((deprecated)) suppresses warnings of uses of other
246 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
249 /* A list of VAR_DECLs whose type was incomplete at the time the
250 variable was declared. */
252 typedef struct GTY(()) incomplete_var_d {
254 tree incomplete_type;
257 DEF_VEC_O(incomplete_var);
258 DEF_VEC_ALLOC_O(incomplete_var,gc);
260 static GTY(()) VEC(incomplete_var,gc) *incomplete_vars;
262 /* Returns the kind of template specialization we are currently
263 processing, given that it's declaration contained N_CLASS_SCOPES
264 explicit scope qualifications. */
267 current_tmpl_spec_kind (int n_class_scopes)
269 int n_template_parm_scopes = 0;
270 int seen_specialization_p = 0;
271 int innermost_specialization_p = 0;
274 /* Scan through the template parameter scopes. */
275 for (b = current_binding_level;
276 b->kind == sk_template_parms;
279 /* If we see a specialization scope inside a parameter scope,
280 then something is wrong. That corresponds to a declaration
283 template <class T> template <> ...
285 which is always invalid since [temp.expl.spec] forbids the
286 specialization of a class member template if the enclosing
287 class templates are not explicitly specialized as well. */
288 if (b->explicit_spec_p)
290 if (n_template_parm_scopes == 0)
291 innermost_specialization_p = 1;
293 seen_specialization_p = 1;
295 else if (seen_specialization_p == 1)
296 return tsk_invalid_member_spec;
298 ++n_template_parm_scopes;
301 /* Handle explicit instantiations. */
302 if (processing_explicit_instantiation)
304 if (n_template_parm_scopes != 0)
305 /* We've seen a template parameter list during an explicit
306 instantiation. For example:
308 template <class T> template void f(int);
310 This is erroneous. */
311 return tsk_invalid_expl_inst;
313 return tsk_expl_inst;
316 if (n_template_parm_scopes < n_class_scopes)
317 /* We've not seen enough template headers to match all the
318 specialized classes present. For example:
320 template <class T> void R<T>::S<T>::f(int);
322 This is invalid; there needs to be one set of template
323 parameters for each class. */
324 return tsk_insufficient_parms;
325 else if (n_template_parm_scopes == n_class_scopes)
326 /* We're processing a non-template declaration (even though it may
327 be a member of a template class.) For example:
329 template <class T> void S<T>::f(int);
331 The `class T' matches the `S<T>', leaving no template headers
332 corresponding to the `f'. */
334 else if (n_template_parm_scopes > n_class_scopes + 1)
335 /* We've got too many template headers. For example:
337 template <> template <class T> void f (T);
339 There need to be more enclosing classes. */
340 return tsk_excessive_parms;
342 /* This must be a template. It's of the form:
344 template <class T> template <class U> void S<T>::f(U);
346 This is a specialization if the innermost level was a
347 specialization; otherwise it's just a definition of the
349 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
352 /* Exit the current scope. */
360 /* When a label goes out of scope, check to see if that label was used
361 in a valid manner, and issue any appropriate warnings or errors. */
364 pop_label (tree label, tree old_value)
366 if (!processing_template_decl)
368 if (DECL_INITIAL (label) == NULL_TREE)
372 error ("label %q+D used but not defined", label);
373 location = input_location; /* FIXME want (input_filename, (line)0) */
374 /* Avoid crashing later. */
375 define_label (location, DECL_NAME (label));
378 warn_for_unused_label (label);
381 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
384 /* At the end of a function, all labels declared within the function
385 go out of scope. BLOCK is the top-level block for the
389 pop_labels_1 (void **slot, void *data)
391 struct named_label_entry *ent = (struct named_label_entry *) *slot;
392 tree block = (tree) data;
394 pop_label (ent->label_decl, NULL_TREE);
396 /* Put the labels into the "variables" of the top-level block,
397 so debugger can see them. */
398 DECL_CHAIN (ent->label_decl) = BLOCK_VARS (block);
399 BLOCK_VARS (block) = ent->label_decl;
401 htab_clear_slot (named_labels, slot);
407 pop_labels (tree block)
411 htab_traverse (named_labels, pop_labels_1, block);
416 /* At the end of a block with local labels, restore the outer definition. */
419 pop_local_label (tree label, tree old_value)
421 struct named_label_entry dummy;
424 pop_label (label, old_value);
426 dummy.label_decl = label;
427 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
428 htab_clear_slot (named_labels, slot);
431 /* The following two routines are used to interface to Objective-C++.
432 The binding level is purposely treated as an opaque type. */
435 objc_get_current_scope (void)
437 return current_binding_level;
440 /* The following routine is used by the NeXT-style SJLJ exceptions;
441 variables get marked 'volatile' so as to not be clobbered by
442 _setjmp()/_longjmp() calls. All variables in the current scope,
443 as well as parent scopes up to (but not including) ENCLOSING_BLK
444 shall be thusly marked. */
447 objc_mark_locals_volatile (void *enclosing_blk)
449 cp_binding_level *scope;
451 for (scope = current_binding_level;
452 scope && scope != enclosing_blk;
453 scope = scope->level_chain)
457 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
458 objc_volatilize_decl (decl);
460 /* Do not climb up past the current function. */
461 if (scope->kind == sk_function_parms)
466 /* Update data for defined and undefined labels when leaving a scope. */
469 poplevel_named_label_1 (void **slot, void *data)
471 struct named_label_entry *ent = (struct named_label_entry *) *slot;
472 cp_binding_level *bl = (cp_binding_level *) data;
473 cp_binding_level *obl = bl->level_chain;
475 if (ent->binding_level == bl)
479 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
480 TREE_LISTs representing OVERLOADs, so be careful. */
481 for (decl = ent->names_in_scope; decl; decl = (DECL_P (decl)
483 : TREE_CHAIN (decl)))
484 if (decl_jump_unsafe (decl))
485 VEC_safe_push (tree, gc, ent->bad_decls, decl);
487 ent->binding_level = obl;
488 ent->names_in_scope = obl->names;
492 ent->in_try_scope = true;
495 ent->in_catch_scope = true;
498 ent->in_omp_scope = true;
506 struct named_label_use_entry *use;
508 for (use = ent->uses; use ; use = use->next)
509 if (use->binding_level == bl)
511 use->binding_level = obl;
512 use->names_in_scope = obl->names;
513 if (bl->kind == sk_omp)
514 use->in_omp_scope = true;
521 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
522 when errors were reported, except for -Werror-unused-but-set-*. */
523 static int unused_but_set_errorcount;
525 /* Exit a binding level.
526 Pop the level off, and restore the state of the identifier-decl mappings
527 that were in effect when this level was entered.
529 If KEEP == 1, this level had explicit declarations, so
530 and create a "block" (a BLOCK node) for the level
531 to record its declarations and subblocks for symbol table output.
533 If FUNCTIONBODY is nonzero, this level is the body of a function,
534 so create a block as if KEEP were set and also clear out all
537 If REVERSE is nonzero, reverse the order of decls before putting
538 them into the BLOCK. */
541 poplevel (int keep, int reverse, int functionbody)
544 /* The chain of decls was accumulated in reverse order.
545 Put it into forward order, just for cleanliness. */
550 int leaving_for_scope;
553 cp_label_binding *label_bind;
555 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
560 gcc_assert (current_binding_level->kind != sk_class);
562 if (current_binding_level->kind == sk_cleanup)
564 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
566 gcc_assert (!VEC_length(cp_class_binding,
567 current_binding_level->class_shadowed));
569 /* We used to use KEEP == 2 to indicate that the new block should go
570 at the beginning of the list of blocks at this binding level,
571 rather than the end. This hack is no longer used. */
572 gcc_assert (keep == 0 || keep == 1);
574 if (current_binding_level->keep)
577 /* Any uses of undefined labels, and any defined labels, now operate
578 under constraints of next binding contour. */
579 if (cfun && !functionbody && named_labels)
580 htab_traverse (named_labels, poplevel_named_label_1,
581 current_binding_level);
583 /* Get the decls in the order they were written.
584 Usually current_binding_level->names is in reverse order.
585 But parameter decls were previously put in forward order. */
588 current_binding_level->names
589 = decls = nreverse (current_binding_level->names);
591 decls = current_binding_level->names;
593 /* If there were any declarations or structure tags in that level,
594 or if this level is a function body,
595 create a BLOCK to record them for the life of this function. */
597 if (keep == 1 || functionbody)
598 block = make_node (BLOCK);
599 if (block != NULL_TREE)
601 BLOCK_VARS (block) = decls;
602 BLOCK_SUBBLOCKS (block) = subblocks;
605 /* In each subblock, record that this is its superior. */
607 for (link = subblocks; link; link = BLOCK_CHAIN (link))
608 BLOCK_SUPERCONTEXT (link) = block;
610 /* We still support the old for-scope rules, whereby the variables
611 in a for-init statement were in scope after the for-statement
612 ended. We only use the new rules if flag_new_for_scope is
615 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
617 /* Before we remove the declarations first check for unused variables. */
618 if ((warn_unused_variable || warn_unused_but_set_variable)
619 && !processing_template_decl)
620 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
621 if (TREE_CODE (decl) == VAR_DECL
622 && (! TREE_USED (decl) || !DECL_READ_P (decl))
623 && ! DECL_IN_SYSTEM_HEADER (decl)
624 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)
625 && TREE_TYPE (decl) != error_mark_node
626 && (!CLASS_TYPE_P (TREE_TYPE (decl))
627 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
629 if (! TREE_USED (decl))
630 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
631 else if (DECL_CONTEXT (decl) == current_function_decl
632 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
633 && errorcount == unused_but_set_errorcount)
635 warning (OPT_Wunused_but_set_variable,
636 "variable %q+D set but not used", decl);
637 unused_but_set_errorcount = errorcount;
641 /* Remove declarations for all the DECLs in this level. */
642 for (link = decls; link; link = TREE_CHAIN (link))
644 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
645 /* It's hard to make this ARM compatibility hack play nicely with
646 lambdas, and it really isn't necessary in C++11 mode. */
647 && cxx_dialect < cxx0x
650 tree name = DECL_NAME (link);
654 ob = outer_binding (name,
655 IDENTIFIER_BINDING (name),
658 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
660 ns_binding = NULL_TREE;
662 if (ob && ob->scope == current_binding_level->level_chain)
663 /* We have something like:
668 and we are leaving the `for' scope. There's no reason to
669 keep the binding of the inner `i' in this case. */
670 pop_binding (name, link);
671 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
672 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
673 /* Here, we have something like:
681 We must pop the for-scope binding so we know what's a
682 type and what isn't. */
683 pop_binding (name, link);
686 /* Mark this VAR_DECL as dead so that we can tell we left it
687 there only for backward compatibility. */
688 DECL_DEAD_FOR_LOCAL (link) = 1;
690 /* Keep track of what should have happened when we
691 popped the binding. */
694 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
695 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
698 /* Add it to the list of dead variables in the next
699 outermost binding to that we can remove these when we
700 leave that binding. */
701 VEC_safe_push (tree, gc,
702 current_binding_level->level_chain->dead_vars_from_for,
705 /* Although we don't pop the cxx_binding, we do clear
706 its SCOPE since the scope is going away now. */
707 IDENTIFIER_BINDING (name)->scope
708 = current_binding_level->level_chain;
715 /* Remove the binding. */
718 if (TREE_CODE (decl) == TREE_LIST)
719 decl = TREE_VALUE (decl);
722 if (TREE_CODE (name) == OVERLOAD)
723 name = OVL_FUNCTION (name);
725 gcc_assert (DECL_P (name));
726 pop_binding (DECL_NAME (name), decl);
730 /* Remove declarations for any `for' variables from inner scopes
731 that we kept around. */
732 FOR_EACH_VEC_ELT_REVERSE (tree, current_binding_level->dead_vars_from_for,
734 pop_binding (DECL_NAME (decl), decl);
736 /* Restore the IDENTIFIER_TYPE_VALUEs. */
737 for (link = current_binding_level->type_shadowed;
738 link; link = TREE_CHAIN (link))
739 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
741 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
742 FOR_EACH_VEC_ELT_REVERSE (cp_label_binding,
743 current_binding_level->shadowed_labels,
745 pop_local_label (label_bind->label, label_bind->prev_value);
747 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
748 list if a `using' declaration put them there. The debugging
749 back ends won't understand OVERLOAD, so we remove them here.
750 Because the BLOCK_VARS are (temporarily) shared with
751 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
752 popped all the bindings. */
757 for (d = &BLOCK_VARS (block); *d; )
759 if (TREE_CODE (*d) == TREE_LIST)
760 *d = TREE_CHAIN (*d);
762 d = &DECL_CHAIN (*d);
766 /* If the level being exited is the top level of a function,
767 check over all the labels. */
770 /* Since this is the top level block of a function, the vars are
771 the function's parameters. Don't leave them in the BLOCK
772 because they are found in the FUNCTION_DECL instead. */
773 BLOCK_VARS (block) = 0;
777 kind = current_binding_level->kind;
778 if (kind == sk_cleanup)
782 /* If this is a temporary binding created for a cleanup, then we'll
783 have pushed a statement list level. Pop that, create a new
784 BIND_EXPR for the block, and insert it into the stream. */
785 stmt = pop_stmt_list (current_binding_level->statement_list);
786 stmt = c_build_bind_expr (input_location, block, stmt);
793 /* The current function is being defined, so its DECL_INITIAL
794 should be error_mark_node. */
795 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
796 DECL_INITIAL (current_function_decl) = block;
799 current_binding_level->blocks
800 = block_chainon (current_binding_level->blocks, block);
802 /* If we did not make a block for the level just exited,
803 any blocks made for inner levels
804 (since they cannot be recorded as subblocks in that level)
805 must be carried forward so they will later become subblocks
806 of something else. */
808 current_binding_level->blocks
809 = block_chainon (current_binding_level->blocks, subblocks);
811 /* Each and every BLOCK node created here in `poplevel' is important
812 (e.g. for proper debugging information) so if we created one
813 earlier, mark it as "used". */
815 TREE_USED (block) = 1;
817 /* All temporary bindings created for cleanups are popped silently. */
818 if (kind == sk_cleanup)
821 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
825 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
826 itself, calling F for each. The DATA is passed to F as well. */
829 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
832 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
834 result |= (*f) (name_space, data);
836 for (; current; current = DECL_CHAIN (current))
837 result |= walk_namespaces_r (current, f, data);
842 /* Walk all the namespaces, calling F for each. The DATA is passed to
846 walk_namespaces (walk_namespaces_fn f, void* data)
848 return walk_namespaces_r (global_namespace, f, data);
851 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
852 DATA is non-NULL, this is the last time we will call
853 wrapup_global_declarations for this NAMESPACE. */
856 wrapup_globals_for_namespace (tree name_space, void* data)
858 cp_binding_level *level = NAMESPACE_LEVEL (name_space);
859 VEC(tree,gc) *statics = level->static_decls;
860 tree *vec = VEC_address (tree, statics);
861 int len = VEC_length (tree, statics);
862 int last_time = (data != 0);
866 check_global_declarations (vec, len);
867 emit_debug_global_declarations (vec, len);
871 /* Write out any globals that need to be output. */
872 return wrapup_global_declarations (vec, len);
876 /* In C++, you don't have to write `struct S' to refer to `S'; you
877 can just use `S'. We accomplish this by creating a TYPE_DECL as
878 if the user had written `typedef struct S S'. Create and return
879 the TYPE_DECL for TYPE. */
882 create_implicit_typedef (tree name, tree type)
886 decl = build_decl (input_location, TYPE_DECL, name, type);
887 DECL_ARTIFICIAL (decl) = 1;
888 /* There are other implicit type declarations, like the one *within*
889 a class that allows you to write `S::S'. We must distinguish
891 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
892 TYPE_NAME (type) = decl;
893 TYPE_STUB_DECL (type) = decl;
898 /* Remember a local name for name-mangling purposes. */
901 push_local_name (tree decl)
906 timevar_start (TV_NAME_LOOKUP);
908 name = DECL_NAME (decl);
910 nelts = VEC_length (tree, local_names);
911 for (i = 0; i < nelts; i++)
913 t = VEC_index (tree, local_names, i);
914 if (DECL_NAME (t) == name)
916 if (!DECL_LANG_SPECIFIC (decl))
917 retrofit_lang_decl (decl);
918 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
919 if (DECL_LANG_SPECIFIC (t))
920 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
922 DECL_DISCRIMINATOR (decl) = 1;
924 VEC_replace (tree, local_names, i, decl);
925 timevar_stop (TV_NAME_LOOKUP);
930 VEC_safe_push (tree, gc, local_names, decl);
931 timevar_stop (TV_NAME_LOOKUP);
934 /* Subroutine of duplicate_decls: return truthvalue of whether
935 or not types of these decls match.
937 For C++, we must compare the parameter list so that `int' can match
938 `int&' in a parameter position, but `int&' is not confused with
942 decls_match (tree newdecl, tree olddecl)
946 if (newdecl == olddecl)
949 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
950 /* If the two DECLs are not even the same kind of thing, we're not
951 interested in their types. */
954 gcc_assert (DECL_P (newdecl));
956 if (TREE_CODE (newdecl) == FUNCTION_DECL)
958 tree f1 = TREE_TYPE (newdecl);
959 tree f2 = TREE_TYPE (olddecl);
960 tree p1 = TYPE_ARG_TYPES (f1);
961 tree p2 = TYPE_ARG_TYPES (f2);
964 /* Specializations of different templates are different functions
965 even if they have the same type. */
966 tree t1 = (DECL_USE_TEMPLATE (newdecl)
967 ? DECL_TI_TEMPLATE (newdecl)
969 tree t2 = (DECL_USE_TEMPLATE (olddecl)
970 ? DECL_TI_TEMPLATE (olddecl)
975 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
976 && ! (DECL_EXTERN_C_P (newdecl)
977 && DECL_EXTERN_C_P (olddecl)))
980 #ifdef NO_IMPLICIT_EXTERN_C
981 /* A new declaration doesn't match a built-in one unless it
982 is also extern "C". */
983 if (DECL_IS_BUILTIN (olddecl)
984 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
988 if (TREE_CODE (f1) != TREE_CODE (f2))
991 /* A declaration with deduced return type should use its pre-deduction
992 type for declaration matching. */
993 if (FNDECL_USED_AUTO (olddecl))
994 r2 = DECL_STRUCT_FUNCTION (olddecl)->language->x_auto_return_pattern;
998 if (same_type_p (TREE_TYPE (f1), r2))
1000 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
1001 && (DECL_BUILT_IN (olddecl)
1002 #ifndef NO_IMPLICIT_EXTERN_C
1003 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
1004 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1008 types_match = self_promoting_args_p (p1);
1009 if (p1 == void_list_node)
1010 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1012 #ifndef NO_IMPLICIT_EXTERN_C
1013 else if (!prototype_p (f1)
1014 && (DECL_EXTERN_C_P (olddecl)
1015 && DECL_IN_SYSTEM_HEADER (olddecl)
1016 && !DECL_CLASS_SCOPE_P (olddecl))
1017 && (DECL_EXTERN_C_P (newdecl)
1018 && DECL_IN_SYSTEM_HEADER (newdecl)
1019 && !DECL_CLASS_SCOPE_P (newdecl)))
1021 types_match = self_promoting_args_p (p2);
1022 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1028 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
1029 || comp_type_attributes (TREE_TYPE (newdecl),
1030 TREE_TYPE (olddecl)) != 0);
1035 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1037 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1038 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1041 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1042 DECL_TEMPLATE_PARMS (olddecl)))
1045 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1046 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1047 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1049 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1050 DECL_TEMPLATE_RESULT (newdecl));
1054 /* Need to check scope for variable declaration (VAR_DECL).
1055 For typedef (TYPE_DECL), scope is ignored. */
1056 if (TREE_CODE (newdecl) == VAR_DECL
1057 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1059 Two declarations for an object with C language linkage
1060 with the same name (ignoring the namespace that qualify
1061 it) that appear in different namespace scopes refer to
1063 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1066 if (TREE_TYPE (newdecl) == error_mark_node)
1067 types_match = TREE_TYPE (olddecl) == error_mark_node;
1068 else if (TREE_TYPE (olddecl) == NULL_TREE)
1069 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1070 else if (TREE_TYPE (newdecl) == NULL_TREE)
1073 types_match = comptypes (TREE_TYPE (newdecl),
1074 TREE_TYPE (olddecl),
1075 COMPARE_REDECLARATION);
1081 /* If NEWDECL is `static' and an `extern' was seen previously,
1082 warn about it. OLDDECL is the previous declaration.
1084 Note that this does not apply to the C++ case of declaring
1085 a variable `extern const' and then later `const'.
1087 Don't complain about built-in functions, since they are beyond
1088 the user's control. */
1091 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1093 if (TREE_CODE (newdecl) == TYPE_DECL
1094 || TREE_CODE (newdecl) == TEMPLATE_DECL
1095 || TREE_CODE (newdecl) == CONST_DECL
1096 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1099 /* Don't get confused by static member functions; that's a different
1101 if (TREE_CODE (newdecl) == FUNCTION_DECL
1102 && DECL_STATIC_FUNCTION_P (newdecl))
1105 /* If the old declaration was `static', or the new one isn't, then
1106 everything is OK. */
1107 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1110 /* It's OK to declare a builtin function as `static'. */
1111 if (TREE_CODE (olddecl) == FUNCTION_DECL
1112 && DECL_ARTIFICIAL (olddecl))
1115 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1116 permerror (input_location, "previous declaration of %q+D", olddecl);
1119 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1120 function templates. If their exception specifications do not
1121 match, issue a diagnostic. */
1124 check_redeclaration_exception_specification (tree new_decl,
1129 tree new_exceptions;
1130 tree old_exceptions;
1132 new_type = TREE_TYPE (new_decl);
1133 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1134 old_type = TREE_TYPE (old_decl);
1135 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1139 If any declaration of a function has an exception-specification,
1140 all declarations, including the definition and an explicit
1141 specialization, of that function shall have an
1142 exception-specification with the same set of type-ids. */
1143 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1144 && ! DECL_IS_BUILTIN (old_decl)
1146 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1148 error ("declaration of %qF has a different exception specifier",
1150 error ("from previous declaration %q+F", old_decl);
1154 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1155 Otherwise issue diagnostics. */
1158 validate_constexpr_redeclaration (tree old_decl, tree new_decl)
1160 old_decl = STRIP_TEMPLATE (old_decl);
1161 new_decl = STRIP_TEMPLATE (new_decl);
1162 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
1163 || !VAR_OR_FUNCTION_DECL_P (new_decl))
1165 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
1166 == DECL_DECLARED_CONSTEXPR_P (new_decl))
1168 if (TREE_CODE (old_decl) == FUNCTION_DECL && DECL_BUILT_IN (old_decl))
1170 /* Hide a built-in declaration. */
1171 DECL_DECLARED_CONSTEXPR_P (old_decl)
1172 = DECL_DECLARED_CONSTEXPR_P (new_decl);
1175 error ("redeclaration %qD differs in %<constexpr%>", new_decl);
1176 error ("from previous declaration %q+D", old_decl);
1180 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1181 && lookup_attribute ("gnu_inline", \
1182 DECL_ATTRIBUTES (fn)))
1184 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1185 If the redeclaration is invalid, a diagnostic is issued, and the
1186 error_mark_node is returned. Otherwise, OLDDECL is returned.
1188 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1191 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1194 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1196 unsigned olddecl_uid = DECL_UID (olddecl);
1197 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1198 int new_defines_function = 0;
1199 tree new_template_info;
1201 if (newdecl == olddecl)
1204 types_match = decls_match (newdecl, olddecl);
1206 /* If either the type of the new decl or the type of the old decl is an
1207 error_mark_node, then that implies that we have already issued an
1208 error (earlier) for some bogus type specification, and in that case,
1209 it is rather pointless to harass the user with yet more error message
1210 about the same declaration, so just pretend the types match here. */
1211 if (TREE_TYPE (newdecl) == error_mark_node
1212 || TREE_TYPE (olddecl) == error_mark_node)
1213 return error_mark_node;
1215 if (UDLIT_OPER_P (DECL_NAME (newdecl))
1216 && UDLIT_OPER_P (DECL_NAME (olddecl)))
1218 if (TREE_CODE (newdecl) == TEMPLATE_DECL
1219 && TREE_CODE (olddecl) != TEMPLATE_DECL
1220 && check_raw_literal_operator (olddecl))
1221 error ("literal operator template %q+D conflicts with"
1222 " raw literal operator %qD", newdecl, olddecl);
1223 else if (TREE_CODE (newdecl) != TEMPLATE_DECL
1224 && TREE_CODE (olddecl) == TEMPLATE_DECL
1225 && check_raw_literal_operator (newdecl))
1226 error ("raw literal operator %q+D conflicts with"
1227 " literal operator template %qD", newdecl, olddecl);
1230 if (DECL_P (olddecl)
1231 && TREE_CODE (newdecl) == FUNCTION_DECL
1232 && TREE_CODE (olddecl) == FUNCTION_DECL
1233 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1235 if (DECL_DECLARED_INLINE_P (newdecl)
1236 && DECL_UNINLINABLE (newdecl)
1237 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1238 /* Already warned elsewhere. */;
1239 else if (DECL_DECLARED_INLINE_P (olddecl)
1240 && DECL_UNINLINABLE (olddecl)
1241 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1242 /* Already warned. */;
1243 else if (DECL_DECLARED_INLINE_P (newdecl)
1244 && DECL_UNINLINABLE (olddecl)
1245 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1247 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1249 warning (OPT_Wattributes, "previous declaration of %q+D "
1250 "with attribute noinline", olddecl);
1252 else if (DECL_DECLARED_INLINE_P (olddecl)
1253 && DECL_UNINLINABLE (newdecl)
1254 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1256 warning (OPT_Wattributes, "function %q+D redeclared with "
1257 "attribute noinline", newdecl);
1258 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1263 /* Check for redeclaration and other discrepancies. */
1264 if (TREE_CODE (olddecl) == FUNCTION_DECL
1265 && DECL_ARTIFICIAL (olddecl))
1267 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1268 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1270 /* Avoid warnings redeclaring built-ins which have not been
1271 explicitly declared. */
1272 if (DECL_ANTICIPATED (olddecl))
1275 /* If you declare a built-in or predefined function name as static,
1276 the old definition is overridden, but optionally warn this was a
1277 bad choice of name. */
1278 if (! TREE_PUBLIC (newdecl))
1280 warning (OPT_Wshadow,
1281 DECL_BUILT_IN (olddecl)
1282 ? G_("shadowing built-in function %q#D")
1283 : G_("shadowing library function %q#D"), olddecl);
1284 /* Discard the old built-in function. */
1287 /* If the built-in is not ansi, then programs can override
1288 it even globally without an error. */
1289 else if (! DECL_BUILT_IN (olddecl))
1290 warning (0, "library function %q#D redeclared as non-function %q#D",
1294 error ("declaration of %q#D", newdecl);
1295 error ("conflicts with built-in declaration %q#D",
1300 else if (!types_match)
1302 /* Avoid warnings redeclaring built-ins which have not been
1303 explicitly declared. */
1304 if (DECL_ANTICIPATED (olddecl))
1306 /* Deal with fileptr_type_node. FILE type is not known
1307 at the time we create the builtins. */
1310 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1311 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1313 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1316 else if (TREE_VALUE (t2) == fileptr_type_node)
1318 tree t = TREE_VALUE (t1);
1320 if (TREE_CODE (t) == POINTER_TYPE
1321 && TYPE_NAME (TREE_TYPE (t))
1322 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1323 == get_identifier ("FILE")
1324 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1326 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1328 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1329 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1330 types_match = decls_match (newdecl, olddecl);
1332 return duplicate_decls (newdecl, olddecl,
1334 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1337 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1340 else if ((DECL_EXTERN_C_P (newdecl)
1341 && DECL_EXTERN_C_P (olddecl))
1342 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1343 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1345 /* A near match; override the builtin. */
1347 if (TREE_PUBLIC (newdecl))
1349 warning (0, "new declaration %q#D", newdecl);
1350 warning (0, "ambiguates built-in declaration %q#D",
1354 warning (OPT_Wshadow,
1355 DECL_BUILT_IN (olddecl)
1356 ? G_("shadowing built-in function %q#D")
1357 : G_("shadowing library function %q#D"), olddecl);
1360 /* Discard the old built-in function. */
1363 /* Replace the old RTL to avoid problems with inlining. */
1364 COPY_DECL_RTL (newdecl, olddecl);
1366 /* Even if the types match, prefer the new declarations type for
1367 built-ins which have not been explicitly declared, for
1368 exception lists, etc... */
1369 else if (DECL_IS_BUILTIN (olddecl))
1371 tree type = TREE_TYPE (newdecl);
1372 tree attribs = (*targetm.merge_type_attributes)
1373 (TREE_TYPE (olddecl), type);
1375 type = cp_build_type_attribute_variant (type, attribs);
1376 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1379 /* If a function is explicitly declared "throw ()", propagate that to
1380 the corresponding builtin. */
1381 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1382 && DECL_ANTICIPATED (olddecl)
1383 && TREE_NOTHROW (newdecl)
1384 && !TREE_NOTHROW (olddecl))
1386 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
1387 tree tmpdecl = builtin_decl_explicit (fncode);
1388 if (tmpdecl && tmpdecl != olddecl && types_match)
1389 TREE_NOTHROW (tmpdecl) = 1;
1392 /* Whether or not the builtin can throw exceptions has no
1393 bearing on this declarator. */
1394 TREE_NOTHROW (olddecl) = 0;
1396 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1398 /* If a builtin function is redeclared as `static', merge
1399 the declarations, but make the original one static. */
1400 DECL_THIS_STATIC (olddecl) = 1;
1401 TREE_PUBLIC (olddecl) = 0;
1403 /* Make the old declaration consistent with the new one so
1404 that all remnants of the builtin-ness of this function
1405 will be banished. */
1406 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1407 COPY_DECL_RTL (newdecl, olddecl);
1410 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1412 /* C++ Standard, 3.3, clause 4:
1413 "[Note: a namespace name or a class template name must be unique
1414 in its declarative region (7.3.2, clause 14). ]" */
1415 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1416 && TREE_CODE (newdecl) != NAMESPACE_DECL
1417 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1418 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1419 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1420 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1422 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1423 && TREE_CODE (newdecl) != TYPE_DECL)
1424 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1425 && TREE_CODE (olddecl) != TYPE_DECL))
1427 /* We do nothing special here, because C++ does such nasty
1428 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1429 get shadowed, and know that if we need to find a TYPE_DECL
1430 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1431 slot of the identifier. */
1435 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1436 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1437 || (TREE_CODE (olddecl) == FUNCTION_DECL
1438 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1442 error ("%q#D redeclared as different kind of symbol", newdecl);
1443 if (TREE_CODE (olddecl) == TREE_LIST)
1444 olddecl = TREE_VALUE (olddecl);
1445 error ("previous declaration of %q+#D", olddecl);
1447 return error_mark_node;
1449 else if (!types_match)
1451 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1452 /* These are certainly not duplicate declarations; they're
1453 from different scopes. */
1456 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1458 /* The name of a class template may not be declared to refer to
1459 any other template, class, function, object, namespace, value,
1460 or type in the same scope. */
1461 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1462 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1464 error ("declaration of template %q#D", newdecl);
1465 error ("conflicts with previous declaration %q+#D", olddecl);
1466 return error_mark_node;
1468 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1469 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1470 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1471 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1472 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1473 DECL_TEMPLATE_PARMS (olddecl))
1474 /* Template functions can be disambiguated by
1476 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1477 TREE_TYPE (TREE_TYPE (olddecl))))
1479 error ("new declaration %q#D", newdecl);
1480 error ("ambiguates old declaration %q+#D", olddecl);
1484 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1486 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1488 error ("declaration of C function %q#D conflicts with",
1490 error ("previous declaration %q+#D here", olddecl);
1493 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1494 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1496 error ("new declaration %q#D", newdecl);
1497 if (FNDECL_USED_AUTO (olddecl))
1498 error_at (DECL_SOURCE_LOCATION (olddecl), "ambiguates old "
1499 "declaration with deduced return type");
1501 error ("ambiguates old declaration %q+#D", olddecl);
1502 return error_mark_node;
1509 error ("conflicting declaration %q#D", newdecl);
1510 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1511 return error_mark_node;
1514 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1515 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1516 && (!DECL_TEMPLATE_INFO (newdecl)
1517 || (DECL_TI_TEMPLATE (newdecl)
1518 != DECL_TI_TEMPLATE (olddecl))))
1519 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1520 && (!DECL_TEMPLATE_INFO (olddecl)
1521 || (DECL_TI_TEMPLATE (olddecl)
1522 != DECL_TI_TEMPLATE (newdecl))))))
1523 /* It's OK to have a template specialization and a non-template
1524 with the same type, or to have specializations of two
1525 different templates with the same type. Note that if one is a
1526 specialization, and the other is an instantiation of the same
1527 template, that we do not exit at this point. That situation
1528 can occur if we instantiate a template class, and then
1529 specialize one of its methods. This situation is valid, but
1530 the declarations must be merged in the usual way. */
1532 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1533 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1534 && !DECL_USE_TEMPLATE (newdecl))
1535 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1536 && !DECL_USE_TEMPLATE (olddecl))))
1537 /* One of the declarations is a template instantiation, and the
1538 other is not a template at all. That's OK. */
1540 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1542 /* In [namespace.alias] we have:
1544 In a declarative region, a namespace-alias-definition can be
1545 used to redefine a namespace-alias declared in that declarative
1546 region to refer only to the namespace to which it already
1549 Therefore, if we encounter a second alias directive for the same
1550 alias, we can just ignore the second directive. */
1551 if (DECL_NAMESPACE_ALIAS (newdecl)
1552 && (DECL_NAMESPACE_ALIAS (newdecl)
1553 == DECL_NAMESPACE_ALIAS (olddecl)))
1555 /* [namespace.alias]
1557 A namespace-name or namespace-alias shall not be declared as
1558 the name of any other entity in the same declarative region.
1559 A namespace-name defined at global scope shall not be
1560 declared as the name of any other entity in any global scope
1562 error ("declaration of namespace %qD conflicts with", newdecl);
1563 error ("previous declaration of namespace %q+D here", olddecl);
1564 return error_mark_node;
1568 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1571 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1572 if (DECL_NAME (olddecl) != NULL_TREE)
1573 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1574 ? G_("%q+#D previously defined here")
1575 : G_("%q+#D previously declared here"), olddecl);
1576 return error_mark_node;
1578 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1579 && DECL_INITIAL (olddecl) != NULL_TREE
1580 && !prototype_p (TREE_TYPE (olddecl))
1581 && prototype_p (TREE_TYPE (newdecl)))
1583 /* Prototype decl follows defn w/o prototype. */
1584 warning_at (input_location, 0, "prototype for %q+#D", newdecl);
1585 warning_at (DECL_SOURCE_LOCATION (olddecl), 0,
1586 "follows non-prototype definition here");
1588 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1589 || TREE_CODE (olddecl) == VAR_DECL)
1590 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1593 If two declarations of the same function or object
1594 specify different linkage-specifications ..., the program
1595 is ill-formed.... Except for functions with C++ linkage,
1596 a function declaration without a linkage specification
1597 shall not precede the first linkage specification for
1598 that function. A function can be declared without a
1599 linkage specification after an explicit linkage
1600 specification has been seen; the linkage explicitly
1601 specified in the earlier declaration is not affected by
1602 such a function declaration.
1604 DR 563 raises the question why the restrictions on
1605 functions should not also apply to objects. Older
1606 versions of G++ silently ignore the linkage-specification
1614 which is clearly wrong. Therefore, we now treat objects
1616 if (current_lang_depth () == 0)
1618 /* There is no explicit linkage-specification, so we use
1619 the linkage from the previous declaration. */
1620 if (!DECL_LANG_SPECIFIC (newdecl))
1621 retrofit_lang_decl (newdecl);
1622 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1626 error ("previous declaration of %q+#D with %qL linkage",
1627 olddecl, DECL_LANGUAGE (olddecl));
1628 error ("conflicts with new declaration with %qL linkage",
1629 DECL_LANGUAGE (newdecl));
1633 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1635 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1637 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1638 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1641 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1642 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1644 for (; t1 && t1 != void_list_node;
1645 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1646 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1648 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1651 permerror (input_location, "default argument given for parameter %d of %q#D",
1653 permerror (input_location, "after previous specification in %q+#D", olddecl);
1657 error ("default argument given for parameter %d of %q#D",
1659 error ("after previous specification in %q+#D",
1666 /* Do not merge an implicit typedef with an explicit one. In:
1670 typedef class A A __attribute__ ((foo));
1672 the attribute should apply only to the typedef. */
1673 if (TREE_CODE (olddecl) == TYPE_DECL
1674 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1675 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1678 /* If new decl is `static' and an `extern' was seen previously,
1680 warn_extern_redeclared_static (newdecl, olddecl);
1682 if (!validate_constexpr_redeclaration (olddecl, newdecl))
1683 return error_mark_node;
1685 /* We have committed to returning 1 at this point. */
1686 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1688 /* Now that functions must hold information normally held
1689 by field decls, there is extra work to do so that
1690 declaration information does not get destroyed during
1692 if (DECL_VINDEX (olddecl))
1693 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1694 if (DECL_CONTEXT (olddecl))
1695 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1696 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1697 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1698 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1699 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1700 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1701 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1702 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1703 SET_OVERLOADED_OPERATOR_CODE
1704 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1705 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1707 /* Optionally warn about more than one declaration for the same
1708 name, but don't warn about a function declaration followed by a
1710 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1711 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1712 /* Don't warn about extern decl followed by definition. */
1713 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1714 /* Don't warn about friends, let add_friend take care of it. */
1715 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
1716 /* Don't warn about declaration followed by specialization. */
1717 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
1718 || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
1720 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1721 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1724 if (DECL_DELETED_FN (newdecl))
1726 error ("deleted definition of %qD", newdecl);
1727 error ("after previous declaration %q+D", olddecl);
1729 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
1732 /* Deal with C++: must preserve virtual function table size. */
1733 if (TREE_CODE (olddecl) == TYPE_DECL)
1735 tree newtype = TREE_TYPE (newdecl);
1736 tree oldtype = TREE_TYPE (olddecl);
1738 if (newtype != error_mark_node && oldtype != error_mark_node
1739 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1740 CLASSTYPE_FRIEND_CLASSES (newtype)
1741 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1743 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1746 /* Copy all the DECL_... slots specified in the new decl
1747 except for any that we copy here from the old type. */
1748 DECL_ATTRIBUTES (newdecl)
1749 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1751 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1755 old_result = DECL_TEMPLATE_RESULT (olddecl);
1756 new_result = DECL_TEMPLATE_RESULT (newdecl);
1757 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1758 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1759 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1760 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1762 DECL_ATTRIBUTES (old_result)
1763 = (*targetm.merge_decl_attributes) (old_result, new_result);
1765 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1767 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1768 && DECL_INITIAL (new_result))
1770 if (DECL_INITIAL (old_result))
1771 DECL_UNINLINABLE (old_result) = 1;
1773 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1774 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1775 DECL_NOT_REALLY_EXTERN (old_result)
1776 = DECL_NOT_REALLY_EXTERN (new_result);
1777 DECL_INTERFACE_KNOWN (old_result)
1778 = DECL_INTERFACE_KNOWN (new_result);
1779 DECL_DECLARED_INLINE_P (old_result)
1780 = DECL_DECLARED_INLINE_P (new_result);
1781 DECL_DISREGARD_INLINE_LIMITS (old_result)
1782 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1787 DECL_DECLARED_INLINE_P (old_result)
1788 |= DECL_DECLARED_INLINE_P (new_result);
1789 DECL_DISREGARD_INLINE_LIMITS (old_result)
1790 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1791 check_redeclaration_exception_specification (newdecl, olddecl);
1795 /* If the new declaration is a definition, update the file and
1796 line information on the declaration, and also make
1797 the old declaration the same definition. */
1798 if (DECL_INITIAL (new_result) != NULL_TREE)
1800 DECL_SOURCE_LOCATION (olddecl)
1801 = DECL_SOURCE_LOCATION (old_result)
1802 = DECL_SOURCE_LOCATION (newdecl);
1803 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1804 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1807 DECL_ARGUMENTS (old_result)
1808 = DECL_ARGUMENTS (new_result);
1809 for (parm = DECL_ARGUMENTS (old_result); parm;
1810 parm = DECL_CHAIN (parm))
1811 DECL_CONTEXT (parm) = old_result;
1820 /* Automatically handles default parameters. */
1821 tree oldtype = TREE_TYPE (olddecl);
1824 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1825 maybe_instantiate_noexcept (olddecl);
1827 /* Merge the data types specified in the two decls. */
1828 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1830 /* If merge_types produces a non-typedef type, just use the old type. */
1831 if (TREE_CODE (newdecl) == TYPE_DECL
1832 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1835 if (TREE_CODE (newdecl) == VAR_DECL)
1837 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1838 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1839 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1840 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1841 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1842 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1844 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1845 if (DECL_LANG_SPECIFIC (olddecl)
1846 && CP_DECL_THREADPRIVATE_P (olddecl))
1848 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1849 if (!DECL_LANG_SPECIFIC (newdecl))
1850 retrofit_lang_decl (newdecl);
1852 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1853 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1857 /* Do this after calling `merge_types' so that default
1858 parameters don't confuse us. */
1859 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1860 check_redeclaration_exception_specification (newdecl, olddecl);
1861 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1863 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1864 check_default_args (newdecl);
1866 /* Lay the type out, unless already done. */
1867 if (! same_type_p (newtype, oldtype)
1868 && TREE_TYPE (newdecl) != error_mark_node
1869 && !(processing_template_decl && uses_template_parms (newdecl)))
1870 layout_type (TREE_TYPE (newdecl));
1872 if ((TREE_CODE (newdecl) == VAR_DECL
1873 || TREE_CODE (newdecl) == PARM_DECL
1874 || TREE_CODE (newdecl) == RESULT_DECL
1875 || TREE_CODE (newdecl) == FIELD_DECL
1876 || TREE_CODE (newdecl) == TYPE_DECL)
1877 && !(processing_template_decl && uses_template_parms (newdecl)))
1878 layout_decl (newdecl, 0);
1880 /* Merge the type qualifiers. */
1881 if (TREE_READONLY (newdecl))
1882 TREE_READONLY (olddecl) = 1;
1883 if (TREE_THIS_VOLATILE (newdecl))
1884 TREE_THIS_VOLATILE (olddecl) = 1;
1885 if (TREE_NOTHROW (newdecl))
1886 TREE_NOTHROW (olddecl) = 1;
1888 /* Merge deprecatedness. */
1889 if (TREE_DEPRECATED (newdecl))
1890 TREE_DEPRECATED (olddecl) = 1;
1892 /* Preserve function specific target and optimization options */
1893 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1895 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1896 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1897 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1898 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1900 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1901 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1902 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1903 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1906 /* Merge the initialization information. */
1907 if (DECL_INITIAL (newdecl) == NULL_TREE
1908 && DECL_INITIAL (olddecl) != NULL_TREE)
1910 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1911 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1912 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1914 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1915 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1919 /* Merge the section attribute.
1920 We want to issue an error if the sections conflict but that must be
1921 done later in decl_attributes since we are called before attributes
1923 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1924 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1926 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1928 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1929 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1930 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1931 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1932 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1933 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1934 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1935 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1936 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1937 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1938 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1939 /* Keep the old RTL. */
1940 COPY_DECL_RTL (olddecl, newdecl);
1942 else if (TREE_CODE (newdecl) == VAR_DECL
1943 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1945 /* Keep the old RTL. We cannot keep the old RTL if the old
1946 declaration was for an incomplete object and the new
1947 declaration is not since many attributes of the RTL will
1949 COPY_DECL_RTL (olddecl, newdecl);
1952 /* If cannot merge, then use the new type and qualifiers,
1953 and don't preserve the old rtl. */
1956 /* Clean out any memory we had of the old declaration. */
1957 tree oldstatic = value_member (olddecl, static_aggregates);
1959 TREE_VALUE (oldstatic) = error_mark_node;
1961 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1962 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1963 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1964 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1967 /* Merge the storage class information. */
1968 merge_weak (newdecl, olddecl);
1970 if (DECL_ONE_ONLY (olddecl))
1971 DECL_COMDAT_GROUP (newdecl) = DECL_COMDAT_GROUP (olddecl);
1973 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1974 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1975 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1976 if (! DECL_EXTERNAL (olddecl))
1977 DECL_EXTERNAL (newdecl) = 0;
1979 new_template_info = NULL_TREE;
1980 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1982 bool new_redefines_gnu_inline = false;
1984 if (new_defines_function
1985 && ((DECL_INTERFACE_KNOWN (olddecl)
1986 && TREE_CODE (olddecl) == FUNCTION_DECL)
1987 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1988 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1989 == FUNCTION_DECL))))
1993 if (TREE_CODE (fn) == TEMPLATE_DECL)
1994 fn = DECL_TEMPLATE_RESULT (olddecl);
1996 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1999 if (!new_redefines_gnu_inline)
2001 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2002 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
2003 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
2005 DECL_TEMPLATE_INSTANTIATED (newdecl)
2006 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
2007 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
2009 /* If the OLDDECL is an instantiation and/or specialization,
2010 then the NEWDECL must be too. But, it may not yet be marked
2011 as such if the caller has created NEWDECL, but has not yet
2012 figured out that it is a redeclaration. */
2013 if (!DECL_USE_TEMPLATE (newdecl))
2014 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
2016 /* Don't really know how much of the language-specific
2017 values we should copy from old to new. */
2018 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2019 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
2020 DECL_INITIALIZED_IN_CLASS_P (newdecl)
2021 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
2023 if (LANG_DECL_HAS_MIN (newdecl))
2025 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
2026 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
2027 if (DECL_TEMPLATE_INFO (newdecl))
2028 new_template_info = DECL_TEMPLATE_INFO (newdecl);
2029 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2031 /* Only functions have these fields. */
2032 if (TREE_CODE (newdecl) == FUNCTION_DECL
2033 || DECL_FUNCTION_TEMPLATE_P (newdecl))
2035 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2036 olddecl_friend = DECL_FRIEND_P (olddecl);
2037 hidden_friend = (DECL_ANTICIPATED (olddecl)
2038 && DECL_HIDDEN_FRIEND_P (olddecl)
2039 && newdecl_is_friend);
2040 DECL_BEFRIENDING_CLASSES (newdecl)
2041 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
2042 DECL_BEFRIENDING_CLASSES (olddecl));
2043 /* DECL_THUNKS is only valid for virtual functions,
2044 otherwise it is a DECL_FRIEND_CONTEXT. */
2045 if (DECL_VIRTUAL_P (newdecl))
2046 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
2048 /* Only variables have this field. */
2049 else if (TREE_CODE (newdecl) == VAR_DECL
2050 && VAR_HAD_UNKNOWN_BOUND (olddecl))
2051 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
2054 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2058 /* Merge parameter attributes. */
2059 tree oldarg, newarg;
2060 for (oldarg = DECL_ARGUMENTS(olddecl),
2061 newarg = DECL_ARGUMENTS(newdecl);
2063 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) {
2064 DECL_ATTRIBUTES (newarg)
2065 = (*targetm.merge_decl_attributes) (oldarg, newarg);
2066 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
2069 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2070 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
2072 /* If newdecl is not a specialization, then it is not a
2073 template-related function at all. And that means that we
2074 should have exited above, returning 0. */
2075 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
2077 if (DECL_ODR_USED (olddecl))
2078 /* From [temp.expl.spec]:
2080 If a template, a member template or the member of a class
2081 template is explicitly specialized then that
2082 specialization shall be declared before the first use of
2083 that specialization that would cause an implicit
2084 instantiation to take place, in every translation unit in
2085 which such a use occurs. */
2086 error ("explicit specialization of %qD after first use",
2089 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2091 /* Don't propagate visibility from the template to the
2092 specialization here. We'll do that in determine_visibility if
2094 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2096 /* [temp.expl.spec/14] We don't inline explicit specialization
2097 just because the primary template says so. */
2099 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2100 the always_inline attribute. */
2101 if (DECL_DISREGARD_INLINE_LIMITS (olddecl)
2102 && !DECL_DISREGARD_INLINE_LIMITS (newdecl))
2104 if (DECL_DECLARED_INLINE_P (newdecl))
2105 DECL_DISREGARD_INLINE_LIMITS (newdecl) = true;
2107 DECL_ATTRIBUTES (newdecl)
2108 = remove_attribute ("always_inline",
2109 DECL_ATTRIBUTES (newdecl));
2112 else if (new_defines_function && DECL_INITIAL (olddecl))
2114 /* Never inline re-defined extern inline functions.
2115 FIXME: this could be better handled by keeping both
2116 function as separate declarations. */
2117 DECL_UNINLINABLE (newdecl) = 1;
2121 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
2122 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2124 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2126 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2127 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2129 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2130 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2131 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2132 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2135 /* Preserve abstractness on cloned [cd]tors. */
2136 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
2138 /* Update newdecl's parms to point at olddecl. */
2139 for (parm = DECL_ARGUMENTS (newdecl); parm;
2140 parm = DECL_CHAIN (parm))
2141 DECL_CONTEXT (parm) = olddecl;
2145 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2146 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2147 COPY_DECL_RTL (newdecl, olddecl);
2149 if (! types_match || new_defines_function)
2151 /* These need to be copied so that the names are available.
2152 Note that if the types do match, we'll preserve inline
2153 info and other bits, but if not, we won't. */
2154 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2155 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2157 if (new_defines_function)
2158 /* If defining a function declared with other language
2159 linkage, use the previously declared language linkage. */
2160 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2161 else if (types_match)
2163 /* If redeclaring a builtin function, and not a definition,
2164 it stays built in. */
2165 if (DECL_BUILT_IN (olddecl))
2167 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2168 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2169 /* If we're keeping the built-in definition, keep the rtl,
2170 regardless of declaration matches. */
2171 COPY_DECL_RTL (olddecl, newdecl);
2172 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2174 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2177 /* If a compatible prototype of these builtin functions
2178 is seen, assume the runtime implements it with the
2179 expected semantics. */
2180 case BUILT_IN_STPCPY:
2181 if (builtin_decl_explicit_p (fncode))
2182 set_builtin_decl_implicit_p (fncode, true);
2190 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2191 /* Don't clear out the arguments if we're just redeclaring a
2193 if (DECL_ARGUMENTS (olddecl))
2194 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2197 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2198 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2200 /* Now preserve various other info from the definition. */
2201 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2202 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2203 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2204 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2206 /* Warn about conflicting visibility specifications. */
2207 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2208 && DECL_VISIBILITY_SPECIFIED (newdecl)
2209 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2211 warning_at (input_location, OPT_Wattributes,
2212 "%q+D: visibility attribute ignored because it", newdecl);
2213 warning_at (DECL_SOURCE_LOCATION (olddecl), OPT_Wattributes,
2214 "conflicts with previous declaration here");
2216 /* Choose the declaration which specified visibility. */
2217 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2219 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2220 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2222 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2223 so keep this behavior. */
2224 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2226 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2227 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2229 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2230 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2232 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2233 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2235 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2236 if (TREE_CODE (newdecl) == FIELD_DECL)
2237 DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
2239 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2240 with that from NEWDECL below. */
2241 if (DECL_LANG_SPECIFIC (olddecl))
2243 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2244 != DECL_LANG_SPECIFIC (newdecl));
2245 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2248 /* Merge the USED information. */
2249 if (TREE_USED (olddecl))
2250 TREE_USED (newdecl) = 1;
2251 else if (TREE_USED (newdecl))
2252 TREE_USED (olddecl) = 1;
2253 if (TREE_CODE (newdecl) == VAR_DECL)
2255 if (DECL_READ_P (olddecl))
2256 DECL_READ_P (newdecl) = 1;
2257 else if (DECL_READ_P (newdecl))
2258 DECL_READ_P (olddecl) = 1;
2260 if (DECL_PRESERVE_P (olddecl))
2261 DECL_PRESERVE_P (newdecl) = 1;
2262 else if (DECL_PRESERVE_P (newdecl))
2263 DECL_PRESERVE_P (olddecl) = 1;
2265 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2269 function_size = sizeof (struct tree_decl_common);
2271 memcpy ((char *) olddecl + sizeof (struct tree_common),
2272 (char *) newdecl + sizeof (struct tree_common),
2273 function_size - sizeof (struct tree_common));
2275 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2276 (char *) newdecl + sizeof (struct tree_decl_common),
2277 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2278 if (new_template_info)
2279 /* If newdecl is a template instantiation, it is possible that
2280 the following sequence of events has occurred:
2282 o A friend function was declared in a class template. The
2283 class template was instantiated.
2285 o The instantiation of the friend declaration was
2286 recorded on the instantiation list, and is newdecl.
2288 o Later, however, instantiate_class_template called pushdecl
2289 on the newdecl to perform name injection. But, pushdecl in
2290 turn called duplicate_decls when it discovered that another
2291 declaration of a global function with the same name already
2294 o Here, in duplicate_decls, we decided to clobber newdecl.
2296 If we're going to do that, we'd better make sure that
2297 olddecl, and not newdecl, is on the list of
2298 instantiations so that if we try to do the instantiation
2299 again we won't get the clobbered declaration. */
2300 reregister_specialization (newdecl,
2306 size_t size = tree_code_size (TREE_CODE (olddecl));
2307 memcpy ((char *) olddecl + sizeof (struct tree_common),
2308 (char *) newdecl + sizeof (struct tree_common),
2309 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2310 switch (TREE_CODE (olddecl))
2320 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2321 (char *) newdecl + sizeof (struct tree_decl_common),
2322 size - sizeof (struct tree_decl_common)
2323 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2327 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2328 (char *) newdecl + sizeof (struct tree_decl_common),
2329 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2330 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2334 DECL_UID (olddecl) = olddecl_uid;
2336 DECL_FRIEND_P (olddecl) = 1;
2339 DECL_ANTICIPATED (olddecl) = 1;
2340 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2343 /* NEWDECL contains the merged attribute lists.
2344 Update OLDDECL to be the same. */
2345 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2347 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2348 so that encode_section_info has a chance to look at the new decl
2349 flags and attributes. */
2350 if (DECL_RTL_SET_P (olddecl)
2351 && (TREE_CODE (olddecl) == FUNCTION_DECL
2352 || (TREE_CODE (olddecl) == VAR_DECL
2353 && TREE_STATIC (olddecl))))
2354 make_decl_rtl (olddecl);
2356 /* The NEWDECL will no longer be needed. Because every out-of-class
2357 declaration of a member results in a call to duplicate_decls,
2358 freeing these nodes represents in a significant savings. */
2364 /* Return zero if the declaration NEWDECL is valid
2365 when the declaration OLDDECL (assumed to be for the same name)
2366 has already been seen.
2367 Otherwise return an error message format string with a %s
2368 where the identifier should go. */
2371 redeclaration_error_message (tree newdecl, tree olddecl)
2373 if (TREE_CODE (newdecl) == TYPE_DECL)
2375 /* Because C++ can put things into name space for free,
2376 constructs like "typedef struct foo { ... } foo"
2377 would look like an erroneous redeclaration. */
2378 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2381 return G_("redefinition of %q#D");
2383 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2385 /* If this is a pure function, its olddecl will actually be
2386 the original initialization to `0' (which we force to call
2387 abort()). Don't complain about redefinition in this case. */
2388 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2389 && DECL_INITIAL (olddecl) == NULL_TREE)
2392 /* If both functions come from different namespaces, this is not
2393 a redeclaration - this is a conflict with a used function. */
2394 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2395 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2396 && ! decls_match (olddecl, newdecl))
2397 return G_("%qD conflicts with used function");
2399 /* We'll complain about linkage mismatches in
2400 warn_extern_redeclared_static. */
2402 /* Defining the same name twice is no good. */
2403 if (DECL_INITIAL (olddecl) != NULL_TREE
2404 && DECL_INITIAL (newdecl) != NULL_TREE)
2406 if (DECL_NAME (olddecl) == NULL_TREE)
2407 return G_("%q#D not declared in class");
2408 else if (!GNU_INLINE_P (olddecl)
2409 || GNU_INLINE_P (newdecl))
2410 return G_("redefinition of %q#D");
2413 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2415 bool olda = GNU_INLINE_P (olddecl);
2416 bool newa = GNU_INLINE_P (newdecl);
2421 return G_("%q+D redeclared inline with "
2422 "%<gnu_inline%> attribute");
2424 return G_("%q+D redeclared inline without "
2425 "%<gnu_inline%> attribute");
2431 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2435 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2437 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2438 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2439 return G_("redefinition of %q#D");
2443 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2444 || (DECL_TEMPLATE_RESULT (newdecl)
2445 == DECL_TEMPLATE_RESULT (olddecl)))
2448 nt = DECL_TEMPLATE_RESULT (newdecl);
2449 if (DECL_TEMPLATE_INFO (nt))
2450 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2451 ot = DECL_TEMPLATE_RESULT (olddecl);
2452 if (DECL_TEMPLATE_INFO (ot))
2453 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2454 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2455 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2456 return G_("redefinition of %q#D");
2458 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2460 bool olda = GNU_INLINE_P (ot);
2461 bool newa = GNU_INLINE_P (nt);
2466 return G_("%q+D redeclared inline with "
2467 "%<gnu_inline%> attribute");
2469 return G_("%q+D redeclared inline without "
2470 "%<gnu_inline%> attribute");
2474 /* Core issue #226 (C++0x):
2476 If a friend function template declaration specifies a
2477 default template-argument, that declaration shall be a
2478 definition and shall be the only declaration of the
2479 function template in the translation unit. */
2480 if ((cxx_dialect != cxx98)
2481 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2482 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2483 /*is_primary=*/true,
2484 /*is_partial=*/false,
2485 /*is_friend_decl=*/2))
2486 return G_("redeclaration of friend %q#D "
2487 "may not have default template arguments");
2491 else if (TREE_CODE (newdecl) == VAR_DECL
2492 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2493 && (! DECL_LANG_SPECIFIC (olddecl)
2494 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2495 || DECL_THREAD_LOCAL_P (newdecl)))
2497 /* Only variables can be thread-local, and all declarations must
2498 agree on this property. */
2499 if (DECL_THREAD_LOCAL_P (newdecl))
2500 return G_("thread-local declaration of %q#D follows "
2501 "non-thread-local declaration");
2503 return G_("non-thread-local declaration of %q#D follows "
2504 "thread-local declaration");
2506 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2508 /* The objects have been declared at namespace scope. If either
2509 is a member of an anonymous union, then this is an invalid
2510 redeclaration. For example:
2516 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2517 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2518 return G_("redeclaration of %q#D");
2519 /* If at least one declaration is a reference, there is no
2520 conflict. For example:
2526 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2528 /* Reject two definitions. */
2529 return G_("redefinition of %q#D");
2533 /* Objects declared with block scope: */
2534 /* Reject two definitions, and reject a definition
2535 together with an external reference. */
2536 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2537 return G_("redeclaration of %q#D");
2542 /* Hash and equality functions for the named_label table. */
2545 named_label_entry_hash (const void *data)
2547 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2548 return DECL_UID (ent->label_decl);
2552 named_label_entry_eq (const void *a, const void *b)
2554 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2555 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2556 return ent_a->label_decl == ent_b->label_decl;
2559 /* Create a new label, named ID. */
2562 make_label_decl (tree id, int local_p)
2564 struct named_label_entry *ent;
2568 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2570 DECL_CONTEXT (decl) = current_function_decl;
2571 DECL_MODE (decl) = VOIDmode;
2572 C_DECLARED_LABEL_FLAG (decl) = local_p;
2574 /* Say where one reference is to the label, for the sake of the
2575 error if it is not defined. */
2576 DECL_SOURCE_LOCATION (decl) = input_location;
2578 /* Record the fact that this identifier is bound to this label. */
2579 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2581 /* Create the label htab for the function on demand. */
2583 named_labels = htab_create_ggc (13, named_label_entry_hash,
2584 named_label_entry_eq, NULL);
2586 /* Record this label on the list of labels used in this function.
2587 We do this before calling make_label_decl so that we get the
2588 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2589 ent = ggc_alloc_cleared_named_label_entry ();
2590 ent->label_decl = decl;
2592 slot = htab_find_slot (named_labels, ent, INSERT);
2593 gcc_assert (*slot == NULL);
2599 /* Look for a label named ID in the current function. If one cannot
2600 be found, create one. (We keep track of used, but undefined,
2601 labels, and complain about them at the end of a function.) */
2604 lookup_label_1 (tree id)
2608 /* You can't use labels at global scope. */
2609 if (current_function_decl == NULL_TREE)
2611 error ("label %qE referenced outside of any function", id);
2615 /* See if we've already got this label. */
2616 decl = IDENTIFIER_LABEL_VALUE (id);
2617 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2620 decl = make_label_decl (id, /*local_p=*/0);
2624 /* Wrapper for lookup_label_1. */
2627 lookup_label (tree id)
2630 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2631 ret = lookup_label_1 (id);
2632 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2636 /* Declare a local label named ID. */
2639 declare_local_label (tree id)
2642 cp_label_binding bind;
2644 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2645 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2646 bind.prev_value = IDENTIFIER_LABEL_VALUE (id);
2648 decl = make_label_decl (id, /*local_p=*/1);
2650 VEC_safe_push (cp_label_binding, gc, current_binding_level->shadowed_labels,
2656 /* Returns nonzero if it is ill-formed to jump past the declaration of
2657 DECL. Returns 2 if it's also a real problem. */
2660 decl_jump_unsafe (tree decl)
2662 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2663 with automatic storage duration is not in scope to a point where it is
2664 in scope is ill-formed unless the variable has scalar type, class type
2665 with a trivial default constructor and a trivial destructor, a
2666 cv-qualified version of one of these types, or an array of one of the
2667 preceding types and is declared without an initializer (8.5). */
2668 tree type = TREE_TYPE (decl);
2670 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2671 || type == error_mark_node)
2674 type = strip_array_types (type);
2676 if (type_has_nontrivial_default_init (TREE_TYPE (decl))
2677 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2680 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2686 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2689 identify_goto (tree decl, const location_t *locus)
2692 permerror (input_location, "jump to label %qD", decl);
2694 permerror (input_location, "jump to case label");
2696 permerror (*locus, " from here");
2699 /* Check that a single previously seen jump to a newly defined label
2700 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2701 the jump context; NAMES are the names in scope in LEVEL at the jump
2702 context; LOCUS is the source position of the jump or 0. Returns
2703 true if all is well. */
2706 check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
2707 bool exited_omp, const location_t *locus)
2709 cp_binding_level *b;
2710 bool identified = false, saw_eh = false, saw_omp = false;
2714 identify_goto (decl, locus);
2715 error (" exits OpenMP structured block");
2716 identified = saw_omp = true;
2719 for (b = current_binding_level; b ; b = b->level_chain)
2721 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2723 for (new_decls = b->names; new_decls != old_decls;
2724 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
2725 : TREE_CHAIN (new_decls)))
2727 int problem = decl_jump_unsafe (new_decls);
2733 identify_goto (decl, locus);
2737 error (" crosses initialization of %q+#D", new_decls);
2739 permerror (input_location, " enters scope of %q+#D which has "
2740 "non-trivial destructor", new_decls);
2745 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2749 identify_goto (decl, locus);
2752 if (b->kind == sk_try)
2753 error (" enters try block");
2755 error (" enters catch block");
2758 if (b->kind == sk_omp && !saw_omp)
2762 identify_goto (decl, locus);
2765 error (" enters OpenMP structured block");
2774 check_previous_goto (tree decl, struct named_label_use_entry *use)
2776 check_previous_goto_1 (decl, use->binding_level,
2777 use->names_in_scope, use->in_omp_scope,
2778 &use->o_goto_locus);
2782 check_switch_goto (cp_binding_level* level)
2784 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2787 /* Check that a new jump to a label DECL is OK. Called by
2788 finish_goto_stmt. */
2791 check_goto (tree decl)
2793 struct named_label_entry *ent, dummy;
2794 bool saw_catch = false, identified = false;
2798 /* We can't know where a computed goto is jumping.
2799 So we assume that it's OK. */
2800 if (TREE_CODE (decl) != LABEL_DECL)
2803 /* We didn't record any information about this label when we created it,
2804 and there's not much point since it's trivial to analyze as a return. */
2805 if (decl == cdtor_label)
2808 dummy.label_decl = decl;
2809 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2810 gcc_assert (ent != NULL);
2812 /* If the label hasn't been defined yet, defer checking. */
2813 if (! DECL_INITIAL (decl))
2815 struct named_label_use_entry *new_use;
2817 /* Don't bother creating another use if the last goto had the
2818 same data, and will therefore create the same set of errors. */
2820 && ent->uses->names_in_scope == current_binding_level->names)
2823 new_use = ggc_alloc_named_label_use_entry ();
2824 new_use->binding_level = current_binding_level;
2825 new_use->names_in_scope = current_binding_level->names;
2826 new_use->o_goto_locus = input_location;
2827 new_use->in_omp_scope = false;
2829 new_use->next = ent->uses;
2830 ent->uses = new_use;
2834 if (ent->in_try_scope || ent->in_catch_scope
2835 || ent->in_omp_scope || !VEC_empty (tree, ent->bad_decls))
2837 permerror (input_location, "jump to label %q+D", decl);
2838 permerror (input_location, " from here");
2842 FOR_EACH_VEC_ELT (tree, ent->bad_decls, ix, bad)
2844 int u = decl_jump_unsafe (bad);
2846 if (u > 1 && DECL_ARTIFICIAL (bad))
2848 /* Can't skip init of __exception_info. */
2849 error_at (DECL_SOURCE_LOCATION (bad), " enters catch block");
2853 error (" skips initialization of %q+#D", bad);
2855 permerror (input_location, " enters scope of %q+#D which has "
2856 "non-trivial destructor", bad);
2859 if (ent->in_try_scope)
2860 error (" enters try block");
2861 else if (ent->in_catch_scope && !saw_catch)
2862 error (" enters catch block");
2864 if (ent->in_omp_scope)
2865 error (" enters OpenMP structured block");
2866 else if (flag_openmp)
2868 cp_binding_level *b;
2869 for (b = current_binding_level; b ; b = b->level_chain)
2871 if (b == ent->binding_level)
2873 if (b->kind == sk_omp)
2877 permerror (input_location, "jump to label %q+D", decl);
2878 permerror (input_location, " from here");
2881 error (" exits OpenMP structured block");
2888 /* Check that a return is ok wrt OpenMP structured blocks.
2889 Called by finish_return_stmt. Returns true if all is well. */
2892 check_omp_return (void)
2894 cp_binding_level *b;
2895 for (b = current_binding_level; b ; b = b->level_chain)
2896 if (b->kind == sk_omp)
2898 error ("invalid exit from OpenMP structured block");
2901 else if (b->kind == sk_function_parms)
2906 /* Define a label, specifying the location in the source file.
2907 Return the LABEL_DECL node for the label. */
2910 define_label_1 (location_t location, tree name)
2912 struct named_label_entry *ent, dummy;
2913 cp_binding_level *p;
2916 decl = lookup_label (name);
2918 dummy.label_decl = decl;
2919 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2920 gcc_assert (ent != NULL);
2922 /* After labels, make any new cleanups in the function go into their
2923 own new (temporary) binding contour. */
2924 for (p = current_binding_level;
2925 p->kind != sk_function_parms;
2927 p->more_cleanups_ok = 0;
2929 if (name == get_identifier ("wchar_t"))
2930 permerror (input_location, "label named wchar_t");
2932 if (DECL_INITIAL (decl) != NULL_TREE)
2934 error ("duplicate label %qD", decl);
2935 return error_mark_node;
2939 struct named_label_use_entry *use;
2941 /* Mark label as having been defined. */
2942 DECL_INITIAL (decl) = error_mark_node;
2943 /* Say where in the source. */
2944 DECL_SOURCE_LOCATION (decl) = location;
2946 ent->binding_level = current_binding_level;
2947 ent->names_in_scope = current_binding_level->names;
2949 for (use = ent->uses; use ; use = use->next)
2950 check_previous_goto (decl, use);
2957 /* Wrapper for define_label_1. */
2960 define_label (location_t location, tree name)
2963 bool running = timevar_cond_start (TV_NAME_LOOKUP);
2964 ret = define_label_1 (location, name);
2965 timevar_cond_stop (TV_NAME_LOOKUP, running);
2972 cp_binding_level *level;
2973 struct cp_switch *next;
2974 /* The SWITCH_STMT being built. */
2976 /* A splay-tree mapping the low element of a case range to the high
2977 element, or NULL_TREE if there is no high element. Used to
2978 determine whether or not a new case label duplicates an old case
2979 label. We need a tree, rather than simply a hash table, because
2980 of the GNU case range extension. */
2984 /* A stack of the currently active switch statements. The innermost
2985 switch statement is on the top of the stack. There is no need to
2986 mark the stack for garbage collection because it is only active
2987 during the processing of the body of a function, and we never
2988 collect at that point. */
2990 static struct cp_switch *switch_stack;
2992 /* Called right after a switch-statement condition is parsed.
2993 SWITCH_STMT is the switch statement being parsed. */
2996 push_switch (tree switch_stmt)
2998 struct cp_switch *p = XNEW (struct cp_switch);
2999 p->level = current_binding_level;
3000 p->next = switch_stack;
3001 p->switch_stmt = switch_stmt;
3002 p->cases = splay_tree_new (case_compare, NULL, NULL);
3009 struct cp_switch *cs = switch_stack;
3010 location_t switch_location;
3012 /* Emit warnings as needed. */
3013 switch_location = EXPR_LOC_OR_HERE (cs->switch_stmt);
3014 if (!processing_template_decl)
3015 c_do_switch_warnings (cs->cases, switch_location,
3016 SWITCH_STMT_TYPE (cs->switch_stmt),
3017 SWITCH_STMT_COND (cs->switch_stmt));
3019 splay_tree_delete (cs->cases);
3020 switch_stack = switch_stack->next;
3024 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3025 condition. Note that if TYPE and VALUE are already integral we don't
3026 really do the conversion because the language-independent
3027 warning/optimization code will work better that way. */
3030 case_conversion (tree type, tree value)
3032 if (value == NULL_TREE)
3035 if (cxx_dialect >= cxx0x
3036 && (SCOPED_ENUM_P (type)
3037 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
3039 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
3040 type = type_promotes_to (type);
3041 value = perform_implicit_conversion (type, value, tf_warning_or_error);
3043 return cxx_constant_value (value);
3046 /* Note that we've seen a definition of a case label, and complain if this
3047 is a bad place for one. */
3050 finish_case_label (location_t loc, tree low_value, tree high_value)
3053 cp_binding_level *p;
3056 if (processing_template_decl)
3060 /* For templates, just add the case label; we'll do semantic
3061 analysis at instantiation-time. */
3062 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
3063 return add_stmt (build_case_label (low_value, high_value, label));
3066 /* Find the condition on which this switch statement depends. */
3067 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
3068 if (cond && TREE_CODE (cond) == TREE_LIST)
3069 cond = TREE_VALUE (cond);
3071 if (!check_switch_goto (switch_stack->level))
3072 return error_mark_node;
3074 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
3076 low_value = case_conversion (type, low_value);
3077 high_value = case_conversion (type, high_value);
3079 r = c_add_case_label (loc, switch_stack->cases, cond, type,
3080 low_value, high_value);
3082 /* After labels, make any new cleanups in the function go into their
3083 own new (temporary) binding contour. */
3084 for (p = current_binding_level;
3085 p->kind != sk_function_parms;
3087 p->more_cleanups_ok = 0;
3092 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3095 typename_hash (const void* k)
3098 const_tree const t = (const_tree) k;
3100 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
3101 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
3106 typedef struct typename_info {
3114 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3115 really of type `typename_info*' */
3118 typename_compare (const void * k1, const void * k2)
3120 const_tree const t1 = (const_tree) k1;
3121 const typename_info *const t2 = (const typename_info *) k2;
3123 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
3124 && TYPE_CONTEXT (t1) == t2->scope
3125 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
3126 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
3127 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
3130 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3131 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3133 Returns the new TYPENAME_TYPE. */
3135 static GTY ((param_is (union tree_node))) htab_t typename_htab;
3138 build_typename_type (tree context, tree name, tree fullname,
3139 enum tag_types tag_type)
3147 if (typename_htab == NULL)
3148 typename_htab = htab_create_ggc (61, &typename_hash,
3149 &typename_compare, NULL);
3151 ti.scope = FROB_CONTEXT (context);
3153 ti.template_id = fullname;
3154 ti.enum_p = tag_type == enum_type;
3155 ti.class_p = (tag_type == class_type
3156 || tag_type == record_type
3157 || tag_type == union_type);
3158 hash = (htab_hash_pointer (ti.scope)
3159 ^ htab_hash_pointer (ti.name));
3161 /* See if we already have this type. */
3162 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
3167 /* Build the TYPENAME_TYPE. */
3168 t = cxx_make_type (TYPENAME_TYPE);
3169 TYPE_CONTEXT (t) = ti.scope;
3170 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
3171 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
3172 TYPENAME_IS_CLASS_P (t) = ti.class_p;
3174 /* Build the corresponding TYPE_DECL. */
3175 d = build_decl (input_location, TYPE_DECL, name, t);
3176 TYPE_NAME (TREE_TYPE (d)) = d;
3177 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3178 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3179 DECL_ARTIFICIAL (d) = 1;
3181 /* Store it in the hash table. */
3184 /* TYPENAME_TYPEs must always be compared structurally, because
3185 they may or may not resolve down to another type depending on
3186 the currently open classes. */
3187 SET_TYPE_STRUCTURAL_EQUALITY (t);
3193 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3194 provided to name the type. Returns an appropriate type, unless an
3195 error occurs, in which case error_mark_node is returned. If we
3196 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3197 return that, rather than the _TYPE it corresponds to, in other
3198 cases we look through the type decl. If TF_ERROR is set, complain
3199 about errors, otherwise be quiet. */
3202 make_typename_type (tree context, tree name, enum tag_types tag_type,
3203 tsubst_flags_t complain)
3209 if (name == error_mark_node
3210 || context == NULL_TREE
3211 || context == error_mark_node)
3212 return error_mark_node;
3216 if (!(TYPE_LANG_SPECIFIC (name)
3217 && (CLASSTYPE_IS_TEMPLATE (name)
3218 || CLASSTYPE_USE_TEMPLATE (name))))
3219 name = TYPE_IDENTIFIER (name);
3221 /* Create a TEMPLATE_ID_EXPR for the type. */
3222 name = build_nt (TEMPLATE_ID_EXPR,
3223 CLASSTYPE_TI_TEMPLATE (name),
3224 CLASSTYPE_TI_ARGS (name));
3226 else if (TREE_CODE (name) == TYPE_DECL)
3227 name = DECL_NAME (name);
3231 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3233 name = TREE_OPERAND (name, 0);
3234 if (TREE_CODE (name) == TEMPLATE_DECL)
3235 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3236 else if (TREE_CODE (name) == OVERLOAD)
3238 if (complain & tf_error)
3239 error ("%qD is not a type", name);
3240 return error_mark_node;
3243 if (TREE_CODE (name) == TEMPLATE_DECL)
3245 if (complain & tf_error)
3246 error ("%qD used without template parameters", name);
3247 return error_mark_node;
3249 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3250 gcc_assert (TYPE_P (context));
3252 if (!MAYBE_CLASS_TYPE_P (context))
3254 if (complain & tf_error)
3255 error ("%q#T is not a class", context);
3256 return error_mark_node;
3259 /* When the CONTEXT is a dependent type, NAME could refer to a
3260 dependent base class of CONTEXT. But look inside it anyway
3261 if CONTEXT is a currently open scope, in case it refers to a
3262 member of the current instantiation or a non-dependent base;
3263 lookup will stop when we hit a dependent base. */
3264 if (!dependent_scope_p (context))
3265 /* We should only set WANT_TYPE when we're a nested typename type.
3266 Then we can give better diagnostics if we find a non-type. */
3267 t = lookup_field (context, name, 2, /*want_type=*/true);
3271 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3272 return build_typename_type (context, name, fullname, tag_type);
3274 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3278 if (complain & tf_error)
3279 error (want_template ? G_("no class template named %q#T in %q#T")
3280 : G_("no type named %q#T in %q#T"), name, context);
3281 return error_mark_node;
3284 /* Pull out the template from an injected-class-name (or multiple). */
3286 t = maybe_get_template_decl_from_type_decl (t);
3288 if (TREE_CODE (t) == TREE_LIST)
3290 if (complain & tf_error)
3292 error ("lookup of %qT in %qT is ambiguous", name, context);
3293 print_candidates (t);
3295 return error_mark_node;
3298 if (want_template && !DECL_TYPE_TEMPLATE_P (t))
3300 if (complain & tf_error)
3301 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3303 return error_mark_node;
3305 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3307 if (complain & tf_error)
3308 error ("%<typename %T::%D%> names %q#T, which is not a type",
3310 return error_mark_node;
3313 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain))
3314 return error_mark_node;
3316 /* If we are currently parsing a template and if T is a typedef accessed
3317 through CONTEXT then we need to remember and check access of T at
3318 template instantiation time. */
3319 add_typedef_to_current_template_for_access_check (t, context, input_location);
3322 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3324 /*entering_scope=*/0,
3325 tf_warning_or_error | tf_user);
3327 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3330 maybe_record_typedef_use (t);
3335 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3336 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3337 in which case error_mark_node is returned.
3339 If PARM_LIST is non-NULL, also make sure that the template parameter
3340 list of TEMPLATE_DECL matches.
3342 If COMPLAIN zero, don't complain about any errors that occur. */
3345 make_unbound_class_template (tree context, tree name, tree parm_list,
3346 tsubst_flags_t complain)
3352 name = TYPE_IDENTIFIER (name);
3353 else if (DECL_P (name))
3354 name = DECL_NAME (name);
3355 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3357 if (!dependent_type_p (context)
3358 || currently_open_class (context))
3360 tree tmpl = NULL_TREE;
3362 if (MAYBE_CLASS_TYPE_P (context))
3363 tmpl = lookup_field (context, name, 0, false);
3365 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
3366 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
3368 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
3370 if (complain & tf_error)
3371 error ("no class template named %q#T in %q#T", name, context);
3372 return error_mark_node;
3376 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3378 if (complain & tf_error)
3380 error ("template parameters do not match template");
3381 error ("%q+D declared here", tmpl);
3383 return error_mark_node;
3386 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl,
3388 return error_mark_node;
3393 /* Build the UNBOUND_CLASS_TEMPLATE. */
3394 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3395 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3396 TREE_TYPE (t) = NULL_TREE;
3397 SET_TYPE_STRUCTURAL_EQUALITY (t);
3399 /* Build the corresponding TEMPLATE_DECL. */
3400 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3401 TYPE_NAME (TREE_TYPE (d)) = d;
3402 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3403 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3404 DECL_ARTIFICIAL (d) = 1;
3405 DECL_TEMPLATE_PARMS (d) = parm_list;
3412 /* Push the declarations of builtin types into the namespace.
3413 RID_INDEX is the index of the builtin type in the array
3414 RID_POINTERS. NAME is the name used when looking up the builtin
3415 type. TYPE is the _TYPE node for the builtin type. */
3418 record_builtin_type (enum rid rid_index,
3422 tree rname = NULL_TREE, tname = NULL_TREE;
3423 tree tdecl = NULL_TREE;
3425 if ((int) rid_index < (int) RID_MAX)
3426 rname = ridpointers[(int) rid_index];
3428 tname = get_identifier (name);
3430 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3431 eliminated. Built-in types should not be looked up name; their
3432 names are keywords that the parser can recognize. However, there
3433 is code in c-common.c that uses identifier_global_value to look
3434 up built-in types by name. */
3437 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3438 DECL_ARTIFICIAL (tdecl) = 1;
3439 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3445 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3446 DECL_ARTIFICIAL (tdecl) = 1;
3448 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3451 if (!TYPE_NAME (type))
3452 TYPE_NAME (type) = tdecl;
3455 debug_hooks->type_decl (tdecl, 0);
3458 /* Record one of the standard Java types.
3459 * Declare it as having the given NAME.
3460 * If SIZE > 0, it is the size of one of the integral types;
3461 * otherwise it is the negative of the size of one of the other types. */
3464 record_builtin_java_type (const char* name, int size)
3469 type = build_nonstandard_integer_type (size, 0);
3470 type = build_distinct_type_copy (type);
3472 else if (size > -32)
3475 /* "__java_char" or ""__java_boolean". */
3476 type = build_nonstandard_integer_type (-size, 1);
3477 type = build_distinct_type_copy (type);
3478 /* Get the signed type cached and attached to the unsigned type,
3479 so it doesn't get garbage-collected at "random" times,
3480 causing potential codegen differences out of different UIDs
3481 and different alias set numbers. */
3482 stype = build_nonstandard_integer_type (-size, 0);
3483 stype = build_distinct_type_copy (stype);
3484 TREE_CHAIN (type) = stype;
3485 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3488 { /* "__java_float" or ""__java_double". */
3489 type = make_node (REAL_TYPE);
3490 TYPE_PRECISION (type) = - size;
3493 record_builtin_type (RID_MAX, name, type);
3494 decl = TYPE_NAME (type);
3496 /* Suppress generate debug symbol entries for these types,
3497 since for normal C++ they are just clutter.
3498 However, push_lang_context undoes this if extern "Java" is seen. */
3499 DECL_IGNORED_P (decl) = 1;
3501 TYPE_FOR_JAVA (type) = 1;
3505 /* Push a type into the namespace so that the back ends ignore it. */
3508 record_unknown_type (tree type, const char* name)
3510 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3511 TYPE_DECL, get_identifier (name), type));
3512 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3513 DECL_IGNORED_P (decl) = 1;
3514 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3515 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3516 TYPE_ALIGN (type) = 1;
3517 TYPE_USER_ALIGN (type) = 0;
3518 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3521 /* A string for which we should create an IDENTIFIER_NODE at
3524 typedef struct predefined_identifier
3526 /* The name of the identifier. */
3527 const char *const name;
3528 /* The place where the IDENTIFIER_NODE should be stored. */
3530 /* Nonzero if this is the name of a constructor or destructor. */
3531 const int ctor_or_dtor_p;
3532 } predefined_identifier;
3534 /* Create all the predefined identifiers. */
3537 initialize_predefined_identifiers (void)
3539 const predefined_identifier *pid;
3541 /* A table of identifiers to create at startup. */
3542 static const predefined_identifier predefined_identifiers[] = {
3543 { "C++", &lang_name_cplusplus, 0 },
3544 { "C", &lang_name_c, 0 },
3545 { "Java", &lang_name_java, 0 },
3546 /* Some of these names have a trailing space so that it is
3547 impossible for them to conflict with names written by users. */
3548 { "__ct ", &ctor_identifier, 1 },
3549 { "__base_ctor ", &base_ctor_identifier, 1 },
3550 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3551 { "__dt ", &dtor_identifier, 1 },
3552 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3553 { "__base_dtor ", &base_dtor_identifier, 1 },
3554 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3555 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3556 { "nelts", &nelts_identifier, 0 },
3557 { THIS_NAME, &this_identifier, 0 },
3558 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3559 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3560 { "_vptr", &vptr_identifier, 0 },
3561 { "__vtt_parm", &vtt_parm_identifier, 0 },
3562 { "::", &global_scope_name, 0 },
3563 { "std", &std_identifier, 0 },
3567 for (pid = predefined_identifiers; pid->name; ++pid)
3569 *pid->node = get_identifier (pid->name);
3570 if (pid->ctor_or_dtor_p)
3571 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3575 /* Create the predefined scalar types of C,
3576 and some nodes representing standard constants (0, 1, (void *)0).
3577 Initialize the global binding level.
3578 Make definitions for built-in primitive functions. */
3581 cxx_init_decl_processing (void)
3584 tree void_ftype_ptr;
3586 /* Create all the identifiers we need. */
3587 initialize_predefined_identifiers ();
3589 /* Create the global variables. */
3590 push_to_top_level ();
3592 current_function_decl = NULL_TREE;
3593 current_binding_level = NULL;
3594 /* Enter the global namespace. */
3595 gcc_assert (global_namespace == NULL_TREE);
3596 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3598 DECL_CONTEXT (global_namespace) = build_translation_unit_decl (NULL_TREE);
3599 TREE_PUBLIC (global_namespace) = 1;
3600 begin_scope (sk_namespace, global_namespace);
3602 if (flag_visibility_ms_compat)
3603 default_visibility = VISIBILITY_HIDDEN;
3606 current_lang_name = lang_name_c;
3608 /* Create the `std' namespace. */
3609 push_namespace (std_identifier);
3610 std_node = current_namespace;
3613 c_common_nodes_and_builtins ();
3615 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3616 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3617 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3618 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3619 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3620 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3621 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3622 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3624 integer_two_node = build_int_cst (NULL_TREE, 2);
3626 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3627 truthvalue_type_node = boolean_type_node;
3628 truthvalue_false_node = boolean_false_node;
3629 truthvalue_true_node = boolean_true_node;
3631 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3632 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
3633 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
3636 record_builtin_type (RID_MAX, NULL, string_type_node);
3639 delta_type_node = ptrdiff_type_node;
3640 vtable_index_type = ptrdiff_type_node;
3642 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3643 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
3644 void_ftype_ptr = build_function_type_list (void_type_node,
3645 ptr_type_node, NULL_TREE);
3647 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3649 /* C++ extensions */
3651 unknown_type_node = make_node (LANG_TYPE);
3652 record_unknown_type (unknown_type_node, "unknown type");
3654 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3655 TREE_TYPE (unknown_type_node) = unknown_type_node;
3657 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3659 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3660 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3662 init_list_type_node = make_node (LANG_TYPE);
3663 record_unknown_type (init_list_type_node, "init list");
3666 /* Make sure we get a unique function type, so we can give
3667 its pointer type a name. (This wins for gdb.) */
3668 tree vfunc_type = make_node (FUNCTION_TYPE);
3669 TREE_TYPE (vfunc_type) = integer_type_node;
3670 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3671 layout_type (vfunc_type);
3673 vtable_entry_type = build_pointer_type (vfunc_type);
3675 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3678 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3679 layout_type (vtbl_type_node);
3680 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3681 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3682 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3683 layout_type (vtbl_ptr_type_node);
3684 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3686 push_namespace (get_identifier ("__cxxabiv1"));
3687 abi_node = current_namespace;
3690 global_type_node = make_node (LANG_TYPE);
3691 record_unknown_type (global_type_node, "global type");
3694 current_lang_name = lang_name_cplusplus;
3697 tree newattrs, extvisattr;
3698 tree newtype, deltype;
3699 tree ptr_ftype_sizetype;
3703 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
3704 if (cxx_dialect == cxx98)
3707 tree bad_alloc_type_node;
3708 tree bad_alloc_decl;
3710 push_namespace (std_identifier);
3711 bad_alloc_id = get_identifier ("bad_alloc");
3712 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3713 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3715 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3716 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3720 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
3723 new_eh_spec = noexcept_false_spec;
3725 /* Ensure attribs.c is initialized. */
3727 extvisattr = build_tree_list (get_identifier ("externally_visible"),
3729 newattrs = tree_cons (get_identifier ("alloc_size"),
3730 build_tree_list (NULL_TREE, integer_one_node),
3732 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
3733 newtype = build_exception_variant (newtype, new_eh_spec);
3734 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
3735 deltype = build_exception_variant (deltype, empty_except_spec);
3736 push_cp_library_fn (NEW_EXPR, newtype);
3737 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3738 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3739 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3741 nullptr_type_node = make_node (NULLPTR_TYPE);
3742 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
3743 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
3744 TYPE_UNSIGNED (nullptr_type_node) = 1;
3745 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
3746 SET_TYPE_MODE (nullptr_type_node, ptr_mode);
3747 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
3748 nullptr_node = build_int_cst (nullptr_type_node, 0);
3752 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3754 /* Perform other language dependent initializations. */
3755 init_class_processing ();
3756 init_rtti_processing ();
3757 init_template_processing ();
3759 if (flag_exceptions)
3760 init_exception_processing ();
3762 if (! supports_one_only ())
3765 make_fname_decl = cp_make_fname_decl;
3766 start_fname_decls ();
3768 /* Show we use EH for cleanups. */
3769 if (flag_exceptions)
3770 using_eh_for_cleanups ();
3773 /* Generate an initializer for a function naming variable from
3774 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3775 filled in with the type of the init. */
3778 cp_fname_init (const char* name, tree *type_p)
3780 tree domain = NULL_TREE;
3782 tree init = NULL_TREE;
3787 length = strlen (name);
3788 domain = build_index_type (size_int (length));
3789 init = build_string (length + 1, name);
3792 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3793 type = build_cplus_array_type (type, domain);
3798 TREE_TYPE (init) = type;
3800 init = error_mark_node;
3805 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3806 the decl, LOC is the location to give the decl, NAME is the
3807 initialization string and TYPE_DEP indicates whether NAME depended
3808 on the type of the function. We make use of that to detect
3809 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3810 at the point of first use, so we mustn't push the decl now. */
3813 cp_make_fname_decl (location_t loc, tree id, int type_dep)
3815 const char *const name = (type_dep && processing_template_decl
3816 ? NULL : fname_as_string (type_dep));
3818 tree init = cp_fname_init (name, &type);
3819 tree decl = build_decl (loc, VAR_DECL, id, type);
3822 free (CONST_CAST (char *, name));
3824 /* As we're using pushdecl_with_scope, we must set the context. */
3825 DECL_CONTEXT (decl) = current_function_decl;
3826 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3828 TREE_STATIC (decl) = 1;
3829 TREE_READONLY (decl) = 1;
3830 DECL_ARTIFICIAL (decl) = 1;
3832 TREE_USED (decl) = 1;
3834 if (current_function_decl)
3836 cp_binding_level *b = current_binding_level;
3837 if (b->kind == sk_function_parms)
3838 return error_mark_node;
3839 while (b->level_chain->kind != sk_function_parms)
3841 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3842 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3843 LOOKUP_ONLYCONVERTING);
3847 DECL_THIS_STATIC (decl) = true;
3848 pushdecl_top_level_and_finish (decl, init);
3855 builtin_function_1 (tree decl, tree context, bool is_global)
3857 tree id = DECL_NAME (decl);
3858 const char *name = IDENTIFIER_POINTER (id);
3860 retrofit_lang_decl (decl);
3862 DECL_ARTIFICIAL (decl) = 1;
3863 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3864 SET_DECL_LANGUAGE (decl, lang_c);
3865 /* Runtime library routines are, by definition, available in an
3866 external shared object. */
3867 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3868 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3870 DECL_CONTEXT (decl) = context;
3873 pushdecl_top_level (decl);
3877 /* A function in the user's namespace should have an explicit
3878 declaration before it is used. Mark the built-in function as
3879 anticipated but not actually declared. */
3880 if (name[0] != '_' || name[1] != '_')
3881 DECL_ANTICIPATED (decl) = 1;
3882 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3884 size_t len = strlen (name);
3886 /* Treat __*_chk fortification functions as anticipated as well,
3887 unless they are __builtin_*. */
3888 if (len > strlen ("___chk")
3889 && memcmp (name + len - strlen ("_chk"),
3890 "_chk", strlen ("_chk") + 1) == 0)
3891 DECL_ANTICIPATED (decl) = 1;
3898 cxx_builtin_function (tree decl)
3900 tree id = DECL_NAME (decl);
3901 const char *name = IDENTIFIER_POINTER (id);
3902 /* All builtins that don't begin with an '_' should additionally
3903 go in the 'std' namespace. */
3906 tree decl2 = copy_node(decl);
3907 push_namespace (std_identifier);
3908 builtin_function_1 (decl2, std_node, false);
3912 return builtin_function_1 (decl, NULL_TREE, false);
3915 /* Like cxx_builtin_function, but guarantee the function is added to the global
3916 scope. This is to allow function specific options to add new machine
3917 dependent builtins when the target ISA changes via attribute((target(...)))
3918 which saves space on program startup if the program does not use non-generic
3922 cxx_builtin_function_ext_scope (tree decl)
3925 tree id = DECL_NAME (decl);
3926 const char *name = IDENTIFIER_POINTER (id);
3927 /* All builtins that don't begin with an '_' should additionally
3928 go in the 'std' namespace. */
3931 tree decl2 = copy_node(decl);
3932 push_namespace (std_identifier);
3933 builtin_function_1 (decl2, std_node, true);
3937 return builtin_function_1 (decl, NULL_TREE, true);
3940 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3941 function. Not called directly. */
3944 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3946 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3947 DECL_EXTERNAL (fn) = 1;
3948 TREE_PUBLIC (fn) = 1;
3949 DECL_ARTIFICIAL (fn) = 1;
3950 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3951 SET_DECL_LANGUAGE (fn, lang_c);
3952 /* Runtime library routines are, by definition, available in an
3953 external shared object. */
3954 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3955 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3959 /* Returns the _DECL for a library function with C linkage.
3960 We assume that such functions never throw; if this is incorrect,
3961 callers should unset TREE_NOTHROW. */
3964 build_library_fn (tree name, tree type)
3966 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3967 TREE_NOTHROW (fn) = 1;
3971 /* Returns the _DECL for a library function with C++ linkage. */
3974 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3976 tree fn = build_library_fn_1 (name, operator_code, type);
3977 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3978 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3979 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3983 /* Like build_library_fn, but takes a C string instead of an
3987 build_library_fn_ptr (const char* name, tree type)
3989 return build_library_fn (get_identifier (name), type);
3992 /* Like build_cp_library_fn, but takes a C string instead of an
3996 build_cp_library_fn_ptr (const char* name, tree type)
3998 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
4001 /* Like build_library_fn, but also pushes the function so that we will
4002 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4003 may throw exceptions listed in RAISES. */
4006 push_library_fn (tree name, tree type, tree raises)
4011 type = build_exception_variant (type, raises);
4013 fn = build_library_fn (name, type);
4014 pushdecl_top_level (fn);
4018 /* Like build_cp_library_fn, but also pushes the function so that it
4019 will be found by normal lookup. */
4022 push_cp_library_fn (enum tree_code operator_code, tree type)
4024 tree fn = build_cp_library_fn (ansi_opname (operator_code),
4029 apply_tm_attr (fn, get_identifier ("transaction_safe"));
4033 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4037 push_void_library_fn (tree name, tree parmtypes)
4039 tree type = build_function_type (void_type_node, parmtypes);
4040 return push_library_fn (name, type, NULL_TREE);
4043 /* Like push_library_fn, but also note that this function throws
4044 and does not return. Used for __throw_foo and the like. */
4047 push_throw_library_fn (tree name, tree type)
4049 tree fn = push_library_fn (name, type, NULL_TREE);
4050 TREE_THIS_VOLATILE (fn) = 1;
4051 TREE_NOTHROW (fn) = 0;
4055 /* When we call finish_struct for an anonymous union, we create
4056 default copy constructors and such. But, an anonymous union
4057 shouldn't have such things; this function undoes the damage to the
4058 anonymous union type T.
4060 (The reason that we create the synthesized methods is that we don't
4061 distinguish `union { int i; }' from `typedef union { int i; } U'.
4062 The first is an anonymous union; the second is just an ordinary
4066 fixup_anonymous_aggr (tree t)
4070 /* Wipe out memory of synthesized methods. */
4071 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
4072 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4073 TYPE_HAS_COPY_CTOR (t) = 0;
4074 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
4075 TYPE_HAS_COPY_ASSIGN (t) = 0;
4076 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
4078 /* Splice the implicitly generated functions out of the TYPE_METHODS
4080 q = &TYPE_METHODS (t);
4083 if (DECL_ARTIFICIAL (*q))
4084 *q = TREE_CHAIN (*q);
4086 q = &DECL_CHAIN (*q);
4089 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4090 if (TYPE_METHODS (t))
4092 tree decl = TYPE_MAIN_DECL (t);
4094 if (TREE_CODE (t) != UNION_TYPE)
4095 error_at (DECL_SOURCE_LOCATION (decl),
4096 "an anonymous struct cannot have function members");
4098 error_at (DECL_SOURCE_LOCATION (decl),
4099 "an anonymous union cannot have function members");
4102 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4103 assignment operators (because they cannot have these methods themselves).
4104 For anonymous unions this is already checked because they are not allowed
4105 in any union, otherwise we have to check it. */
4106 if (TREE_CODE (t) != UNION_TYPE)
4110 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4111 if (TREE_CODE (field) == FIELD_DECL)
4113 type = TREE_TYPE (field);
4114 if (CLASS_TYPE_P (type))
4116 if (TYPE_NEEDS_CONSTRUCTING (type))
4117 error ("member %q+#D with constructor not allowed "
4118 "in anonymous aggregate", field);
4119 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4120 error ("member %q+#D with destructor not allowed "
4121 "in anonymous aggregate", field);
4122 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
4123 error ("member %q+#D with copy assignment operator "
4124 "not allowed in anonymous aggregate", field);
4130 /* Make sure that a declaration with no declarator is well-formed, i.e.
4131 just declares a tagged type or anonymous union.
4133 Returns the type declared; or NULL_TREE if none. */
4136 check_tag_decl (cp_decl_specifier_seq *declspecs)
4138 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend);
4139 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
4140 /* If a class, struct, or enum type is declared by the DECLSPECS
4141 (i.e, if a class-specifier, enum-specifier, or non-typename
4142 elaborated-type-specifier appears in the DECLSPECS),
4143 DECLARED_TYPE is set to the corresponding type. */
4144 tree declared_type = NULL_TREE;
4145 bool error_p = false;
4147 if (declspecs->multiple_types_p)
4148 error ("multiple types in one declaration");
4149 else if (declspecs->redefined_builtin_type)
4151 if (!in_system_header)
4152 permerror (declspecs->locations[ds_redefined_builtin_type_spec],
4153 "redeclaration of C++ built-in type %qT",
4154 declspecs->redefined_builtin_type);
4159 && TYPE_P (declspecs->type)
4160 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
4161 && MAYBE_CLASS_TYPE_P (declspecs->type))
4162 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
4163 declared_type = declspecs->type;
4164 else if (declspecs->type == error_mark_node)
4166 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
4167 permerror (input_location, "declaration does not declare anything");
4168 else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
4170 error ("%<auto%> can only be specified for variables "
4171 "or function declarations");
4172 return error_mark_node;
4174 /* Check for an anonymous union. */
4175 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
4176 && TYPE_ANONYMOUS_P (declared_type))
4178 /* 7/3 In a simple-declaration, the optional init-declarator-list
4179 can be omitted only when declaring a class (clause 9) or
4180 enumeration (7.2), that is, when the decl-specifier-seq contains
4181 either a class-specifier, an elaborated-type-specifier with
4182 a class-key (9.1), or an enum-specifier. In these cases and
4183 whenever a class-specifier or enum-specifier is present in the
4184 decl-specifier-seq, the identifiers in these specifiers are among
4185 the names being declared by the declaration (as class-name,
4186 enum-names, or enumerators, depending on the syntax). In such
4187 cases, and except for the declaration of an unnamed bit-field (9.6),
4188 the decl-specifier-seq shall introduce one or more names into the
4189 program, or shall redeclare a name introduced by a previous
4190 declaration. [Example:
4191 enum { }; // ill-formed
4192 typedef class { }; // ill-formed
4196 error ("missing type-name in typedef-declaration");
4199 /* Anonymous unions are objects, so they can have specifiers. */;
4200 SET_ANON_AGGR_TYPE_P (declared_type);
4202 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
4203 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
4208 if (decl_spec_seq_has_spec_p (declspecs, ds_inline)
4209 || decl_spec_seq_has_spec_p (declspecs, ds_virtual))
4210 error ("%qs can only be specified for functions",
4211 decl_spec_seq_has_spec_p (declspecs, ds_inline)
4212 ? "inline" : "virtual");
4214 && (!current_class_type
4215 || current_scope () != current_class_type))
4216 error ("%<friend%> can only be specified inside a class");
4217 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit))
4218 error ("%<explicit%> can only be specified for constructors");
4219 else if (declspecs->storage_class)
4220 error ("a storage class can only be specified for objects "
4222 else if (decl_spec_seq_has_spec_p (declspecs, ds_const)
4223 || decl_spec_seq_has_spec_p (declspecs, ds_volatile)
4224 || decl_spec_seq_has_spec_p (declspecs, ds_restrict)
4225 || decl_spec_seq_has_spec_p (declspecs, ds_thread))
4226 error ("qualifiers can only be specified for objects "
4228 else if (saw_typedef)
4229 warning (0, "%<typedef%> was ignored in this declaration");
4230 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
4231 error ("%<constexpr%> cannot be used for type declarations");
4234 if (declspecs->attributes && warn_attributes && declared_type)
4237 if (!CLASS_TYPE_P (declared_type)
4238 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
4239 /* For a non-template class, use the name location. */
4240 loc = location_of (declared_type);
4242 /* For a template class (an explicit instantiation), use the
4243 current location. */
4244 loc = input_location;
4245 warning_at (loc, OPT_Wattributes, "attribute ignored in declaration "
4246 "of %q#T", declared_type);
4247 inform (loc, "attribute for %q#T must follow the %qs keyword",
4248 declared_type, class_key_or_enum_as_string (declared_type));
4251 return declared_type;
4254 /* Called when a declaration is seen that contains no names to declare.
4255 If its type is a reference to a structure, union or enum inherited
4256 from a containing scope, shadow that tag name for the current scope
4257 with a forward reference.
4258 If its type defines a new named structure or union
4259 or defines an enum, it is valid but we need not do anything here.
4260 Otherwise, it is an error.
4262 C++: may have to grok the declspecs to learn about static,
4263 complain for anonymous unions.
4265 Returns the TYPE declared -- or NULL_TREE if none. */
4268 shadow_tag (cp_decl_specifier_seq *declspecs)
4270 tree t = check_tag_decl (declspecs);
4275 if (maybe_process_partial_specialization (t) == error_mark_node)
4278 /* This is where the variables in an anonymous union are
4279 declared. An anonymous union declaration looks like:
4281 because there is no declarator after the union, the parser
4282 sends that declaration here. */
4283 if (ANON_AGGR_TYPE_P (t))
4285 fixup_anonymous_aggr (t);
4287 if (TYPE_FIELDS (t))
4289 tree decl = grokdeclarator (/*declarator=*/NULL,
4290 declspecs, NORMAL, 0, NULL);
4291 finish_anon_union (decl);
4298 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4301 groktypename (cp_decl_specifier_seq *type_specifiers,
4302 const cp_declarator *declarator,
4303 bool is_template_arg)
4307 enum decl_context context
4308 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
4309 attrs = type_specifiers->attributes;
4310 type_specifiers->attributes = NULL_TREE;
4311 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
4312 if (attrs && type != error_mark_node)
4314 if (CLASS_TYPE_P (type))
4315 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
4316 "outside of definition", type);
4317 else if (MAYBE_CLASS_TYPE_P (type))
4318 /* A template type parameter or other dependent type. */
4319 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4320 "type %qT without an associated declaration", type);
4322 cplus_decl_attributes (&type, attrs, 0);
4327 /* Process a DECLARATOR for a function-scope variable declaration,
4328 namespace-scope variable declaration, or function declaration.
4329 (Function definitions go through start_function; class member
4330 declarations appearing in the body of the class go through
4331 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4332 If an error occurs, the error_mark_node is returned instead.
4334 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4335 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4336 for an explicitly defaulted function, or SD_DELETED for an explicitly
4337 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4338 implicitly initialized via a default constructor. ATTRIBUTES and
4339 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4341 The scope represented by the context of the returned DECL is pushed
4342 (if it is not the global namespace) and is assigned to
4343 *PUSHED_SCOPE_P. The caller is then responsible for calling
4344 pop_scope on *PUSHED_SCOPE_P if it is set. */
4347 start_decl (const cp_declarator *declarator,
4348 cp_decl_specifier_seq *declspecs,
4351 tree prefix_attributes,
4352 tree *pushed_scope_p)
4360 *pushed_scope_p = NULL_TREE;
4362 /* An object declared as __attribute__((deprecated)) suppresses
4363 warnings of uses of other deprecated items. */
4364 if (lookup_attribute ("deprecated", attributes))
4365 deprecated_state = DEPRECATED_SUPPRESS;
4367 attributes = chainon (attributes, prefix_attributes);
4369 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4372 deprecated_state = DEPRECATED_NORMAL;
4374 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4375 || decl == error_mark_node)
4376 return error_mark_node;
4378 context = CP_DECL_CONTEXT (decl);
4379 if (context != global_namespace)
4380 *pushed_scope_p = push_scope (context);
4383 /* Is it valid for this decl to have an initializer at all?
4384 If not, set INITIALIZED to zero, which will indirectly
4385 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4386 switch (TREE_CODE (decl))
4389 error ("typedef %qD is initialized (use decltype instead)", decl);
4390 return error_mark_node;
4393 if (initialized == SD_DELETED)
4394 /* We'll handle the rest of the semantics later, but we need to
4395 set this now so it's visible to duplicate_decls. */
4396 DECL_DELETED_FN (decl) = 1;
4405 if (! toplevel_bindings_p ()
4406 && DECL_EXTERNAL (decl))
4407 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4409 DECL_EXTERNAL (decl) = 0;
4410 if (toplevel_bindings_p ())
4411 TREE_STATIC (decl) = 1;
4413 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
4415 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
4416 record_key_method_defined (decl);
4418 /* If this is a typedef that names the class for linkage purposes
4419 (7.1.3p8), apply any attributes directly to the type. */
4420 if (TREE_CODE (decl) == TYPE_DECL
4421 && TAGGED_TYPE_P (TREE_TYPE (decl))
4422 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4423 flags = ATTR_FLAG_TYPE_IN_PLACE;
4427 /* Set attributes here so if duplicate decl, will have proper attributes. */
4428 cplus_decl_attributes (&decl, attributes, flags);
4430 /* Dllimported symbols cannot be defined. Static data members (which
4431 can be initialized in-class and dllimported) go through grokfield,
4432 not here, so we don't need to exclude those decls when checking for
4434 if (initialized && DECL_DLLIMPORT_P (decl))
4436 error ("definition of %q#D is marked %<dllimport%>", decl);
4437 DECL_DLLIMPORT_P (decl) = 0;
4440 /* If #pragma weak was used, mark the decl weak now. */
4441 if (!processing_template_decl)
4442 maybe_apply_pragma_weak (decl);
4444 if (TREE_CODE (decl) == FUNCTION_DECL
4445 && DECL_DECLARED_INLINE_P (decl)
4446 && DECL_UNINLINABLE (decl)
4447 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4448 warning (0, "inline function %q+D given attribute noinline", decl);
4450 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
4452 if (TREE_CODE (decl) == VAR_DECL)
4454 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4455 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4456 error ("%q#D is not a static member of %q#T", decl, context);
4459 if (DECL_CONTEXT (field) != context)
4461 if (!same_type_p (DECL_CONTEXT (field), context))
4462 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4463 "to be defined as %<%T::%D%>",
4464 DECL_CONTEXT (field), DECL_NAME (decl),
4465 context, DECL_NAME (decl));
4466 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4468 /* Static data member are tricky; an in-class initialization
4469 still doesn't provide a definition, so the in-class
4470 declaration will have DECL_EXTERNAL set, but will have an
4471 initialization. Thus, duplicate_decls won't warn
4472 about this situation, and so we check here. */
4473 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4474 error ("duplicate initialization of %qD", decl);
4475 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4477 if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr)
4478 && !DECL_DECLARED_CONSTEXPR_P (field))
4479 error ("%qD declared %<constexpr%> outside its class", field);
4484 tree field = check_classfn (context, decl,
4485 (processing_template_decl
4486 > template_class_depth (context))
4487 ? current_template_parms
4489 if (field && field != error_mark_node
4490 && duplicate_decls (decl, field,
4491 /*newdecl_is_friend=*/false))
4495 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4496 DECL_IN_AGGR_P (decl) = 0;
4497 /* Do not mark DECL as an explicit specialization if it was not
4498 already marked as an instantiation; a declaration should
4499 never be marked as a specialization unless we know what
4500 template is being specialized. */
4501 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4503 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4505 /* [temp.expl.spec] An explicit specialization of a static data
4506 member of a template is a definition if the declaration
4507 includes an initializer; otherwise, it is a declaration.
4509 We check for processing_specialization so this only applies
4510 to the new specialization syntax. */
4511 if (!initialized && processing_specialization)
4512 DECL_EXTERNAL (decl) = 1;
4515 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
4516 /* Aliases are definitions. */
4518 permerror (input_location, "declaration of %q#D outside of class is not definition",
4522 was_public = TREE_PUBLIC (decl);
4524 /* Enter this declaration into the symbol table. */
4525 decl = maybe_push_decl (decl);
4527 if (processing_template_decl)
4528 decl = push_template_decl (decl);
4529 if (decl == error_mark_node)
4530 return error_mark_node;
4532 if (TREE_CODE (decl) == VAR_DECL
4533 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4534 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4536 /* This is a const variable with implicit 'static'. Set
4537 DECL_THIS_STATIC so we can tell it from variables that are
4538 !TREE_PUBLIC because of the anonymous namespace. */
4539 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount);
4540 DECL_THIS_STATIC (decl) = 1;
4543 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4544 start_decl_1 (decl, initialized);
4549 /* Process the declaration of a variable DECL. INITIALIZED is true
4550 iff DECL is explicitly initialized. (INITIALIZED is false if the
4551 variable is initialized via an implicitly-called constructor.)
4552 This function must be called for ordinary variables (including, for
4553 example, implicit instantiations of templates), but must not be
4554 called for template declarations. */
4557 start_decl_1 (tree decl, bool initialized)
4561 bool aggregate_definition_p;
4563 gcc_assert (!processing_template_decl);
4565 if (error_operand_p (decl))
4568 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4570 type = TREE_TYPE (decl);
4571 complete_p = COMPLETE_TYPE_P (type);
4572 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4574 /* If an explicit initializer is present, or if this is a definition
4575 of an aggregate, then we need a complete type at this point.
4576 (Scalars are always complete types, so there is nothing to
4577 check.) This code just sets COMPLETE_P; errors (if necessary)
4578 are issued below. */
4579 if ((initialized || aggregate_definition_p)
4581 && COMPLETE_TYPE_P (complete_type (type)))
4584 /* We will not yet have set TREE_READONLY on DECL if the type
4585 was "const", but incomplete, before this point. But, now, we
4586 have a complete type, so we can try again. */
4587 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4591 /* Is it valid for this decl to have an initializer at all? */
4593 /* Don't allow initializations for incomplete types except for
4594 arrays which might be completed by the initialization. */
4596 ; /* A complete type is ok. */
4597 else if (type_uses_auto (type))
4598 ; /* An auto type is ok. */
4599 else if (TREE_CODE (type) != ARRAY_TYPE)
4601 error ("variable %q#D has initializer but incomplete type", decl);
4602 type = TREE_TYPE (decl) = error_mark_node;
4604 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4606 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4607 error ("elements of array %q#D have incomplete type", decl);
4608 /* else we already gave an error in start_decl. */
4611 else if (aggregate_definition_p && !complete_p)
4613 if (type_uses_auto (type))
4614 error ("declaration of %q#D has no initializer", decl);
4616 error ("aggregate %q#D has incomplete type and cannot be defined",
4618 /* Change the type so that assemble_variable will give
4619 DECL an rtl we can live with: (mem (const_int 0)). */
4620 type = TREE_TYPE (decl) = error_mark_node;
4623 /* Create a new scope to hold this declaration if necessary.
4624 Whether or not a new scope is necessary cannot be determined
4625 until after the type has been completed; if the type is a
4626 specialization of a class template it is not until after
4627 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4628 will be set correctly. */
4629 maybe_push_cleanup_level (type);
4632 /* Handle initialization of references. DECL, TYPE, and INIT have the
4633 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4634 but will be set to a new CLEANUP_STMT if a temporary is created
4635 that must be destroyed subsequently.
4637 Returns an initializer expression to use to initialize DECL, or
4638 NULL if the initialization can be performed statically.
4640 Quotes on semantics can be found in ARM 8.4.3. */
4643 grok_reference_init (tree decl, tree type, tree init, int flags)
4645 if (init == NULL_TREE)
4647 if ((DECL_LANG_SPECIFIC (decl) == 0
4648 || DECL_IN_AGGR_P (decl) == 0)
4649 && ! DECL_THIS_EXTERN (decl))
4650 error ("%qD declared as reference but not initialized", decl);
4654 if (TREE_CODE (init) == TREE_LIST)
4655 init = build_x_compound_expr_from_list (init, ELK_INIT,
4656 tf_warning_or_error);
4658 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4659 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4660 /* Note: default conversion is only called in very special cases. */
4661 init = decay_conversion (init, tf_warning_or_error);
4663 /* Convert INIT to the reference type TYPE. This may involve the
4664 creation of a temporary, whose lifetime must be the same as that
4665 of the reference. If so, a DECL_EXPR for the temporary will be
4666 added just after the DECL_EXPR for DECL. That's why we don't set
4667 DECL_INITIAL for local references (instead assigning to them
4668 explicitly); we need to allow the temporary to be initialized
4670 return initialize_reference (type, init, flags,
4671 tf_warning_or_error);
4674 /* Designated initializers in arrays are not supported in GNU C++.
4675 The parser cannot detect this error since it does not know whether
4676 a given brace-enclosed initializer is for a class type or for an
4677 array. This function checks that CE does not use a designated
4678 initializer. If it does, an error is issued. Returns true if CE
4679 is valid, i.e., does not have a designated initializer. */
4682 check_array_designated_initializer (const constructor_elt *ce,
4683 unsigned HOST_WIDE_INT index)
4685 /* Designated initializers for array elements are not supported. */
4688 /* The parser only allows identifiers as designated
4690 if (ce->index == error_mark_node)
4691 error ("name used in a GNU-style designated "
4692 "initializer for an array");
4693 else if (TREE_CODE (ce->index) == INTEGER_CST)
4695 /* A C99 designator is OK if it matches the current index. */
4696 if (TREE_INT_CST_LOW (ce->index) == index)
4699 sorry ("non-trivial designated initializers not supported");
4703 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4704 error ("name %qD used in a GNU-style designated "
4705 "initializer for an array", ce->index);
4713 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4714 array until we finish parsing the initializer. If that's the
4715 situation we're in, update DECL accordingly. */
4718 maybe_deduce_size_from_array_init (tree decl, tree init)
4720 tree type = TREE_TYPE (decl);
4722 if (TREE_CODE (type) == ARRAY_TYPE
4723 && TYPE_DOMAIN (type) == NULL_TREE
4724 && TREE_CODE (decl) != TYPE_DECL)
4726 /* do_default is really a C-ism to deal with tentative definitions.
4727 But let's leave it here to ease the eventual merge. */
4728 int do_default = !DECL_EXTERNAL (decl);
4729 tree initializer = init ? init : DECL_INITIAL (decl);
4732 /* Check that there are no designated initializers in INIT, as
4733 those are not supported in GNU C++, and as the middle-end
4734 will crash if presented with a non-numeric designated
4736 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4738 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4739 constructor_elt *ce;
4741 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
4742 if (!check_array_designated_initializer (ce, i))
4748 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4752 error ("initializer fails to determine size of %qD", decl);
4753 TREE_TYPE (decl) = error_mark_node;
4755 else if (failure == 2)
4759 error ("array size missing in %qD", decl);
4760 TREE_TYPE (decl) = error_mark_node;
4762 /* If a `static' var's size isn't known, make it extern as
4763 well as static, so it does not get allocated. If it's not
4764 `static', then don't mark it extern; finish_incomplete_decl
4765 will give it a default size and it will get allocated. */
4766 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4767 DECL_EXTERNAL (decl) = 1;
4769 else if (failure == 3)
4771 error ("zero-size array %qD", decl);
4772 TREE_TYPE (decl) = error_mark_node;
4776 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4778 relayout_decl (decl);
4782 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4783 any appropriate error messages regarding the layout. */
4786 layout_var_decl (tree decl)
4790 type = TREE_TYPE (decl);
4791 if (type == error_mark_node)
4794 /* If we haven't already layed out this declaration, do so now.
4795 Note that we must not call complete type for an external object
4796 because it's type might involve templates that we are not
4797 supposed to instantiate yet. (And it's perfectly valid to say
4798 `extern X x' for some incomplete type `X'.) */
4799 if (!DECL_EXTERNAL (decl))
4800 complete_type (type);
4801 if (!DECL_SIZE (decl)
4802 && TREE_TYPE (decl) != error_mark_node
4803 && (COMPLETE_TYPE_P (type)
4804 || (TREE_CODE (type) == ARRAY_TYPE
4805 && !TYPE_DOMAIN (type)
4806 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4807 layout_decl (decl, 0);
4809 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4811 /* An automatic variable with an incomplete type: that is an error.
4812 Don't talk about array types here, since we took care of that
4813 message in grokdeclarator. */
4814 error ("storage size of %qD isn%'t known", decl);
4815 TREE_TYPE (decl) = error_mark_node;
4818 /* Keep this code around in case we later want to control debug info
4819 based on whether a type is "used". (jason 1999-11-11) */
4821 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4822 /* Let debugger know it should output info for this type. */
4823 note_debug_info_needed (ttype);
4825 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4826 note_debug_info_needed (DECL_CONTEXT (decl));
4829 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4830 && DECL_SIZE (decl) != NULL_TREE
4831 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4833 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4834 constant_expression_warning (DECL_SIZE (decl));
4837 error ("storage size of %qD isn%'t constant", decl);
4838 TREE_TYPE (decl) = error_mark_node;
4843 /* If a local static variable is declared in an inline function, or if
4844 we have a weak definition, we must endeavor to create only one
4845 instance of the variable at link-time. */
4848 maybe_commonize_var (tree decl)
4850 /* Static data in a function with comdat linkage also has comdat
4852 if (TREE_STATIC (decl)
4853 /* Don't mess with __FUNCTION__. */
4854 && ! DECL_ARTIFICIAL (decl)
4855 && DECL_FUNCTION_SCOPE_P (decl)
4856 && vague_linkage_p (DECL_CONTEXT (decl)))
4860 /* With weak symbols, we simply make the variable COMDAT;
4861 that will cause copies in multiple translations units to
4863 comdat_linkage (decl);
4867 if (DECL_INITIAL (decl) == NULL_TREE
4868 || DECL_INITIAL (decl) == error_mark_node)
4870 /* Without weak symbols, we can use COMMON to merge
4871 uninitialized variables. */
4872 TREE_PUBLIC (decl) = 1;
4873 DECL_COMMON (decl) = 1;
4877 /* While for initialized variables, we must use internal
4878 linkage -- which means that multiple copies will not
4880 TREE_PUBLIC (decl) = 0;
4881 DECL_COMMON (decl) = 0;
4882 warning_at (input_location, 0,
4883 "sorry: semantics of inline function static "
4884 "data %q+#D are wrong (you%'ll wind up "
4885 "with multiple copies)", decl);
4886 warning_at (DECL_SOURCE_LOCATION (decl), 0,
4887 " you can work around this by removing "
4892 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4893 /* Set it up again; we might have set DECL_INITIAL since the last
4895 comdat_linkage (decl);
4898 /* Issue an error message if DECL is an uninitialized const variable. */
4901 check_for_uninitialized_const_var (tree decl)
4903 tree type = strip_array_types (TREE_TYPE (decl));
4905 /* ``Unless explicitly declared extern, a const object does not have
4906 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4908 if (TREE_CODE (decl) == VAR_DECL
4909 && TREE_CODE (type) != REFERENCE_TYPE
4910 && CP_TYPE_CONST_P (type)
4911 && !DECL_INITIAL (decl))
4913 tree field = default_init_uninitialized_part (type);
4917 permerror (DECL_SOURCE_LOCATION (decl),
4918 "uninitialized const %qD", decl);
4920 if (CLASS_TYPE_P (type))
4922 tree defaulted_ctor;
4924 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
4925 "%q#T has no user-provided default constructor", type);
4926 defaulted_ctor = in_class_defaulted_default_constructor (type);
4928 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
4929 "constructor is not user-provided because it is "
4930 "explicitly defaulted in the class body");
4931 inform (0, "and the implicitly-defined constructor does not "
4932 "initialize %q+#D", field);
4937 /* Structure holding the current initializer being processed by reshape_init.
4938 CUR is a pointer to the current element being processed, END is a pointer
4939 after the last element present in the initializer. */
4940 typedef struct reshape_iterator_t
4942 constructor_elt *cur;
4943 constructor_elt *end;
4946 static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
4948 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4949 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4950 initialized. If there are no more such fields, the return value
4954 next_initializable_field (tree field)
4957 && (TREE_CODE (field) != FIELD_DECL
4958 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4959 || DECL_ARTIFICIAL (field)))
4960 field = DECL_CHAIN (field);
4965 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4966 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4967 INTEGER_CST representing the size of the array minus one (the maximum index),
4968 or NULL_TREE if the array was declared without specifying the size. D is
4969 the iterator within the constructor. */
4972 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
4973 tsubst_flags_t complain)
4976 bool sized_array_p = (max_index != NULL_TREE);
4977 unsigned HOST_WIDE_INT max_index_cst = 0;
4978 unsigned HOST_WIDE_INT index;
4980 /* The initializer for an array is always a CONSTRUCTOR. */
4981 new_init = build_constructor (init_list_type_node, NULL);
4985 /* Minus 1 is used for zero sized arrays. */
4986 if (integer_all_onesp (max_index))
4989 if (host_integerp (max_index, 1))
4990 max_index_cst = tree_low_cst (max_index, 1);
4991 /* sizetype is sign extended, not zero extended. */
4993 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4997 /* Loop until there are no more initializers. */
4999 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
5004 check_array_designated_initializer (d->cur, index);
5005 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
5007 if (elt_init == error_mark_node)
5008 return error_mark_node;
5009 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
5010 size_int (index), elt_init);
5011 if (!TREE_CONSTANT (elt_init))
5012 TREE_CONSTANT (new_init) = false;
5018 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5019 Parameters are the same of reshape_init_r. */
5022 reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
5024 tree max_index = NULL_TREE;
5026 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
5028 if (TYPE_DOMAIN (type))
5029 max_index = array_type_nelts (type);
5031 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5034 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5035 Parameters are the same of reshape_init_r. */
5038 reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain)
5040 tree max_index = NULL_TREE;
5042 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
5044 if (COMPOUND_LITERAL_P (d->cur->value))
5046 tree value = d->cur->value;
5047 if (!same_type_p (TREE_TYPE (value), type))
5049 if (complain & tf_error)
5050 error ("invalid type %qT as initializer for a vector of type %qT",
5051 TREE_TYPE (d->cur->value), type);
5052 value = error_mark_node;
5058 /* For a vector, we initialize it as an array of the appropriate size. */
5059 if (TREE_CODE (type) == VECTOR_TYPE)
5060 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
5062 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5065 /* Subroutine of reshape_init_r, processes the initializers for classes
5066 or union. Parameters are the same of reshape_init_r. */
5069 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
5070 tsubst_flags_t complain)
5075 gcc_assert (CLASS_TYPE_P (type));
5077 /* The initializer for a class is always a CONSTRUCTOR. */
5078 new_init = build_constructor (init_list_type_node, NULL);
5079 field = next_initializable_field (TYPE_FIELDS (type));
5085 An initializer for an aggregate member that is an
5086 empty class shall have the form of an empty
5087 initializer-list {}. */
5088 if (!first_initializer_p)
5090 if (complain & tf_error)
5091 error ("initializer for %qT must be brace-enclosed", type);
5092 return error_mark_node;
5097 /* Loop through the initializable fields, gathering initializers. */
5098 while (d->cur != d->end)
5101 constructor_elt *old_cur = d->cur;
5103 /* Handle designated initializers, as an extension. */
5106 if (TREE_CODE (d->cur->index) == INTEGER_CST)
5108 if (complain & tf_error)
5109 error ("%<[%E] =%> used in a GNU-style designated initializer"
5110 " for class %qT", d->cur->index, type);
5111 return error_mark_node;
5114 if (TREE_CODE (d->cur->index) == FIELD_DECL)
5115 /* We already reshaped this. */
5116 gcc_assert (d->cur->index == field);
5118 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
5120 if (!field || TREE_CODE (field) != FIELD_DECL)
5122 if (complain & tf_error)
5123 error ("%qT has no non-static data member named %qD", type,
5125 return error_mark_node;
5129 /* If we processed all the member of the class, we are done. */
5133 field_init = reshape_init_r (TREE_TYPE (field), d,
5134 /*first_initializer_p=*/false, complain);
5135 if (field_init == error_mark_node)
5136 return error_mark_node;
5138 if (d->cur == old_cur && d->cur->index)
5140 /* This can happen with an invalid initializer for a flexible
5141 array member (c++/54441). */
5142 if (complain & tf_error)
5143 error ("invalid initializer for %q#D", field);
5144 return error_mark_node;
5147 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
5151 When a union is initialized with a brace-enclosed
5152 initializer, the braces shall only contain an
5153 initializer for the first member of the union. */
5154 if (TREE_CODE (type) == UNION_TYPE)
5157 field = next_initializable_field (DECL_CHAIN (field));
5163 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5164 designators are not valid; either complain or return true to indicate
5165 that reshape_init_r should return error_mark_node. */
5168 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
5172 if (complain & tf_error)
5173 error ("C99 designator %qE outside aggregate initializer",
5181 /* Subroutine of reshape_init, which processes a single initializer (part of
5182 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5183 iterator within the CONSTRUCTOR which points to the initializer to process.
5184 FIRST_INITIALIZER_P is true if this is the first initializer of the
5185 outermost CONSTRUCTOR node. */
5188 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
5189 tsubst_flags_t complain)
5191 tree init = d->cur->value;
5193 if (error_operand_p (init))
5194 return error_mark_node;
5196 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
5197 && has_designator_problem (d, complain))
5198 return error_mark_node;
5200 if (TREE_CODE (type) == COMPLEX_TYPE)
5202 /* A complex type can be initialized from one or two initializers,
5203 but braces are not elided. */
5205 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5207 if (CONSTRUCTOR_NELTS (init) > 2)
5209 if (complain & tf_error)
5210 error ("too many initializers for %qT", type);
5212 return error_mark_node;
5215 else if (first_initializer_p && d->cur != d->end)
5217 VEC(constructor_elt, gc) *v = 0;
5218 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
5219 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
5220 if (has_designator_problem (d, complain))
5221 return error_mark_node;
5223 init = build_constructor (init_list_type_node, v);
5228 /* A non-aggregate type is always initialized with a single
5230 if (!CP_AGGREGATE_TYPE_P (type))
5232 /* It is invalid to initialize a non-aggregate type with a
5233 brace-enclosed initializer before C++0x.
5234 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5235 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5236 a CONSTRUCTOR (with a record type). */
5237 if (TREE_CODE (init) == CONSTRUCTOR
5238 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
5240 if (SCALAR_TYPE_P (type))
5242 if (complain & tf_error)
5243 error ("braces around scalar initializer for type %qT", type);
5244 init = error_mark_node;
5247 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5256 All implicit type conversions (clause _conv_) are considered when
5257 initializing the aggregate member with an initializer from an
5258 initializer-list. If the initializer can initialize a member,
5259 the member is initialized. Otherwise, if the member is itself a
5260 non-empty subaggregate, brace elision is assumed and the
5261 initializer is considered for the initialization of the first
5262 member of the subaggregate. */
5263 if (TREE_CODE (init) != CONSTRUCTOR
5264 /* But don't try this for the first initializer, since that would be
5265 looking through the outermost braces; A a2 = { a1 }; is not a
5266 valid aggregate initialization. */
5267 && !first_initializer_p
5268 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
5269 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL,
5276 /* [dcl.init.string]
5278 A char array (whether plain char, signed char, or unsigned char)
5279 can be initialized by a string-literal (optionally enclosed in
5280 braces); a wchar_t array can be initialized by a wide
5281 string-literal (optionally enclosed in braces). */
5282 if (TREE_CODE (type) == ARRAY_TYPE
5283 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
5285 tree str_init = init;
5287 /* Strip one level of braces if and only if they enclose a single
5288 element (as allowed by [dcl.init.string]). */
5289 if (!first_initializer_p
5290 && TREE_CODE (str_init) == CONSTRUCTOR
5291 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
5293 str_init = VEC_index (constructor_elt,
5294 CONSTRUCTOR_ELTS (str_init), 0).value;
5297 /* If it's a string literal, then it's the initializer for the array
5298 as a whole. Otherwise, continue with normal initialization for
5299 array types (one value per array element). */
5300 if (TREE_CODE (str_init) == STRING_CST)
5302 if (has_designator_problem (d, complain))
5303 return error_mark_node;
5309 /* The following cases are about aggregates. If we are not within a full
5310 initializer already, and there is not a CONSTRUCTOR, it means that there
5311 is a missing set of braces (that is, we are processing the case for
5312 which reshape_init exists). */
5313 if (!first_initializer_p)
5315 if (TREE_CODE (init) == CONSTRUCTOR)
5317 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
5318 /* There is no need to reshape pointer-to-member function
5319 initializers, as they are always constructed correctly
5320 by the front end. */
5322 else if (COMPOUND_LITERAL_P (init))
5323 /* For a nested compound literal, there is no need to reshape since
5324 brace elision is not allowed. Even if we decided to allow it,
5325 we should add a call to reshape_init in finish_compound_literal,
5326 before calling digest_init, so changing this code would still
5327 not be necessary. */
5328 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
5332 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5333 return reshape_init (type, init, complain);
5337 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
5341 /* Dispatch to specialized routines. */
5342 if (CLASS_TYPE_P (type))
5343 return reshape_init_class (type, d, first_initializer_p, complain);
5344 else if (TREE_CODE (type) == ARRAY_TYPE)
5345 return reshape_init_array (type, d, complain);
5346 else if (TREE_CODE (type) == VECTOR_TYPE)
5347 return reshape_init_vector (type, d, complain);
5352 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5353 brace-enclosed aggregate initializer.
5355 INIT is the CONSTRUCTOR containing the list of initializers describing
5356 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5357 It may not presently match the shape of the TYPE; for example:
5359 struct S { int a; int b; };
5360 struct S a[] = { 1, 2, 3, 4 };
5362 Here INIT will hold a VEC of four elements, rather than a
5363 VEC of two elements, each itself a VEC of two elements. This
5364 routine transforms INIT from the former form into the latter. The
5365 revised CONSTRUCTOR node is returned. */
5368 reshape_init (tree type, tree init, tsubst_flags_t complain)
5370 VEC(constructor_elt, gc) *v;
5374 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5376 v = CONSTRUCTOR_ELTS (init);
5378 /* An empty constructor does not need reshaping, and it is always a valid
5380 if (VEC_empty (constructor_elt, v))
5383 /* Recurse on this CONSTRUCTOR. */
5384 d.cur = &VEC_index (constructor_elt, v, 0);
5385 d.end = d.cur + VEC_length (constructor_elt, v);
5387 new_init = reshape_init_r (type, &d, true, complain);
5388 if (new_init == error_mark_node)
5389 return error_mark_node;
5391 /* Make sure all the element of the constructor were used. Otherwise,
5392 issue an error about exceeding initializers. */
5395 if (complain & tf_error)
5396 error ("too many initializers for %qT", type);
5398 return error_mark_node;
5404 /* Verify array initializer. Returns true if errors have been reported. */
5407 check_array_initializer (tree decl, tree type, tree init)
5409 tree element_type = TREE_TYPE (type);
5411 /* The array type itself need not be complete, because the
5412 initializer may tell us how many elements are in the array.
5413 But, the elements of the array must be complete. */
5414 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5417 error ("elements of array %q#D have incomplete type", decl);
5419 error ("elements of array %q#T have incomplete type", type);
5422 /* It is not valid to initialize a VLA. */
5424 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5425 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5428 error ("variable-sized object %qD may not be initialized", decl);
5430 error ("variable-sized compound literal");
5436 /* Subroutine of check_initializer; args are passed down from that function.
5437 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5440 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5443 gcc_assert (stmts_are_full_exprs_p ());
5444 return build_aggr_init (decl, init, flags, tf_warning_or_error);
5447 /* Verify INIT (the initializer for DECL), and record the
5448 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5449 grok_reference_init.
5451 If the return value is non-NULL, it is an expression that must be
5452 evaluated dynamically to initialize DECL. */
5455 check_initializer (tree decl, tree init, int flags, VEC(tree,gc) **cleanups)
5457 tree type = TREE_TYPE (decl);
5458 tree init_code = NULL;
5459 tree extra_init = NULL_TREE;
5462 /* Things that are going to be initialized need to have complete
5464 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5466 if (DECL_HAS_VALUE_EXPR_P (decl))
5468 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5469 it doesn't have storage to be initialized. */
5470 gcc_assert (init == NULL_TREE);
5474 if (type == error_mark_node)
5475 /* We will have already complained. */
5478 if (TREE_CODE (type) == ARRAY_TYPE)
5480 if (check_array_initializer (decl, type, init))
5483 else if (!COMPLETE_TYPE_P (type))
5485 error ("%q#D has incomplete type", decl);
5486 TREE_TYPE (decl) = error_mark_node;
5490 /* There is no way to make a variable-sized class type in GNU C++. */
5491 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5493 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5495 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5496 if (SCALAR_TYPE_P (type))
5500 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5501 init = build_zero_init (type, NULL_TREE, false);
5503 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
5505 error ("scalar object %qD requires one element in initializer",
5507 TREE_TYPE (decl) = error_mark_node;
5513 if (TREE_CODE (decl) == CONST_DECL)
5515 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5517 DECL_INITIAL (decl) = init;
5519 gcc_assert (init != NULL_TREE);
5522 else if (!init && DECL_REALLY_EXTERN (decl))
5524 else if (init || type_build_ctor_call (type)
5525 || TREE_CODE (type) == REFERENCE_TYPE)
5527 if (TREE_CODE (type) == REFERENCE_TYPE)
5529 init = grok_reference_init (decl, type, init, flags);
5530 flags |= LOOKUP_ALREADY_DIGESTED;
5533 check_for_uninitialized_const_var (decl);
5534 /* Do not reshape constructors of vectors (they don't need to be
5536 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
5538 if (is_std_init_list (type))
5540 init = perform_implicit_conversion (type, init,
5541 tf_warning_or_error);
5542 flags |= LOOKUP_ALREADY_DIGESTED;
5544 else if (TYPE_NON_AGGREGATE_CLASS (type))
5546 /* Don't reshape if the class has constructors. */
5547 if (cxx_dialect == cxx98)
5548 error ("in C++98 %qD must be initialized by constructor, "
5552 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5554 error ("opaque vector types cannot be initialized");
5555 init = error_mark_node;
5559 init = reshape_init (type, init, tf_warning_or_error);
5560 if (SCALAR_TYPE_P (type))
5561 check_narrowing (type, init);
5565 /* If DECL has an array type without a specific bound, deduce the
5566 array size from the initializer. */
5567 maybe_deduce_size_from_array_init (decl, init);
5568 type = TREE_TYPE (decl);
5569 if (type == error_mark_node)
5572 if ((type_build_ctor_call (type) || CLASS_TYPE_P (type))
5573 && !(flags & LOOKUP_ALREADY_DIGESTED)
5574 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
5575 && CP_AGGREGATE_TYPE_P (type)))
5577 init_code = build_aggr_init_full_exprs (decl, init, flags);
5579 /* If this is a constexpr initializer, expand_default_init will
5580 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5581 case, pull the initializer back out and pass it down into
5582 store_init_value. */
5583 while (TREE_CODE (init_code) == EXPR_STMT
5584 || TREE_CODE (init_code) == CONVERT_EXPR)
5585 init_code = TREE_OPERAND (init_code, 0);
5586 if (TREE_CODE (init_code) == INIT_EXPR)
5588 init = TREE_OPERAND (init_code, 1);
5589 init_code = NULL_TREE;
5590 /* Don't call digest_init; it's unnecessary and will complain
5591 about aggregate initialization of non-aggregate classes. */
5592 flags |= LOOKUP_ALREADY_DIGESTED;
5594 else if (DECL_DECLARED_CONSTEXPR_P (decl))
5596 /* Declared constexpr, but no suitable initializer; massage
5597 init appropriately so we can pass it into store_init_value
5599 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5600 init = finish_compound_literal (type, init,
5601 tf_warning_or_error);
5602 else if (CLASS_TYPE_P (type)
5603 && (!init || TREE_CODE (init) == TREE_LIST))
5605 init = build_functional_cast (type, init, tf_none);
5606 if (init != error_mark_node)
5607 TARGET_EXPR_DIRECT_INIT_P (init) = true;
5609 init_code = NULL_TREE;
5615 if (init && TREE_CODE (init) != TREE_VEC)
5617 /* In aggregate initialization of a variable, each element
5618 initialization is a full-expression because there is no
5619 enclosing expression. */
5620 gcc_assert (stmts_are_full_exprs_p ());
5622 init_code = store_init_value (decl, init, cleanups, flags);
5624 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5625 && DECL_INITIAL (decl)
5626 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5627 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5628 warning (0, "array %qD initialized by parenthesized string literal %qE",
5629 decl, DECL_INITIAL (decl));
5635 if (CLASS_TYPE_P (core_type = strip_array_types (type))
5636 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
5637 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
5638 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
5641 check_for_uninitialized_const_var (decl);
5644 if (init && init != error_mark_node)
5645 init_code = build2 (INIT_EXPR, type, decl, init);
5648 init_code = add_stmt_to_compound (extra_init, init_code);
5650 if (init_code && DECL_IN_AGGR_P (decl))
5652 static int explained = 0;
5654 if (cxx_dialect < cxx0x)
5655 error ("initializer invalid for static member with constructor");
5657 error ("non-constant in-class initialization invalid for static "
5658 "member %qD", decl);
5661 error ("(an out of class initialization is required)");
5669 /* If DECL is not a local variable, give it RTL. */
5672 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5674 int toplev = toplevel_bindings_p ();
5676 const char *filename;
5678 /* Set the DECL_ASSEMBLER_NAME for the object. */
5681 /* The `register' keyword, when used together with an
5682 asm-specification, indicates that the variable should be
5683 placed in a particular register. */
5684 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5686 set_user_assembler_name (decl, asmspec);
5687 DECL_HARD_REGISTER (decl) = 1;
5691 if (TREE_CODE (decl) == FUNCTION_DECL
5692 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5693 set_builtin_user_assembler_name (decl, asmspec);
5694 set_user_assembler_name (decl, asmspec);
5698 /* Handle non-variables up front. */
5699 if (TREE_CODE (decl) != VAR_DECL)
5701 rest_of_decl_compilation (decl, toplev, at_eof);
5705 /* If we see a class member here, it should be a static data
5707 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5709 gcc_assert (TREE_STATIC (decl));
5710 /* An in-class declaration of a static data member should be
5711 external; it is only a declaration, and not a definition. */
5712 if (init == NULL_TREE)
5713 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5716 /* We don't create any RTL for local variables. */
5717 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5720 /* We defer emission of local statics until the corresponding
5721 DECL_EXPR is expanded. */
5722 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5724 /* We try to defer namespace-scope static constants so that they are
5725 not emitted into the object file unnecessarily. */
5726 filename = input_filename;
5727 if (!DECL_VIRTUAL_P (decl)
5728 && TREE_READONLY (decl)
5729 && DECL_INITIAL (decl) != NULL_TREE
5730 && DECL_INITIAL (decl) != error_mark_node
5732 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5734 && !TREE_PUBLIC (decl))
5736 /* Fool with the linkage of static consts according to #pragma
5738 struct c_fileinfo *finfo = get_fileinfo (filename);
5739 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5741 TREE_PUBLIC (decl) = 1;
5742 DECL_EXTERNAL (decl) = finfo->interface_only;
5747 /* Likewise for template instantiations. */
5748 else if (DECL_LANG_SPECIFIC (decl)
5749 && DECL_IMPLICIT_INSTANTIATION (decl))
5752 /* If we're not deferring, go ahead and assemble the variable. */
5754 rest_of_decl_compilation (decl, toplev, at_eof);
5757 /* walk_tree helper for wrap_temporary_cleanups, below. */
5760 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5762 /* Stop at types or full-expression boundaries. */
5763 if (TYPE_P (*stmt_p)
5764 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
5770 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5772 tree guard = (tree)data;
5773 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5775 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5776 /* Tell honor_protect_cleanup_actions to handle this as a separate
5778 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5780 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5786 /* We're initializing a local variable which has a cleanup GUARD. If there
5787 are any temporaries used in the initializer INIT of this variable, we
5788 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5789 variable will be cleaned up properly if one of them throws.
5791 Unfortunately, there's no way to express this properly in terms of
5792 nesting, as the regions for the temporaries overlap the region for the
5793 variable itself; if there are two temporaries, the variable needs to be
5794 the first thing destroyed if either of them throws. However, we only
5795 want to run the variable's cleanup if it actually got constructed. So
5796 we need to guard the temporary cleanups with the variable's cleanup if
5797 they are run on the normal path, but not if they are run on the
5798 exceptional path. We implement this by telling
5799 honor_protect_cleanup_actions to strip the variable cleanup from the
5800 exceptional path. */
5803 wrap_temporary_cleanups (tree init, tree guard)
5805 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5808 /* Generate code to initialize DECL (a local variable). */
5811 initialize_local_var (tree decl, tree init)
5813 tree type = TREE_TYPE (decl);
5817 gcc_assert (TREE_CODE (decl) == VAR_DECL
5818 || TREE_CODE (decl) == RESULT_DECL);
5819 gcc_assert (!TREE_STATIC (decl));
5821 if (DECL_SIZE (decl) == NULL_TREE)
5823 /* If we used it already as memory, it must stay in memory. */
5824 DECL_INITIAL (decl) = NULL_TREE;
5825 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5829 if (type == error_mark_node)
5832 /* Compute and store the initial value. */
5833 already_used = TREE_USED (decl) || TREE_USED (type);
5834 if (TREE_USED (type))
5835 DECL_READ_P (decl) = 1;
5837 /* Generate a cleanup, if necessary. */
5838 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
5840 /* Perform the initialization. */
5843 if (TREE_CODE (init) == INIT_EXPR
5844 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init, 1)))
5846 /* Stick simple initializers in DECL_INITIAL so that
5847 -Wno-init-self works (c++/34772). */
5848 gcc_assert (TREE_OPERAND (init, 0) == decl);
5849 DECL_INITIAL (decl) = TREE_OPERAND (init, 1);
5853 int saved_stmts_are_full_exprs_p;
5855 /* If we're only initializing a single object, guard the
5856 destructors of any temporaries used in its initializer with
5857 its destructor. This isn't right for arrays because each
5858 element initialization is a full-expression. */
5859 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5860 wrap_temporary_cleanups (init, cleanup);
5862 gcc_assert (building_stmt_list_p ());
5863 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5864 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5865 finish_expr_stmt (init);
5866 current_stmt_tree ()->stmts_are_full_exprs_p =
5867 saved_stmts_are_full_exprs_p;
5871 /* Set this to 0 so we can tell whether an aggregate which was
5872 initialized was ever used. Don't do this if it has a
5873 destructor, so we don't complain about the 'resource
5874 allocation is initialization' idiom. Now set
5875 attribute((unused)) on types so decls of that type will be
5876 marked used. (see TREE_USED, above.) */
5877 if (TYPE_NEEDS_CONSTRUCTING (type)
5879 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5880 && DECL_NAME (decl))
5881 TREE_USED (decl) = 0;
5882 else if (already_used)
5883 TREE_USED (decl) = 1;
5886 finish_decl_cleanup (decl, cleanup);
5889 /* DECL is a VAR_DECL for a compiler-generated variable with static
5890 storage duration (like a virtual table) whose initializer is a
5891 compile-time constant. Initialize the variable and provide it to the
5895 initialize_artificial_var (tree decl, VEC(constructor_elt,gc) *v)
5898 gcc_assert (DECL_ARTIFICIAL (decl));
5899 init = build_constructor (TREE_TYPE (decl), v);
5900 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5901 DECL_INITIAL (decl) = init;
5902 DECL_INITIALIZED_P (decl) = 1;
5903 determine_visibility (decl);
5904 layout_var_decl (decl);
5905 maybe_commonize_var (decl);
5906 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5909 /* INIT is the initializer for a variable, as represented by the
5910 parser. Returns true iff INIT is type-dependent. */
5913 type_dependent_init_p (tree init)
5915 if (TREE_CODE (init) == TREE_LIST)
5916 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5917 return any_type_dependent_elements_p (init);
5918 else if (TREE_CODE (init) == CONSTRUCTOR)
5919 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5921 VEC(constructor_elt, gc) *elts;
5925 elts = CONSTRUCTOR_ELTS (init);
5926 nelts = VEC_length (constructor_elt, elts);
5927 for (i = 0; i < nelts; ++i)
5928 if (type_dependent_init_p (VEC_index (constructor_elt,
5933 /* It must be a simple expression, e.g., int i = 3; */
5934 return type_dependent_expression_p (init);
5939 /* INIT is the initializer for a variable, as represented by the
5940 parser. Returns true iff INIT is value-dependent. */
5943 value_dependent_init_p (tree init)
5945 if (TREE_CODE (init) == TREE_LIST)
5946 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5947 return any_value_dependent_elements_p (init);
5948 else if (TREE_CODE (init) == CONSTRUCTOR)
5949 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5951 VEC(constructor_elt, gc) *elts;
5955 elts = CONSTRUCTOR_ELTS (init);
5956 nelts = VEC_length (constructor_elt, elts);
5957 for (i = 0; i < nelts; ++i)
5958 if (value_dependent_init_p (VEC_index (constructor_elt,
5963 /* It must be a simple expression, e.g., int i = 3; */
5964 return value_dependent_expression_p (init);
5969 /* Finish processing of a declaration;
5970 install its line number and initial value.
5971 If the length of an array type is not known before,
5972 it must be determined now, from the initial value, or it is an error.
5974 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5975 true, then INIT is an integral constant expression.
5977 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5978 if the (init) syntax was used. */
5981 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5982 tree asmspec_tree, int flags)
5985 VEC(tree,gc) *cleanups = NULL;
5986 const char *asmspec = NULL;
5987 int was_readonly = 0;
5988 bool var_definition_p = false;
5991 if (decl == error_mark_node)
5996 error ("assignment (not initialization) in declaration");
6000 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6001 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6002 gcc_assert (TREE_CODE (decl) != PARM_DECL);
6004 type = TREE_TYPE (decl);
6005 if (type == error_mark_node)
6008 /* If a name was specified, get the string. */
6009 if (at_namespace_scope_p ())
6010 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
6011 if (asmspec_tree && asmspec_tree != error_mark_node)
6012 asmspec = TREE_STRING_POINTER (asmspec_tree);
6014 if (current_class_type
6015 && CP_DECL_CONTEXT (decl) == current_class_type
6016 && TYPE_BEING_DEFINED (current_class_type)
6017 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
6018 && (DECL_INITIAL (decl) || init))
6019 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6021 if (TREE_CODE (decl) != FUNCTION_DECL
6022 && (auto_node = type_uses_auto (type)))
6025 if (init == NULL_TREE)
6027 error ("declaration of %q#D has no initializer", decl);
6028 TREE_TYPE (decl) = error_mark_node;
6032 if (TREE_CODE (d_init) == TREE_LIST)
6033 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT,
6034 tf_warning_or_error);
6035 d_init = resolve_nondeduced_context (d_init);
6036 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init,
6038 if (type == error_mark_node)
6042 if (!ensure_literal_type_for_constexpr_object (decl))
6043 DECL_DECLARED_CONSTEXPR_P (decl) = 0;
6045 if (TREE_CODE (decl) == VAR_DECL
6046 && DECL_CLASS_SCOPE_P (decl)
6047 && DECL_INITIALIZED_IN_CLASS_P (decl))
6048 check_static_variable_definition (decl, type);
6050 if (init && TREE_CODE (decl) == FUNCTION_DECL)
6053 if (init == ridpointers[(int)RID_DELETE])
6055 /* FIXME check this is 1st decl. */
6056 DECL_DELETED_FN (decl) = 1;
6057 DECL_DECLARED_INLINE_P (decl) = 1;
6058 DECL_INITIAL (decl) = error_mark_node;
6059 FOR_EACH_CLONE (clone, decl)
6061 DECL_DELETED_FN (clone) = 1;
6062 DECL_DECLARED_INLINE_P (clone) = 1;
6063 DECL_INITIAL (clone) = error_mark_node;
6067 else if (init == ridpointers[(int)RID_DEFAULT])
6069 if (defaultable_fn_check (decl))
6070 DECL_DEFAULTED_FN (decl) = 1;
6072 DECL_INITIAL (decl) = NULL_TREE;
6076 if (init && TREE_CODE (decl) == VAR_DECL)
6078 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
6079 /* If DECL is a reference, then we want to know whether init is a
6080 reference constant; init_const_expr_p as passed tells us whether
6081 it's an rvalue constant. */
6082 if (TREE_CODE (type) == REFERENCE_TYPE)
6083 init_const_expr_p = potential_constant_expression (init);
6084 if (init_const_expr_p)
6086 /* Set these flags now for templates. We'll update the flags in
6087 store_init_value for instantiations. */
6088 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
6089 if (decl_maybe_constant_var_p (decl))
6090 TREE_CONSTANT (decl) = 1;
6094 if (processing_template_decl)
6096 bool type_dependent_p;
6098 /* Add this declaration to the statement-tree. */
6099 if (at_function_scope_p ())
6100 add_decl_expr (decl);
6102 type_dependent_p = dependent_type_p (type);
6104 if (check_for_bare_parameter_packs (init))
6107 DECL_INITIAL (decl) = NULL_TREE;
6110 /* Generally, initializers in templates are expanded when the
6111 template is instantiated. But, if DECL is a variable constant
6112 then it can be used in future constant expressions, so its value
6113 must be available. */
6115 if (TREE_CODE (decl) != VAR_DECL || dependent_type_p (type))
6116 /* We can't do anything if the decl has dependent type. */;
6118 && init_const_expr_p
6119 && !type_dependent_p
6120 && decl_maybe_constant_var_p (decl)
6121 && !type_dependent_init_p (init)
6122 && !value_dependent_init_p (init))
6124 /* This variable seems to be a non-dependent constant, so process
6125 its initializer. If check_initializer returns non-null the
6126 initialization wasn't constant after all. */
6128 cleanups = make_tree_vector ();
6129 init_code = check_initializer (decl, init, flags, &cleanups);
6130 if (init_code == NULL_TREE)
6132 release_tree_vector (cleanups);
6134 else if (!DECL_PRETTY_FUNCTION_P (decl))
6136 /* Deduce array size even if the initializer is dependent. */
6137 maybe_deduce_size_from_array_init (decl, init);
6138 /* And complain about multiple initializers. */
6139 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
6140 && !MAYBE_CLASS_TYPE_P (type))
6141 init = build_x_compound_expr_from_list (init, ELK_INIT,
6142 tf_warning_or_error);
6146 DECL_INITIAL (decl) = init;
6150 /* Just store non-static data member initializers for later. */
6151 if (init && TREE_CODE (decl) == FIELD_DECL)
6152 DECL_INITIAL (decl) = init;
6154 /* Take care of TYPE_DECLs up front. */
6155 if (TREE_CODE (decl) == TYPE_DECL)
6157 if (type != error_mark_node
6158 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
6160 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6161 warning (0, "shadowing previous type declaration of %q#D", decl);
6162 set_identifier_type_value (DECL_NAME (decl), decl);
6165 /* If we have installed this as the canonical typedef for this
6166 type, and that type has not been defined yet, delay emitting
6167 the debug information for it, as we will emit it later. */
6168 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6169 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
6170 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6172 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl),
6177 /* A reference will be modified here, as it is initialized. */
6178 if (! DECL_EXTERNAL (decl)
6179 && TREE_READONLY (decl)
6180 && TREE_CODE (type) == REFERENCE_TYPE)
6183 TREE_READONLY (decl) = 0;
6186 if (TREE_CODE (decl) == VAR_DECL)
6188 /* Only variables with trivial initialization and destruction can
6189 have thread-local storage. */
6190 if (DECL_THREAD_LOCAL_P (decl)
6191 && (type_has_nontrivial_default_init (TREE_TYPE (decl))
6192 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
6193 error ("%qD cannot be thread-local because it has non-trivial "
6194 "type %qT", decl, TREE_TYPE (decl));
6195 /* If this is a local variable that will need a mangled name,
6196 register it now. We must do this before processing the
6197 initializer for the variable, since the initialization might
6198 require a guard variable, and since the mangled name of the
6199 guard variable will depend on the mangled name of this
6201 if (DECL_FUNCTION_SCOPE_P (decl)
6202 && TREE_STATIC (decl)
6203 && !DECL_ARTIFICIAL (decl))
6205 push_local_name (decl);
6206 if (DECL_CONSTRUCTOR_P (current_function_decl)
6207 || DECL_DESTRUCTOR_P (current_function_decl))
6208 /* Normally local_decls is populated during GIMPLE lowering,
6209 but [cd]tors are never actually compiled directly. We need
6210 to put statics on the list so we can deal with the label
6211 address extension. FIXME. */
6212 add_local_decl (cfun, decl);
6215 /* Convert the initializer to the type of DECL, if we have not
6216 already initialized DECL. */
6217 if (!DECL_INITIALIZED_P (decl)
6218 /* If !DECL_EXTERNAL then DECL is being defined. In the
6219 case of a static data member initialized inside the
6220 class-specifier, there can be an initializer even if DECL
6221 is *not* defined. */
6222 && (!DECL_EXTERNAL (decl) || init))
6224 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6227 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6228 /* Allow libjava/prims.cc define primitive classes. */
6229 if (init != NULL_TREE
6230 || jclass == NULL_TREE
6231 || TREE_CODE (jclass) != TYPE_DECL
6232 || !POINTER_TYPE_P (TREE_TYPE (jclass))
6233 || !same_type_ignoring_top_level_qualifiers_p
6234 (type, TREE_TYPE (TREE_TYPE (jclass))))
6235 error ("Java object %qD not allocated with %<new%>", decl);
6238 cleanups = make_tree_vector ();
6239 init = check_initializer (decl, init, flags, &cleanups);
6240 /* Thread-local storage cannot be dynamically initialized. */
6241 if (DECL_THREAD_LOCAL_P (decl) && init)
6243 error ("%qD is thread-local and so cannot be dynamically "
6244 "initialized", decl);
6248 /* Check that the initializer for a static data member was a
6249 constant. Although we check in the parser that the
6250 initializer is an integral constant expression, we do not
6251 simplify division-by-zero at the point at which it
6252 occurs. Therefore, in:
6254 struct S { static const int i = 7 / 0; };
6256 we issue an error at this point. It would
6257 probably be better to forbid division by zero in
6258 integral constant expressions. */
6259 if (DECL_EXTERNAL (decl) && init)
6261 error ("%qD cannot be initialized by a non-constant expression"
6262 " when being declared", decl);
6263 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
6271 The memory occupied by any object of static storage
6272 duration is zero-initialized at program startup before
6273 any other initialization takes place.
6275 We cannot create an appropriate initializer until after
6276 the type of DECL is finalized. If DECL_INITIAL is set,
6277 then the DECL is statically initialized, and any
6278 necessary zero-initialization has already been performed. */
6279 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
6280 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
6281 /*nelts=*/NULL_TREE,
6282 /*static_storage_p=*/true);
6283 /* Remember that the initialization for this variable has
6285 DECL_INITIALIZED_P (decl) = 1;
6286 /* This declaration is the definition of this variable,
6287 unless we are initializing a static data member within
6288 the class specifier. */
6289 if (!DECL_EXTERNAL (decl))
6290 var_definition_p = true;
6292 /* If the variable has an array type, lay out the type, even if
6293 there is no initializer. It is valid to index through the
6294 array, and we must get TYPE_ALIGN set correctly on the array
6296 else if (TREE_CODE (type) == ARRAY_TYPE)
6299 if (TREE_STATIC (decl)
6300 && !at_function_scope_p ()
6301 && current_function_decl == NULL)
6302 /* So decl is a global variable or a static member of a
6303 non local class. Record the types it uses
6304 so that we can decide later to emit debug info for them. */
6305 record_types_used_by_current_var_decl (decl);
6307 else if (TREE_CODE (decl) == FIELD_DECL
6308 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6309 error ("non-static data member %qD has Java class type", decl);
6311 /* Add this declaration to the statement-tree. This needs to happen
6312 after the call to check_initializer so that the DECL_EXPR for a
6313 reference temp is added before the DECL_EXPR for the reference itself. */
6314 if (DECL_FUNCTION_SCOPE_P (decl))
6315 add_decl_expr (decl);
6317 /* Let the middle end know about variables and functions -- but not
6318 static data members in uninstantiated class templates. */
6319 if (TREE_CODE (decl) == VAR_DECL
6320 || TREE_CODE (decl) == FUNCTION_DECL)
6322 if (TREE_CODE (decl) == VAR_DECL)
6324 layout_var_decl (decl);
6325 maybe_commonize_var (decl);
6328 /* This needs to happen after the linkage is set. */
6329 determine_visibility (decl);
6331 if (var_definition_p && TREE_STATIC (decl))
6333 /* If a TREE_READONLY variable needs initialization
6334 at runtime, it is no longer readonly and we need to
6335 avoid MEM_READONLY_P being set on RTL created for it. */
6338 if (TREE_READONLY (decl))
6339 TREE_READONLY (decl) = 0;
6342 else if (was_readonly)
6343 TREE_READONLY (decl) = 1;
6346 make_rtl_for_nonlocal_decl (decl, init, asmspec);
6348 /* Check for abstractness of the type. Notice that there is no
6349 need to strip array types here since the check for those types
6350 is already done within create_array_type_for_decl. */
6351 if (TREE_CODE (type) == FUNCTION_TYPE
6352 || TREE_CODE (type) == METHOD_TYPE)
6353 abstract_virtuals_error (decl, TREE_TYPE (type));
6355 abstract_virtuals_error (decl, type);
6357 if (TREE_TYPE (decl) == error_mark_node)
6358 /* No initialization required. */
6360 else if (TREE_CODE (decl) == FUNCTION_DECL)
6364 if (init == ridpointers[(int)RID_DEFAULT])
6366 /* An out-of-class default definition is defined at
6367 the point where it is explicitly defaulted. */
6368 if (DECL_DELETED_FN (decl))
6369 maybe_explain_implicit_delete (decl);
6370 else if (DECL_INITIAL (decl) == error_mark_node)
6371 synthesize_method (decl);
6374 error ("function %q#D is initialized like a variable", decl);
6376 /* else no initialization required. */
6378 else if (DECL_EXTERNAL (decl)
6379 && ! (DECL_LANG_SPECIFIC (decl)
6380 && DECL_NOT_REALLY_EXTERN (decl)))
6383 DECL_INITIAL (decl) = init;
6385 /* A variable definition. */
6386 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6387 /* Initialize the local variable. */
6388 initialize_local_var (decl, init);
6390 /* If a variable is defined, and then a subsequent
6391 definition with external linkage is encountered, we will
6392 get here twice for the same variable. We want to avoid
6393 calling expand_static_init more than once. For variables
6394 that are not static data members, we can call
6395 expand_static_init only when we actually process the
6396 initializer. It is not legal to redeclare a static data
6397 member, so this issue does not arise in that case. */
6398 else if (var_definition_p && TREE_STATIC (decl))
6399 expand_static_init (decl, init);
6402 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6403 reference, insert it in the statement-tree now. */
6407 FOR_EACH_VEC_ELT (tree, cleanups, i, t)
6408 push_cleanup (decl, t, false);
6409 release_tree_vector (cleanups);
6413 TREE_READONLY (decl) = 1;
6415 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
6418 /* Returns a declaration for a VAR_DECL as if:
6420 extern "C" TYPE NAME;
6422 had been seen. Used to create compiler-generated global
6426 declare_global_var (tree name, tree type)
6430 push_to_top_level ();
6431 decl = build_decl (input_location, VAR_DECL, name, type);
6432 TREE_PUBLIC (decl) = 1;
6433 DECL_EXTERNAL (decl) = 1;
6434 DECL_ARTIFICIAL (decl) = 1;
6435 /* If the user has explicitly declared this variable (perhaps
6436 because the code we are compiling is part of a low-level runtime
6437 library), then it is possible that our declaration will be merged
6438 with theirs by pushdecl. */
6439 decl = pushdecl (decl);
6440 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
6441 pop_from_top_level ();
6446 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6447 if "__cxa_atexit" is not being used) corresponding to the function
6448 to be called when the program exits. */
6451 get_atexit_fn_ptr_type (void)
6455 if (!atexit_fn_ptr_type_node)
6458 if (flag_use_cxa_atexit
6459 && !targetm.cxx.use_atexit_for_cxa_atexit ())
6460 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6461 arg_type = ptr_type_node;
6463 /* The parameter to "atexit" is "void (*)(void)". */
6464 arg_type = NULL_TREE;
6466 fn_type = build_function_type_list (void_type_node,
6467 arg_type, NULL_TREE);
6468 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
6471 return atexit_fn_ptr_type_node;
6474 /* Returns a pointer to the `atexit' function. Note that if
6475 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6476 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6479 get_atexit_node (void)
6485 bool use_aeabi_atexit;
6490 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6492 /* The declaration for `__cxa_atexit' is:
6494 int __cxa_atexit (void (*)(void *), void *, void *)
6496 We build up the argument types and then the function type
6498 tree argtype0, argtype1, argtype2;
6500 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
6501 /* First, build the pointer-to-function type for the first
6503 fn_ptr_type = get_atexit_fn_ptr_type ();
6504 /* Then, build the rest of the argument types. */
6505 argtype2 = ptr_type_node;
6506 if (use_aeabi_atexit)
6508 argtype1 = fn_ptr_type;
6509 argtype0 = ptr_type_node;
6513 argtype1 = ptr_type_node;
6514 argtype0 = fn_ptr_type;
6516 /* And the final __cxa_atexit type. */
6517 fn_type = build_function_type_list (integer_type_node,
6518 argtype0, argtype1, argtype2,
6520 if (use_aeabi_atexit)
6521 name = "__aeabi_atexit";
6523 name = "__cxa_atexit";
6527 /* The declaration for `atexit' is:
6529 int atexit (void (*)());
6531 We build up the argument types and then the function type
6533 fn_ptr_type = get_atexit_fn_ptr_type ();
6534 /* Build the final atexit type. */
6535 fn_type = build_function_type_list (integer_type_node,
6536 fn_ptr_type, NULL_TREE);
6540 /* Now, build the function declaration. */
6541 push_lang_context (lang_name_c);
6542 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6543 mark_used (atexit_fndecl);
6544 pop_lang_context ();
6545 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error);
6550 /* Returns the __dso_handle VAR_DECL. */
6553 get_dso_handle_node (void)
6555 if (dso_handle_node)
6556 return dso_handle_node;
6558 /* Declare the variable. */
6559 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6562 #ifdef HAVE_GAS_HIDDEN
6563 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN;
6564 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1;
6567 return dso_handle_node;
6570 /* Begin a new function with internal linkage whose job will be simply
6571 to destroy some particular variable. */
6573 static GTY(()) int start_cleanup_cnt;
6576 start_cleanup_fn (void)
6581 bool use_cxa_atexit = flag_use_cxa_atexit
6582 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6584 push_to_top_level ();
6586 /* No need to mangle this. */
6587 push_lang_context (lang_name_c);
6589 /* Build the name of the function. */
6590 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6591 /* Build the function declaration. */
6592 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6593 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6594 /* It's a function with internal linkage, generated by the
6596 TREE_PUBLIC (fndecl) = 0;
6597 DECL_ARTIFICIAL (fndecl) = 1;
6598 /* Make the function `inline' so that it is only emitted if it is
6599 actually needed. It is unlikely that it will be inlined, since
6600 it is only called via a function pointer, but we avoid unnecessary
6601 emissions this way. */
6602 DECL_DECLARED_INLINE_P (fndecl) = 1;
6603 DECL_INTERFACE_KNOWN (fndecl) = 1;
6604 /* Build the parameter. */
6609 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6610 DECL_CONTEXT (parmdecl) = fndecl;
6611 TREE_USED (parmdecl) = 1;
6612 DECL_READ_P (parmdecl) = 1;
6613 DECL_ARGUMENTS (fndecl) = parmdecl;
6617 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6619 pop_lang_context ();
6621 return current_function_decl;
6624 /* Finish the cleanup function begun by start_cleanup_fn. */
6627 end_cleanup_fn (void)
6629 expand_or_defer_fn (finish_function (0));
6631 pop_from_top_level ();
6634 /* Generate code to handle the destruction of DECL, an object with
6635 static storage duration. */
6638 register_dtor_fn (tree decl)
6645 tree arg0, arg1 = NULL_TREE, arg2 = NULL_TREE;
6647 type = TREE_TYPE (decl);
6648 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6649 return void_zero_node;
6651 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6652 a class object, we can just pass the destructor to
6653 "__cxa_atexit"; we don't have to build a temporary function to do
6655 use_dtor = (flag_use_cxa_atexit
6656 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6657 && CLASS_TYPE_P (type));
6662 /* Find the destructor. */
6663 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6664 gcc_assert (idx >= 0);
6665 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6666 /* Make sure it is accessible. */
6667 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup,
6668 tf_warning_or_error);
6672 /* Call build_cleanup before we enter the anonymous function so
6673 that any access checks will be done relative to the current
6674 scope, rather than the scope of the anonymous function. */
6675 build_cleanup (decl);
6677 /* Now start the function. */
6678 cleanup = start_cleanup_fn ();
6680 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6681 to the original function, rather than the anonymous one. That
6682 will make the back end think that nested functions are in use,
6683 which causes confusion. */
6684 push_deferring_access_checks (dk_no_check);
6685 fcall = build_cleanup (decl);
6686 pop_deferring_access_checks ();
6688 /* Create the body of the anonymous function. */
6689 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6690 finish_expr_stmt (fcall);
6691 finish_compound_stmt (compound_stmt);
6695 /* Call atexit with the cleanup function. */
6696 mark_used (cleanup);
6697 cleanup = build_address (cleanup);
6698 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6704 /* We must convert CLEANUP to the type that "__cxa_atexit"
6706 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6707 /* "__cxa_atexit" will pass the address of DECL to the
6708 cleanup function. */
6710 addr = build_address (decl);
6711 /* The declared type of the parameter to "__cxa_atexit" is
6712 "void *". For plain "T*", we could just let the
6713 machinery in cp_build_function_call convert it -- but if the
6714 type is "cv-qualified T *", then we need to convert it
6715 before passing it in, to avoid spurious errors. */
6716 addr = build_nop (ptr_type_node, addr);
6719 /* Since the cleanup functions we build ignore the address
6720 they're given, there's no reason to pass the actual address
6721 in, and, in general, it's cheaper to pass NULL than any
6723 addr = null_pointer_node;
6724 arg2 = cp_build_addr_expr (get_dso_handle_node (),
6725 tf_warning_or_error);
6726 if (targetm.cxx.use_aeabi_atexit ())
6739 return cp_build_function_call_nary (get_atexit_node (), tf_warning_or_error,
6740 arg0, arg1, arg2, NULL_TREE);
6743 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6744 is its initializer. Generate code to handle the construction
6745 and destruction of DECL. */
6748 expand_static_init (tree decl, tree init)
6750 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6751 gcc_assert (TREE_STATIC (decl));
6753 /* Some variables require no dynamic initialization. */
6755 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6758 if (DECL_FUNCTION_SCOPE_P (decl))
6760 /* Emit code to perform this initialization but once. */
6761 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6762 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6763 tree guard, guard_addr;
6766 /* Emit code to perform this initialization but once. This code
6769 static <type> guard;
6770 if (!guard.first_byte) {
6771 if (__cxa_guard_acquire (&guard)) {
6774 // Do initialization.
6775 flag = true; __cxa_guard_release (&guard);
6776 // Register variable for destruction at end of program.
6778 if (!flag) __cxa_guard_abort (&guard);
6782 Note that the `flag' variable is only set to 1 *after* the
6783 initialization is complete. This ensures that an exception,
6784 thrown during the construction, will cause the variable to
6785 reinitialized when we pass through this code again, as per:
6789 If the initialization exits by throwing an exception, the
6790 initialization is not complete, so it will be tried again
6791 the next time control enters the declaration.
6793 This process should be thread-safe, too; multiple threads
6794 should not be able to initialize the variable more than
6797 /* Create the guard variable. */
6798 guard = get_guard (decl);
6800 /* This optimization isn't safe on targets with relaxed memory
6801 consistency. On such targets we force synchronization in
6802 __cxa_guard_acquire. */
6803 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6805 /* Begin the conditional initialization. */
6806 if_stmt = begin_if_stmt ();
6807 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6808 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6811 if (flag_threadsafe_statics)
6813 tree vfntype = NULL_TREE;
6814 tree acquire_name, release_name, abort_name;
6815 tree acquire_fn, release_fn, abort_fn;
6816 guard_addr = build_address (guard);
6818 acquire_name = get_identifier ("__cxa_guard_acquire");
6819 release_name = get_identifier ("__cxa_guard_release");
6820 abort_name = get_identifier ("__cxa_guard_abort");
6821 acquire_fn = identifier_global_value (acquire_name);
6822 release_fn = identifier_global_value (release_name);
6823 abort_fn = identifier_global_value (abort_name);
6825 acquire_fn = push_library_fn
6826 (acquire_name, build_function_type_list (integer_type_node,
6827 TREE_TYPE (guard_addr),
6830 if (!release_fn || !abort_fn)
6831 vfntype = build_function_type_list (void_type_node,
6832 TREE_TYPE (guard_addr),
6835 release_fn = push_library_fn (release_name, vfntype, NULL_TREE);
6837 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE);
6839 inner_if_stmt = begin_if_stmt ();
6840 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6843 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6844 begin = get_target_expr (boolean_false_node);
6845 flag = TARGET_EXPR_SLOT (begin);
6847 TARGET_EXPR_CLEANUP (begin)
6848 = build3 (COND_EXPR, void_type_node, flag,
6850 build_call_n (abort_fn, 1, guard_addr));
6851 CLEANUP_EH_ONLY (begin) = 1;
6853 /* Do the initialization itself. */
6854 init = add_stmt_to_compound (begin, init);
6855 init = add_stmt_to_compound
6856 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6857 init = add_stmt_to_compound
6858 (init, build_call_n (release_fn, 1, guard_addr));
6861 init = add_stmt_to_compound (init, set_guard (guard));
6863 /* Use atexit to register a function for destroying this static
6865 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6867 finish_expr_stmt (init);
6869 if (flag_threadsafe_statics)
6871 finish_compound_stmt (inner_then_clause);
6872 finish_then_clause (inner_if_stmt);
6873 finish_if_stmt (inner_if_stmt);
6876 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6878 finish_compound_stmt (then_clause);
6879 finish_then_clause (if_stmt);
6880 finish_if_stmt (if_stmt);
6884 static_aggregates = tree_cons (init, decl, static_aggregates);
6888 /* Make TYPE a complete type based on INITIAL_VALUE.
6889 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6890 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6891 3 if the initializer list is empty (in pedantic mode). */
6894 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6897 tree type, elt_type;
6901 unsigned HOST_WIDE_INT i;
6904 /* An array of character type can be initialized from a
6905 brace-enclosed string constant.
6907 FIXME: this code is duplicated from reshape_init. Probably
6908 we should just call reshape_init here? */
6909 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6910 && TREE_CODE (initial_value) == CONSTRUCTOR
6911 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6913 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6914 tree value = VEC_index (constructor_elt, v, 0).value;
6916 if (TREE_CODE (value) == STRING_CST
6917 && VEC_length (constructor_elt, v) == 1)
6918 initial_value = value;
6921 /* If any of the elements are parameter packs, we can't actually
6922 complete this type now because the array size is dependent. */
6923 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6925 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6928 if (PACK_EXPANSION_P (value))
6934 failure = complete_array_type (ptype, initial_value, do_default);
6936 /* We can create the array before the element type is complete, which
6937 means that we didn't have these two bits set in the original type
6938 either. In completing the type, we are expected to propagate these
6939 bits. See also complete_type which does the same thing for arrays
6942 if (TYPE_DOMAIN (type))
6944 elt_type = TREE_TYPE (type);
6945 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6946 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6947 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6953 /* As above, but either give an error or reject zero-size arrays, depending
6957 cp_complete_array_type_or_error (tree *ptype, tree initial_value,
6958 bool do_default, tsubst_flags_t complain)
6961 bool sfinae = !(complain & tf_error);
6962 /* In SFINAE context we can't be lenient about zero-size arrays. */
6965 failure = cp_complete_array_type (ptype, initial_value, do_default);
6971 /* Not an error. */;
6972 else if (failure == 1)
6973 error ("initializer fails to determine size of %qT", *ptype);
6974 else if (failure == 2)
6977 error ("array size missing in %qT", *ptype);
6979 else if (failure == 3)
6980 error ("zero-size array %qT", *ptype);
6981 *ptype = error_mark_node;
6986 /* Return zero if something is declared to be a member of type
6987 CTYPE when in the context of CUR_TYPE. STRING is the error
6988 message to print in that case. Otherwise, quietly return 1. */
6991 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6993 if (ctype && ctype != cur_type)
6995 if (flags == DTOR_FLAG)
6996 error ("destructor for alien class %qT cannot be a member", ctype);
6998 error ("constructor for alien class %qT cannot be a member", ctype);
7004 /* Subroutine of `grokdeclarator'. */
7006 /* Generate errors possibly applicable for a given set of specifiers.
7007 This is for ARM $7.1.2. */
7010 bad_specifiers (tree object,
7011 enum bad_spec_place type,
7022 error ("%qD declared as a %<virtual%> variable", object);
7024 error ("%qD declared as an %<inline%> variable", object);
7026 error ("%<const%> and %<volatile%> function specifiers on "
7027 "%qD invalid in variable declaration", object);
7031 error ("%qD declared as a %<virtual%> parameter", object);
7033 error ("%qD declared as an %<inline%> parameter", object);
7035 error ("%<const%> and %<volatile%> function specifiers on "
7036 "%qD invalid in parameter declaration", object);
7040 error ("%qD declared as a %<virtual%> type", object);
7042 error ("%qD declared as an %<inline%> type", object);
7044 error ("%<const%> and %<volatile%> function specifiers on "
7045 "%qD invalid in type declaration", object);
7049 error ("%qD declared as a %<virtual%> field", object);
7051 error ("%qD declared as an %<inline%> field", object);
7053 error ("%<const%> and %<volatile%> function specifiers on "
7054 "%qD invalid in field declaration", object);
7060 error ("%q+D declared as a friend", object);
7062 && (TREE_CODE (object) == TYPE_DECL
7063 || (!TYPE_PTRFN_P (TREE_TYPE (object))
7064 && !TYPE_REFFN_P (TREE_TYPE (object))
7065 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
7066 error ("%q+D declared with an exception specification", object);
7069 /* DECL is a member function or static data member and is presently
7070 being defined. Check that the definition is taking place in a
7074 check_class_member_definition_namespace (tree decl)
7076 /* These checks only apply to member functions and static data
7078 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
7079 || TREE_CODE (decl) == VAR_DECL);
7080 /* We check for problems with specializations in pt.c in
7081 check_specialization_namespace, where we can issue better
7083 if (processing_specialization)
7085 /* There are no restrictions on the placement of
7086 explicit instantiations. */
7087 if (processing_explicit_instantiation)
7091 A member function definition that appears outside of the
7092 class definition shall appear in a namespace scope enclosing
7093 the class definition.
7097 The definition for a static data member shall appear in a
7098 namespace scope enclosing the member's class definition. */
7099 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
7100 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
7101 decl, DECL_CONTEXT (decl));
7104 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7105 METHOD_TYPE for a non-static member function; QUALS are the
7106 cv-qualifiers that apply to the function. */
7109 build_this_parm (tree type, cp_cv_quals quals)
7114 cp_cv_quals this_quals;
7116 if (CLASS_TYPE_P (type))
7119 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT);
7120 this_type = build_pointer_type (this_type);
7123 this_type = type_of_this_parm (type);
7124 /* The `this' parameter is implicitly `const'; it cannot be
7126 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
7127 qual_type = cp_build_qualified_type (this_type, this_quals);
7128 parm = build_artificial_parm (this_identifier, qual_type);
7129 cp_apply_type_quals_to_decl (this_quals, parm);
7133 /* DECL is a static member function. Complain if it was declared
7134 with function-cv-quals. */
7137 check_static_quals (tree decl, cp_cv_quals quals)
7139 if (quals != TYPE_UNQUALIFIED)
7140 error ("static member function %q#D declared with type qualifiers",
7144 /* CTYPE is class type, or null if non-class.
7145 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7147 DECLARATOR is the function's name.
7148 PARMS is a chain of PARM_DECLs for the function.
7149 VIRTUALP is truthvalue of whether the function is virtual or not.
7150 FLAGS are to be passed through to `grokclassfn'.
7151 QUALS are qualifiers indicating whether the function is `const'
7153 RAISES is a list of exceptions that this function can raise.
7154 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7155 not look, and -1 if we should not call `grokclassfn' at all.
7157 SFK is the kind of special function (if any) for the new function.
7159 Returns `NULL_TREE' if something goes wrong, after issuing
7160 applicable error messages. */
7163 grokfndecl (tree ctype,
7167 tree orig_declarator,
7169 enum overload_flags flags,
7176 special_function_kind sfk,
7181 location_t location)
7184 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7188 type = build_exception_variant (type, raises);
7190 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7192 /* If we have an explicit location, use it, otherwise use whatever
7193 build_lang_decl used (probably input_location). */
7194 if (location != UNKNOWN_LOCATION)
7195 DECL_SOURCE_LOCATION (decl) = location;
7197 if (TREE_CODE (type) == METHOD_TYPE)
7200 parm = build_this_parm (type, quals);
7201 DECL_CHAIN (parm) = parms;
7204 DECL_ARGUMENTS (decl) = parms;
7205 for (t = parms; t; t = DECL_CHAIN (t))
7206 DECL_CONTEXT (t) = decl;
7207 /* Propagate volatile out from type to decl. */
7208 if (TYPE_VOLATILE (type))
7209 TREE_THIS_VOLATILE (decl) = 1;
7211 /* Setup decl according to sfk. */
7214 case sfk_constructor:
7215 case sfk_copy_constructor:
7216 case sfk_move_constructor:
7217 DECL_CONSTRUCTOR_P (decl) = 1;
7219 case sfk_destructor:
7220 DECL_DESTRUCTOR_P (decl) = 1;
7226 /* If pointers to member functions use the least significant bit to
7227 indicate whether a function is virtual, ensure a pointer
7228 to this function will have that bit clear. */
7229 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
7230 && TREE_CODE (type) == METHOD_TYPE
7231 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
7232 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
7235 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7239 ("defining explicit specialization %qD in friend declaration",
7243 tree fns = TREE_OPERAND (orig_declarator, 0);
7244 tree args = TREE_OPERAND (orig_declarator, 1);
7246 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7248 /* Something like `template <class T> friend void f<T>()'. */
7249 error ("invalid use of template-id %qD in declaration "
7250 "of primary template",
7256 /* A friend declaration of the form friend void f<>(). Record
7257 the information in the TEMPLATE_ID_EXPR. */
7258 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7260 if (TREE_CODE (fns) == COMPONENT_REF)
7262 /* Due to bison parser ickiness, we will have already looked
7263 up an operator_name or PFUNCNAME within the current class
7264 (see template_id in parse.y). If the current class contains
7265 such a name, we'll get a COMPONENT_REF here. Undo that. */
7267 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
7268 == current_class_type);
7269 fns = TREE_OPERAND (fns, 1);
7271 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
7272 || TREE_CODE (fns) == OVERLOAD);
7273 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
7275 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7276 if (TREE_PURPOSE (t)
7277 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7279 error ("default arguments are not allowed in declaration "
7280 "of friend template specialization %qD",
7287 error ("%<inline%> is not allowed in declaration of friend "
7288 "template specialization %qD",
7295 /* If this decl has namespace scope, set that up. */
7297 set_decl_namespace (decl, in_namespace, friendp);
7299 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
7301 /* `main' and builtins have implicit 'C' linkage. */
7302 if ((MAIN_NAME_P (declarator)
7303 || (IDENTIFIER_LENGTH (declarator) > 10
7304 && IDENTIFIER_POINTER (declarator)[0] == '_'
7305 && IDENTIFIER_POINTER (declarator)[1] == '_'
7306 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
7307 && current_lang_name == lang_name_cplusplus
7308 && ctype == NULL_TREE
7309 && DECL_FILE_SCOPE_P (decl))
7310 SET_DECL_LANGUAGE (decl, lang_c);
7312 /* Should probably propagate const out from type to decl I bet (mrs). */
7315 DECL_STATIC_FUNCTION_P (decl) = 1;
7316 DECL_CONTEXT (decl) = ctype;
7321 DECL_CONTEXT (decl) = ctype;
7323 check_class_member_definition_namespace (decl);
7326 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7328 if (processing_template_decl)
7329 error ("cannot declare %<::main%> to be a template");
7331 error ("cannot declare %<::main%> to be inline");
7333 error ("cannot declare %<::main%> to be static");
7338 /* Members of anonymous types and local classes have no linkage; make
7339 them internal. If a typedef is made later, this will be changed. */
7340 if (ctype && (TYPE_ANONYMOUS_P (ctype)
7341 || decl_function_context (TYPE_MAIN_DECL (ctype))))
7344 if (publicp && cxx_dialect == cxx98)
7346 /* [basic.link]: A name with no linkage (notably, the name of a class
7347 or enumeration declared in a local scope) shall not be used to
7348 declare an entity with linkage.
7350 DR 757 relaxes this restriction for C++0x. */
7351 t = no_linkage_check (TREE_TYPE (decl),
7352 /*relaxed_p=*/false);
7355 if (TYPE_ANONYMOUS_P (t))
7357 if (DECL_EXTERN_C_P (decl))
7358 /* Allow this; it's pretty common in C. */;
7361 permerror (input_location, "anonymous type with no linkage "
7362 "used to declare function %q#D with linkage",
7364 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7365 permerror (input_location, "%q+#D does not refer to the unqualified "
7366 "type, so it is not used for linkage",
7371 permerror (input_location, "type %qT with no linkage used to "
7372 "declare function %q#D with linkage", t, decl);
7376 TREE_PUBLIC (decl) = publicp;
7379 DECL_INTERFACE_KNOWN (decl) = 1;
7380 DECL_NOT_REALLY_EXTERN (decl) = 1;
7383 /* If the declaration was declared inline, mark it as such. */
7385 DECL_DECLARED_INLINE_P (decl) = 1;
7387 DECL_DECLARED_CONSTEXPR_P (decl) = true;
7389 DECL_EXTERNAL (decl) = 1;
7390 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
7393 ? G_("static member function %qD cannot have cv-qualifier")
7394 : G_("non-member function %qD cannot have cv-qualifier"),
7396 quals = TYPE_UNQUALIFIED;
7399 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
7400 && !grok_op_properties (decl, /*complain=*/true))
7402 else if (UDLIT_OPER_P (DECL_NAME (decl)))
7404 bool long_long_unsigned_p;
7406 const char *suffix = NULL;
7407 /* [over.literal]/6: Literal operators shall not have C linkage. */
7408 if (DECL_LANGUAGE (decl) == lang_c)
7410 error ("literal operator with C linkage");
7414 if (DECL_NAMESPACE_SCOPE_P (decl))
7416 if (!check_literal_operator_args (decl, &long_long_unsigned_p,
7419 error ("%qD has invalid argument list", decl);
7423 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
7424 if (long_long_unsigned_p)
7426 if (cpp_interpret_int_suffix (suffix, strlen (suffix)))
7427 warning (0, "integer suffix %<%s%>"
7428 " shadowed by implementation", suffix);
7430 else if (long_double_p)
7432 if (cpp_interpret_float_suffix (suffix, strlen (suffix)))
7433 warning (0, "floating point suffix %<%s%>"
7434 " shadowed by implementation", suffix);
7439 error ("%qD must be a non-member function", decl);
7445 /* Make the init_value nonzero so pushdecl knows this is not
7446 tentative. error_mark_node is replaced later with the BLOCK. */
7447 DECL_INITIAL (decl) = error_mark_node;
7449 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
7450 TREE_NOTHROW (decl) = 1;
7452 /* Caller will do the rest of this. */
7456 if (ctype != NULL_TREE)
7457 grokclassfn (ctype, decl, flags);
7460 if (cxx_dialect >= cxx0x
7461 && DECL_DESTRUCTOR_P (decl)
7462 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl))
7463 && !processing_template_decl)
7464 deduce_noexcept_on_destructor (decl);
7466 decl = check_explicit_specialization (orig_declarator, decl,
7469 4 * (friendp != 0));
7470 if (decl == error_mark_node)
7473 if (DECL_STATIC_FUNCTION_P (decl))
7474 check_static_quals (decl, quals);
7478 cplus_decl_attributes (&decl, *attrlist, 0);
7479 *attrlist = NULL_TREE;
7482 /* Check main's type after attributes have been applied. */
7483 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7485 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
7488 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
7490 error ("%<::main%> must return %<int%>");
7491 newtype = build_function_type (integer_type_node, oldtypeargs);
7492 TREE_TYPE (decl) = newtype;
7495 check_main_parameter_types (decl);
7498 if (ctype != NULL_TREE
7499 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
7502 tree old_decl = check_classfn (ctype, decl,
7503 (processing_template_decl
7504 > template_class_depth (ctype))
7505 ? current_template_parms
7508 if (old_decl == error_mark_node)
7516 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
7517 /* Because grokfndecl is always supposed to return a
7518 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7519 here. We depend on our callers to figure out that its
7520 really a template that's being returned. */
7521 old_decl = DECL_TEMPLATE_RESULT (old_decl);
7523 if (DECL_STATIC_FUNCTION_P (old_decl)
7524 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7526 /* Remove the `this' parm added by grokclassfn. */
7527 revert_static_member_fn (decl);
7528 check_static_quals (decl, quals);
7530 if (DECL_ARTIFICIAL (old_decl))
7532 error ("definition of implicitly-declared %qD", old_decl);
7535 else if (DECL_DEFAULTED_FN (old_decl))
7537 error ("definition of explicitly-defaulted %q+D", decl);
7538 error ("%q+#D explicitly defaulted here", old_decl);
7542 /* Since we've smashed OLD_DECL to its
7543 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7544 if (TREE_CODE (decl) == TEMPLATE_DECL)
7545 decl = DECL_TEMPLATE_RESULT (decl);
7547 /* Attempt to merge the declarations. This can fail, in
7548 the case of some invalid specialization declarations. */
7549 pushed_scope = push_scope (ctype);
7550 ok = duplicate_decls (decl, old_decl, friendp);
7552 pop_scope (pushed_scope);
7555 error ("no %q#D member function declared in class %qT",
7563 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
7566 if (ctype == NULL_TREE || check)
7570 DECL_VIRTUAL_P (decl) = 1;
7575 /* decl is a FUNCTION_DECL.
7576 specifiers are the parsed virt-specifiers.
7578 Set flags to reflect the virt-specifiers.
7583 set_virt_specifiers (tree decl, cp_virt_specifiers specifiers)
7585 if (decl == NULL_TREE)
7587 if (specifiers & VIRT_SPEC_OVERRIDE)
7588 DECL_OVERRIDE_P (decl) = 1;
7589 if (specifiers & VIRT_SPEC_FINAL)
7590 DECL_FINAL_P (decl) = 1;
7594 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7595 the linkage that DECL will receive in the object file. */
7598 set_linkage_for_static_data_member (tree decl)
7600 /* A static data member always has static storage duration and
7601 external linkage. Note that static data members are forbidden in
7602 local classes -- the only situation in which a class has
7603 non-external linkage. */
7604 TREE_PUBLIC (decl) = 1;
7605 TREE_STATIC (decl) = 1;
7606 /* For non-template classes, static data members are always put
7607 out in exactly those files where they are defined, just as
7608 with ordinary namespace-scope variables. */
7609 if (!processing_template_decl)
7610 DECL_INTERFACE_KNOWN (decl) = 1;
7613 /* Create a VAR_DECL named NAME with the indicated TYPE.
7615 If SCOPE is non-NULL, it is the class type or namespace containing
7616 the variable. If SCOPE is NULL, the variable should is created in
7617 the innermost enclosings scope. */
7620 grokvardecl (tree type,
7622 const cp_decl_specifier_seq *declspecs,
7628 tree explicit_scope;
7630 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
7632 /* Compute the scope in which to place the variable, but remember
7633 whether or not that scope was explicitly specified by the user. */
7634 explicit_scope = scope;
7637 /* An explicit "extern" specifier indicates a namespace-scope
7639 if (declspecs->storage_class == sc_extern)
7640 scope = current_decl_namespace ();
7641 else if (!at_function_scope_p ())
7642 scope = current_scope ();
7646 && (/* If the variable is a namespace-scope variable declared in a
7647 template, we need DECL_LANG_SPECIFIC. */
7648 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
7649 /* Similarly for namespace-scope variables with language linkage
7651 || (TREE_CODE (scope) == NAMESPACE_DECL
7652 && current_lang_name != lang_name_cplusplus)
7653 /* Similarly for static data members. */
7655 decl = build_lang_decl (VAR_DECL, name, type);
7657 decl = build_decl (input_location, VAR_DECL, name, type);
7659 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
7660 set_decl_namespace (decl, explicit_scope, 0);
7662 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
7664 if (declspecs->storage_class == sc_extern)
7666 DECL_THIS_EXTERN (decl) = 1;
7667 DECL_EXTERNAL (decl) = !initialized;
7670 if (DECL_CLASS_SCOPE_P (decl))
7672 set_linkage_for_static_data_member (decl);
7673 /* This function is only called with out-of-class definitions. */
7674 DECL_EXTERNAL (decl) = 0;
7675 check_class_member_definition_namespace (decl);
7677 /* At top level, either `static' or no s.c. makes a definition
7678 (perhaps tentative), and absence of `static' makes it public. */
7679 else if (toplevel_bindings_p ())
7681 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
7682 && (DECL_THIS_EXTERN (decl) || ! constp));
7683 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
7685 /* Not at top level, only `static' makes a static definition. */
7688 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
7689 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7692 if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
7693 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
7695 /* If the type of the decl has no linkage, make sure that we'll
7696 notice that in mark_used. */
7697 if (cxx_dialect > cxx98
7698 && decl_linkage (decl) != lk_none
7699 && DECL_LANG_SPECIFIC (decl) == NULL
7700 && !DECL_EXTERN_C_P (decl)
7701 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
7702 retrofit_lang_decl (decl);
7704 if (TREE_PUBLIC (decl))
7706 /* [basic.link]: A name with no linkage (notably, the name of a class
7707 or enumeration declared in a local scope) shall not be used to
7708 declare an entity with linkage.
7710 DR 757 relaxes this restriction for C++0x. */
7711 tree t = (cxx_dialect > cxx98 ? NULL_TREE
7712 : no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false));
7715 if (TYPE_ANONYMOUS_P (t))
7717 if (DECL_EXTERN_C_P (decl))
7718 /* Allow this; it's pretty common in C. */
7722 /* DRs 132, 319 and 389 seem to indicate types with
7723 no linkage can only be used to declare extern "C"
7724 entities. Since it's not always an error in the
7725 ISO C++ 90 Standard, we only issue a warning. */
7726 warning (0, "anonymous type with no linkage used to declare "
7727 "variable %q#D with linkage", decl);
7728 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7729 warning (0, "%q+#D does not refer to the unqualified "
7730 "type, so it is not used for linkage",
7735 warning (0, "type %qT with no linkage used to declare variable "
7736 "%q#D with linkage", t, decl);
7740 DECL_INTERFACE_KNOWN (decl) = 1;
7745 /* Create and return a canonical pointer to member function type, for
7746 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7749 build_ptrmemfunc_type (tree type)
7753 tree unqualified_variant = NULL_TREE;
7755 if (type == error_mark_node)
7758 /* If a canonical type already exists for this type, use it. We use
7759 this method instead of type_hash_canon, because it only does a
7760 simple equality check on the list of field members. */
7762 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7765 /* Make sure that we always have the unqualified pointer-to-member
7767 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7769 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7771 t = make_class_type (RECORD_TYPE);
7772 xref_basetypes (t, NULL_TREE);
7774 /* Let the front end know this is a pointer to member function... */
7775 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7776 /* ... and not really a class type. */
7777 SET_CLASS_TYPE_P (t, 0);
7779 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
7782 field = build_decl (input_location, FIELD_DECL, delta_identifier,
7784 DECL_CHAIN (field) = fields;
7787 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7789 /* Zap out the name so that the back end will give us the debugging
7790 information for this anonymous RECORD_TYPE. */
7791 TYPE_NAME (t) = NULL_TREE;
7793 /* If this is not the unqualified form of this pointer-to-member
7794 type, set the TYPE_MAIN_VARIANT for this type to be the
7795 unqualified type. Since they are actually RECORD_TYPEs that are
7796 not variants of each other, we must do this manually.
7797 As we just built a new type there is no need to do yet another copy. */
7798 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7800 int type_quals = cp_type_quals (type);
7801 TYPE_READONLY (t) = (type_quals & TYPE_QUAL_CONST) != 0;
7802 TYPE_VOLATILE (t) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
7803 TYPE_RESTRICT (t) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
7804 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7805 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7806 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7807 TREE_TYPE (TYPE_BINFO (t)) = t;
7810 /* Cache this pointer-to-member type so that we can find it again
7812 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7814 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7815 SET_TYPE_STRUCTURAL_EQUALITY (t);
7816 else if (TYPE_CANONICAL (type) != type)
7817 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7822 /* Create and return a pointer to data member type. */
7825 build_ptrmem_type (tree class_type, tree member_type)
7827 if (TREE_CODE (member_type) == METHOD_TYPE)
7829 cp_cv_quals quals = type_memfn_quals (member_type);
7830 member_type = build_memfn_type (member_type, class_type, quals);
7831 return build_ptrmemfunc_type (build_pointer_type (member_type));
7835 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7836 return build_offset_type (class_type, member_type);
7840 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7841 Check to see that the definition is valid. Issue appropriate error
7842 messages. Return 1 if the definition is particularly bad, or 0
7846 check_static_variable_definition (tree decl, tree type)
7848 /* Can't check yet if we don't know the type. */
7849 if (dependent_type_p (type))
7851 /* If DECL is declared constexpr, we'll do the appropriate checks
7852 in check_initializer. */
7853 if (DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
7855 else if (cxx_dialect >= cxx0x && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7857 if (!COMPLETE_TYPE_P (type))
7858 error ("in-class initialization of static data member %q#D of "
7859 "incomplete type", decl);
7860 else if (literal_type_p (type))
7861 permerror (input_location,
7862 "%<constexpr%> needed for in-class initialization of "
7863 "static data member %q#D of non-integral type", decl);
7865 error ("in-class initialization of static data member %q#D of "
7866 "non-literal type", decl);
7870 /* Motion 10 at San Diego: If a static const integral data member is
7871 initialized with an integral constant expression, the initializer
7872 may appear either in the declaration (within the class), or in
7873 the definition, but not both. If it appears in the class, the
7874 member is a member constant. The file-scope definition is always
7876 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7878 error ("invalid in-class initialization of static data member "
7879 "of non-integral type %qT",
7883 else if (!CP_TYPE_CONST_P (type))
7884 error ("ISO C++ forbids in-class initialization of non-const "
7885 "static member %qD",
7887 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7888 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant "
7889 "%qD of non-integral type %qT", decl, type);
7894 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
7895 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
7896 expressions out into temporary variables so that walk_tree doesn't
7897 step into them (c++/15764). */
7900 stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data)
7902 struct pointer_set_t *pset = (struct pointer_set_t *)data;
7903 tree expr = *expr_p;
7904 if (TREE_CODE (expr) == SAVE_EXPR)
7906 tree op = TREE_OPERAND (expr, 0);
7907 cp_walk_tree (&op, stabilize_save_expr_r, data, pset);
7908 if (TREE_SIDE_EFFECTS (op))
7909 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op);
7912 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr))
7917 /* Entry point for the above. */
7920 stabilize_vla_size (tree size)
7922 struct pointer_set_t *pset = pointer_set_create ();
7923 /* Break out any function calls into temporary variables. */
7924 cp_walk_tree (&size, stabilize_save_expr_r, pset, pset);
7927 /* Given the SIZE (i.e., number of elements) in an array, compute an
7928 appropriate index type for the array. If non-NULL, NAME is the
7929 name of the thing being declared. */
7932 compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
7936 tree abi_1_itype = NULL_TREE;
7938 if (error_operand_p (size))
7939 return error_mark_node;
7941 if (!type_dependent_expression_p (size))
7943 tree type = TREE_TYPE (size);
7945 mark_rvalue_use (size);
7947 if (cxx_dialect < cxx0x && TREE_CODE (size) == NOP_EXPR
7948 && TREE_SIDE_EFFECTS (size))
7949 /* In C++98, we mark a non-constant array bound with a magic
7950 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
7953 size = fold_non_dependent_expr (size);
7955 if (CLASS_TYPE_P (type)
7956 && CLASSTYPE_LITERAL_P (type))
7958 size = build_expr_type_conversion (WANT_INT, size, true);
7961 if (!(complain & tf_error))
7962 return error_mark_node;
7964 error ("size of array %qD has non-integral type %qT",
7967 error ("size of array has non-integral type %qT", type);
7968 size = integer_one_node;
7970 if (size == error_mark_node)
7971 return error_mark_node;
7972 type = TREE_TYPE (size);
7973 /* We didn't support this case in GCC 3.2, so don't bother
7974 trying to model it now in ABI v1. */
7975 abi_1_itype = error_mark_node;
7978 size = maybe_constant_value (size);
7979 if (!TREE_CONSTANT (size))
7983 if (error_operand_p (size))
7984 return error_mark_node;
7986 /* The array bound must be an integer type. */
7987 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
7989 if (!(complain & tf_error))
7990 return error_mark_node;
7992 error ("size of array %qD has non-integral type %qT", name, type);
7994 error ("size of array has non-integral type %qT", type);
7995 size = integer_one_node;
7996 type = TREE_TYPE (size);
8000 /* A type is dependent if it is...an array type constructed from any
8001 dependent type or whose size is specified by a constant expression
8002 that is value-dependent. */
8003 /* We can only call value_dependent_expression_p on integral constant
8004 expressions; treat non-constant expressions as dependent, too. */
8005 if (processing_template_decl
8006 && (type_dependent_expression_p (size)
8007 || !TREE_CONSTANT (size) || value_dependent_expression_p (size)))
8009 /* We cannot do any checking for a SIZE that isn't known to be
8010 constant. Just build the index type and mark that it requires
8011 structural equality checks. */
8012 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8013 size, integer_one_node));
8014 TYPE_DEPENDENT_P (itype) = 1;
8015 TYPE_DEPENDENT_P_VALID (itype) = 1;
8016 SET_TYPE_STRUCTURAL_EQUALITY (itype);
8020 if (!abi_version_at_least (2) && processing_template_decl
8021 && abi_1_itype == NULL_TREE)
8022 /* For abi-1, we handled all instances in templates the same way,
8023 even when they were non-dependent. This affects the manglings
8024 produced. So, we do the normal checking for non-dependent
8025 sizes, but at the end we'll return the same type that abi-1
8026 would have, but with TYPE_CANONICAL set to the "right"
8027 value that the current ABI would provide. */
8028 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8029 osize, integer_one_node));
8031 /* Normally, the array-bound will be a constant. */
8032 if (TREE_CODE (size) == INTEGER_CST)
8034 /* Check to see if the array bound overflowed. Make that an
8035 error, no matter how generous we're being. */
8036 constant_expression_error (size);
8038 /* An array must have a positive number of elements. */
8039 if (INT_CST_LT (size, integer_zero_node))
8041 if (!(complain & tf_error))
8042 return error_mark_node;
8044 error ("size of array %qD is negative", name);
8046 error ("size of array is negative");
8047 size = integer_one_node;
8049 /* As an extension we allow zero-sized arrays. */
8050 else if (integer_zerop (size))
8052 if (!(complain & tf_error))
8053 /* We must fail if performing argument deduction (as
8054 indicated by the state of complain), so that
8055 another substitution can be found. */
8056 return error_mark_node;
8057 else if (in_system_header)
8058 /* Allow them in system headers because glibc uses them. */;
8060 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
8062 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
8065 else if (TREE_CONSTANT (size)
8066 /* We don't allow VLAs at non-function scopes, or during
8067 tentative template substitution. */
8068 || !at_function_scope_p () || !(complain & tf_error))
8070 if (!(complain & tf_error))
8071 return error_mark_node;
8072 /* `(int) &fn' is not a valid array bound. */
8074 error ("size of array %qD is not an integral constant-expression",
8077 error ("size of array is not an integral constant-expression");
8078 size = integer_one_node;
8080 else if (pedantic && warn_vla != 0)
8083 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
8085 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
8087 else if (warn_vla > 0)
8091 "variable length array %qD is used", name);
8094 "variable length array is used");
8097 if (processing_template_decl && !TREE_CONSTANT (size))
8098 /* A variable sized array. */
8099 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
8102 HOST_WIDE_INT saved_processing_template_decl;
8104 /* Compute the index of the largest element in the array. It is
8105 one less than the number of elements in the array. We save
8106 and restore PROCESSING_TEMPLATE_DECL so that computations in
8107 cp_build_binary_op will be appropriately folded. */
8108 saved_processing_template_decl = processing_template_decl;
8109 processing_template_decl = 0;
8110 itype = cp_build_binary_op (input_location,
8112 cp_convert (ssizetype, size, complain),
8113 cp_convert (ssizetype, integer_one_node,
8116 itype = fold (itype);
8117 processing_template_decl = saved_processing_template_decl;
8119 if (!TREE_CONSTANT (itype))
8120 /* A variable sized array. */
8121 itype = variable_size (itype);
8122 /* Make sure that there was no overflow when creating to a signed
8123 index type. (For example, on a 32-bit machine, an array with
8124 size 2^32 - 1 is too big.) */
8125 else if (TREE_CODE (itype) == INTEGER_CST
8126 && TREE_OVERFLOW (itype))
8128 if (!(complain & tf_error))
8129 return error_mark_node;
8130 error ("overflow in array dimension");
8131 TREE_OVERFLOW (itype) = 0;
8135 /* Create and return the appropriate index type. */
8136 if (abi_1_itype && abi_1_itype != error_mark_node)
8138 tree t = build_index_type (itype);
8139 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
8140 itype = abi_1_itype;
8143 itype = build_index_type (itype);
8145 /* If the index type were dependent, we would have returned early, so
8146 remember that it isn't. */
8147 TYPE_DEPENDENT_P (itype) = 0;
8148 TYPE_DEPENDENT_P_VALID (itype) = 1;
8152 /* Returns the scope (if any) in which the entity declared by
8153 DECLARATOR will be located. If the entity was declared with an
8154 unqualified name, NULL_TREE is returned. */
8157 get_scope_of_declarator (const cp_declarator *declarator)
8159 while (declarator && declarator->kind != cdk_id)
8160 declarator = declarator->declarator;
8162 /* If the declarator-id is a SCOPE_REF, the scope in which the
8163 declaration occurs is the first operand. */
8165 && declarator->u.id.qualifying_scope)
8166 return declarator->u.id.qualifying_scope;
8168 /* Otherwise, the declarator is not a qualified name; the entity will
8169 be declared in the current scope. */
8173 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8174 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8178 create_array_type_for_decl (tree name, tree type, tree size)
8180 tree itype = NULL_TREE;
8182 /* If things have already gone awry, bail now. */
8183 if (type == error_mark_node || size == error_mark_node)
8184 return error_mark_node;
8186 /* 8.3.4/1: If the type of the identifier of D contains the auto
8187 type-specifier, the program is ill-formed. */
8188 if (pedantic && type_uses_auto (type))
8189 pedwarn (input_location, OPT_Wpedantic,
8190 "declaration of %qD as array of %<auto%>", name);
8192 /* If there are some types which cannot be array elements,
8193 issue an error-message and return. */
8194 switch (TREE_CODE (type))
8198 error ("declaration of %qD as array of void", name);
8200 error ("creating array of void");
8201 return error_mark_node;
8205 error ("declaration of %qD as array of functions", name);
8207 error ("creating array of functions");
8208 return error_mark_node;
8210 case REFERENCE_TYPE:
8212 error ("declaration of %qD as array of references", name);
8214 error ("creating array of references");
8215 return error_mark_node;
8219 error ("declaration of %qD as array of function members", name);
8221 error ("creating array of function members");
8222 return error_mark_node;
8230 The constant expressions that specify the bounds of the arrays
8231 can be omitted only for the first member of the sequence. */
8232 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
8235 error ("declaration of %qD as multidimensional array must "
8236 "have bounds for all dimensions except the first",
8239 error ("multidimensional array must have bounds for all "
8240 "dimensions except the first");
8242 return error_mark_node;
8245 /* Figure out the index type for the array. */
8247 itype = compute_array_index_type (name, size, tf_warning_or_error);
8250 T is called the array element type; this type shall not be [...] an
8251 abstract class type. */
8252 abstract_virtuals_error (name, type);
8254 return build_cplus_array_type (type, itype);
8257 /* Check that it's OK to declare a function with the indicated TYPE.
8258 SFK indicates the kind of special function (if any) that this
8259 function is. OPTYPE is the type given in a conversion operator
8260 declaration, or the class type for a constructor/destructor.
8261 Returns the actual return type of the function; that
8262 may be different than TYPE if an error occurs, or for certain
8263 special functions. */
8266 check_special_function_return_type (special_function_kind sfk,
8272 case sfk_constructor:
8274 error ("return type specification for constructor invalid");
8276 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8277 type = build_pointer_type (optype);
8279 type = void_type_node;
8282 case sfk_destructor:
8284 error ("return type specification for destructor invalid");
8285 /* We can't use the proper return type here because we run into
8286 problems with ambiguous bases and covariant returns.
8287 Java classes are left unchanged because (void *) isn't a valid
8288 Java type, and we don't want to change the Java ABI. */
8289 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8290 type = build_pointer_type (void_type_node);
8292 type = void_type_node;
8295 case sfk_conversion:
8297 error ("return type specified for %<operator %T%>", optype);
8308 /* A variable or data member (whose unqualified name is IDENTIFIER)
8309 has been declared with the indicated TYPE. If the TYPE is not
8310 acceptable, issue an error message and return a type to use for
8311 error-recovery purposes. */
8314 check_var_type (tree identifier, tree type)
8316 if (VOID_TYPE_P (type))
8319 error ("unnamed variable or field declared void");
8320 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
8322 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
8323 error ("variable or field %qE declared void", identifier);
8326 error ("variable or field declared void");
8327 type = error_mark_node;
8333 /* Given declspecs and a declarator (abstract or otherwise), determine
8334 the name and type of the object declared and construct a DECL node
8337 DECLSPECS points to the representation of declaration-specifier
8338 sequence that precedes declarator.
8340 DECL_CONTEXT says which syntactic context this declaration is in:
8341 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8342 FUNCDEF for a function definition. Like NORMAL but a few different
8343 error messages in each case. Return value may be zero meaning
8344 this definition is too screwy to try to parse.
8345 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8346 handle member functions (which have FIELD context).
8347 Return value may be zero meaning this definition is too screwy to
8349 PARM for a parameter declaration (either within a function prototype
8350 or before a function body). Make a PARM_DECL, or return void_type_node.
8351 TPARM for a template parameter declaration.
8352 CATCHPARM for a parameter declaration before a catch clause.
8353 TYPENAME if for a typename (in a cast or sizeof).
8354 Don't make a DECL node; just return the ..._TYPE node.
8355 FIELD for a struct or union field; make a FIELD_DECL.
8356 BITFIELD for a field with specified width.
8358 INITIALIZED is as for start_decl.
8360 ATTRLIST is a pointer to the list of attributes, which may be NULL
8361 if there are none; *ATTRLIST may be modified if attributes from inside
8362 the declarator should be applied to the declaration.
8364 When this function is called, scoping variables (such as
8365 CURRENT_CLASS_TYPE) should reflect the scope in which the
8366 declaration occurs, not the scope in which the new declaration will
8367 be placed. For example, on:
8371 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8374 Returns a DECL (if a declarator is present), a TYPE (if there is no
8375 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8379 grokdeclarator (const cp_declarator *declarator,
8380 const cp_decl_specifier_seq *declspecs,
8381 enum decl_context decl_context,
8385 tree type = NULL_TREE;
8387 int explicit_int128 = 0;
8388 int virtualp, explicitp, friendp, inlinep, staticp;
8389 int explicit_int = 0;
8390 int explicit_char = 0;
8391 int defaulted_int = 0;
8392 tree dependent_name = NULL_TREE;
8394 tree typedef_decl = NULL_TREE;
8395 const char *name = NULL;
8396 tree typedef_type = NULL_TREE;
8397 /* True if this declarator is a function definition. */
8398 bool funcdef_flag = false;
8399 cp_declarator_kind innermost_code = cdk_error;
8402 /* See the code below that used this. */
8403 tree decl_attr = NULL_TREE;
8406 /* Keep track of what sort of function is being processed
8407 so that we can warn about default return values, or explicit
8408 return values which do not match prescribed defaults. */
8409 special_function_kind sfk = sfk_none;
8411 tree dname = NULL_TREE;
8412 tree ctor_return_type = NULL_TREE;
8413 enum overload_flags flags = NO_SPECIAL;
8414 /* cv-qualifiers that apply to the declarator, for a declaration of
8415 a member function. */
8416 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
8417 /* virt-specifiers that apply to the declarator, for a declaration of
8418 a member function. */
8419 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
8420 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8422 tree raises = NULL_TREE;
8423 int template_count = 0;
8424 tree returned_attrs = NULL_TREE;
8425 tree parms = NULL_TREE;
8426 const cp_declarator *id_declarator;
8427 /* The unqualified name of the declarator; either an
8428 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8429 tree unqualified_id;
8430 /* The class type, if any, in which this entity is located,
8431 or NULL_TREE if none. Note that this value may be different from
8432 the current class type; for example if an attempt is made to declare
8433 "A::f" inside "B", this value will be "A". */
8434 tree ctype = current_class_type;
8435 /* The NAMESPACE_DECL for the namespace in which this entity is
8436 located. If an unqualified name is used to declare the entity,
8437 this value will be NULL_TREE, even if the entity is located at
8439 tree in_namespace = NULL_TREE;
8440 cp_storage_class storage_class;
8441 bool unsigned_p, signed_p, short_p, long_p, thread_p;
8442 bool type_was_error_mark_node = false;
8443 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
8444 bool template_type_arg = false;
8445 bool template_parm_flag = false;
8446 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
8449 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
8450 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
8451 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
8452 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
8453 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
8454 explicit_int128 = declspecs->explicit_int128_p;
8455 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
8457 if (decl_context == FUNCDEF)
8458 funcdef_flag = true, decl_context = NORMAL;
8459 else if (decl_context == MEMFUNCDEF)
8460 funcdef_flag = true, decl_context = FIELD;
8461 else if (decl_context == BITFIELD)
8462 bitfield = 1, decl_context = FIELD;
8463 else if (decl_context == TEMPLATE_TYPE_ARG)
8464 template_type_arg = true, decl_context = TYPENAME;
8465 else if (decl_context == TPARM)
8466 template_parm_flag = true, decl_context = PARM;
8468 if (initialized > 1)
8469 funcdef_flag = true;
8471 /* Look inside a declarator for the name being declared
8472 and get it as a string, for an error message. */
8473 for (id_declarator = declarator;
8475 id_declarator = id_declarator->declarator)
8477 if (id_declarator->kind != cdk_id)
8478 innermost_code = id_declarator->kind;
8480 switch (id_declarator->kind)
8483 if (id_declarator->declarator
8484 && id_declarator->declarator->kind == cdk_id)
8486 sfk = id_declarator->declarator->u.id.sfk;
8487 if (sfk == sfk_destructor)
8494 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
8495 tree decl = id_declarator->u.id.unqualified_name;
8498 if (qualifying_scope)
8500 if (at_function_scope_p ())
8504 A declarator-id shall not be qualified except
8507 None of the cases are permitted in block
8509 if (qualifying_scope == global_namespace)
8510 error ("invalid use of qualified-name %<::%D%>",
8512 else if (TYPE_P (qualifying_scope))
8513 error ("invalid use of qualified-name %<%T::%D%>",
8514 qualifying_scope, decl);
8516 error ("invalid use of qualified-name %<%D::%D%>",
8517 qualifying_scope, decl);
8518 return error_mark_node;
8520 else if (TYPE_P (qualifying_scope))
8522 ctype = qualifying_scope;
8523 if (!MAYBE_CLASS_TYPE_P (ctype))
8525 error ("%q#T is not a class or a namespace", ctype);
8528 else if (innermost_code != cdk_function
8529 && current_class_type
8530 && !uniquely_derived_from_p (ctype,
8531 current_class_type))
8533 error ("type %qT is not derived from type %qT",
8534 ctype, current_class_type);
8535 return error_mark_node;
8538 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
8539 in_namespace = qualifying_scope;
8541 switch (TREE_CODE (decl))
8547 if (innermost_code != cdk_function)
8549 error ("declaration of %qD as non-function", decl);
8550 return error_mark_node;
8552 else if (!qualifying_scope
8553 && !(current_class_type && at_class_scope_p ()))
8555 error ("declaration of %qD as non-member", decl);
8556 return error_mark_node;
8559 type = TREE_OPERAND (decl, 0);
8561 type = constructor_name (type);
8562 name = identifier_to_locale (IDENTIFIER_POINTER (type));
8567 case TEMPLATE_ID_EXPR:
8569 tree fns = TREE_OPERAND (decl, 0);
8572 if (TREE_CODE (dname) != IDENTIFIER_NODE)
8574 gcc_assert (is_overloaded_fn (dname));
8575 dname = DECL_NAME (get_first_fn (dname));
8580 case IDENTIFIER_NODE:
8581 if (TREE_CODE (decl) == IDENTIFIER_NODE)
8584 if (C_IS_RESERVED_WORD (dname))
8586 error ("declarator-id missing; using reserved word %qD",
8588 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8590 else if (!IDENTIFIER_TYPENAME_P (dname))
8591 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8594 gcc_assert (flags == NO_SPECIAL);
8595 flags = TYPENAME_FLAG;
8596 ctor_return_type = TREE_TYPE (dname);
8597 sfk = sfk_conversion;
8598 if (is_typename_at_global_scope (dname))
8599 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8601 name = "<invalid operator>";
8618 return error_mark_node;
8623 if (id_declarator->kind == cdk_id)
8629 The declarator in a function-definition shall have the form
8630 D1 ( parameter-declaration-clause) ... */
8631 if (funcdef_flag && innermost_code != cdk_function)
8633 error ("function definition does not declare parameters");
8634 return error_mark_node;
8637 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8638 && innermost_code != cdk_function
8639 && ! (ctype && !declspecs->any_specifiers_p))
8641 error ("declaration of %qD as non-function", dname);
8642 return error_mark_node;
8646 && TREE_CODE (dname) == IDENTIFIER_NODE
8647 && UDLIT_OPER_P (dname)
8648 && innermost_code != cdk_function)
8650 error ("declaration of %qD as non-function", dname);
8651 return error_mark_node;
8654 if (dname && IDENTIFIER_OPNAME_P (dname))
8656 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
8658 error ("declaration of %qD as %<typedef%>", dname);
8659 return error_mark_node;
8661 else if (decl_context == PARM || decl_context == CATCHPARM)
8663 error ("declaration of %qD as parameter", dname);
8664 return error_mark_node;
8668 /* Anything declared one level down from the top level
8669 must be one of the parameters of a function
8670 (because the body is at least two levels down). */
8672 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8673 by not allowing C++ class definitions to specify their parameters
8674 with xdecls (must be spec.d in the parmlist).
8676 Since we now wait to push a class scope until we are sure that
8677 we are in a legitimate method context, we must set oldcname
8678 explicitly (since current_class_name is not yet alive).
8680 We also want to avoid calling this a PARM if it is in a namespace. */
8682 if (decl_context == NORMAL && !toplevel_bindings_p ())
8684 cp_binding_level *b = current_binding_level;
8685 current_binding_level = b->level_chain;
8686 if (current_binding_level != 0 && toplevel_bindings_p ())
8687 decl_context = PARM;
8688 current_binding_level = b;
8692 name = decl_context == PARM ? "parameter" : "type name";
8694 if (constexpr_p && decl_spec_seq_has_spec_p (declspecs, ds_typedef))
8696 error ("%<constexpr%> cannot appear in a typedef declaration");
8697 return error_mark_node;
8700 /* If there were multiple types specified in the decl-specifier-seq,
8701 issue an error message. */
8702 if (declspecs->multiple_types_p)
8704 error ("two or more data types in declaration of %qs", name);
8705 return error_mark_node;
8708 if (declspecs->conflicting_specifiers_p)
8710 error ("conflicting specifiers in declaration of %qs", name);
8711 return error_mark_node;
8714 /* Extract the basic type from the decl-specifier-seq. */
8715 type = declspecs->type;
8716 if (type == error_mark_node)
8719 type_was_error_mark_node = true;
8721 /* If the entire declaration is itself tagged as deprecated then
8722 suppress reports of deprecated items. */
8723 if (type && TREE_DEPRECATED (type)
8724 && deprecated_state != DEPRECATED_SUPPRESS)
8725 warn_deprecated_use (type, NULL_TREE);
8726 if (type && TREE_CODE (type) == TYPE_DECL)
8728 typedef_decl = type;
8729 type = TREE_TYPE (typedef_decl);
8730 if (TREE_DEPRECATED (type)
8731 && DECL_ARTIFICIAL (typedef_decl)
8732 && deprecated_state != DEPRECATED_SUPPRESS)
8733 warn_deprecated_use (type, NULL_TREE);
8735 /* No type at all: default to `int', and set DEFAULTED_INT
8736 because it was not a user-defined typedef. */
8737 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
8739 /* These imply 'int'. */
8740 type = integer_type_node;
8744 explicit_int = declspecs->explicit_int_p;
8745 explicit_char = declspecs->explicit_char_p;
8748 /* See the code below that used this. */
8750 decl_attr = DECL_ATTRIBUTES (typedef_decl);
8752 typedef_type = type;
8755 if (sfk != sfk_conversion)
8756 ctor_return_type = ctype;
8758 if (sfk != sfk_none)
8759 type = check_special_function_return_type (sfk, type,
8761 else if (type == NULL_TREE)
8767 /* We handle `main' specially here, because 'main () { }' is so
8768 common. With no options, it is allowed. With -Wreturn-type,
8769 it is a warning. It is only an error with -pedantic-errors. */
8770 is_main = (funcdef_flag
8771 && dname && TREE_CODE (dname) == IDENTIFIER_NODE
8772 && MAIN_NAME_P (dname)
8773 && ctype == NULL_TREE
8774 && in_namespace == NULL_TREE
8775 && current_namespace == global_namespace);
8777 if (type_was_error_mark_node)
8778 /* We've already issued an error, don't complain more. */;
8779 else if (in_system_header || flag_ms_extensions)
8780 /* Allow it, sigh. */;
8782 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
8784 pedwarn (input_location, OPT_Wpedantic,
8785 "ISO C++ forbids declaration of %qs with no type", name);
8787 warning (OPT_Wreturn_type,
8788 "ISO C++ forbids declaration of %qs with no type", name);
8790 type = integer_type_node;
8795 if (explicit_int128)
8797 if (int128_integer_type_node == NULL_TREE)
8799 error ("%<__int128%> is not supported by this target");
8800 explicit_int128 = false;
8802 else if (pedantic && ! in_system_header)
8803 pedwarn (input_location, OPT_Wpedantic,
8804 "ISO C++ does not support %<__int128%> for %qs", name);
8807 /* Now process the modifiers that were specified
8808 and check for invalid combinations. */
8810 /* Long double is a special combination. */
8811 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
8814 type = cp_build_qualified_type (long_double_type_node,
8815 cp_type_quals (type));
8818 /* Check all other uses of type modifiers. */
8820 if (unsigned_p || signed_p || long_p || short_p)
8824 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
8825 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
8826 else if (signed_p && unsigned_p)
8827 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
8828 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
8829 error ("%<long long%> invalid for %qs", name);
8830 else if (long_p && TREE_CODE (type) == REAL_TYPE)
8831 error ("%<long%> invalid for %qs", name);
8832 else if (short_p && TREE_CODE (type) == REAL_TYPE)
8833 error ("%<short%> invalid for %qs", name);
8834 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
8835 error ("%<long%> or %<short%> invalid for %qs", name);
8836 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_int128)
8837 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
8838 else if ((long_p || short_p) && explicit_char)
8839 error ("%<long%> or %<short%> specified with char for %qs", name);
8840 else if (long_p && short_p)
8841 error ("%<long%> and %<short%> specified together for %qs", name);
8842 else if (type == char16_type_node || type == char32_type_node)
8844 if (signed_p || unsigned_p)
8845 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
8846 else if (short_p || long_p)
8847 error ("%<short%> or %<long%> invalid for %qs", name);
8852 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic)
8854 pedwarn (input_location, OPT_Wpedantic,
8855 "long, short, signed or unsigned used invalidly for %qs",
8857 if (flag_pedantic_errors)
8862 /* Discard the type modifiers if they are invalid. */
8873 /* Decide whether an integer type is signed or not.
8874 Optionally treat bitfields as signed by default. */
8878 It is implementation-defined whether a plain (neither
8879 explicitly signed or unsigned) char, short, int, or long
8880 bit-field is signed or unsigned.
8882 Naturally, we extend this to long long as well. Note that
8883 this does not include wchar_t. */
8884 || (bitfield && !flag_signed_bitfields
8886 /* A typedef for plain `int' without `signed' can be
8887 controlled just like plain `int', but a typedef for
8888 `signed int' cannot be so controlled. */
8890 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
8891 && TREE_CODE (type) == INTEGER_TYPE
8892 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
8894 if (explicit_int128)
8895 type = int128_unsigned_type_node;
8897 type = long_long_unsigned_type_node;
8899 type = long_unsigned_type_node;
8901 type = short_unsigned_type_node;
8902 else if (type == char_type_node)
8903 type = unsigned_char_type_node;
8904 else if (typedef_decl)
8905 type = unsigned_type_for (type);
8907 type = unsigned_type_node;
8909 else if (signed_p && type == char_type_node)
8910 type = signed_char_type_node;
8911 else if (explicit_int128)
8912 type = int128_integer_type_node;
8914 type = long_long_integer_type_node;
8916 type = long_integer_type_node;
8918 type = short_integer_type_node;
8920 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
8922 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8923 error ("complex invalid for %qs", name);
8924 /* If we just have "complex", it is equivalent to
8925 "complex double", but if any modifiers at all are specified it is
8926 the complex form of TYPE. E.g, "complex short" is
8927 "complex short int". */
8928 else if (defaulted_int && ! longlong && ! explicit_int128
8929 && ! (long_p || short_p || signed_p || unsigned_p))
8930 type = complex_double_type_node;
8931 else if (type == integer_type_node)
8932 type = complex_integer_type_node;
8933 else if (type == float_type_node)
8934 type = complex_float_type_node;
8935 else if (type == double_type_node)
8936 type = complex_double_type_node;
8937 else if (type == long_double_type_node)
8938 type = complex_long_double_type_node;
8940 type = build_complex_type (type);
8943 type_quals = TYPE_UNQUALIFIED;
8944 if (decl_spec_seq_has_spec_p (declspecs, ds_const))
8945 type_quals |= TYPE_QUAL_CONST;
8946 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
8947 type_quals |= TYPE_QUAL_VOLATILE;
8948 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
8949 type_quals |= TYPE_QUAL_RESTRICT;
8950 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8951 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8954 /* If we're using the injected-class-name to form a compound type or a
8955 declaration, replace it with the underlying class so we don't get
8956 redundant typedefs in the debug output. But if we are returning the
8957 type unchanged, leave it alone so that it's available to
8958 maybe_get_template_decl_from_type_decl. */
8959 if (CLASS_TYPE_P (type)
8960 && DECL_SELF_REFERENCE_P (TYPE_NAME (type))
8961 && type == TREE_TYPE (TYPE_NAME (type))
8962 && (declarator || type_quals))
8963 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
8965 type_quals |= cp_type_quals (type);
8966 type = cp_build_qualified_type_real
8967 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8968 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8969 /* We might have ignored or rejected some of the qualifiers. */
8970 type_quals = cp_type_quals (type);
8973 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
8974 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual);
8975 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit);
8977 storage_class = declspecs->storage_class;
8978 if (storage_class == sc_static)
8979 staticp = 1 + (decl_context == FIELD);
8981 if (virtualp && staticp == 2)
8983 error ("member %qD cannot be declared both virtual and static", dname);
8984 storage_class = sc_none;
8987 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
8989 if (dependent_name && !friendp)
8991 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8992 return error_mark_node;
8995 /* Issue errors about use of storage classes for parameters. */
8996 if (decl_context == PARM)
8998 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9000 error ("typedef declaration invalid in parameter declaration");
9001 return error_mark_node;
9003 else if (template_parm_flag && storage_class != sc_none)
9005 error ("storage class specified for template parameter %qs", name);
9006 return error_mark_node;
9008 else if (storage_class == sc_static
9009 || storage_class == sc_extern
9011 error ("storage class specifiers invalid in parameter declarations");
9013 /* Function parameters cannot be constexpr. If we saw one, moan
9014 and pretend it wasn't there. */
9017 error ("a parameter cannot be declared %<constexpr%>");
9022 /* Give error if `virtual' is used outside of class declaration. */
9024 && (current_class_name == NULL_TREE || decl_context != FIELD))
9026 error ("%<virtual%> outside class declaration");
9030 /* Static anonymous unions are dealt with here. */
9031 if (staticp && decl_context == TYPENAME
9033 && ANON_AGGR_TYPE_P (declspecs->type))
9034 decl_context = FIELD;
9036 /* Warn about storage classes that are invalid for certain
9037 kinds of declarations (parameters, typenames, etc.). */
9040 && storage_class != sc_extern
9041 && storage_class != sc_static)
9042 || decl_spec_seq_has_spec_p (declspecs, ds_typedef)))
9044 error ("multiple storage classes in declaration of %qs", name);
9047 if (decl_context != NORMAL
9048 && ((storage_class != sc_none
9049 && storage_class != sc_mutable)
9052 if ((decl_context == PARM || decl_context == CATCHPARM)
9053 && (storage_class == sc_register
9054 || storage_class == sc_auto))
9056 else if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9058 else if (decl_context == FIELD
9059 /* C++ allows static class elements. */
9060 && storage_class == sc_static)
9061 /* C++ also allows inlines and signed and unsigned elements,
9062 but in those cases we don't come in here. */
9066 if (decl_context == FIELD)
9067 error ("storage class specified for %qs", name);
9070 if (decl_context == PARM || decl_context == CATCHPARM)
9071 error ("storage class specified for parameter %qs", name);
9073 error ("storage class specified for typename");
9075 if (storage_class == sc_register
9076 || storage_class == sc_auto
9077 || storage_class == sc_extern
9079 storage_class = sc_none;
9082 else if (storage_class == sc_extern && funcdef_flag
9083 && ! toplevel_bindings_p ())
9084 error ("nested function %qs declared %<extern%>", name);
9085 else if (toplevel_bindings_p ())
9087 if (storage_class == sc_auto)
9088 error ("top-level declaration of %qs specifies %<auto%>", name);
9091 && storage_class != sc_extern
9092 && storage_class != sc_static)
9094 error ("function-scope %qs implicitly auto and declared %<__thread%>",
9099 if (storage_class && friendp)
9101 error ("storage class specifiers invalid in friend function declarations");
9102 storage_class = sc_none;
9107 unqualified_id = NULL_TREE;
9110 unqualified_id = id_declarator->u.id.unqualified_name;
9111 switch (TREE_CODE (unqualified_id))
9114 unqualified_id = TREE_OPERAND (unqualified_id, 0);
9115 if (TYPE_P (unqualified_id))
9116 unqualified_id = constructor_name (unqualified_id);
9119 case IDENTIFIER_NODE:
9120 case TEMPLATE_ID_EXPR:
9128 /* Determine the type of the entity declared by recurring on the
9130 for (; declarator; declarator = declarator->declarator)
9132 const cp_declarator *inner_declarator;
9135 if (type == error_mark_node)
9136 return error_mark_node;
9138 attrs = declarator->attributes;
9144 if (declarator == NULL || declarator->kind == cdk_id)
9145 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
9146 if (declarator->kind == cdk_function)
9147 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
9148 if (declarator->kind == cdk_array)
9149 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
9150 returned_attrs = decl_attributes (&type,
9151 chainon (returned_attrs, attrs),
9155 if (declarator->kind == cdk_id)
9158 inner_declarator = declarator->declarator;
9160 switch (declarator->kind)
9163 type = create_array_type_for_decl (dname, type,
9164 declarator->u.array.bounds);
9172 /* Declaring a function type.
9173 Make sure we have a valid type for the function to return. */
9175 if (type_quals != TYPE_UNQUALIFIED)
9177 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
9178 warning (OPT_Wignored_qualifiers,
9179 "type qualifiers ignored on function return type");
9180 /* We now know that the TYPE_QUALS don't apply to the
9181 decl, but to its return type. */
9182 type_quals = TYPE_UNQUALIFIED;
9184 errmsg = targetm.invalid_return_type (type);
9188 type = integer_type_node;
9191 /* Error about some types functions can't return. */
9193 if (TREE_CODE (type) == FUNCTION_TYPE)
9195 error ("%qs declared as function returning a function", name);
9196 return error_mark_node;
9198 if (TREE_CODE (type) == ARRAY_TYPE)
9200 error ("%qs declared as function returning an array", name);
9201 return error_mark_node;
9203 /* When decl_context == NORMAL we emit a better error message
9204 later in abstract_virtuals_error. */
9205 if (decl_context == TYPENAME && ABSTRACT_CLASS_TYPE_P (type))
9206 error ("%qs declared as function returning an abstract "
9207 "class type", name);
9209 /* Pick up type qualifiers which should be applied to `this'. */
9210 memfn_quals = declarator->u.function.qualifiers;
9211 /* Pick up virt-specifiers. */
9212 virt_specifiers = declarator->u.function.virt_specifiers;
9213 /* Pick up the exception specifications. */
9214 raises = declarator->u.function.exception_specification;
9215 /* If the exception-specification is ill-formed, let's pretend
9216 there wasn't one. */
9217 if (raises == error_mark_node)
9220 /* Say it's a definition only for the CALL_EXPR
9221 closest to the identifier. */
9222 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
9224 /* Handle a late-specified return type. */
9227 if (type_uses_auto (type))
9229 if (!declarator->u.function.late_return_type)
9231 if (current_class_type
9232 && LAMBDA_TYPE_P (current_class_type))
9233 /* OK for C++11 lambdas. */;
9234 else if (cxx_dialect < cxx1y)
9235 pedwarn (input_location, 0, "%qs function uses "
9236 "%<auto%> type specifier without trailing "
9237 "return type", name);
9239 else if (!is_auto (type))
9241 error ("%qs function with trailing return type has"
9242 " %qT as its type rather than plain %<auto%>",
9244 return error_mark_node;
9247 else if (declarator->u.function.late_return_type)
9249 if (cxx_dialect < cxx0x)
9250 /* Not using maybe_warn_cpp0x because this should
9251 always be an error. */
9252 error ("trailing return type only available with "
9253 "-std=c++11 or -std=gnu++11");
9255 error ("%qs function with trailing return type not "
9256 "declared with %<auto%> type specifier", name);
9257 return error_mark_node;
9260 type = splice_late_return_type
9261 (type, declarator->u.function.late_return_type);
9262 if (type == error_mark_node)
9263 return error_mark_node;
9265 if (ctype == NULL_TREE
9266 && decl_context == FIELD
9268 && (friendp == 0 || dname == current_class_name))
9269 ctype = current_class_type;
9271 if (ctype && (sfk == sfk_constructor
9272 || sfk == sfk_destructor))
9274 /* We are within a class's scope. If our declarator name
9275 is the same as the class name, and we are defining
9276 a function, then it is a constructor/destructor, and
9277 therefore returns a void type. */
9279 /* ISO C++ 12.4/2. A destructor may not be declared
9280 const or volatile. A destructor may not be
9283 ISO C++ 12.1. A constructor may not be declared
9284 const or volatile. A constructor may not be
9285 virtual. A constructor may not be static. */
9287 error ((flags == DTOR_FLAG)
9288 ? G_("destructor cannot be static member function")
9289 : G_("constructor cannot be static member function"));
9292 error ((flags == DTOR_FLAG)
9293 ? G_("destructors may not be cv-qualified")
9294 : G_("constructors may not be cv-qualified"));
9295 memfn_quals = TYPE_UNQUALIFIED;
9298 if (decl_context == FIELD
9299 && !member_function_or_else (ctype,
9302 return error_mark_node;
9304 if (flags != DTOR_FLAG)
9306 /* It's a constructor. */
9311 permerror (input_location, "constructors cannot be declared virtual");
9314 if (decl_context == FIELD
9315 && sfk != sfk_constructor)
9316 return error_mark_node;
9318 if (decl_context == FIELD)
9324 error ("can%'t initialize friend function %qs", name);
9327 /* Cannot be both friend and virtual. */
9328 error ("virtual functions cannot be friends");
9331 if (decl_context == NORMAL)
9332 error ("friend declaration not in class definition");
9333 if (current_function_decl && funcdef_flag)
9334 error ("can%'t define friend function %qs in a local "
9338 else if (ctype && sfk == sfk_conversion)
9342 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
9347 arg_types = grokparms (declarator->u.function.parameters,
9350 if (inner_declarator
9351 && inner_declarator->kind == cdk_id
9352 && inner_declarator->u.id.sfk == sfk_destructor
9353 && arg_types != void_list_node)
9355 error ("destructors may not have parameters");
9356 arg_types = void_list_node;
9360 type = build_function_type (type, arg_types);
9367 /* Filter out pointers-to-references and references-to-references.
9368 We can get these if a TYPE_DECL is used. */
9370 if (TREE_CODE (type) == REFERENCE_TYPE)
9372 if (declarator->kind != cdk_reference)
9374 error ("cannot declare pointer to %q#T", type);
9375 type = TREE_TYPE (type);
9378 /* In C++0x, we allow reference to reference declarations
9379 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9380 and template type arguments [14.3.1/4 temp.arg.type]. The
9381 check for direct reference to reference declarations, which
9382 are still forbidden, occurs below. Reasoning behind the change
9383 can be found in DR106, DR540, and the rvalue reference
9385 else if (cxx_dialect == cxx98)
9387 error ("cannot declare reference to %q#T", type);
9388 type = TREE_TYPE (type);
9391 else if (VOID_TYPE_P (type))
9393 if (declarator->kind == cdk_reference)
9394 error ("cannot declare reference to %q#T", type);
9395 else if (declarator->kind == cdk_ptrmem)
9396 error ("cannot declare pointer to %q#T member", type);
9399 /* We now know that the TYPE_QUALS don't apply to the decl,
9400 but to the target of the pointer. */
9401 type_quals = TYPE_UNQUALIFIED;
9403 if (declarator->kind == cdk_ptrmem
9404 && (TREE_CODE (type) == FUNCTION_TYPE
9405 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
9407 memfn_quals |= type_memfn_quals (type);
9408 type = build_memfn_type (type,
9409 declarator->u.pointer.class_type,
9411 if (type == error_mark_node)
9412 return error_mark_node;
9413 memfn_quals = TYPE_UNQUALIFIED;
9416 if (TREE_CODE (type) == FUNCTION_TYPE
9417 && type_memfn_quals (type) != TYPE_UNQUALIFIED)
9418 error (declarator->kind == cdk_reference
9419 ? G_("cannot declare reference to qualified function type %qT")
9420 : G_("cannot declare pointer to qualified function type %qT"),
9423 /* When the pointed-to type involves components of variable size,
9424 care must be taken to ensure that the size evaluation code is
9425 emitted early enough to dominate all the possible later uses
9426 and late enough for the variables on which it depends to have
9429 This is expected to happen automatically when the pointed-to
9430 type has a name/declaration of it's own, but special attention
9431 is required if the type is anonymous.
9433 We handle the NORMAL and FIELD contexts here by inserting a
9434 dummy statement that just evaluates the size at a safe point
9435 and ensures it is not deferred until e.g. within a deeper
9436 conditional context (c++/43555).
9438 We expect nothing to be needed here for PARM or TYPENAME.
9439 Evaluating the size at this point for TYPENAME would
9440 actually be incorrect, as we might be in the middle of an
9441 expression with side effects on the pointed-to type size
9442 "arguments" prior to the pointer declaration point and the
9443 size evaluation could end up prior to the side effects. */
9445 if (!TYPE_NAME (type)
9446 && (decl_context == NORMAL || decl_context == FIELD)
9447 && at_function_scope_p ()
9448 && variably_modified_type_p (type, NULL_TREE))
9450 /* First break out any side-effects. */
9451 stabilize_vla_size (TYPE_SIZE (type));
9452 /* And then force evaluation of the SAVE_EXPR. */
9453 finish_expr_stmt (TYPE_SIZE (type));
9456 if (declarator->kind == cdk_reference)
9458 /* In C++0x, the type we are creating a reference to might be
9459 a typedef which is itself a reference type. In that case,
9460 we follow the reference collapsing rules in
9461 [7.1.3/8 dcl.typedef] to create the final reference type:
9463 "If a typedef TD names a type that is a reference to a type
9464 T, an attempt to create the type 'lvalue reference to cv TD'
9465 creates the type 'lvalue reference to T,' while an attempt
9466 to create the type "rvalue reference to cv TD' creates the
9469 if (VOID_TYPE_P (type))
9470 /* We already gave an error. */;
9471 else if (TREE_CODE (type) == REFERENCE_TYPE)
9473 if (declarator->u.reference.rvalue_ref)
9474 /* Leave type alone. */;
9476 type = cp_build_reference_type (TREE_TYPE (type), false);
9479 type = cp_build_reference_type
9480 (type, declarator->u.reference.rvalue_ref);
9482 /* In C++0x, we need this check for direct reference to
9483 reference declarations, which are forbidden by
9484 [8.3.2/5 dcl.ref]. Reference to reference declarations
9485 are only allowed indirectly through typedefs and template
9486 type arguments. Example:
9488 void foo(int & &); // invalid ref-to-ref decl
9490 typedef int & int_ref;
9491 void foo(int_ref &); // valid ref-to-ref decl
9493 if (inner_declarator && inner_declarator->kind == cdk_reference)
9494 error ("cannot declare reference to %q#T, which is not "
9495 "a typedef or a template type argument", type);
9497 else if (TREE_CODE (type) == METHOD_TYPE)
9498 type = build_ptrmemfunc_type (build_pointer_type (type));
9499 else if (declarator->kind == cdk_ptrmem)
9501 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
9503 if (declarator->u.pointer.class_type == error_mark_node)
9504 /* We will already have complained. */
9505 type = error_mark_node;
9507 type = build_ptrmem_type (declarator->u.pointer.class_type,
9511 type = build_pointer_type (type);
9513 /* Process a list of type modifier keywords (such as
9514 const or volatile) that were given inside the `*' or `&'. */
9516 if (declarator->u.pointer.qualifiers)
9519 = cp_build_qualified_type (type,
9520 declarator->u.pointer.qualifiers);
9521 type_quals = cp_type_quals (type);
9534 /* We need to stabilize side-effects in VLA sizes for regular array
9535 declarations too, not just pointers to arrays. */
9536 if (type != error_mark_node && !TYPE_NAME (type)
9537 && (decl_context == NORMAL || decl_context == FIELD)
9538 && at_function_scope_p ()
9539 && variably_modified_type_p (type, NULL_TREE))
9540 stabilize_vla_size (TYPE_SIZE (type));
9542 /* A `constexpr' specifier used in an object declaration declares
9543 the object as `const'. */
9544 if (constexpr_p && innermost_code != cdk_function)
9546 if (type_quals & TYPE_QUAL_VOLATILE)
9547 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9548 if (TREE_CODE (type) != REFERENCE_TYPE)
9550 type_quals |= TYPE_QUAL_CONST;
9551 type = cp_build_qualified_type (type, type_quals);
9555 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
9556 && TREE_CODE (type) != FUNCTION_TYPE
9557 && TREE_CODE (type) != METHOD_TYPE)
9559 error ("template-id %qD used as a declarator",
9561 unqualified_id = dname;
9564 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9565 qualified with a class-name, turn it into a METHOD_TYPE, unless
9566 we know that the function is static. We take advantage of this
9567 opportunity to do other processing that pertains to entities
9568 explicitly declared to be class members. Note that if DECLARATOR
9569 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9570 would not have exited the loop above. */
9572 && declarator->u.id.qualifying_scope
9573 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope))
9575 ctype = declarator->u.id.qualifying_scope;
9576 ctype = TYPE_MAIN_VARIANT (ctype);
9577 template_count = num_template_headers_for_class (ctype);
9579 if (ctype == current_class_type)
9583 permerror (input_location, "member functions are implicitly friends of their class");
9587 permerror (declarator->id_loc,
9588 "extra qualification %<%T::%> on member %qs",
9591 else if (/* If the qualifying type is already complete, then we
9592 can skip the following checks. */
9593 !COMPLETE_TYPE_P (ctype)
9594 && (/* If the function is being defined, then
9595 qualifying type must certainly be complete. */
9597 /* A friend declaration of "T::f" is OK, even if
9598 "T" is a template parameter. But, if this
9599 function is not a friend, the qualifying type
9601 || (!friendp && !CLASS_TYPE_P (ctype))
9602 /* For a declaration, the type need not be
9603 complete, if either it is dependent (since there
9604 is no meaningful definition of complete in that
9605 case) or the qualifying class is currently being
9607 || !(dependent_type_p (ctype)
9608 || currently_open_class (ctype)))
9609 /* Check that the qualifying type is complete. */
9610 && !complete_type_or_else (ctype, NULL_TREE))
9611 return error_mark_node;
9612 else if (TREE_CODE (type) == FUNCTION_TYPE)
9614 if (current_class_type
9615 && (!friendp || funcdef_flag))
9618 ? G_("cannot define member function %<%T::%s%> "
9620 : G_("cannot declare member function %<%T::%s%> "
9622 ctype, name, current_class_type);
9623 return error_mark_node;
9626 else if (decl_spec_seq_has_spec_p (declspecs, ds_typedef)
9627 && current_class_type)
9629 error ("cannot declare member %<%T::%s%> within %qT",
9630 ctype, name, current_class_type);
9631 return error_mark_node;
9635 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
9636 ctype = current_class_type;
9638 /* Now TYPE has the actual type. */
9643 *attrlist = chainon (returned_attrs, *attrlist);
9645 attrlist = &returned_attrs;
9648 /* Handle parameter packs. */
9649 if (parameter_pack_p)
9651 if (decl_context == PARM)
9652 /* Turn the type into a pack expansion.*/
9653 type = make_pack_expansion (type);
9655 error ("non-parameter %qs cannot be a parameter pack", name);
9658 /* Did array size calculations overflow or does the array cover more
9659 than half of the address-space? */
9660 if (TREE_CODE (type) == ARRAY_TYPE
9661 && COMPLETE_TYPE_P (type)
9662 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
9663 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type)))
9665 error ("size of array %qs is too large", name);
9666 /* If we proceed with the array type as it is, we'll eventually
9667 crash in tree_low_cst(). */
9668 type = error_mark_node;
9671 if ((decl_context == FIELD || decl_context == PARM)
9672 && !processing_template_decl
9673 && variably_modified_type_p (type, NULL_TREE))
9675 if (decl_context == FIELD)
9676 error ("data member may not have variably modified type %qT", type);
9678 error ("parameter may not have variably modified type %qT", type);
9679 type = error_mark_node;
9682 if (explicitp == 1 || (explicitp && friendp))
9684 /* [dcl.fct.spec] The explicit specifier shall only be used in
9685 declarations of constructors within a class definition. */
9686 error ("only declarations of constructors can be %<explicit%>");
9690 if (storage_class == sc_mutable)
9692 if (decl_context != FIELD || friendp)
9694 error ("non-member %qs cannot be declared %<mutable%>", name);
9695 storage_class = sc_none;
9697 else if (decl_context == TYPENAME
9698 || decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9700 error ("non-object member %qs cannot be declared %<mutable%>", name);
9701 storage_class = sc_none;
9703 else if (TREE_CODE (type) == FUNCTION_TYPE
9704 || TREE_CODE (type) == METHOD_TYPE)
9706 error ("function %qs cannot be declared %<mutable%>", name);
9707 storage_class = sc_none;
9711 error ("static %qs cannot be declared %<mutable%>", name);
9712 storage_class = sc_none;
9714 else if (type_quals & TYPE_QUAL_CONST)
9716 error ("const %qs cannot be declared %<mutable%>", name);
9717 storage_class = sc_none;
9719 else if (TREE_CODE (type) == REFERENCE_TYPE)
9721 permerror (input_location, "reference %qs cannot be declared "
9722 "%<mutable%>", name);
9723 storage_class = sc_none;
9727 /* If this is declaring a typedef name, return a TYPE_DECL. */
9728 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef) && decl_context != TYPENAME)
9732 /* Note that the grammar rejects storage classes
9733 in typenames, fields or parameters. */
9734 if (current_lang_name == lang_name_java)
9735 TYPE_FOR_JAVA (type) = 1;
9737 /* This declaration:
9739 typedef void f(int) const;
9741 declares a function type which is not a member of any
9742 particular class, but which is cv-qualified; for
9743 example "f S::*" declares a pointer to a const-qualified
9744 member function of S. We record the cv-qualification in the
9746 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
9748 type = apply_memfn_quals (type, memfn_quals);
9750 /* We have now dealt with these qualifiers. */
9751 memfn_quals = TYPE_UNQUALIFIED;
9754 if (type_uses_auto (type))
9756 error ("typedef declared %<auto%>");
9757 type = error_mark_node;
9760 if (decl_context == FIELD)
9761 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
9763 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
9764 if (id_declarator && declarator->u.id.qualifying_scope) {
9765 error_at (DECL_SOURCE_LOCATION (decl),
9766 "typedef name may not be a nested-name-specifier");
9767 TREE_TYPE (decl) = error_mark_node;
9770 if (decl_context != FIELD)
9772 if (!current_function_decl)
9773 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
9774 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
9775 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
9776 (current_function_decl)))
9777 /* The TYPE_DECL is "abstract" because there will be
9778 clones of this constructor/destructor, and there will
9779 be copies of this TYPE_DECL generated in those
9781 DECL_ABSTRACT (decl) = 1;
9783 else if (current_class_type
9784 && constructor_name_p (unqualified_id, current_class_type))
9785 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
9786 "as enclosing class",
9789 /* If the user declares "typedef struct {...} foo" then the
9790 struct will have an anonymous name. Fill that name in now.
9791 Nothing can refer to it, so nothing needs know about the name
9793 if (type != error_mark_node
9796 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9797 && TYPE_ANONYMOUS_P (type)
9798 && declspecs->type_definition_p
9799 && cp_type_quals (type) == TYPE_UNQUALIFIED)
9803 /* Replace the anonymous name with the real name everywhere. */
9804 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
9806 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9807 /* We do not rename the debug info representing the
9808 anonymous tagged type because the standard says in
9809 [dcl.typedef] that the naming applies only for
9810 linkage purposes. */
9811 /*debug_hooks->set_name (t, decl);*/
9812 TYPE_NAME (t) = decl;
9815 if (TYPE_LANG_SPECIFIC (type))
9816 TYPE_WAS_ANONYMOUS (type) = 1;
9818 /* If this is a typedef within a template class, the nested
9819 type is a (non-primary) template. The name for the
9820 template needs updating as well. */
9821 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
9822 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
9823 = TYPE_IDENTIFIER (type);
9825 /* Adjust linkage now that we aren't anonymous anymore. */
9826 set_linkage_according_to_type (type, TYPE_MAIN_DECL (type));
9827 determine_visibility (TYPE_MAIN_DECL (type));
9829 /* FIXME remangle member functions; member functions of a
9830 type with external linkage have external linkage. */
9834 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
9835 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
9837 bad_specifiers (decl, BSP_TYPE, virtualp,
9838 memfn_quals != TYPE_UNQUALIFIED,
9839 inlinep, friendp, raises != NULL_TREE);
9841 if (decl_spec_seq_has_spec_p (declspecs, ds_alias))
9842 /* Acknowledge that this was written:
9843 `using analias = atype;'. */
9844 TYPE_DECL_ALIAS_P (decl) = 1;
9849 /* Detect the case of an array type of unspecified size
9850 which came, as such, direct from a typedef name.
9851 We must copy the type, so that the array's domain can be
9852 individually set by the object's initializer. */
9854 if (type && typedef_type
9855 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
9856 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
9857 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
9859 /* Detect where we're using a typedef of function type to declare a
9860 function. PARMS will not be set, so we must create it now. */
9862 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
9864 tree decls = NULL_TREE;
9867 for (args = TYPE_ARG_TYPES (type);
9868 args && args != void_list_node;
9869 args = TREE_CHAIN (args))
9871 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
9873 DECL_CHAIN (decl) = decls;
9877 parms = nreverse (decls);
9879 if (decl_context != TYPENAME)
9881 /* A cv-qualifier-seq shall only be part of the function type
9882 for a non-static member function. [8.3.5/4 dcl.fct] */
9883 if (type_memfn_quals (type) != TYPE_UNQUALIFIED
9884 && (current_class_type == NULL_TREE || staticp) )
9887 ? G_("qualified function types cannot be used to "
9888 "declare static member functions")
9889 : G_("qualified function types cannot be used to "
9890 "declare free functions"));
9891 type = TYPE_MAIN_VARIANT (type);
9894 /* The qualifiers on the function type become the qualifiers on
9895 the non-static member function. */
9896 memfn_quals |= type_memfn_quals (type);
9897 type_quals = TYPE_UNQUALIFIED;
9901 /* If this is a type name (such as, in a cast or sizeof),
9902 compute the type and return it now. */
9904 if (decl_context == TYPENAME)
9906 /* Note that the grammar rejects storage classes
9907 in typenames, fields or parameters. */
9908 if (type_quals != TYPE_UNQUALIFIED)
9909 type_quals = TYPE_UNQUALIFIED;
9911 /* Special case: "friend class foo" looks like a TYPENAME context. */
9914 if (type_quals != TYPE_UNQUALIFIED)
9916 error ("type qualifiers specified for friend class declaration");
9917 type_quals = TYPE_UNQUALIFIED;
9921 error ("%<inline%> specified for friend class declaration");
9927 /* Don't allow friend declaration without a class-key. */
9928 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9929 permerror (input_location, "template parameters cannot be friends");
9930 else if (TREE_CODE (type) == TYPENAME_TYPE)
9931 permerror (input_location, "friend declaration requires class-key, "
9932 "i.e. %<friend class %T::%D%>",
9933 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
9935 permerror (input_location, "friend declaration requires class-key, "
9936 "i.e. %<friend %#T%>",
9940 /* Only try to do this stuff if we didn't already give up. */
9941 if (type != integer_type_node)
9943 /* A friendly class? */
9944 if (current_class_type)
9945 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
9948 error ("trying to make class %qT a friend of global scope",
9951 type = void_type_node;
9954 else if (memfn_quals)
9956 if (ctype == NULL_TREE
9957 && TREE_CODE (type) == METHOD_TYPE)
9958 ctype = TYPE_METHOD_BASETYPE (type);
9961 type = build_memfn_type (type, ctype, memfn_quals);
9962 /* Core issue #547: need to allow this in template type args. */
9963 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
9964 type = apply_memfn_quals (type, memfn_quals);
9966 error ("invalid qualifiers on non-member function type");
9971 else if (unqualified_id == NULL_TREE && decl_context != PARM
9972 && decl_context != CATCHPARM
9973 && TREE_CODE (type) != UNION_TYPE
9976 error ("abstract declarator %qT used as declaration", type);
9977 return error_mark_node;
9980 /* Only functions may be declared using an operator-function-id. */
9982 && IDENTIFIER_OPNAME_P (unqualified_id)
9983 && TREE_CODE (type) != FUNCTION_TYPE
9984 && TREE_CODE (type) != METHOD_TYPE)
9986 error ("declaration of %qD as non-function", unqualified_id);
9987 return error_mark_node;
9990 /* We don't check parameter types here because we can emit a better
9991 error message later. */
9992 if (decl_context != PARM)
9994 type = check_var_type (unqualified_id, type);
9995 if (type == error_mark_node)
9996 return error_mark_node;
9999 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10000 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10002 if (decl_context == PARM || decl_context == CATCHPARM)
10004 if (ctype || in_namespace)
10005 error ("cannot use %<::%> in parameter declaration");
10007 if (type_uses_auto (type))
10009 error ("parameter declared %<auto%>");
10010 type = error_mark_node;
10013 /* A parameter declared as an array of T is really a pointer to T.
10014 One declared as a function is really a pointer to a function.
10015 One declared as a member is really a pointer to member. */
10017 if (TREE_CODE (type) == ARRAY_TYPE)
10019 /* Transfer const-ness of array into that of type pointed to. */
10020 type = build_pointer_type (TREE_TYPE (type));
10021 type_quals = TYPE_UNQUALIFIED;
10023 else if (TREE_CODE (type) == FUNCTION_TYPE)
10024 type = build_pointer_type (type);
10027 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
10028 && !NEW_DELETE_OPNAME_P (unqualified_id))
10030 cp_cv_quals real_quals = memfn_quals;
10031 if (constexpr_p && sfk != sfk_constructor && sfk != sfk_destructor)
10032 real_quals |= TYPE_QUAL_CONST;
10033 type = build_memfn_type (type, ctype, real_quals);
10039 if (decl_context == PARM)
10041 decl = cp_build_parm_decl (unqualified_id, type);
10043 bad_specifiers (decl, BSP_PARM, virtualp,
10044 memfn_quals != TYPE_UNQUALIFIED,
10045 inlinep, friendp, raises != NULL_TREE);
10047 else if (decl_context == FIELD)
10049 if (!staticp && TREE_CODE (type) != METHOD_TYPE
10050 && type_uses_auto (type))
10052 error ("non-static data member declared %<auto%>");
10053 type = error_mark_node;
10056 /* The C99 flexible array extension. */
10057 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
10058 && TYPE_DOMAIN (type) == NULL_TREE)
10060 tree itype = compute_array_index_type (dname, integer_zero_node,
10061 tf_warning_or_error);
10062 type = build_cplus_array_type (TREE_TYPE (type), itype);
10065 if (type == error_mark_node)
10067 /* Happens when declaring arrays of sizes which
10068 are error_mark_node, for example. */
10071 else if (in_namespace && !friendp)
10073 /* Something like struct S { int N::j; }; */
10074 error ("invalid use of %<::%>");
10075 return error_mark_node;
10077 else if (TREE_CODE (type) == FUNCTION_TYPE
10078 || TREE_CODE (type) == METHOD_TYPE)
10081 tree function_context;
10085 /* This should never happen in pure C++ (the check
10086 could be an assert). It could happen in
10087 Objective-C++ if someone writes invalid code that
10088 uses a function declaration for an instance
10089 variable or property (instance variables and
10090 properties are parsed as FIELD_DECLs, but they are
10091 part of an Objective-C class, not a C++ class).
10092 That code is invalid and is caught by this
10096 error ("declaration of function %qD in invalid context",
10098 return error_mark_node;
10101 /* ``A union may [ ... ] not [ have ] virtual functions.''
10103 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10105 error ("function %qD declared virtual inside a union",
10107 return error_mark_node;
10110 if (NEW_DELETE_OPNAME_P (unqualified_id))
10114 error ("%qD cannot be declared virtual, since it "
10115 "is always static",
10122 /* Check that the name used for a destructor makes sense. */
10123 if (sfk == sfk_destructor)
10125 tree uqname = id_declarator->u.id.unqualified_name;
10129 gcc_assert (friendp);
10130 error ("expected qualified name in friend declaration "
10131 "for destructor %qD", uqname);
10132 return error_mark_node;
10135 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
10137 error ("declaration of %qD as member of %qT",
10139 return error_mark_node;
10143 error ("a destructor cannot be %<constexpr%>");
10144 return error_mark_node;
10147 else if (sfk == sfk_constructor && friendp && !ctype)
10149 error ("expected qualified name in friend declaration "
10150 "for constructor %qD",
10151 id_declarator->u.id.unqualified_name);
10152 return error_mark_node;
10155 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10156 function_context = (ctype != NULL_TREE) ?
10157 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10158 publicp = (! friendp || ! staticp)
10159 && function_context == NULL_TREE;
10160 decl = grokfndecl (ctype, type,
10161 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
10162 ? unqualified_id : dname,
10165 virtualp, flags, memfn_quals, raises,
10166 friendp ? -1 : 0, friendp, publicp,
10167 inlinep | (2 * constexpr_p),
10169 funcdef_flag, template_count, in_namespace,
10170 attrlist, declarator->id_loc);
10171 decl = set_virt_specifiers (decl, virt_specifiers);
10172 if (decl == NULL_TREE)
10173 return error_mark_node;
10175 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10176 /* The decl and setting of decl_attr is also turned off. */
10177 decl = build_decl_attribute_variant (decl, decl_attr);
10180 /* [class.conv.ctor]
10182 A constructor declared without the function-specifier
10183 explicit that can be called with a single parameter
10184 specifies a conversion from the type of its first
10185 parameter to the type of its class. Such a constructor
10186 is called a converting constructor. */
10187 if (explicitp == 2)
10188 DECL_NONCONVERTING_P (decl) = 1;
10190 else if (!staticp && !dependent_type_p (type)
10191 && !COMPLETE_TYPE_P (complete_type (type))
10192 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10194 if (unqualified_id)
10195 error ("field %qD has incomplete type", unqualified_id);
10197 error ("name %qT has incomplete type", type);
10199 /* If we're instantiating a template, tell them which
10200 instantiation made the field's type be incomplete. */
10201 if (current_class_type
10202 && TYPE_NAME (current_class_type)
10203 && IDENTIFIER_TEMPLATE (current_class_name)
10205 && declspecs->type == type)
10206 error (" in instantiation of template %qT",
10207 current_class_type);
10209 return error_mark_node;
10215 error ("%qE is neither function nor member function; "
10216 "cannot be declared friend", unqualified_id);
10224 /* Friends are treated specially. */
10225 if (ctype == current_class_type)
10226 ; /* We already issued a permerror. */
10227 else if (decl && DECL_NAME (decl))
10229 if (template_class_depth (current_class_type) == 0)
10231 decl = check_explicit_specialization
10232 (unqualified_id, decl, template_count,
10233 2 * funcdef_flag + 4);
10234 if (decl == error_mark_node)
10235 return error_mark_node;
10238 decl = do_friend (ctype, unqualified_id, decl,
10244 return error_mark_node;
10247 /* Structure field. It may not be a function, except for C++. */
10249 if (decl == NULL_TREE)
10253 /* C++ allows static class members. All other work
10254 for this is done by grokfield. */
10255 decl = build_lang_decl_loc (declarator->id_loc,
10256 VAR_DECL, unqualified_id, type);
10257 set_linkage_for_static_data_member (decl);
10258 /* Even if there is an in-class initialization, DECL
10259 is considered undefined until an out-of-class
10260 definition is provided. */
10261 DECL_EXTERNAL (decl) = 1;
10264 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
10266 if (constexpr_p && !initialized)
10268 error ("constexpr static data member %qD must have an "
10269 "initializer", decl);
10270 constexpr_p = false;
10277 error ("non-static data member %qE declared %<constexpr%>",
10279 constexpr_p = false;
10281 decl = build_decl (input_location,
10282 FIELD_DECL, unqualified_id, type);
10283 DECL_NONADDRESSABLE_P (decl) = bitfield;
10284 if (bitfield && !unqualified_id)
10285 TREE_NO_WARNING (decl) = 1;
10287 if (storage_class == sc_mutable)
10289 DECL_MUTABLE_P (decl) = 1;
10290 storage_class = sc_none;
10295 /* An attempt is being made to initialize a non-static
10296 member. This is new in C++11. */
10297 maybe_warn_cpp0x (CPP0X_NSDMI);
10299 /* If this has been parsed with static storage class, but
10300 errors forced staticp to be cleared, ensure NSDMI is
10302 if (declspecs->storage_class == sc_static)
10303 DECL_INITIAL (decl) = error_mark_node;
10307 bad_specifiers (decl, BSP_FIELD, virtualp,
10308 memfn_quals != TYPE_UNQUALIFIED,
10309 inlinep, friendp, raises != NULL_TREE);
10312 else if (TREE_CODE (type) == FUNCTION_TYPE
10313 || TREE_CODE (type) == METHOD_TYPE)
10315 tree original_name;
10318 if (!unqualified_id)
10319 return error_mark_node;
10321 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10322 original_name = dname;
10324 original_name = unqualified_id;
10326 if (storage_class == sc_auto)
10327 error ("storage class %<auto%> invalid for function %qs", name);
10328 else if (storage_class == sc_register)
10329 error ("storage class %<register%> invalid for function %qs", name);
10331 error ("storage class %<__thread%> invalid for function %qs", name);
10333 if (virt_specifiers)
10334 error ("virt-specifiers in %qs not allowed outside a class definition", name);
10335 /* Function declaration not at top level.
10336 Storage classes other than `extern' are not allowed
10337 and `extern' makes no difference. */
10338 if (! toplevel_bindings_p ()
10339 && (storage_class == sc_static
10340 || decl_spec_seq_has_spec_p (declspecs, ds_inline))
10343 if (storage_class == sc_static)
10344 pedwarn (input_location, OPT_Wpedantic,
10345 "%<static%> specified invalid for function %qs "
10346 "declared out of global scope", name);
10348 pedwarn (input_location, OPT_Wpedantic,
10349 "%<inline%> specifier invalid for function %qs "
10350 "declared out of global scope", name);
10353 if (ctype == NULL_TREE)
10357 error ("virtual non-class function %qs", name);
10360 else if (sfk == sfk_constructor
10361 || sfk == sfk_destructor)
10363 error (funcdef_flag
10364 ? G_("%qs defined in a non-class scope")
10365 : G_("%qs declared in a non-class scope"), name);
10370 /* Record presence of `static'. */
10371 publicp = (ctype != NULL_TREE
10372 || storage_class == sc_extern
10373 || storage_class != sc_static);
10375 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
10376 virtualp, flags, memfn_quals, raises,
10378 publicp, inlinep | (2 * constexpr_p), sfk,
10380 template_count, in_namespace, attrlist,
10381 declarator->id_loc);
10382 if (decl == NULL_TREE)
10383 return error_mark_node;
10387 int invalid_static = 0;
10389 /* Don't allow a static member function in a class, and forbid
10390 declaring main to be static. */
10391 if (TREE_CODE (type) == METHOD_TYPE)
10393 permerror (input_location, "cannot declare member function %qD to have "
10394 "static linkage", decl);
10395 invalid_static = 1;
10397 else if (current_function_decl)
10399 /* FIXME need arm citation */
10400 error ("cannot declare static function inside another function");
10401 invalid_static = 1;
10404 if (invalid_static)
10407 storage_class = sc_none;
10413 /* It's a variable. */
10415 /* An uninitialized decl with `extern' is a reference. */
10416 decl = grokvardecl (type, unqualified_id,
10419 (type_quals & TYPE_QUAL_CONST) != 0,
10420 ctype ? ctype : in_namespace);
10421 bad_specifiers (decl, BSP_VAR, virtualp,
10422 memfn_quals != TYPE_UNQUALIFIED,
10423 inlinep, friendp, raises != NULL_TREE);
10427 DECL_CONTEXT (decl) = ctype;
10430 permerror (input_location, "%<static%> may not be used when defining "
10431 "(as opposed to declaring) a static data member");
10433 storage_class = sc_none;
10435 if (storage_class == sc_register && TREE_STATIC (decl))
10437 error ("static member %qD declared %<register%>", decl);
10438 storage_class = sc_none;
10440 if (storage_class == sc_extern && pedantic)
10442 pedwarn (input_location, OPT_Wpedantic,
10443 "cannot explicitly declare member %q#D to have "
10444 "extern linkage", decl);
10445 storage_class = sc_none;
10448 else if (constexpr_p && DECL_EXTERNAL (decl))
10450 error ("declaration of constexpr variable %qD is not a definition",
10452 constexpr_p = false;
10456 if (storage_class == sc_extern && initialized && !funcdef_flag)
10458 if (toplevel_bindings_p ())
10460 /* It's common practice (and completely valid) to have a const
10461 be initialized and declared extern. */
10462 if (!(type_quals & TYPE_QUAL_CONST))
10463 warning (0, "%qs initialized and declared %<extern%>", name);
10467 error ("%qs has both %<extern%> and initializer", name);
10468 return error_mark_node;
10472 /* Record `register' declaration for warnings on &
10473 and in case doing stupid register allocation. */
10475 if (storage_class == sc_register)
10476 DECL_REGISTER (decl) = 1;
10477 else if (storage_class == sc_extern)
10478 DECL_THIS_EXTERN (decl) = 1;
10479 else if (storage_class == sc_static)
10480 DECL_THIS_STATIC (decl) = 1;
10482 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10483 if (constexpr_p && TREE_CODE (decl) == VAR_DECL)
10484 DECL_DECLARED_CONSTEXPR_P (decl) = true;
10486 /* Record constancy and volatility on the DECL itself . There's
10487 no need to do this when processing a template; we'll do this
10488 for the instantiated declaration based on the type of DECL. */
10489 if (!processing_template_decl)
10490 cp_apply_type_quals_to_decl (type_quals, decl);
10496 /* Subroutine of start_function. Ensure that each of the parameter
10497 types (as listed in PARMS) is complete, as is required for a
10498 function definition. */
10501 require_complete_types_for_parms (tree parms)
10503 for (; parms; parms = DECL_CHAIN (parms))
10505 if (dependent_type_p (TREE_TYPE (parms)))
10507 if (!VOID_TYPE_P (TREE_TYPE (parms))
10508 && complete_type_or_else (TREE_TYPE (parms), parms))
10510 relayout_decl (parms);
10511 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
10514 /* grokparms or complete_type_or_else will have already issued
10516 TREE_TYPE (parms) = error_mark_node;
10520 /* Returns nonzero if T is a local variable. */
10523 local_variable_p (const_tree t)
10525 if ((TREE_CODE (t) == VAR_DECL
10526 /* A VAR_DECL with a context that is a _TYPE is a static data
10528 && !TYPE_P (CP_DECL_CONTEXT (t))
10529 /* Any other non-local variable must be at namespace scope. */
10530 && !DECL_NAMESPACE_SCOPE_P (t))
10531 || (TREE_CODE (t) == PARM_DECL))
10537 /* Like local_variable_p, but suitable for use as a tree-walking
10541 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
10544 /* Check DECL_NAME to avoid including temporaries. We don't check
10545 DECL_ARTIFICIAL because we do want to complain about 'this'. */
10546 if (local_variable_p (*tp) && DECL_NAME (*tp))
10548 else if (TYPE_P (*tp))
10549 *walk_subtrees = 0;
10554 /* Check that ARG, which is a default-argument expression for a
10555 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10556 something goes wrong. DECL may also be a _TYPE node, rather than a
10557 DECL, if there is no DECL available. */
10560 check_default_argument (tree decl, tree arg)
10565 if (TREE_CODE (arg) == DEFAULT_ARG)
10566 /* We get a DEFAULT_ARG when looking at an in-class declaration
10567 with a default argument. Ignore the argument for now; we'll
10568 deal with it after the class is complete. */
10577 decl_type = TREE_TYPE (decl);
10579 if (arg == error_mark_node
10580 || decl == error_mark_node
10581 || TREE_TYPE (arg) == error_mark_node
10582 || decl_type == error_mark_node)
10583 /* Something already went wrong. There's no need to check
10585 return error_mark_node;
10587 /* [dcl.fct.default]
10589 A default argument expression is implicitly converted to the
10591 ++cp_unevaluated_operand;
10592 perform_implicit_conversion_flags (decl_type, arg, tf_warning_or_error,
10594 --cp_unevaluated_operand;
10596 if (warn_zero_as_null_pointer_constant
10597 && c_inhibit_evaluation_warnings == 0
10598 && TYPE_PTR_OR_PTRMEM_P (decl_type)
10599 && null_ptr_cst_p (arg)
10600 && !NULLPTR_TYPE_P (TREE_TYPE (arg)))
10602 warning (OPT_Wzero_as_null_pointer_constant,
10603 "zero as null pointer constant");
10604 return nullptr_node;
10607 /* [dcl.fct.default]
10609 Local variables shall not be used in default argument
10612 The keyword `this' shall not be used in a default argument of a
10613 member function. */
10614 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
10617 if (DECL_NAME (var) == this_identifier)
10618 permerror (input_location, "default argument %qE uses %qD", arg, var);
10620 error ("default argument %qE uses local variable %qD", arg, var);
10621 return error_mark_node;
10628 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
10631 type_is_deprecated (tree type)
10633 enum tree_code code;
10634 if (TREE_DEPRECATED (type))
10636 if (TYPE_NAME (type)
10637 && TREE_DEPRECATED (TYPE_NAME (type)))
10640 /* Do warn about using typedefs to a deprecated class. */
10641 if (TAGGED_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
10642 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
10644 code = TREE_CODE (type);
10646 if (code == POINTER_TYPE || code == REFERENCE_TYPE
10647 || code == OFFSET_TYPE || code == FUNCTION_TYPE
10648 || code == METHOD_TYPE || code == ARRAY_TYPE)
10649 return type_is_deprecated (TREE_TYPE (type));
10651 if (TYPE_PTRMEMFUNC_P (type))
10652 return type_is_deprecated
10653 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
10658 /* Decode the list of parameter types for a function type.
10659 Given the list of things declared inside the parens,
10660 return a list of types.
10662 If this parameter does not end with an ellipsis, we append
10665 *PARMS is set to the chain of PARM_DECLs created. */
10668 grokparms (tree parmlist, tree *parms)
10670 tree result = NULL_TREE;
10671 tree decls = NULL_TREE;
10675 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
10677 tree type = NULL_TREE;
10678 tree init = TREE_PURPOSE (parm);
10679 tree decl = TREE_VALUE (parm);
10680 const char *errmsg;
10682 if (parm == void_list_node)
10685 if (! decl || TREE_TYPE (decl) == error_mark_node)
10688 type = TREE_TYPE (decl);
10689 if (VOID_TYPE_P (type))
10691 if (same_type_p (type, void_type_node)
10692 && DECL_SELF_REFERENCE_P (type)
10693 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
10694 /* this is a parmlist of `(void)', which is ok. */
10696 cxx_incomplete_type_error (decl, type);
10697 /* It's not a good idea to actually create parameters of
10698 type `void'; other parts of the compiler assume that a
10699 void type terminates the parameter list. */
10700 type = error_mark_node;
10701 TREE_TYPE (decl) = error_mark_node;
10704 if (type != error_mark_node
10705 && TYPE_FOR_JAVA (type)
10706 && MAYBE_CLASS_TYPE_P (type))
10708 error ("parameter %qD has Java class type", decl);
10709 type = error_mark_node;
10710 TREE_TYPE (decl) = error_mark_node;
10714 if (type != error_mark_node
10715 && (errmsg = targetm.invalid_parameter_type (type)))
10718 type = error_mark_node;
10719 TREE_TYPE (decl) = error_mark_node;
10722 if (type != error_mark_node)
10724 if (deprecated_state != DEPRECATED_SUPPRESS)
10726 tree deptype = type_is_deprecated (type);
10728 warn_deprecated_use (deptype, NULL_TREE);
10731 /* Top-level qualifiers on the parameters are
10732 ignored for function types. */
10733 type = cp_build_qualified_type (type, 0);
10734 if (TREE_CODE (type) == METHOD_TYPE)
10736 error ("parameter %qD invalidly declared method type", decl);
10737 type = build_pointer_type (type);
10738 TREE_TYPE (decl) = type;
10740 else if (abstract_virtuals_error (decl, type))
10741 any_error = 1; /* Seems like a good idea. */
10742 else if (POINTER_TYPE_P (type))
10744 /* [dcl.fct]/6, parameter types cannot contain pointers
10745 (references) to arrays of unknown bound. */
10746 tree t = TREE_TYPE (type);
10747 int ptr = TYPE_PTR_P (type);
10751 if (TYPE_PTR_P (t))
10753 else if (TREE_CODE (t) != ARRAY_TYPE)
10755 else if (!TYPE_DOMAIN (t))
10759 if (TREE_CODE (t) == ARRAY_TYPE)
10761 ? G_("parameter %qD includes pointer to array of "
10762 "unknown bound %qT")
10763 : G_("parameter %qD includes reference to array of "
10764 "unknown bound %qT"),
10770 else if (init && !processing_template_decl)
10771 init = check_default_argument (decl, init);
10774 DECL_CHAIN (decl) = decls;
10776 result = tree_cons (init, type, result);
10778 decls = nreverse (decls);
10779 result = nreverse (result);
10781 result = chainon (result, void_list_node);
10788 /* D is a constructor or overloaded `operator='.
10790 Let T be the class in which D is declared. Then, this function
10793 -1 if D's is an ill-formed constructor or copy assignment operator
10794 whose first parameter is of type `T'.
10795 0 if D is not a copy constructor or copy assignment
10797 1 if D is a copy constructor or copy assignment operator whose
10798 first parameter is a reference to non-const qualified T.
10799 2 if D is a copy constructor or copy assignment operator whose
10800 first parameter is a reference to const qualified T.
10802 This function can be used as a predicate. Positive values indicate
10803 a copy constructor and nonzero values indicate a copy assignment
10807 copy_fn_p (const_tree d)
10813 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
10815 if (TREE_CODE (d) == TEMPLATE_DECL
10816 || (DECL_TEMPLATE_INFO (d)
10817 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
10818 /* Instantiations of template member functions are never copy
10819 functions. Note that member functions of templated classes are
10820 represented as template functions internally, and we must
10821 accept those as copy functions. */
10824 args = FUNCTION_FIRST_USER_PARMTYPE (d);
10828 arg_type = TREE_VALUE (args);
10829 if (arg_type == error_mark_node)
10832 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
10834 /* Pass by value copy assignment operator. */
10837 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
10838 && !TYPE_REF_IS_RVALUE (arg_type)
10839 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
10841 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
10847 args = TREE_CHAIN (args);
10849 if (args && args != void_list_node && !TREE_PURPOSE (args))
10850 /* There are more non-optional args. */
10856 /* D is a constructor or overloaded `operator='.
10858 Let T be the class in which D is declared. Then, this function
10859 returns true when D is a move constructor or move assignment
10860 operator, false otherwise. */
10863 move_fn_p (const_tree d)
10865 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
10867 if (cxx_dialect == cxx98)
10868 /* There are no move constructors if we are in C++98 mode. */
10871 if (TREE_CODE (d) == TEMPLATE_DECL
10872 || (DECL_TEMPLATE_INFO (d)
10873 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
10874 /* Instantiations of template member functions are never move
10875 functions. Note that member functions of templated classes are
10876 represented as template functions internally, and we must
10877 accept those as move functions. */
10880 return move_signature_fn_p (d);
10883 /* D is a constructor or overloaded `operator='.
10885 Then, this function returns true when D has the same signature as a move
10886 constructor or move assignment operator (because either it is such a
10887 ctor/op= or it is a template specialization with the same signature),
10888 false otherwise. */
10891 move_signature_fn_p (const_tree d)
10895 bool result = false;
10897 args = FUNCTION_FIRST_USER_PARMTYPE (d);
10901 arg_type = TREE_VALUE (args);
10902 if (arg_type == error_mark_node)
10905 if (TREE_CODE (arg_type) == REFERENCE_TYPE
10906 && TYPE_REF_IS_RVALUE (arg_type)
10907 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
10911 args = TREE_CHAIN (args);
10913 if (args && args != void_list_node && !TREE_PURPOSE (args))
10914 /* There are more non-optional args. */
10920 /* Remember any special properties of member function DECL. */
10923 grok_special_member_properties (tree decl)
10927 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10930 class_type = DECL_CONTEXT (decl);
10931 if (DECL_CONSTRUCTOR_P (decl))
10933 int ctor = copy_fn_p (decl);
10935 if (!DECL_ARTIFICIAL (decl))
10936 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
10942 A non-template constructor for class X is a copy
10943 constructor if its first parameter is of type X&, const
10944 X&, volatile X& or const volatile X&, and either there
10945 are no other parameters or else all other parameters have
10946 default arguments. */
10947 TYPE_HAS_COPY_CTOR (class_type) = 1;
10948 if (user_provided_p (decl))
10949 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
10951 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
10953 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
10955 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
10956 if (user_provided_p (decl))
10957 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
10959 else if (move_fn_p (decl) && user_provided_p (decl))
10960 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
10961 else if (is_list_ctor (decl))
10962 TYPE_HAS_LIST_CTOR (class_type) = 1;
10964 if (DECL_DECLARED_CONSTEXPR_P (decl)
10965 && !copy_fn_p (decl) && !move_fn_p (decl))
10966 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
10968 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
10972 A non-template assignment operator for class X is a copy
10973 assignment operator if its parameter is of type X, X&, const
10974 X&, volatile X& or const volatile X&. */
10976 int assop = copy_fn_p (decl);
10980 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
10981 if (user_provided_p (decl))
10982 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
10984 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
10986 else if (move_fn_p (decl) && user_provided_p (decl))
10987 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
10989 /* Destructors are handled in check_methods. */
10992 /* Check a constructor DECL has the correct form. Complains
10993 if the class has a constructor of the form X(X). */
10996 grok_ctor_properties (const_tree ctype, const_tree decl)
10998 int ctor_parm = copy_fn_p (decl);
11004 A declaration of a constructor for a class X is ill-formed if
11005 its first parameter is of type (optionally cv-qualified) X
11006 and either there are no other parameters or else all other
11007 parameters have default arguments.
11009 We *don't* complain about member template instantiations that
11010 have this form, though; they can occur as we try to decide
11011 what constructor to use during overload resolution. Since
11012 overload resolution will never prefer such a constructor to
11013 the non-template copy constructor (which is either explicitly
11014 or implicitly defined), there's no need to worry about their
11015 existence. Theoretically, they should never even be
11016 instantiated, but that's hard to forestall. */
11017 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11025 /* An operator with this code is unary, but can also be binary. */
11028 ambi_op_p (enum tree_code code)
11030 return (code == INDIRECT_REF
11031 || code == ADDR_EXPR
11032 || code == UNARY_PLUS_EXPR
11033 || code == NEGATE_EXPR
11034 || code == PREINCREMENT_EXPR
11035 || code == PREDECREMENT_EXPR);
11038 /* An operator with this name can only be unary. */
11041 unary_op_p (enum tree_code code)
11043 return (code == TRUTH_NOT_EXPR
11044 || code == BIT_NOT_EXPR
11045 || code == COMPONENT_REF
11046 || code == TYPE_EXPR);
11049 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11050 errors are issued for invalid declarations. */
11053 grok_op_properties (tree decl, bool complain)
11055 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11057 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11058 tree name = DECL_NAME (decl);
11059 enum tree_code operator_code;
11064 /* Count the number of arguments and check for ellipsis. */
11065 for (argtype = argtypes, arity = 0;
11066 argtype && argtype != void_list_node;
11067 argtype = TREE_CHAIN (argtype))
11069 ellipsis_p = !argtype;
11071 class_type = DECL_CONTEXT (decl);
11072 if (class_type && !CLASS_TYPE_P (class_type))
11073 class_type = NULL_TREE;
11075 if (DECL_CONV_FN_P (decl))
11076 operator_code = TYPE_EXPR;
11080 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11081 if (ansi_opname (CODE) == name) \
11083 operator_code = (CODE); \
11086 else if (ansi_assopname (CODE) == name) \
11088 operator_code = (CODE); \
11089 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11093 #include "operators.def"
11094 #undef DEF_OPERATOR
11096 gcc_unreachable ();
11099 gcc_assert (operator_code != MAX_TREE_CODES);
11100 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11103 switch (operator_code)
11106 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
11110 TYPE_GETS_DELETE (class_type) |= 1;
11114 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
11117 case VEC_DELETE_EXPR:
11118 TYPE_GETS_DELETE (class_type) |= 2;
11125 /* [basic.std.dynamic.allocation]/1:
11127 A program is ill-formed if an allocation function is declared
11128 in a namespace scope other than global scope or declared static
11131 The same also holds true for deallocation functions. */
11132 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
11133 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11135 if (DECL_NAMESPACE_SCOPE_P (decl))
11137 if (CP_DECL_CONTEXT (decl) != global_namespace)
11139 error ("%qD may not be declared within a namespace", decl);
11142 else if (!TREE_PUBLIC (decl))
11144 error ("%qD may not be declared as static", decl);
11150 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
11152 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11153 DECL_IS_OPERATOR_NEW (decl) = 1;
11155 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11156 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11159 /* An operator function must either be a non-static member function
11160 or have at least one parameter of a class, a reference to a class,
11161 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11162 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11164 if (operator_code == TYPE_EXPR
11165 || operator_code == CALL_EXPR
11166 || operator_code == COMPONENT_REF
11167 || operator_code == ARRAY_REF
11168 || operator_code == NOP_EXPR)
11170 error ("%qD must be a nonstatic member function", decl);
11177 if (DECL_STATIC_FUNCTION_P (decl))
11179 error ("%qD must be either a non-static member "
11180 "function or a non-member function", decl);
11184 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
11186 tree arg = non_reference (TREE_VALUE (p));
11187 if (arg == error_mark_node)
11190 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11191 because these checks are performed even on
11192 template functions. */
11193 if (MAYBE_CLASS_TYPE_P (arg)
11194 || TREE_CODE (arg) == ENUMERAL_TYPE)
11198 if (!p || p == void_list_node)
11201 error ("%qD must have an argument of class or "
11202 "enumerated type", decl);
11208 /* There are no restrictions on the arguments to an overloaded
11210 if (operator_code == CALL_EXPR)
11213 /* Warn about conversion operators that will never be used. */
11214 if (IDENTIFIER_TYPENAME_P (name)
11215 && ! DECL_TEMPLATE_INFO (decl)
11217 /* Warn only declaring the function; there is no need to
11218 warn again about out-of-class definitions. */
11219 && class_type == current_class_type)
11221 tree t = TREE_TYPE (name);
11222 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11225 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11227 if (TREE_CODE (t) == VOID_TYPE)
11228 warning (OPT_Wconversion,
11230 ? G_("conversion to a reference to void "
11231 "will never use a type conversion operator")
11232 : G_("conversion to void "
11233 "will never use a type conversion operator"));
11234 else if (class_type)
11236 if (t == class_type)
11237 warning (OPT_Wconversion,
11239 ? G_("conversion to a reference to the same type "
11240 "will never use a type conversion operator")
11241 : G_("conversion to the same type "
11242 "will never use a type conversion operator"));
11243 /* Don't force t to be complete here. */
11244 else if (MAYBE_CLASS_TYPE_P (t)
11245 && COMPLETE_TYPE_P (t)
11246 && DERIVED_FROM_P (t, class_type))
11247 warning (OPT_Wconversion,
11249 ? G_("conversion to a reference to a base class "
11250 "will never use a type conversion operator")
11251 : G_("conversion to a base class "
11252 "will never use a type conversion operator"));
11257 if (operator_code == COND_EXPR)
11260 error ("ISO C++ prohibits overloading operator ?:");
11263 else if (ellipsis_p)
11265 error ("%qD must not have variable number of arguments", decl);
11268 else if (ambi_op_p (operator_code))
11271 /* We pick the one-argument operator codes by default, so
11272 we don't have to change anything. */
11274 else if (arity == 2)
11276 /* If we thought this was a unary operator, we now know
11277 it to be a binary operator. */
11278 switch (operator_code)
11281 operator_code = MULT_EXPR;
11285 operator_code = BIT_AND_EXPR;
11288 case UNARY_PLUS_EXPR:
11289 operator_code = PLUS_EXPR;
11293 operator_code = MINUS_EXPR;
11296 case PREINCREMENT_EXPR:
11297 operator_code = POSTINCREMENT_EXPR;
11300 case PREDECREMENT_EXPR:
11301 operator_code = POSTDECREMENT_EXPR;
11305 gcc_unreachable ();
11308 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11310 if ((operator_code == POSTINCREMENT_EXPR
11311 || operator_code == POSTDECREMENT_EXPR)
11312 && ! processing_template_decl
11313 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11316 error ("postfix %qD must take %<int%> as its argument",
11319 error ("postfix %qD must take %<int%> as its second "
11327 error ("%qD must take either zero or one argument", decl);
11329 error ("%qD must take either one or two arguments", decl);
11333 /* More Effective C++ rule 6. */
11335 && (operator_code == POSTINCREMENT_EXPR
11336 || operator_code == POSTDECREMENT_EXPR
11337 || operator_code == PREINCREMENT_EXPR
11338 || operator_code == PREDECREMENT_EXPR))
11340 tree arg = TREE_VALUE (argtypes);
11341 tree ret = TREE_TYPE (TREE_TYPE (decl));
11342 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11343 arg = TREE_TYPE (arg);
11344 arg = TYPE_MAIN_VARIANT (arg);
11345 if (operator_code == PREINCREMENT_EXPR
11346 || operator_code == PREDECREMENT_EXPR)
11348 if (TREE_CODE (ret) != REFERENCE_TYPE
11349 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11351 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
11352 build_reference_type (arg));
11356 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
11357 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
11361 else if (unary_op_p (operator_code))
11366 error ("%qD must take %<void%>", decl);
11368 error ("%qD must take exactly one argument", decl);
11372 else /* if (binary_op_p (operator_code)) */
11377 error ("%qD must take exactly one argument", decl);
11379 error ("%qD must take exactly two arguments", decl);
11383 /* More Effective C++ rule 7. */
11385 && (operator_code == TRUTH_ANDIF_EXPR
11386 || operator_code == TRUTH_ORIF_EXPR
11387 || operator_code == COMPOUND_EXPR))
11388 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
11392 /* Effective C++ rule 23. */
11395 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
11396 && (operator_code == PLUS_EXPR
11397 || operator_code == MINUS_EXPR
11398 || operator_code == TRUNC_DIV_EXPR
11399 || operator_code == MULT_EXPR
11400 || operator_code == TRUNC_MOD_EXPR)
11401 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
11402 warning (OPT_Weffc__, "%qD should return by value", decl);
11404 /* [over.oper]/8 */
11405 for (; argtypes && argtypes != void_list_node;
11406 argtypes = TREE_CHAIN (argtypes))
11407 if (TREE_PURPOSE (argtypes))
11409 TREE_PURPOSE (argtypes) = NULL_TREE;
11410 if (operator_code == POSTINCREMENT_EXPR
11411 || operator_code == POSTDECREMENT_EXPR)
11413 pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
11418 error ("%qD cannot have default arguments", decl);
11426 /* Return a string giving the keyword associate with CODE. */
11428 static const char *
11429 tag_name (enum tag_types code)
11441 case typename_type:
11444 gcc_unreachable ();
11448 /* Name lookup in an elaborated-type-specifier (after the keyword
11449 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11450 elaborated-type-specifier is invalid, issue a diagnostic and return
11451 error_mark_node; otherwise, return the *_TYPE to which it referred.
11452 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11455 check_elaborated_type_specifier (enum tag_types tag_code,
11457 bool allow_template_p)
11461 if (decl == error_mark_node)
11462 return error_mark_node;
11466 struct S { struct S *p; };
11468 name lookup will find the TYPE_DECL for the implicit "S::S"
11469 typedef. Adjust for that here. */
11470 if (DECL_SELF_REFERENCE_P (decl))
11471 decl = TYPE_NAME (TREE_TYPE (decl));
11473 type = TREE_TYPE (decl);
11475 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11476 is false for this case as well. */
11477 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11479 error ("using template type parameter %qT after %qs",
11480 type, tag_name (tag_code));
11481 return error_mark_node;
11483 /* Accept template template parameters. */
11484 else if (allow_template_p
11485 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
11486 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM))
11490 If the identifier resolves to a typedef-name or the
11491 simple-template-id resolves to an alias template
11492 specialization, the elaborated-type-specifier is ill-formed.
11494 In other words, the only legitimate declaration to use in the
11495 elaborated type specifier is the implicit typedef created when
11496 the type is declared. */
11497 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
11498 && !DECL_SELF_REFERENCE_P (decl)
11499 && tag_code != typename_type)
11501 if (alias_template_specialization_p (type))
11502 error ("using alias template specialization %qT after %qs",
11503 type, tag_name (tag_code));
11505 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
11506 inform (DECL_SOURCE_LOCATION (decl),
11507 "%qD has a previous declaration here", decl);
11508 return error_mark_node;
11510 else if (TREE_CODE (type) != RECORD_TYPE
11511 && TREE_CODE (type) != UNION_TYPE
11512 && tag_code != enum_type
11513 && tag_code != typename_type)
11515 error ("%qT referred to as %qs", type, tag_name (tag_code));
11516 error ("%q+T has a previous declaration here", type);
11517 return error_mark_node;
11519 else if (TREE_CODE (type) != ENUMERAL_TYPE
11520 && tag_code == enum_type)
11522 error ("%qT referred to as enum", type);
11523 error ("%q+T has a previous declaration here", type);
11524 return error_mark_node;
11526 else if (!allow_template_p
11527 && TREE_CODE (type) == RECORD_TYPE
11528 && CLASSTYPE_IS_TEMPLATE (type))
11530 /* If a class template appears as elaborated type specifier
11531 without a template header such as:
11533 template <class T> class C {};
11534 void f(class C); // No template header here
11536 then the required template argument is missing. */
11537 error ("template argument required for %<%s %T%>",
11538 tag_name (tag_code),
11539 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
11540 return error_mark_node;
11546 /* Lookup NAME in elaborate type specifier in scope according to
11547 SCOPE and issue diagnostics if necessary.
11548 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11549 found, and ERROR_MARK_NODE for type error. */
11552 lookup_and_check_tag (enum tag_types tag_code, tree name,
11553 tag_scope scope, bool template_header_p)
11557 if (scope == ts_global)
11559 /* First try ordinary name lookup, ignoring hidden class name
11560 injected via friend declaration. */
11561 decl = lookup_name_prefer_type (name, 2);
11562 /* If that fails, the name will be placed in the smallest
11563 non-class, non-function-prototype scope according to 3.3.1/5.
11564 We may already have a hidden name declared as friend in this
11565 scope. So lookup again but not ignoring hidden names.
11566 If we find one, that name will be made visible rather than
11567 creating a new tag. */
11569 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
11572 decl = lookup_type_scope (name, scope);
11575 && (DECL_CLASS_TEMPLATE_P (decl)
11576 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl)))
11577 decl = DECL_TEMPLATE_RESULT (decl);
11579 if (decl && TREE_CODE (decl) == TYPE_DECL)
11581 /* Look for invalid nested type:
11585 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
11587 error ("%qD has the same name as the class in which it is "
11590 return error_mark_node;
11593 /* Two cases we need to consider when deciding if a class
11594 template is allowed as an elaborated type specifier:
11595 1. It is a self reference to its own class.
11596 2. It comes with a template header.
11600 template <class T> class C {
11601 class C *c1; // DECL_SELF_REFERENCE_P is true
11604 template <class U> class C; // template_header_p is true
11605 template <class T> class C<T>::D {
11606 class C *c2; // DECL_SELF_REFERENCE_P is true
11609 t = check_elaborated_type_specifier (tag_code,
11612 | DECL_SELF_REFERENCE_P (decl));
11615 else if (decl && TREE_CODE (decl) == TREE_LIST)
11617 error ("reference to %qD is ambiguous", name);
11618 print_candidates (decl);
11619 return error_mark_node;
11625 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
11626 Define the tag as a forward-reference if it is not defined.
11628 If a declaration is given, process it here, and report an error if
11629 multiple declarations are not identical.
11631 SCOPE is TS_CURRENT when this is also a definition. Only look in
11632 the current frame for the name (since C++ allows new names in any
11633 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
11634 declaration. Only look beginning from the current scope outward up
11635 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
11637 TEMPLATE_HEADER_P is true when this declaration is preceded by
11638 a set of template parameters. */
11641 xref_tag_1 (enum tag_types tag_code, tree name,
11642 tag_scope scope, bool template_header_p)
11644 enum tree_code code;
11646 tree context = NULL_TREE;
11648 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
11654 code = RECORD_TYPE;
11660 code = ENUMERAL_TYPE;
11663 gcc_unreachable ();
11666 /* In case of anonymous name, xref_tag is only called to
11667 make type node and push name. Name lookup is not required. */
11668 if (ANON_AGGRNAME_P (name))
11671 t = lookup_and_check_tag (tag_code, name,
11672 scope, template_header_p);
11674 if (t == error_mark_node)
11675 return error_mark_node;
11677 if (scope != ts_current && t && current_class_type
11678 && template_class_depth (current_class_type)
11679 && template_header_p)
11681 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
11684 /* Since SCOPE is not TS_CURRENT, we are not looking at a
11685 definition of this tag. Since, in addition, we are currently
11686 processing a (member) template declaration of a template
11687 class, we must be very careful; consider:
11694 { template <class V>
11695 friend struct S1; };
11697 Here, the S2::S1 declaration should not be confused with the
11698 outer declaration. In particular, the inner version should
11699 have a template parameter of level 2, not level 1. This
11700 would be particularly important if the member declaration
11703 template <class V = U> friend struct S1;
11705 say, when we should tsubst into `U' when instantiating
11706 S2. On the other hand, when presented with:
11716 we must find the inner binding eventually. We
11717 accomplish this by making sure that the new type we
11718 create to represent this declaration has the right
11720 context = TYPE_CONTEXT (t);
11726 /* If no such tag is yet defined, create a forward-reference node
11727 and record it as the "definition".
11728 When a real declaration of this type is found,
11729 the forward-reference will be altered into a real type. */
11730 if (code == ENUMERAL_TYPE)
11732 error ("use of enum %q#D without previous declaration", name);
11733 return error_mark_node;
11737 t = make_class_type (code);
11738 TYPE_CONTEXT (t) = context;
11739 t = pushtag (name, t, scope);
11744 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
11746 if (!redeclare_class_template (t, current_template_parms))
11747 return error_mark_node;
11749 else if (!processing_template_decl
11750 && CLASS_TYPE_P (t)
11751 && CLASSTYPE_IS_TEMPLATE (t))
11753 error ("redeclaration of %qT as a non-template", t);
11754 error ("previous declaration %q+D", t);
11755 return error_mark_node;
11758 /* Make injected friend class visible. */
11759 if (scope != ts_within_enclosing_non_class
11760 && hidden_name_p (TYPE_NAME (t)))
11762 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
11763 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
11765 if (TYPE_TEMPLATE_INFO (t))
11767 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
11768 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
11776 /* Wrapper for xref_tag_1. */
11779 xref_tag (enum tag_types tag_code, tree name,
11780 tag_scope scope, bool template_header_p)
11784 subtime = timevar_cond_start (TV_NAME_LOOKUP);
11785 ret = xref_tag_1 (tag_code, name, scope, template_header_p);
11786 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
11792 xref_tag_from_type (tree old, tree id, tag_scope scope)
11794 enum tag_types tag_kind;
11796 if (TREE_CODE (old) == RECORD_TYPE)
11797 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
11799 tag_kind = union_type;
11801 if (id == NULL_TREE)
11802 id = TYPE_IDENTIFIER (old);
11804 return xref_tag (tag_kind, id, scope, false);
11807 /* Create the binfo hierarchy for REF with (possibly NULL) base list
11808 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
11809 access_* node, and the TREE_VALUE is the type of the base-class.
11810 Non-NULL TREE_TYPE indicates virtual inheritance.
11812 Returns true if the binfo hierarchy was successfully created,
11813 false if an error was detected. */
11816 xref_basetypes (tree ref, tree base_list)
11819 tree binfo, base_binfo;
11820 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
11821 unsigned max_bases = 0; /* Maximum direct bases. */
11823 tree default_access;
11824 tree igo_prev; /* Track Inheritance Graph Order. */
11826 if (ref == error_mark_node)
11829 /* The base of a derived class is private by default, all others are
11831 default_access = (TREE_CODE (ref) == RECORD_TYPE
11832 && CLASSTYPE_DECLARED_CLASS (ref)
11833 ? access_private_node : access_public_node);
11835 /* First, make sure that any templates in base-classes are
11836 instantiated. This ensures that if we call ourselves recursively
11837 we do not get confused about which classes are marked and which
11839 basep = &base_list;
11842 tree basetype = TREE_VALUE (*basep);
11844 /* The dependent_type_p call below should really be dependent_scope_p
11845 so that we give a hard error about using an incomplete type as a
11846 base, but we allow it with a pedwarn for backward
11848 if (processing_template_decl
11849 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype))
11850 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN);
11851 if (!dependent_type_p (basetype)
11852 && !complete_type_or_else (basetype, NULL))
11853 /* An incomplete type. Remove it from the list. */
11854 *basep = TREE_CHAIN (*basep);
11858 if (TREE_TYPE (*basep))
11860 if (CLASS_TYPE_P (basetype))
11861 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
11862 basep = &TREE_CHAIN (*basep);
11866 TYPE_MARKED_P (ref) = 1;
11868 /* The binfo slot should be empty, unless this is an (ill-formed)
11870 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref))
11872 error ("redefinition of %q#T", ref);
11876 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
11878 binfo = make_tree_binfo (max_bases);
11880 TYPE_BINFO (ref) = binfo;
11881 BINFO_OFFSET (binfo) = size_zero_node;
11882 BINFO_TYPE (binfo) = ref;
11884 /* Apply base-class info set up to the variants of this type. */
11885 fixup_type_variants (ref);
11889 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
11890 /* An aggregate cannot have baseclasses. */
11891 CLASSTYPE_NON_AGGREGATE (ref) = 1;
11893 if (TREE_CODE (ref) == UNION_TYPE)
11895 error ("derived union %qT invalid", ref);
11902 if (TYPE_FOR_JAVA (ref))
11904 error ("Java class %qT cannot have multiple bases", ref);
11911 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
11913 if (TYPE_FOR_JAVA (ref))
11915 error ("Java class %qT cannot have virtual bases", ref);
11920 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
11922 tree access = TREE_PURPOSE (base_list);
11923 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
11924 tree basetype = TREE_VALUE (base_list);
11926 if (access == access_default_node)
11927 access = default_access;
11929 if (PACK_EXPANSION_P (basetype))
11930 basetype = PACK_EXPANSION_PATTERN (basetype);
11931 if (TREE_CODE (basetype) == TYPE_DECL)
11932 basetype = TREE_TYPE (basetype);
11933 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
11935 error ("base type %qT fails to be a struct or class type",
11940 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
11941 TYPE_FOR_JAVA (ref) = 1;
11943 base_binfo = NULL_TREE;
11944 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
11946 base_binfo = TYPE_BINFO (basetype);
11947 /* The original basetype could have been a typedef'd type. */
11948 basetype = BINFO_TYPE (base_binfo);
11950 /* Inherit flags from the base. */
11951 TYPE_HAS_NEW_OPERATOR (ref)
11952 |= TYPE_HAS_NEW_OPERATOR (basetype);
11953 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
11954 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
11955 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
11956 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
11957 CLASSTYPE_DIAMOND_SHAPED_P (ref)
11958 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
11959 CLASSTYPE_REPEATED_BASE_P (ref)
11960 |= CLASSTYPE_REPEATED_BASE_P (basetype);
11963 /* We must do this test after we've seen through a typedef
11965 if (TYPE_MARKED_P (basetype))
11967 if (basetype == ref)
11968 error ("recursive type %qT undefined", basetype);
11970 error ("duplicate base type %qT invalid", basetype);
11974 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
11975 /* Regenerate the pack expansion for the bases. */
11976 basetype = make_pack_expansion (basetype);
11978 TYPE_MARKED_P (basetype) = 1;
11980 base_binfo = copy_binfo (base_binfo, basetype, ref,
11981 &igo_prev, via_virtual);
11982 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
11983 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
11985 BINFO_BASE_APPEND (binfo, base_binfo);
11986 BINFO_BASE_ACCESS_APPEND (binfo, access);
11989 if (VEC_length (tree, CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
11990 /* If we didn't get max_vbases vbases, we must have shared at
11991 least one of them, and are therefore diamond shaped. */
11992 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
11994 /* Unmark all the types. */
11995 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
11996 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
11997 TYPE_MARKED_P (ref) = 0;
11999 /* Now see if we have a repeated base type. */
12000 if (!CLASSTYPE_REPEATED_BASE_P (ref))
12002 for (base_binfo = binfo; base_binfo;
12003 base_binfo = TREE_CHAIN (base_binfo))
12005 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12007 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
12010 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
12012 for (base_binfo = binfo; base_binfo;
12013 base_binfo = TREE_CHAIN (base_binfo))
12014 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12015 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12024 /* Copies the enum-related properties from type SRC to type DST.
12025 Used with the underlying type of an enum and the enum itself. */
12027 copy_type_enum (tree dst, tree src)
12030 for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
12032 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
12033 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
12034 TYPE_SIZE (t) = TYPE_SIZE (src);
12035 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
12036 SET_TYPE_MODE (dst, TYPE_MODE (src));
12037 TYPE_PRECISION (t) = TYPE_PRECISION (src);
12038 TYPE_ALIGN (t) = TYPE_ALIGN (src);
12039 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
12040 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
12044 /* Begin compiling the definition of an enumeration type.
12047 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12049 UNDERLYING_TYPE is the type that will be used as the storage for
12050 the enumeration type. This should be NULL_TREE if no storage type
12053 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12055 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12057 Returns the type object, as yet incomplete.
12058 Also records info about it so that build_enumerator
12059 may be used to declare the individual values as they are read. */
12062 start_enum (tree name, tree enumtype, tree underlying_type,
12063 bool scoped_enum_p, bool *is_new)
12065 tree prevtype = NULL_TREE;
12066 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
12070 /* [C++0x dcl.enum]p5:
12072 If not explicitly specified, the underlying type of a scoped
12073 enumeration type is int. */
12074 if (!underlying_type && scoped_enum_p)
12075 underlying_type = integer_type_node;
12077 if (underlying_type)
12078 underlying_type = cv_unqualified (underlying_type);
12080 /* If this is the real definition for a previous forward reference,
12081 fill in the contents in the same object that used to be the
12082 forward reference. */
12084 enumtype = lookup_and_check_tag (enum_type, name,
12085 /*tag_scope=*/ts_current,
12086 /*template_header_p=*/false);
12088 /* In case of a template_decl, the only check that should be deferred
12089 to instantiation time is the comparison of underlying types. */
12090 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12092 if (scoped_enum_p != SCOPED_ENUM_P (enumtype))
12094 error_at (input_location, "scoped/unscoped mismatch "
12095 "in enum %q#T", enumtype);
12096 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12097 "previous definition here");
12098 enumtype = error_mark_node;
12100 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type)
12102 error_at (input_location, "underlying type mismatch "
12103 "in enum %q#T", enumtype);
12104 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12105 "previous definition here");
12106 enumtype = error_mark_node;
12108 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
12109 && !dependent_type_p (underlying_type)
12110 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))
12111 && !same_type_p (underlying_type,
12112 ENUM_UNDERLYING_TYPE (enumtype)))
12114 error_at (input_location, "different underlying type "
12115 "in enum %q#T", enumtype);
12116 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12117 "previous definition here");
12118 underlying_type = NULL_TREE;
12122 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE
12123 || processing_template_decl)
12125 /* In case of error, make a dummy enum to allow parsing to
12127 if (enumtype == error_mark_node)
12129 name = make_anon_name ();
12130 enumtype = NULL_TREE;
12133 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12134 of an opaque enum, or an opaque enum of an already defined
12135 enumeration (C++0x only).
12136 In any other case, it'll be NULL_TREE. */
12142 prevtype = enumtype;
12144 /* Do not push the decl more than once, unless we need to
12145 compare underlying types at instantiation time */
12147 || TREE_CODE (enumtype) != ENUMERAL_TYPE
12148 || (underlying_type
12149 && dependent_type_p (underlying_type))
12150 || (ENUM_UNDERLYING_TYPE (enumtype)
12151 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))))
12153 enumtype = cxx_make_type (ENUMERAL_TYPE);
12154 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
12157 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
12160 if (enumtype == error_mark_node)
12161 return error_mark_node;
12163 /* The enum is considered opaque until the opening '{' of the
12164 enumerator list. */
12165 SET_OPAQUE_ENUM_P (enumtype, true);
12166 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type;
12169 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p);
12171 if (underlying_type)
12173 if (CP_INTEGRAL_TYPE_P (underlying_type))
12175 copy_type_enum (enumtype, underlying_type);
12176 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12178 else if (dependent_type_p (underlying_type))
12179 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12181 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12182 underlying_type, enumtype);
12185 /* If into a template class, the returned enum is always the first
12186 declaration (opaque or not) seen. This way all the references to
12187 this type will be to the same declaration. The following ones are used
12188 only to check for definition errors. */
12189 if (prevtype && processing_template_decl)
12195 /* After processing and defining all the values of an enumeration type,
12196 install their decls in the enumeration type.
12197 ENUMTYPE is the type object. */
12200 finish_enum_value_list (tree enumtype)
12203 tree underlying_type;
12206 tree minnode, maxnode;
12209 bool fixed_underlying_type_p
12210 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
12212 /* We built up the VALUES in reverse order. */
12213 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12215 /* For an enum defined in a template, just set the type of the values;
12216 all further processing is postponed until the template is
12217 instantiated. We need to set the type so that tsubst of a CONST_DECL
12219 if (processing_template_decl)
12221 for (values = TYPE_VALUES (enumtype);
12223 values = TREE_CHAIN (values))
12224 TREE_TYPE (TREE_VALUE (values)) = enumtype;
12228 /* Determine the minimum and maximum values of the enumerators. */
12229 if (TYPE_VALUES (enumtype))
12231 minnode = maxnode = NULL_TREE;
12233 for (values = TYPE_VALUES (enumtype);
12235 values = TREE_CHAIN (values))
12237 decl = TREE_VALUE (values);
12239 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12240 each enumerator has the type of its enumeration. Prior to the
12241 closing brace, the type of each enumerator is the type of its
12242 initializing value. */
12243 TREE_TYPE (decl) = enumtype;
12245 /* Update the minimum and maximum values, if appropriate. */
12246 value = DECL_INITIAL (decl);
12247 if (value == error_mark_node)
12248 value = integer_zero_node;
12249 /* Figure out what the minimum and maximum values of the
12250 enumerators are. */
12252 minnode = maxnode = value;
12253 else if (tree_int_cst_lt (maxnode, value))
12255 else if (tree_int_cst_lt (value, minnode))
12262 If the enumerator-list is empty, the underlying type is as if
12263 the enumeration had a single enumerator with value 0. */
12264 minnode = maxnode = integer_zero_node;
12266 if (!fixed_underlying_type_p)
12268 /* Compute the number of bits require to represent all values of the
12269 enumeration. We must do this before the type of MINNODE and
12270 MAXNODE are transformed, since tree_int_cst_min_precision relies
12271 on the TREE_TYPE of the value it is passed. */
12272 bool unsignedp = tree_int_cst_sgn (minnode) >= 0;
12273 int lowprec = tree_int_cst_min_precision (minnode, unsignedp);
12274 int highprec = tree_int_cst_min_precision (maxnode, unsignedp);
12275 int precision = MAX (lowprec, highprec);
12277 bool use_short_enum;
12279 /* Determine the underlying type of the enumeration.
12283 The underlying type of an enumeration is an integral type that
12284 can represent all the enumerator values defined in the
12285 enumeration. It is implementation-defined which integral type is
12286 used as the underlying type for an enumeration except that the
12287 underlying type shall not be larger than int unless the value of
12288 an enumerator cannot fit in an int or unsigned int.
12290 We use "int" or an "unsigned int" as the underlying type, even if
12291 a smaller integral type would work, unless the user has
12292 explicitly requested that we use the smallest possible type. The
12293 user can request that for all enumerations with a command line
12294 flag, or for just one enumeration with an attribute. */
12296 use_short_enum = flag_short_enums
12297 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
12299 for (itk = (use_short_enum ? itk_char : itk_int);
12303 underlying_type = integer_types[itk];
12304 if (underlying_type != NULL_TREE
12305 && TYPE_PRECISION (underlying_type) >= precision
12306 && TYPE_UNSIGNED (underlying_type) == unsignedp)
12309 if (itk == itk_none)
12313 IF no integral type can represent all the enumerator values, the
12314 enumeration is ill-formed. */
12315 error ("no integral type can represent all of the enumerator values "
12316 "for %qT", enumtype);
12317 precision = TYPE_PRECISION (long_long_integer_type_node);
12318 underlying_type = integer_types[itk_unsigned_long_long];
12323 The value of sizeof() applied to an enumeration type, an object
12324 of an enumeration type, or an enumerator, is the value of sizeof()
12325 applied to the underlying type. */
12326 copy_type_enum (enumtype, underlying_type);
12328 /* Compute the minimum and maximum values for the type.
12332 For an enumeration where emin is the smallest enumerator and emax
12333 is the largest, the values of the enumeration are the values of the
12334 underlying type in the range bmin to bmax, where bmin and bmax are,
12335 respectively, the smallest and largest values of the smallest bit-
12336 field that can store emin and emax. */
12338 /* The middle-end currently assumes that types with TYPE_PRECISION
12339 narrower than their underlying type are suitably zero or sign
12340 extended to fill their mode. Similarly, it assumes that the front
12341 end assures that a value of a particular type must be within
12342 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12344 We used to set these fields based on bmin and bmax, but that led
12345 to invalid assumptions like optimizing away bounds checking. So
12346 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12347 TYPE_MAX_VALUE to the values for the mode above and only restrict
12348 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12349 ENUM_UNDERLYING_TYPE (enumtype)
12350 = build_distinct_type_copy (underlying_type);
12351 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
12352 set_min_and_max_values_for_integral_type
12353 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
12355 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12356 if (flag_strict_enums)
12357 set_min_and_max_values_for_integral_type (enumtype, precision,
12361 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
12363 /* Convert each of the enumerators to the type of the underlying
12364 type of the enumeration. */
12365 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12367 location_t saved_location;
12369 decl = TREE_VALUE (values);
12370 saved_location = input_location;
12371 input_location = DECL_SOURCE_LOCATION (decl);
12372 if (fixed_underlying_type_p)
12373 /* If the enumeration type has a fixed underlying type, we
12374 already checked all of the enumerator values. */
12375 value = DECL_INITIAL (decl);
12377 value = perform_implicit_conversion (underlying_type,
12378 DECL_INITIAL (decl),
12379 tf_warning_or_error);
12380 input_location = saved_location;
12382 /* Do not clobber shared ints. */
12383 value = copy_node (value);
12385 TREE_TYPE (value) = enumtype;
12386 DECL_INITIAL (decl) = value;
12389 /* Fix up all variant types of this enum type. */
12390 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
12391 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
12393 if (at_class_scope_p ()
12394 && COMPLETE_TYPE_P (current_class_type)
12395 && UNSCOPED_ENUM_P (enumtype))
12396 insert_late_enum_def_into_classtype_sorted_fields (enumtype,
12397 current_class_type);
12399 /* Finish debugging output for this type. */
12400 rest_of_type_compilation (enumtype, namespace_bindings_p ());
12403 /* Finishes the enum type. This is called only the first time an
12404 enumeration is seen, be it opaque or odinary.
12405 ENUMTYPE is the type object. */
12408 finish_enum (tree enumtype)
12410 if (processing_template_decl)
12412 if (at_function_scope_p ())
12413 add_stmt (build_min (TAG_DEFN, enumtype));
12417 /* If this is a forward declaration, there should not be any variants,
12418 though we can get a variant in the middle of an enum-specifier with
12419 wacky code like 'enum E { e = sizeof(const E*) };' */
12420 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
12421 && (TYPE_VALUES (enumtype)
12422 || !TYPE_NEXT_VARIANT (enumtype)));
12425 /* Build and install a CONST_DECL for an enumeration constant of the
12426 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12427 LOC is the location of NAME.
12428 Assignment of sequential values by default is handled here. */
12431 build_enumerator (tree name, tree value, tree enumtype, location_t loc)
12437 /* If the VALUE was erroneous, pretend it wasn't there; that will
12438 result in the enum being assigned the next value in sequence. */
12439 if (value == error_mark_node)
12442 /* Remove no-op casts from the value. */
12444 STRIP_TYPE_NOPS (value);
12446 if (! processing_template_decl)
12448 /* Validate and default VALUE. */
12449 if (value != NULL_TREE)
12451 value = cxx_constant_value (value);
12453 if (TREE_CODE (value) != INTEGER_CST
12454 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
12456 error ("enumerator value for %qD is not an integer constant",
12462 /* Default based on previous value. */
12463 if (value == NULL_TREE)
12465 if (TYPE_VALUES (enumtype))
12470 /* C++03 7.2/4: If no initializer is specified for the first
12471 enumerator, the type is an unspecified integral
12472 type. Otherwise the type is the same as the type of the
12473 initializing value of the preceding enumerator unless the
12474 incremented value is not representable in that type, in
12475 which case the type is an unspecified integral type
12476 sufficient to contain the incremented value. */
12477 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12478 if (error_operand_p (prev_value))
12479 value = error_mark_node;
12482 double_int di = TREE_INT_CST (prev_value)
12483 .add_with_sign (double_int_one,
12484 false, &overflowed);
12487 tree type = TREE_TYPE (prev_value);
12488 bool pos = TYPE_UNSIGNED (type) || !di.is_negative ();
12489 if (!double_int_fits_to_tree_p (type, di))
12492 for (itk = itk_int; itk != itk_none; itk++)
12494 type = integer_types[itk];
12495 if (type != NULL_TREE
12496 && (pos || !TYPE_UNSIGNED (type))
12497 && double_int_fits_to_tree_p (type, di))
12500 if (type && cxx_dialect < cxx0x
12501 && itk > itk_unsigned_long)
12502 pedwarn (input_location, OPT_Wlong_long, pos ? "\
12503 incremented enumerator value is too large for %<unsigned long%>" : "\
12504 incremented enumerator value is too large for %<long%>");
12506 if (type == NULL_TREE)
12509 value = double_int_to_tree (type, di);
12514 error ("overflow in enumeration values at %qD", name);
12515 value = error_mark_node;
12520 value = integer_zero_node;
12523 /* Remove no-op casts from the value. */
12524 STRIP_TYPE_NOPS (value);
12526 /* If the underlying type of the enum is fixed, check whether
12527 the enumerator values fits in the underlying type. If it
12528 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12529 if (ENUM_UNDERLYING_TYPE (enumtype)
12531 && TREE_CODE (value) == INTEGER_CST
12532 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
12534 error ("enumerator value %E is too large for underlying type %<%T%>",
12535 value, ENUM_UNDERLYING_TYPE (enumtype));
12537 /* Silently convert the value so that we can continue. */
12538 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
12543 /* C++ associates enums with global, function, or class declarations. */
12544 context = current_scope ();
12546 /* Build the actual enumeration constant. Note that the enumeration
12547 constants have the underlying type of the enum (if it is fixed)
12548 or the type of their initializer (if the underlying type of the
12549 enum is not fixed):
12553 If the underlying type is fixed, the type of each enumerator
12554 prior to the closing brace is the underlying type; if the
12555 initializing value of an enumerator cannot be represented by
12556 the underlying type, the program is ill-formed. If the
12557 underlying type is not fixed, the type of each enumerator is
12558 the type of its initializing value.
12560 If the underlying type is not fixed, it will be computed by
12561 finish_enum and we will reset the type of this enumerator. Of
12562 course, if we're processing a template, there may be no value. */
12563 type = value ? TREE_TYPE (value) : NULL_TREE;
12565 decl = build_decl (loc, CONST_DECL, name, type);
12567 DECL_CONTEXT (decl) = enumtype;
12568 TREE_CONSTANT (decl) = 1;
12569 TREE_READONLY (decl) = 1;
12570 DECL_INITIAL (decl) = value;
12572 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
12573 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12574 on the TYPE_FIELDS list for `S'. (That's so that you can say
12575 things like `S::i' later.) */
12576 finish_member_declaration (decl);
12580 /* Add this enumeration constant to the list for this type. */
12581 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12584 /* Look for an enumerator with the given NAME within the enumeration
12585 type ENUMTYPE. This routine is used primarily for qualified name
12586 lookup into an enumerator in C++0x, e.g.,
12588 enum class Color { Red, Green, Blue };
12590 Color color = Color::Red;
12592 Returns the value corresponding to the enumerator, or
12593 NULL_TREE if no such enumerator was found. */
12595 lookup_enumerator (tree enumtype, tree name)
12598 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
12600 e = purpose_member (name, TYPE_VALUES (enumtype));
12601 return e? TREE_VALUE (e) : NULL_TREE;
12605 /* We're defining DECL. Make sure that its type is OK. */
12608 check_function_type (tree decl, tree current_function_parms)
12610 tree fntype = TREE_TYPE (decl);
12611 tree return_type = complete_type (TREE_TYPE (fntype));
12613 /* In a function definition, arg types must be complete. */
12614 require_complete_types_for_parms (current_function_parms);
12616 if (dependent_type_p (return_type)
12617 || type_uses_auto (return_type))
12619 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
12620 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
12622 tree args = TYPE_ARG_TYPES (fntype);
12624 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
12625 error ("return type %q#T is incomplete", return_type);
12627 error ("return type has Java class type %q#T", return_type);
12629 /* Make it return void instead. */
12630 if (TREE_CODE (fntype) == METHOD_TYPE)
12631 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
12633 TREE_CHAIN (args));
12635 fntype = build_function_type (void_type_node, args);
12637 = build_exception_variant (fntype,
12638 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
12639 fntype = (cp_build_type_attribute_variant
12640 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
12641 TREE_TYPE (decl) = fntype;
12644 abstract_virtuals_error (decl, TREE_TYPE (fntype));
12647 /* Create the FUNCTION_DECL for a function definition.
12648 DECLSPECS and DECLARATOR are the parts of the declaration;
12649 they describe the function's name and the type it returns,
12650 but twisted together in a fashion that parallels the syntax of C.
12652 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12653 DECLARATOR is really the DECL for the function we are about to
12654 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12655 indicating that the function is an inline defined in-class.
12657 This function creates a binding context for the function body
12658 as well as setting up the FUNCTION_DECL in current_function_decl.
12660 For C++, we must first check whether that datum makes any sense.
12661 For example, "class A local_a(1,2);" means that variable local_a
12662 is an aggregate of type A, which should have a constructor
12663 applied to it with the argument list [1, 2].
12665 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
12666 or may be a BLOCK if the function has been defined previously
12667 in this translation unit. On exit, DECL_INITIAL (decl1) will be
12668 error_mark_node if the function has never been defined, or
12669 a BLOCK if the function has been defined somewhere. */
12672 start_preparsed_function (tree decl1, tree attrs, int flags)
12674 tree ctype = NULL_TREE;
12677 int doing_friend = 0;
12678 cp_binding_level *bl;
12679 tree current_function_parms;
12680 struct c_fileinfo *finfo
12681 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
12682 bool honor_interface;
12684 /* Sanity check. */
12685 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
12686 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
12688 fntype = TREE_TYPE (decl1);
12689 if (TREE_CODE (fntype) == METHOD_TYPE)
12690 ctype = TYPE_METHOD_BASETYPE (fntype);
12692 /* ISO C++ 11.4/5. A friend function defined in a class is in
12693 the (lexical) scope of the class in which it is defined. */
12694 if (!ctype && DECL_FRIEND_P (decl1))
12696 ctype = DECL_FRIEND_CONTEXT (decl1);
12698 /* CTYPE could be null here if we're dealing with a template;
12699 for example, `inline friend float foo()' inside a template
12700 will have no CTYPE set. */
12701 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12707 if (DECL_DECLARED_INLINE_P (decl1)
12708 && lookup_attribute ("noinline", attrs))
12709 warning (0, "inline function %q+D given attribute noinline", decl1);
12711 /* Handle gnu_inline attribute. */
12712 if (GNU_INLINE_P (decl1))
12714 DECL_EXTERNAL (decl1) = 1;
12715 DECL_NOT_REALLY_EXTERN (decl1) = 0;
12716 DECL_INTERFACE_KNOWN (decl1) = 1;
12717 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
12720 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
12721 /* This is a constructor, we must ensure that any default args
12722 introduced by this definition are propagated to the clones
12723 now. The clones are used directly in overload resolution. */
12724 adjust_clone_args (decl1);
12726 /* Sometimes we don't notice that a function is a static member, and
12727 build a METHOD_TYPE for it. Fix that up now. */
12728 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
12729 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE));
12731 /* Set up current_class_type, and enter the scope of the class, if
12734 push_nested_class (ctype);
12735 else if (DECL_STATIC_FUNCTION_P (decl1))
12736 push_nested_class (DECL_CONTEXT (decl1));
12738 /* Now that we have entered the scope of the class, we must restore
12739 the bindings for any template parameters surrounding DECL1, if it
12740 is an inline member template. (Order is important; consider the
12741 case where a template parameter has the same name as a field of
12742 the class.) It is not until after this point that
12743 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
12744 if (flags & SF_INCLASS_INLINE)
12745 maybe_begin_member_template_processing (decl1);
12747 /* Effective C++ rule 15. */
12749 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
12750 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
12751 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
12753 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12754 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12755 if (!DECL_INITIAL (decl1))
12756 DECL_INITIAL (decl1) = error_mark_node;
12758 /* This function exists in static storage.
12759 (This does not mean `static' in the C sense!) */
12760 TREE_STATIC (decl1) = 1;
12762 /* We must call push_template_decl after current_class_type is set
12763 up. (If we are processing inline definitions after exiting a
12764 class scope, current_class_type will be NULL_TREE until set above
12765 by push_nested_class.) */
12766 if (processing_template_decl)
12768 /* FIXME: Handle error_mark_node more gracefully. */
12769 tree newdecl1 = push_template_decl (decl1);
12770 if (newdecl1 != error_mark_node)
12774 /* We are now in the scope of the function being defined. */
12775 current_function_decl = decl1;
12777 /* Save the parm names or decls from this function's declarator
12778 where store_parm_decls will find them. */
12779 current_function_parms = DECL_ARGUMENTS (decl1);
12781 /* Make sure the parameter and return types are reasonable. When
12782 you declare a function, these types can be incomplete, but they
12783 must be complete when you define the function. */
12784 check_function_type (decl1, current_function_parms);
12786 /* Build the return declaration for the function. */
12787 restype = TREE_TYPE (fntype);
12789 if (DECL_RESULT (decl1) == NULL_TREE)
12793 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
12794 DECL_ARTIFICIAL (resdecl) = 1;
12795 DECL_IGNORED_P (resdecl) = 1;
12796 DECL_RESULT (decl1) = resdecl;
12798 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
12801 /* Let the user know we're compiling this function. */
12802 announce_function (decl1);
12804 /* Record the decl so that the function name is defined.
12805 If we already have a decl for this name, and it is a FUNCTION_DECL,
12806 use the old decl. */
12807 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
12809 /* A specialization is not used to guide overload resolution. */
12810 if (!DECL_FUNCTION_MEMBER_P (decl1)
12811 && !(DECL_USE_TEMPLATE (decl1) &&
12812 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
12814 tree olddecl = pushdecl (decl1);
12816 if (olddecl == error_mark_node)
12817 /* If something went wrong when registering the declaration,
12818 use DECL1; we have to have a FUNCTION_DECL to use when
12819 parsing the body of the function. */
12823 /* Otherwise, OLDDECL is either a previous declaration
12824 of the same function or DECL1 itself. */
12826 if (warn_missing_declarations
12827 && olddecl == decl1
12828 && !DECL_MAIN_P (decl1)
12829 && TREE_PUBLIC (decl1)
12830 && !DECL_DECLARED_INLINE_P (decl1))
12834 /* Check whether DECL1 is in an anonymous
12836 for (context = DECL_CONTEXT (decl1);
12838 context = DECL_CONTEXT (context))
12840 if (TREE_CODE (context) == NAMESPACE_DECL
12841 && DECL_NAME (context) == NULL_TREE)
12845 if (context == NULL)
12846 warning (OPT_Wmissing_declarations,
12847 "no previous declaration for %q+D", decl1);
12855 /* We need to set the DECL_CONTEXT. */
12856 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
12857 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
12859 fntype = TREE_TYPE (decl1);
12861 /* If #pragma weak applies, mark the decl appropriately now.
12862 The pragma only applies to global functions. Because
12863 determining whether or not the #pragma applies involves
12864 computing the mangled name for the declaration, we cannot
12865 apply the pragma until after we have merged this declaration
12866 with any previous declarations; if the original declaration
12867 has a linkage specification, that specification applies to
12868 the definition as well, and may affect the mangled name. */
12869 if (DECL_FILE_SCOPE_P (decl1))
12870 maybe_apply_pragma_weak (decl1);
12873 /* Reset this in case the call to pushdecl changed it. */
12874 current_function_decl = decl1;
12876 gcc_assert (DECL_INITIAL (decl1));
12878 /* This function may already have been parsed, in which case just
12879 return; our caller will skip over the body without parsing. */
12880 if (DECL_INITIAL (decl1) != error_mark_node)
12883 /* Initialize RTL machinery. We cannot do this until
12884 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
12885 even when processing a template; this is how we get
12886 CFUN set up, and our per-function variables initialized.
12887 FIXME factor out the non-RTL stuff. */
12888 bl = current_binding_level;
12889 allocate_struct_function (decl1, processing_template_decl);
12891 /* Initialize the language data structures. Whenever we start
12892 a new function, we destroy temporaries in the usual way. */
12893 cfun->language = ggc_alloc_cleared_language_function ();
12894 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12895 current_binding_level = bl;
12897 if (!processing_template_decl && type_uses_auto (restype))
12899 FNDECL_USED_AUTO (decl1) = true;
12900 current_function_auto_return_pattern = restype;
12903 /* Start the statement-tree, start the tree now. */
12904 DECL_SAVED_TREE (decl1) = push_stmt_list ();
12906 /* If we are (erroneously) defining a function that we have already
12907 defined before, wipe out what we knew before. */
12908 if (!DECL_PENDING_INLINE_P (decl1))
12909 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
12911 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
12913 /* We know that this was set up by `grokclassfn'. We do not
12914 wait until `store_parm_decls', since evil parse errors may
12915 never get us to that point. Here we keep the consistency
12916 between `current_class_type' and `current_class_ptr'. */
12917 tree t = DECL_ARGUMENTS (decl1);
12919 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
12920 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
12922 cp_function_chain->x_current_class_ref
12923 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
12924 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
12925 cp_function_chain->x_current_class_ptr = t;
12927 /* Constructors and destructors need to know whether they're "in
12928 charge" of initializing virtual base classes. */
12929 t = DECL_CHAIN (t);
12930 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
12932 current_in_charge_parm = t;
12933 t = DECL_CHAIN (t);
12935 if (DECL_HAS_VTT_PARM_P (decl1))
12937 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
12938 current_vtt_parm = t;
12942 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
12943 /* Implicitly-defined methods (like the
12944 destructor for a class in which no destructor
12945 is explicitly declared) must not be defined
12946 until their definition is needed. So, we
12947 ignore interface specifications for
12948 compiler-generated functions. */
12949 && !DECL_ARTIFICIAL (decl1));
12951 if (processing_template_decl)
12952 /* Don't mess with interface flags. */;
12953 else if (DECL_INTERFACE_KNOWN (decl1))
12955 tree ctx = decl_function_context (decl1);
12957 if (DECL_NOT_REALLY_EXTERN (decl1))
12958 DECL_EXTERNAL (decl1) = 0;
12960 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
12961 && TREE_PUBLIC (ctx))
12962 /* This is a function in a local class in an extern inline
12964 comdat_linkage (decl1);
12966 /* If this function belongs to an interface, it is public.
12967 If it belongs to someone else's interface, it is also external.
12968 This only affects inlines and template instantiations. */
12969 else if (!finfo->interface_unknown && honor_interface)
12971 if (DECL_DECLARED_INLINE_P (decl1)
12972 || DECL_TEMPLATE_INSTANTIATION (decl1))
12974 DECL_EXTERNAL (decl1)
12975 = (finfo->interface_only
12976 || (DECL_DECLARED_INLINE_P (decl1)
12977 && ! flag_implement_inlines
12978 && !DECL_VINDEX (decl1)));
12980 /* For WIN32 we also want to put these in linkonce sections. */
12981 maybe_make_one_only (decl1);
12984 DECL_EXTERNAL (decl1) = 0;
12985 DECL_INTERFACE_KNOWN (decl1) = 1;
12986 /* If this function is in an interface implemented in this file,
12987 make sure that the back end knows to emit this function
12989 if (!DECL_EXTERNAL (decl1))
12990 mark_needed (decl1);
12992 else if (finfo->interface_unknown && finfo->interface_only
12993 && honor_interface)
12995 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
12996 interface, we will have both finfo->interface_unknown and
12997 finfo->interface_only set. In that case, we don't want to
12998 use the normal heuristics because someone will supply a
12999 #pragma implementation elsewhere, and deducing it here would
13000 produce a conflict. */
13001 comdat_linkage (decl1);
13002 DECL_EXTERNAL (decl1) = 0;
13003 DECL_INTERFACE_KNOWN (decl1) = 1;
13004 DECL_DEFER_OUTPUT (decl1) = 1;
13008 /* This is a definition, not a reference.
13009 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13010 if (!GNU_INLINE_P (decl1))
13011 DECL_EXTERNAL (decl1) = 0;
13013 if ((DECL_DECLARED_INLINE_P (decl1)
13014 || DECL_TEMPLATE_INSTANTIATION (decl1))
13015 && ! DECL_INTERFACE_KNOWN (decl1))
13016 DECL_DEFER_OUTPUT (decl1) = 1;
13018 DECL_INTERFACE_KNOWN (decl1) = 1;
13021 /* Determine the ELF visibility attribute for the function. We must not
13022 do this before calling "pushdecl", as we must allow "duplicate_decls"
13023 to merge any attributes appropriately. We also need to wait until
13025 if (!DECL_CLONED_FUNCTION_P (decl1))
13026 determine_visibility (decl1);
13028 begin_scope (sk_function_parms, decl1);
13032 if (DECL_DESTRUCTOR_P (decl1)
13033 || (DECL_CONSTRUCTOR_P (decl1)
13034 && targetm.cxx.cdtor_returns_this ()))
13036 cdtor_label = build_decl (input_location,
13037 LABEL_DECL, NULL_TREE, NULL_TREE);
13038 DECL_CONTEXT (cdtor_label) = current_function_decl;
13041 start_fname_decls ();
13043 store_parm_decls (current_function_parms);
13047 /* Like start_preparsed_function, except that instead of a
13048 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13050 Returns 1 on success. If the DECLARATOR is not suitable for a function
13051 (it defines a datum instead), we return 0, which tells
13052 yyparse to report a parse error. */
13055 start_function (cp_decl_specifier_seq *declspecs,
13056 const cp_declarator *declarator,
13061 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
13062 if (decl1 == error_mark_node)
13064 /* If the declarator is not suitable for a function definition,
13065 cause a syntax error. */
13066 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13068 error ("invalid function declaration");
13072 if (DECL_MAIN_P (decl1))
13073 /* main must return int. grokfndecl should have corrected it
13074 (and issued a diagnostic) if the user got it wrong. */
13075 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
13076 integer_type_node));
13078 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
13083 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13087 use_eh_spec_block (tree fn)
13089 return (flag_exceptions && flag_enforce_eh_specs
13090 && !processing_template_decl
13091 && !type_throw_all_p (TREE_TYPE (fn))
13092 /* We insert the EH_SPEC_BLOCK only in the original
13093 function; then, it is copied automatically to the
13095 && !DECL_CLONED_FUNCTION_P (fn)
13096 /* Implicitly-generated constructors and destructors have
13097 exception specifications. However, those specifications
13098 are the union of the possible exceptions specified by the
13099 constructors/destructors for bases and members, so no
13100 unallowed exception will ever reach this function. By
13101 not creating the EH_SPEC_BLOCK we save a little memory,
13102 and we avoid spurious warnings about unreachable
13104 && !DECL_DEFAULTED_FN (fn));
13107 /* Store the parameter declarations into the current function declaration.
13108 This is called after parsing the parameter declarations, before
13109 digesting the body of the function.
13111 Also install to binding contour return value identifier, if any. */
13114 store_parm_decls (tree current_function_parms)
13116 tree fndecl = current_function_decl;
13119 /* This is a chain of any other decls that came in among the parm
13120 declarations. If a parm is declared with enum {foo, bar} x;
13121 then CONST_DECLs for foo and bar are put here. */
13122 tree nonparms = NULL_TREE;
13124 if (current_function_parms)
13126 /* This case is when the function was defined with an ANSI prototype.
13127 The parms already have decls, so we need not do anything here
13128 except record them as in effect
13129 and complain if any redundant old-style parm decls were written. */
13131 tree specparms = current_function_parms;
13134 /* Must clear this because it might contain TYPE_DECLs declared
13136 current_binding_level->names = NULL;
13138 /* If we're doing semantic analysis, then we'll call pushdecl
13139 for each of these. We must do them in reverse order so that
13140 they end in the correct forward order. */
13141 specparms = nreverse (specparms);
13143 for (parm = specparms; parm; parm = next)
13145 next = DECL_CHAIN (parm);
13146 if (TREE_CODE (parm) == PARM_DECL)
13148 if (DECL_NAME (parm) == NULL_TREE
13149 || TREE_CODE (parm) != VOID_TYPE)
13152 error ("parameter %qD declared void", parm);
13156 /* If we find an enum constant or a type tag,
13157 put it aside for the moment. */
13158 TREE_CHAIN (parm) = NULL_TREE;
13159 nonparms = chainon (nonparms, parm);
13163 /* Get the decls in their original chain order and record in the
13164 function. This is all and only the PARM_DECLs that were
13165 pushed into scope by the loop above. */
13166 DECL_ARGUMENTS (fndecl) = getdecls ();
13169 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13171 /* Now store the final chain of decls for the arguments
13172 as the decl-chain of the current lexical scope.
13173 Put the enumerators in as well, at the front so that
13174 DECL_ARGUMENTS is not modified. */
13175 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
13177 if (use_eh_spec_block (current_function_decl))
13178 current_eh_spec_block = begin_eh_spec_block ();
13182 /* We have finished doing semantic analysis on DECL, but have not yet
13183 generated RTL for its body. Save away our current state, so that
13184 when we want to generate RTL later we know what to do. */
13187 save_function_data (tree decl)
13189 struct language_function *f;
13191 /* Save the language-specific per-function data so that we can
13192 get it back when we really expand this function. */
13193 gcc_assert (!DECL_PENDING_INLINE_P (decl));
13196 f = ggc_alloc_language_function ();
13197 memcpy (f, cp_function_chain, sizeof (struct language_function));
13198 DECL_SAVED_FUNCTION_DATA (decl) = f;
13200 /* Clear out the bits we don't need. */
13201 f->base.x_stmt_tree.x_cur_stmt_list = NULL;
13202 f->bindings = NULL;
13203 f->x_local_names = NULL;
13204 f->base.local_typedefs = NULL;
13208 /* Set the return value of the constructor (if present). */
13211 finish_constructor_body (void)
13216 if (targetm.cxx.cdtor_returns_this ()
13217 && (! TYPE_FOR_JAVA (current_class_type)))
13219 /* Any return from a constructor will end up here. */
13220 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13222 val = DECL_ARGUMENTS (current_function_decl);
13223 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13224 DECL_RESULT (current_function_decl), val);
13225 /* Return the address of the object. */
13226 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13227 add_stmt (exprstmt);
13231 /* Do all the processing for the beginning of a destructor; set up the
13232 vtable pointers and cleanups for bases and members. */
13235 begin_destructor_body (void)
13237 tree compound_stmt;
13239 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13240 issued an error message. We still want to try to process the
13241 body of the function, but initialize_vtbl_ptrs will crash if
13242 TYPE_BINFO is NULL. */
13243 if (COMPLETE_TYPE_P (current_class_type))
13245 compound_stmt = begin_compound_stmt (0);
13246 /* Make all virtual function table pointers in non-virtual base
13247 classes point to CURRENT_CLASS_TYPE's virtual function
13249 initialize_vtbl_ptrs (current_class_ptr);
13250 finish_compound_stmt (compound_stmt);
13252 /* And insert cleanups for our bases and members so that they
13253 will be properly destroyed if we throw. */
13254 push_base_cleanups ();
13258 /* At the end of every destructor we generate code to delete the object if
13259 necessary. Do that now. */
13262 finish_destructor_body (void)
13266 /* Any return from a destructor will end up here; that way all base
13267 and member cleanups will be run when the function returns. */
13268 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13270 /* In a virtual destructor, we must call delete. */
13271 if (DECL_VIRTUAL_P (current_function_decl))
13274 tree virtual_size = cxx_sizeof (current_class_type);
13278 At the point of definition of a virtual destructor (including
13279 an implicit definition), non-placement operator delete shall
13280 be looked up in the scope of the destructor's class and if
13281 found shall be accessible and unambiguous. */
13282 exprstmt = build_op_delete_call (DELETE_EXPR, current_class_ptr,
13284 /*global_p=*/false,
13285 /*placement=*/NULL_TREE,
13286 /*alloc_fn=*/NULL_TREE,
13287 tf_warning_or_error);
13289 if_stmt = begin_if_stmt ();
13290 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
13291 current_in_charge_parm,
13294 finish_expr_stmt (exprstmt);
13295 finish_then_clause (if_stmt);
13296 finish_if_stmt (if_stmt);
13299 if (targetm.cxx.cdtor_returns_this ())
13303 val = DECL_ARGUMENTS (current_function_decl);
13304 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13305 DECL_RESULT (current_function_decl), val);
13306 /* Return the address of the object. */
13307 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13308 add_stmt (exprstmt);
13312 /* Do the necessary processing for the beginning of a function body, which
13313 in this case includes member-initializers, but not the catch clauses of
13314 a function-try-block. Currently, this means opening a binding level
13315 for the member-initializers (in a ctor), member cleanups (in a dtor),
13316 and capture proxies (in a lambda operator()). */
13319 begin_function_body (void)
13323 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13326 if (processing_template_decl)
13327 /* Do nothing now. */;
13329 /* Always keep the BLOCK node associated with the outermost pair of
13330 curly braces of a function. These are needed for correct
13331 operation of dwarfout.c. */
13332 keep_next_level (true);
13334 stmt = begin_compound_stmt (BCS_FN_BODY);
13336 if (processing_template_decl)
13337 /* Do nothing now. */;
13338 else if (DECL_DESTRUCTOR_P (current_function_decl))
13339 begin_destructor_body ();
13344 /* Do the processing for the end of a function body. Currently, this means
13345 closing out the cleanups for fully-constructed bases and members, and in
13346 the case of the destructor, deleting the object if desired. Again, this
13347 is only meaningful for [cd]tors, since they are the only functions where
13348 there is a significant distinction between the main body and any
13349 function catch clauses. Handling, say, main() return semantics here
13350 would be wrong, as flowing off the end of a function catch clause for
13351 main() would also need to return 0. */
13354 finish_function_body (tree compstmt)
13356 if (compstmt == NULL_TREE)
13359 /* Close the block. */
13360 finish_compound_stmt (compstmt);
13362 if (processing_template_decl)
13363 /* Do nothing now. */;
13364 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13365 finish_constructor_body ();
13366 else if (DECL_DESTRUCTOR_P (current_function_decl))
13367 finish_destructor_body ();
13370 /* Given a function, returns the BLOCK corresponding to the outermost level
13371 of curly braces, skipping the artificial block created for constructor
13375 outer_curly_brace_block (tree fndecl)
13377 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
13378 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13379 /* Skip the artificial function body block. */
13380 block = BLOCK_SUBBLOCKS (block);
13384 /* If FNDECL is a class's key method, add the class to the list of
13385 keyed classes that should be emitted. */
13388 record_key_method_defined (tree fndecl)
13390 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
13391 && DECL_VIRTUAL_P (fndecl)
13392 && !processing_template_decl)
13394 tree fnclass = DECL_CONTEXT (fndecl);
13395 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
13396 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
13400 /* Subroutine of finish_function.
13401 Save the body of constexpr functions for possible
13402 future compile time evaluation. */
13405 maybe_save_function_definition (tree fun)
13407 if (!processing_template_decl
13408 && DECL_DECLARED_CONSTEXPR_P (fun)
13409 && !DECL_CLONED_FUNCTION_P (fun))
13410 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
13413 /* Finish up a function declaration and compile that function
13414 all the way to assembler language output. The free the storage
13415 for the function definition.
13417 FLAGS is a bitwise or of the following values:
13419 We just finished processing the body of an in-class inline
13420 function definition. (This processing will have taken place
13421 after the class definition is complete.) */
13424 finish_function (int flags)
13426 tree fndecl = current_function_decl;
13427 tree fntype, ctype = NULL_TREE;
13428 int inclass_inline = (flags & 2) != 0;
13430 /* When we get some parse errors, we can end up without a
13431 current_function_decl, so cope. */
13432 if (fndecl == NULL_TREE)
13433 return error_mark_node;
13435 if (c_dialect_objc ())
13436 objc_finish_function ();
13438 gcc_assert (!defer_mark_used_calls);
13439 defer_mark_used_calls = true;
13441 record_key_method_defined (fndecl);
13443 fntype = TREE_TYPE (fndecl);
13445 /* TREE_READONLY (fndecl) = 1;
13446 This caused &foo to be of type ptr-to-const-function
13447 which then got a warning when stored in a ptr-to-function variable. */
13449 gcc_assert (building_stmt_list_p ());
13450 /* The current function is being defined, so its DECL_INITIAL should
13451 be set, and unless there's a multiple definition, it should be
13452 error_mark_node. */
13453 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
13455 /* For a cloned function, we've already got all the code we need;
13456 there's no need to add any extra bits. */
13457 if (!DECL_CLONED_FUNCTION_P (fndecl))
13459 /* Make it so that `main' always returns 0 by default. */
13460 if (DECL_MAIN_P (current_function_decl))
13461 finish_return_stmt (integer_zero_node);
13463 if (use_eh_spec_block (current_function_decl))
13464 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13465 (TREE_TYPE (current_function_decl)),
13466 current_eh_spec_block);
13469 /* If we're saving up tree structure, tie off the function now. */
13470 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
13472 finish_fname_decls ();
13474 /* If this function can't throw any exceptions, remember that. */
13475 if (!processing_template_decl
13476 && !cp_function_chain->can_throw
13477 && !flag_non_call_exceptions
13478 && !decl_replaceable_p (fndecl))
13479 TREE_NOTHROW (fndecl) = 1;
13481 /* This must come after expand_function_end because cleanups might
13482 have declarations (from inline functions) that need to go into
13483 this function's blocks. */
13485 /* If the current binding level isn't the outermost binding level
13486 for this function, either there is a bug, or we have experienced
13487 syntax errors and the statement tree is malformed. */
13488 if (current_binding_level->kind != sk_function_parms)
13490 /* Make sure we have already experienced errors. */
13491 gcc_assert (errorcount);
13493 /* Throw away the broken statement tree and extra binding
13495 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
13497 while (current_binding_level->kind != sk_function_parms)
13499 if (current_binding_level->kind == sk_class)
13500 pop_nested_class ();
13502 poplevel (0, 0, 0);
13505 poplevel (1, 0, 1);
13507 /* Statements should always be full-expressions at the outermost set
13508 of curly braces for a function. */
13509 gcc_assert (stmts_are_full_exprs_p ());
13511 /* If there are no return statements in a function with auto return type,
13512 the return type is void. But if the declared type is something like
13513 auto*, this is an error. */
13514 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
13515 && TREE_TYPE (fntype) == current_function_auto_return_pattern)
13517 if (!is_auto (current_function_auto_return_pattern)
13518 && !current_function_returns_value && !current_function_returns_null)
13520 error ("no return statements in function returning %qT",
13521 current_function_auto_return_pattern);
13522 inform (input_location, "only plain %<auto%> return type can be "
13523 "deduced to %<void%>");
13525 apply_deduced_return_type (fndecl, void_type_node);
13526 fntype = TREE_TYPE (fndecl);
13529 /* Save constexpr function body before it gets munged by
13530 the NRV transformation. */
13531 maybe_save_function_definition (fndecl);
13533 /* Set up the named return value optimization, if we can. Candidate
13534 variables are selected in check_return_expr. */
13535 if (current_function_return_value)
13537 tree r = current_function_return_value;
13540 if (r != error_mark_node
13541 /* This is only worth doing for fns that return in memory--and
13542 simpler, since we don't have to worry about promoted modes. */
13543 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
13544 /* Only allow this for variables declared in the outer scope of
13545 the function so we know that their lifetime always ends with a
13546 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13547 we were to do this optimization in tree-ssa. */
13548 && (outer = outer_curly_brace_block (fndecl))
13549 && chain_member (r, BLOCK_VARS (outer)))
13550 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
13552 current_function_return_value = NULL_TREE;
13555 /* Remember that we were in class scope. */
13556 if (current_class_name)
13557 ctype = current_class_type;
13559 /* Must mark the RESULT_DECL as being in this function. */
13560 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13562 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13563 to the FUNCTION_DECL node itself. */
13564 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13566 /* Save away current state, if appropriate. */
13567 if (!processing_template_decl)
13568 save_function_data (fndecl);
13570 /* Complain if there's just no return statement. */
13571 if (warn_return_type
13572 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
13573 && !dependent_type_p (TREE_TYPE (fntype))
13574 && !current_function_returns_value && !current_function_returns_null
13575 /* Don't complain if we abort or throw. */
13576 && !current_function_returns_abnormally
13577 /* Don't complain if we are declared noreturn. */
13578 && !TREE_THIS_VOLATILE (fndecl)
13579 && !DECL_NAME (DECL_RESULT (fndecl))
13580 && !TREE_NO_WARNING (fndecl)
13581 /* Structor return values (if any) are set by the compiler. */
13582 && !DECL_CONSTRUCTOR_P (fndecl)
13583 && !DECL_DESTRUCTOR_P (fndecl)
13584 && targetm.warn_func_return (fndecl))
13586 warning (OPT_Wreturn_type,
13587 "no return statement in function returning non-void");
13588 TREE_NO_WARNING (fndecl) = 1;
13591 /* Store the end of the function, so that we get good line number
13592 info for the epilogue. */
13593 cfun->function_end_locus = input_location;
13595 /* Complain about parameters that are only set, but never otherwise used. */
13596 if (warn_unused_but_set_parameter
13597 && !processing_template_decl
13598 && errorcount == unused_but_set_errorcount
13599 && !DECL_CLONED_FUNCTION_P (fndecl))
13603 for (decl = DECL_ARGUMENTS (fndecl);
13605 decl = DECL_CHAIN (decl))
13606 if (TREE_USED (decl)
13607 && TREE_CODE (decl) == PARM_DECL
13608 && !DECL_READ_P (decl)
13609 && DECL_NAME (decl)
13610 && !DECL_ARTIFICIAL (decl)
13611 && !TREE_NO_WARNING (decl)
13612 && !DECL_IN_SYSTEM_HEADER (decl)
13613 && TREE_TYPE (decl) != error_mark_node
13614 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
13615 && (!CLASS_TYPE_P (TREE_TYPE (decl))
13616 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
13617 warning (OPT_Wunused_but_set_parameter,
13618 "parameter %q+D set but not used", decl);
13619 unused_but_set_errorcount = errorcount;
13622 /* Complain about locally defined typedefs that are not used in this
13624 maybe_warn_unused_local_typedefs ();
13626 /* Genericize before inlining. */
13627 if (!processing_template_decl)
13629 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
13630 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
13631 cp_genericize (fndecl);
13632 /* Clear out the bits we don't need. */
13633 f->x_current_class_ptr = NULL;
13634 f->x_current_class_ref = NULL;
13635 f->x_eh_spec_block = NULL;
13636 f->x_in_charge_parm = NULL;
13637 f->x_vtt_parm = NULL;
13638 f->x_return_value = NULL;
13639 f->bindings = NULL;
13640 f->extern_decl_map = NULL;
13642 /* Clear out the bits we don't need. */
13643 local_names = NULL;
13645 /* We're leaving the context of this function, so zap cfun. It's still in
13646 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
13648 current_function_decl = NULL;
13650 /* If this is an in-class inline definition, we may have to pop the
13651 bindings for the template parameters that we added in
13652 maybe_begin_member_template_processing when start_function was
13654 if (inclass_inline)
13655 maybe_end_member_template_processing ();
13657 /* Leave the scope of the class. */
13659 pop_nested_class ();
13664 current_function_decl = NULL_TREE;
13666 defer_mark_used_calls = false;
13667 if (deferred_mark_used_calls)
13672 FOR_EACH_VEC_ELT (tree, deferred_mark_used_calls, i, decl)
13674 VEC_free (tree, gc, deferred_mark_used_calls);
13680 /* Create the FUNCTION_DECL for a function definition.
13681 DECLSPECS and DECLARATOR are the parts of the declaration;
13682 they describe the return type and the name of the function,
13683 but twisted together in a fashion that parallels the syntax of C.
13685 This function creates a binding context for the function body
13686 as well as setting up the FUNCTION_DECL in current_function_decl.
13688 Returns a FUNCTION_DECL on success.
13690 If the DECLARATOR is not suitable for a function (it defines a datum
13691 instead), we return 0, which tells yyparse to report a parse error.
13693 May return void_type_node indicating that this method is actually
13694 a friend. See grokfield for more details.
13696 Came here with a `.pushlevel' .
13698 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13699 CHANGES TO CODE IN `grokfield'. */
13702 grokmethod (cp_decl_specifier_seq *declspecs,
13703 const cp_declarator *declarator, tree attrlist)
13705 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
13708 if (fndecl == error_mark_node)
13709 return error_mark_node;
13711 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
13713 error ("invalid member function declaration");
13714 return error_mark_node;
13718 cplus_decl_attributes (&fndecl, attrlist, 0);
13720 /* Pass friends other than inline friend functions back. */
13721 if (fndecl == void_type_node)
13724 if (DECL_IN_AGGR_P (fndecl))
13726 if (DECL_CLASS_SCOPE_P (fndecl))
13727 error ("%qD is already defined in class %qT", fndecl,
13728 DECL_CONTEXT (fndecl));
13729 return error_mark_node;
13732 check_template_shadow (fndecl);
13734 DECL_DECLARED_INLINE_P (fndecl) = 1;
13735 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
13737 /* We process method specializations in finish_struct_1. */
13738 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
13740 fndecl = push_template_decl (fndecl);
13741 if (fndecl == error_mark_node)
13745 if (! DECL_FRIEND_P (fndecl))
13747 if (DECL_CHAIN (fndecl))
13749 fndecl = copy_node (fndecl);
13750 TREE_CHAIN (fndecl) = NULL_TREE;
13754 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
13756 DECL_IN_AGGR_P (fndecl) = 1;
13761 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
13762 we can lay it out later, when and if its type becomes complete. */
13765 maybe_register_incomplete_var (tree var)
13767 gcc_assert (TREE_CODE (var) == VAR_DECL);
13769 /* Keep track of variables with incomplete types. */
13770 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
13771 && DECL_EXTERNAL (var))
13773 tree inner_type = TREE_TYPE (var);
13775 while (TREE_CODE (inner_type) == ARRAY_TYPE)
13776 inner_type = TREE_TYPE (inner_type);
13777 inner_type = TYPE_MAIN_VARIANT (inner_type);
13779 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
13780 /* RTTI TD entries are created while defining the type_info. */
13781 || (TYPE_LANG_SPECIFIC (inner_type)
13782 && TYPE_BEING_DEFINED (inner_type)))
13784 incomplete_var iv = {var, inner_type};
13785 VEC_safe_push (incomplete_var, gc, incomplete_vars, iv);
13790 /* Called when a class type (given by TYPE) is defined. If there are
13791 any existing VAR_DECLs whose type has been completed by this
13792 declaration, update them now. */
13795 complete_vars (tree type)
13798 incomplete_var *iv;
13800 for (ix = 0; VEC_iterate (incomplete_var, incomplete_vars, ix, iv); )
13802 if (same_type_p (type, iv->incomplete_type))
13804 tree var = iv->decl;
13805 tree type = TREE_TYPE (var);
13806 /* Complete the type of the variable. The VAR_DECL itself
13807 will be laid out in expand_expr. */
13808 complete_type (type);
13809 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
13810 /* Remove this entry from the list. */
13811 VEC_unordered_remove (incomplete_var, incomplete_vars, ix);
13817 /* Check for pending declarations which may have abstract type. */
13818 complete_type_check_abstract (type);
13821 /* If DECL is of a type which needs a cleanup, build and return an
13822 expression to perform that cleanup here. Return NULL_TREE if no
13823 cleanup need be done. */
13826 cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
13832 /* Assume no cleanup is required. */
13833 cleanup = NULL_TREE;
13835 if (error_operand_p (decl))
13838 /* Handle "__attribute__((cleanup))". We run the cleanup function
13839 before the destructor since the destructor is what actually
13840 terminates the lifetime of the object. */
13841 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
13848 /* Get the name specified by the user for the cleanup function. */
13849 id = TREE_VALUE (TREE_VALUE (attr));
13850 /* Look up the name to find the cleanup function to call. It is
13851 important to use lookup_name here because that is what is
13852 used in c-common.c:handle_cleanup_attribute when performing
13853 initial checks on the attribute. Note that those checks
13854 include ensuring that the function found is not an overloaded
13855 function, or an object with an overloaded call operator,
13856 etc.; we can rely on the fact that the function found is an
13857 ordinary FUNCTION_DECL. */
13858 fn = lookup_name (id);
13859 arg = build_address (decl);
13861 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE);
13862 if (cleanup == error_mark_node)
13863 return error_mark_node;
13865 /* Handle ordinary C++ destructors. */
13866 type = TREE_TYPE (decl);
13867 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13869 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
13870 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
13871 && CLASSTYPE_VBASECLASSES (type));
13875 if (TREE_CODE (type) == ARRAY_TYPE)
13878 addr = build_address (decl);
13880 /* Optimize for space over speed here. */
13881 if (!has_vbases || flag_expensive_optimizations)
13882 flags |= LOOKUP_NONVIRTUAL;
13884 call = build_delete (TREE_TYPE (addr), addr,
13885 sfk_complete_destructor, flags, 0, complain);
13886 if (call == error_mark_node)
13887 cleanup = error_mark_node;
13889 cleanup = cp_build_compound_expr (cleanup, call, complain);
13894 /* build_delete sets the location of the destructor call to the
13895 current location, even though the destructor is going to be
13896 called later, at the end of the current scope. This can lead to
13897 a "jumpy" behaviour for users of debuggers when they step around
13898 the end of the block. So let's unset the location of the
13899 destructor call instead. */
13900 if (cleanup != NULL && EXPR_P (cleanup))
13901 SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
13906 /* When a stmt has been parsed, this function is called. */
13913 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
13914 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
13915 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
13918 static_fn_type (tree memfntype)
13923 if (TYPE_PTRMEMFUNC_P (memfntype))
13924 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
13925 if (POINTER_TYPE_P (memfntype)
13926 || TREE_CODE (memfntype) == FUNCTION_DECL)
13927 memfntype = TREE_TYPE (memfntype);
13928 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
13930 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
13931 args = TYPE_ARG_TYPES (memfntype);
13932 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
13933 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype));
13934 fntype = (cp_build_type_attribute_variant
13935 (fntype, TYPE_ATTRIBUTES (memfntype)));
13936 fntype = (build_exception_variant
13937 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
13941 /* DECL was originally constructed as a non-static member function,
13942 but turned out to be static. Update it accordingly. */
13945 revert_static_member_fn (tree decl)
13947 tree stype = static_fn_type (decl);
13948 cp_cv_quals quals = type_memfn_quals (stype);
13950 if (quals != TYPE_UNQUALIFIED)
13951 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED);
13953 TREE_TYPE (decl) = stype;
13955 if (DECL_ARGUMENTS (decl))
13956 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl));
13957 DECL_STATIC_FUNCTION_P (decl) = 1;
13960 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
13961 one of the language-independent trees. */
13963 enum cp_tree_node_structure_enum
13964 cp_tree_node_structure (union lang_tree_node * t)
13966 switch (TREE_CODE (&t->generic))
13968 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
13969 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT;
13970 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
13971 case OVERLOAD: return TS_CP_OVERLOAD;
13972 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
13973 case PTRMEM_CST: return TS_CP_PTRMEM;
13974 case BASELINK: return TS_CP_BASELINK;
13975 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
13976 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
13977 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
13978 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
13979 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
13980 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL;
13981 default: return TS_CP_GENERIC;
13985 /* Build the void_list_node (void_type_node having been created). */
13987 build_void_list_node (void)
13989 tree t = build_tree_list (NULL_TREE, void_type_node);
13994 cp_missing_noreturn_ok_p (tree decl)
13996 /* A missing noreturn is ok for the `main' function. */
13997 return DECL_MAIN_P (decl);
14000 /* Return the COMDAT group into which DECL should be placed. */
14003 cxx_comdat_group (tree decl)
14007 /* Virtual tables, construction virtual tables, and virtual table
14008 tables all go in a single COMDAT group, named after the primary
14010 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
14011 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
14012 /* For all other DECLs, the COMDAT group is the mangled name of the
14013 declaration itself. */
14016 while (DECL_THUNK_P (decl))
14018 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14019 into the same section as the target function. In that case
14020 we must return target's name. */
14021 tree target = THUNK_TARGET (decl);
14022 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
14023 && DECL_SECTION_NAME (target) != NULL
14024 && DECL_ONE_ONLY (target))
14029 name = DECL_ASSEMBLER_NAME (decl);
14035 #include "gt-cp-decl.h"